source: spip-zone/_plugins_/noizetier/trunk/ncore/noizetier.php

Last change on this file was 113568, checked in by eric@…, 3 months ago

Oubli d'un include.

  • Property svn:eol-style set to native
File size: 29.1 KB
Line 
1<?php
2
3if (!defined('_ECRIRE_INC_VERSION')) {
4        return;
5}
6
7// -----------------------------------------------------------------------
8// ------------------------- TYPES DE NOISETTE ---------------------------
9// -----------------------------------------------------------------------
10
11/**
12 * Stocke les descriptions des types de noisette en distinguant les types de noisette obsolètes, les types de
13 * noisettes modifiés et les types de noisettes nouveaux.
14 * Chaque description de type de noisette est un tableau associatif dont tous les index possibles - y compris
15 * la signature - sont initialisés quelque soit le contenu du fichier YAML.
16 *
17 * Les types de noisettes sont stockés dans la table `spip_types_noisettes`.
18 *
19 * @package SPIP\NOIZETIER\TYPE_NOISETTE\SERVICE
20 *
21 * @param string $plugin
22 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
23 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
24 * @param array  $types_noisettes
25 *        Tableau associatif à 3 entrées fournissant les descriptions des types de noisettes nouveaux, obsolètes
26 *        et modifiés:
27 *        `a_effacer` : liste des identifiants de type de noisette devenus obsolètes.
28 *        `a_changer` : liste des descriptions des types de noisette dont le fichier YAML a été modifié.
29 *        `a_ajouter` : liste des descriptions des nouveaux types de noisette.
30 *        Si $recharger est à `true`, seul l'index `a_ajouter` est fourni dans le tableau $types_noisette.
31 * @param bool   $recharger
32 *        Indique si le chargement en cours est forcé ou pas. Cela permet à la fonction N-Core ou au service
33 *        concerné d'optimiser le traitement sachant que seules les types de noisette nouveaux sont fournis.
34 *
35 * @return bool
36 *        `true` si le traitement s'est bien déroulé, `false` sinon.
37 */
38function noizetier_type_noisette_stocker($plugin, $types_noisettes, $recharger) {
39
40        $retour = true;
41
42        // Mise à jour de la table des noisettes 'spip_types_noisettes'.
43        $from = 'spip_types_noisettes';
44
45        // -- Suppression des types de noisette obsolètes ou de tous les types de noisette d'un coup si on est en mode
46        //    rechargement forcé.
47        if (sql_preferer_transaction()) {
48                sql_demarrer_transaction();
49        }
50        $where = array('plugin=' . sql_quote($plugin));
51        if ($recharger) {
52                sql_delete($from, $where);
53        } elseif (!empty($types_noisettes['a_effacer'])) {
54                $where[] = sql_in('type_noisette', $types_noisettes['a_effacer']);
55                sql_delete($from, $where);
56        }
57        // -- Update des types de noisettes modifiés
58        if (!empty($types_noisettes['a_changer'])) {
59                sql_replace_multi($from, $types_noisettes['a_changer']);
60        }
61        // -- Insertion des nouveaux types de noisette
62        if (!empty($types_noisettes['a_ajouter'])) {
63                sql_insertq_multi($from, $types_noisettes['a_ajouter']);
64        }
65        if (sql_preferer_transaction()) {
66                sql_terminer_transaction();
67        }
68
69        return $retour;
70}
71
72/**
73 * Complète la description d'un type de noisette issue de la lecture de son fichier YAML.
74 *
75 * Le noiZetier phrase le type de noisette pour détecter son type et sa composition éventuelle.
76 *
77 * @package SPIP\NOIZETIER\TYPE_NOISETTE\SERVICE
78 *
79 * @param string $plugin
80 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
81 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
82 * @param array  $description
83 *        Description du type de noisette issue de la lecture du fichier YAML. Suivant le plugin utilisateur elle
84 *        nécessite d'être compléter avant son stockage.
85 *
86 * @return array
87 *        Description du type de noisette complétée avec le type de page et la composition (éventuellement vides).
88 */
89function noizetier_type_noisette_completer($plugin, $description) {
90
91        // Initialiser les composants de l'identifiant du type de noisette:
92        // - type_page-type_noisette si le type de noisette est dédié uniquement à une page
93        // - type_page-composition-type_noisette si le type de noisette est dédié uniquement à une composition
94        // - type_noisette sinon
95        $description['type'] = '';
96        $description['composition'] = '';
97        $identifiants = explode('-', $description['type_noisette']);
98        if (isset($identifiants[1])) {
99                $description['type'] = $identifiants[0];
100        }
101        if (isset($identifiants[2])) {
102                $description['composition'] = $identifiants[1];
103        }
104
105        return $description;
106}
107
108/**
109 * Renvoie la description brute d'un type de noisette sans traitement typo ni désérialisation des champs de type
110 * tableau sérialisé.
111 *
112 * Le noiZetier lit la description du type de noisette concerné dans la table `spip_types_noisettes`.
113 *
114 * @package SPIP\NOIZETIER\TYPE_NOISETTE\SERVICE
115 *
116 * @param string $plugin
117 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
118 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
119 * @param string $type_noisette
120 *        Identifiant du type de noisette.
121 *
122 * @return array
123 *        Tableau de la description du type de noisette. Les champs textuels et les champs de type tableau sérialisé
124 *        sont retournés en l'état, le timestamp `maj n'est pas fourni.
125 */
126function noizetier_type_noisette_decrire($plugin, $type_noisette) {
127
128        // Table des types de noisette.
129        $from = 'spip_types_noisettes';
130
131        // Chargement de toute la configuration de la noisette en base de données sauf le timestamp 'maj'.
132        // Les données sont renvoyées brutes sans traitement sur les textes ni les tableaux sérialisés.
133        $trouver_table = charger_fonction('trouver_table', 'base');
134        $table = $trouver_table($from);
135        $select = array_diff(array_keys($table['field']), array('maj'));
136
137        $where = array('plugin=' . sql_quote($plugin), 'type_noisette=' . sql_quote($type_noisette));
138        $description = sql_fetsel($select, $from, $where);
139
140        return $description;
141}
142
143/**
144 * Renvoie l'information brute demandée pour l'ensemble des types de noisette utilisés
145 * ou toute les descriptions si aucune information n'est explicitement demandée.
146 *
147 * @package SPIP\NOIZETIER\TYPE_NOISETTE\SERVICE
148 *
149 * @param string $plugin
150 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
151 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
152 * @param string $information
153 *        Identifiant d'un champ de la description d'un type de noisette.
154 *        Si l'argument est vide, la fonction renvoie les descriptions complètes et si l'argument est
155 *        un champ invalide la fonction renvoie un tableau vide.
156 *
157 * @return array
158 *        Tableau de la forme `[type_noisette] = information ou description complète`. Les champs textuels et
159 *        les champs de type tableau sérialisé sont retournés en l'état, le timestamp `maj n'est pas fourni.
160 */
161function noizetier_type_noisette_lister($plugin, $information = '') {
162
163        // Initialiser le tableau de sortie en cas d'erreur
164        $types_noisettes = array();
165
166        $from = 'spip_types_noisettes';
167        $trouver_table = charger_fonction('trouver_table', 'base');
168        $table = $trouver_table($from);
169        $champs = array_keys($table['field']);
170        if ($information) {
171                // Si une information précise est demandée on vérifie sa validité
172                $information_valide = in_array($information, $champs);
173                $select = array('type_noisette', $information);
174        } else {
175                // Tous les champs sauf le timestamp 'maj' sont renvoyés.
176                $select = array_diff($champs, array('maj'));
177        }
178        $where = array('plugin=' . sql_quote($plugin));
179
180        if ((!$information or ($information and $information_valide))
181        and ($types_noisettes = sql_allfetsel($select, $from, $where))) {
182                if ($information) {
183                        $types_noisettes = array_column($types_noisettes, $information, 'type_noisette');
184                } else {
185                        $types_noisettes = array_column($types_noisettes, null, 'type_noisette');
186                }
187        }
188
189        return $types_noisettes;
190}
191
192/**
193 * Renvoie la configuration par défaut de l'ajax à appliquer pour la compilation des noisettes.
194 * Cette information est utilisée si la description YAML d'un type noisette ne contient pas de tag ajax
195 * ou contient un tag ajax à `defaut`.
196 *
197 * @package SPIP\NOIZETIER\TYPE_NOISETTE\SERVICE
198 *
199 * @param string $plugin
200 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
201 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
202 *
203 * @return bool
204 *              `true` si par défaut un type de noisette est insérée en ajax, `false` sinon.
205 */
206function noizetier_type_noisette_initialiser_ajax($plugin) {
207
208        // La valeur Ajax par défaut est inscrite dans la configuration du plugin.
209        include_spip('inc/config');
210        $defaut_ajax = lire_config("${plugin}/ajax_noisette");
211
212        return $defaut_ajax;
213}
214
215/**
216 * Renvoie la configuration par défaut de l'inclusion à appliquer pour la compilation des noisettes.
217 * Cette information est utilisée si la description YAML d'un type noisette ne contient pas de tag inclusion
218 * ou contient un tag inclusion à `defaut`.
219 *
220 * @package SPIP\NOIZETIER\TYPE_NOISETTE\SERVICE
221 *
222 * @param string $plugin
223 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
224 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
225 *
226 * @return bool
227 *              `true` si par défaut un type noisette est insérée en dynamique, `false` sinon.
228 */
229function noizetier_type_noisette_initialiser_inclusion($plugin) {
230
231        // La valeur d'inclusion dynamique par défaut est inscrite dans la configuration du plugin.
232        include_spip('inc/config');
233        $defaut_inclusion = lire_config("${plugin}/inclusion_dynamique_noisette");
234
235        return $defaut_inclusion;
236}
237
238
239// -----------------------------------------------------------------------
240// ----------------------------- NOISETTES -------------------------------
241// -----------------------------------------------------------------------
242
243/**
244 * Stocke la description d'une nouvelle noisette et calcule son identifiant unique, ou met à jour les paramètres
245 * d'affichage d'une noisette existante.
246 *
247 * @package SPIP\NOIZETIER\NOISETTE\SERVICE
248 *
249 * @param string $plugin
250 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noizetier ou
251 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
252 * @param array  $description
253 *        Description de la noisette. Soit la description ne contient pas l'id de la noisette et c'est un ajout,
254 *        soit la description contient l'id et c'est une mise à jour.
255 *
256 * @return int
257 *        Id de la noisette de type entier ou 0 en cas d'erreur.
258 */
259function noizetier_noisette_stocker($plugin, $description) {
260
261        // Mise à jour en base de données.
262        if (empty($description['id_noisette'])) {
263                // On s'assure que la description contient bien le plugin et alors on insère la nouvelle noisette.
264                $id_noisette = 0;
265                if (isset($description['plugin']) and ($description['plugin'] == $plugin)) {
266                        // Insertion de la nouvelle noisette.
267                        $id_noisette = sql_insertq('spip_noisettes', $description);
268                }
269        } else {
270                // On sauvegarde l'id de la noisette et on le retire de la description pour éviter une erreur à l'update.
271                $id_noisette = intval($description['id_noisette']);
272                unset($description['id_noisette']);
273
274                // Mise à jour de la noisette.
275                $where = array('id_noisette=' . $id_noisette, 'plugin=' . sql_quote($plugin));
276                if (!sql_updateq('spip_noisettes', $description, $where)) {
277                        $id_noisette = 0;
278                }
279        }
280
281        return $id_noisette;
282}
283
284/**
285 * Transfère une noisette d'un conteneur vers un autre à un rang donné.
286 * Le rang destination n'est pas vérifié lors du rangement dans le conteneur destination. Il convient
287 * à l'appelant de vérifier que le rang est libre.
288 * La description complète de la noisette est renvoyée avec mise à jour des champs de positionnement (id_conteneur,
289 * conteneur, rang_noisette et profondeur).
290 *
291 * @param string $plugin
292 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
293 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
294 * @param array  $description
295 *        Description de la noisette à changer de conteneur.
296 * @param string $id_conteneur
297 *        Identifiant unique sous forme de chaine du conteneur destination.
298 * @param int    $rang
299 *        Rang où positionner la noisette dans le conteneur destination. Il faut toujours vérifier au préalable
300 *        que ce rang est libre.
301 * @param int    $profondeur
302 *        Profondeur de la noisette à sa nouvelle position.
303 *
304 * @return array
305 *         Description de la noisette mise à jour avec les informations sur le nouvel emplacement
306 */
307function noizetier_noisette_changer_conteneur($plugin, $description, $id_conteneur, $rang, $profondeur) {
308
309        // On rajoute la description à son emplacement destination en prenant soin de modifier les index id_conteneur,
310        // conteneur et rang_noisette qui doivent représenter le conteneur destination.
311        include_spip('inc/ncore_conteneur');
312        $description['conteneur'] = serialize(conteneur_construire($plugin, $id_conteneur));
313        $description['id_conteneur'] = $id_conteneur;
314        $description['rang_noisette'] = $rang;
315        $description['profondeur'] = $profondeur;
316
317        // On met à jour l'objet en base
318        // On sauvegarde l'id de la noisette et on le retire de la description pour éviter une erreur à l'update.
319        $id_noisette = intval($description['id_noisette']);
320        unset($description['id_noisette']);
321
322        // Mise à jour de la noisette.
323        $where = array('id_noisette=' . $id_noisette, 'plugin=' . sql_quote($plugin));
324        sql_updateq('spip_noisettes', $description, $where);
325
326        // On remet l'ide de la noisette pour renvoyer la description complète
327        $description['id_noisette'] = $id_noisette;
328
329        return $description;
330}
331
332/**
333 * Complète la description fournie avec les champs propres au noiZetier, à savoir, ceux identifiant
334 * la page/composition ou l'objet et le bloc.
335 * On parse le squelette pour identifier les données manquantes.
336 *
337 * @package SPIP\NOIZETIER\NOISETTE\SERVICE
338 *
339 * @param string $plugin
340 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
341 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
342 * @param array  $description
343 *        Description  par défaut de la noisette.
344 *
345 * @return array
346 *        Description de la noisette complétée avec les champs de type de page, composition, bloc et
347 *        de l'objet concerné si cela est le cas. Le champ conteneur est lui supprimé car non stocké en
348 *        base de données.
349 */
350function noizetier_noisette_completer($plugin, $description) {
351
352        if (!empty($description['conteneur'])) {
353                //
354                $complement = array(
355                        'type'        => '',
356                        'composition' => '',
357                        'objet'       => '',
358                        'id_objet'    => 0,
359                        'bloc'        => ''
360                );
361
362                // La description de la noisette contient l'id du conteneur : on le décompose car il contient certains
363                // des champs complémentaires.
364                include_spip('inc/noizetier_conteneur');
365                $id_conteneur = $description['id_conteneur'];
366                $conteneur_etendu = conteneur_noizetier_decomposer($id_conteneur);
367
368                if ($conteneur_etendu) {
369                        // On ajoute les index manquants avec leur valeur par défaut
370                        $conteneur_etendu = array_merge($complement, $conteneur_etendu);
371                        // On filtre les index inutiles comme squelette par exemple.
372                        $complement = array_intersect_key($conteneur_etendu, $complement);
373                }
374
375                // Ajout du complément à la description.
376                $description = array_merge($description, $complement);
377        }
378
379        return $description;
380}
381
382/**
383 * Positionne une noisette à un rang différent que celui qu'elle occupe dans le conteneur.
384 *
385 * @package SPIP\NOIZETIER\NOISETTE\SERVICE
386 *
387 * @param string $plugin
388 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
389 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
390 * @param array  $description
391 *        Description complète de la noisette.
392 * @param int    $rang_destination
393 *        Position à laquelle ranger la noisette au sein du conteneur.
394 *
395 * @return bool
396 *        `true` si le traitement s'est bien déroulé, `false` sinon.
397 */
398function noizetier_noisette_ranger($plugin, $description, $rang_destination) {
399
400        // Initialisation de la sortie.
401        $retour = false;
402
403        if (isset($description['id_noisette']) and ($id = intval($description['id_noisette']))) {
404                $where = array('id_noisette=' . $id, 'plugin=' . sql_quote($plugin));
405                $update = array('rang_noisette' => $rang_destination);
406                if (sql_updateq('spip_noisettes', $update, $where)) {
407                        $retour = true;
408                }
409        }
410
411        return $retour;
412}
413
414/**
415 * Retire, de l'espace de stockage, une noisette donnée de son conteneur.
416 *
417 * @package SPIP\NOIZETIER\NOISETTE\SERVICE
418 *
419 * @param string       $plugin
420 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
421 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
422 * @param array|string $description
423 *        Description complète de la noisette.
424 *
425 * @return bool
426 *        `true` si le traitement s'est bien déroulé, `false` sinon.
427 */
428function noizetier_noisette_destocker($plugin, $description) {
429
430        // Initialisation de la sortie.
431        $retour = false;
432
433        // Calcul de la clause where à partir de l'id du conteneur.
434        if (isset($description['id_noisette'])) {
435                $where = array('id_noisette=' . intval($description['id_noisette']), 'plugin=' . sql_quote($plugin));
436
437                // Suppression de la noisette.
438                if (sql_delete('spip_noisettes', $where)) {
439                        $retour = true;
440                }
441        }
442
443        return $retour;
444}
445
446/**
447 * Renvoie un champ ou toute la description des noisettes d'un conteneur ou de tous les conteneurs.
448 * Le tableau retourné est indexé soit par identifiant de noisette soit par identifiant du conteneur et rang.
449 *
450 * @package SPIP\NOIZETIER\NOISETTE\SERVICE
451 *
452 * @param string $plugin
453 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
454 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
455 * @param array|string $conteneur
456 *        Tableau descriptif du conteneur ou identifiant du conteneur ou vide si on souhaite adresser tous les
457 *        conteneurs.
458 * @param string $information
459 *        Identifiant d'un champ de la description d'une type de noisette.
460 *        Si l'argument est vide, la fonction renvoie les descriptions complètes et si l'argument est
461 *        un champ invalide la fonction renvoie un tableau vide.
462 * @param string $cle
463 *        Champ de la description d'une noisette servant d'index du tableau. En général on utilisera soit `id_noisette`
464 *        soit `rang`.
465 *
466 * @return array
467 *        Tableau de la liste des informations demandées indexé par identifiant de noisette ou par rang.
468 */
469function noizetier_noisette_lister($plugin, $conteneur = array(), $information = '', $cle = 'rang_noisette') {
470
471        // Initialisation du tableau de sortie.
472        $noisettes = array();
473
474        // Construction du where et du order by en fonction du conteneur qui est soit un squelette,
475        // soit un squelette d'un objet donné, soit vide (on veut toutes les noisettes du plugin).
476        $where = array('plugin=' . sql_quote($plugin));
477        if ($conteneur) {
478                // On sélectionne le contenant par son identifiant qui est stocké dans la table.
479                if (is_array($conteneur)) {
480                        include_spip('inc/ncore_conteneur');
481                        $id_conteneur = conteneur_identifier($plugin, $conteneur);
482                } else {
483                        $id_conteneur = $conteneur;
484                }
485                $where[] = array('id_conteneur=' . sql_quote($id_conteneur));
486                $order_by = array('rang_noisette');
487        } else {
488                // On veut toutes les noisettes, on ordonne toujours le tableau résultant par conteneur et par rang dans chaque
489                // conteneur.
490                $order_by = array('id_conteneur', 'rang_noisette');
491        }
492
493        // Construction du select en fonction des informations à retourner.
494        $select = $information ? array_merge(array('id_conteneur', 'rang_noisette', 'id_noisette'), array($information)) : '*';
495
496        if ($table_noisettes = sql_allfetsel($select, 'spip_noisettes', $where, '', $order_by)) {
497                if ($cle == 'rang_noisette') {
498                        // On demande un rangement par rang.
499                        // Il faut tenir compte du fait que la liste est réduite à un conteneur ou pas.
500                        foreach ($table_noisettes as $_noisette) {
501                                if ($conteneur) {
502                                        $noisettes[$_noisette['rang_noisette']] = $information
503                                                ? array($information => $_noisette[$information])
504                                                : $_noisette;
505                                } else {
506                                        $noisettes[$_noisette['id_conteneur']][$_noisette['rang_noisette']] = $information
507                                                ? array($information => $_noisette[$information])
508                                                : $_noisette;
509                                }
510                        }
511                } else {
512                        // On demande un rangement par id_noisette
513                        $noisettes = $information
514                                ? array_column($table_noisettes, $information, 'id_noisette')
515                                : array_column($table_noisettes, null, 'id_noisette');
516                }
517        }
518
519        return $noisettes;
520}
521
522
523/**
524 * Renvoie la description brute d'une noisette sans traitement typo des champs textuels ni désérialisation
525 * des champs de type tableau sérialisé.
526 *
527 * @package SPIP\NOIZETIER\NOISETTE\SERVICE
528 *
529 * @param string $plugin
530 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
531 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
532 * @param mixed  $noisette
533 *        Identifiant de la noisette qui peut prendre soit la forme d'un entier ou d'une chaine unique, soit la forme
534 *        d'un couple (conteneur, rang).
535 *
536 * @return array
537 *        Tableau de la description du type de noisette. Les champs textuels et les champs de type tableau sérialisé
538 *        sont retournés en l'état.
539 */
540function noizetier_noisette_decrire($plugin, $noisette) {
541
542        $description = array();
543
544        $where = array();
545        if (!is_array($noisette)) {
546                // L'identifiant est l'id unique de la noisette. Il faut donc parcourir le tableau pour trouver la
547                // noisette désirée
548                // => C'est la méthode optimale pour le stockage noiZetier.
549                $where[] = 'id_noisette=' . intval($noisette);
550        } elseif (isset($noisette['id_conteneur']) and isset($noisette['rang_noisette'])) {
551                // L'identifiant est un tableau associatif fournissant l'id du conteneur et le rang.
552                $where[] = 'id_conteneur=' . sql_quote($noisette['id_conteneur']);
553                $where[] = 'rang_noisette=' . intval($noisette['rang_noisette']);
554        }
555
556        if ($where) {
557                $where[] = 'plugin=' . sql_quote($plugin);
558                $description = sql_fetsel('*', 'spip_noisettes', $where);
559        }
560
561        return $description;
562}
563
564/**
565 * Renvoie la configuration par défaut de l'encapsulation d'une noisette.
566 * Cette information est utilisée si le champ `encapsulation` de la noisette vaut `defaut`.
567 *
568 * @package SPIP\NOIZETIER\NOISETTE\SERVICE
569 *
570 * @param string $plugin
571 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
572 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
573 *
574 * @return string
575 *              Vaut `on` pour une encapsulation ou chaine vide sinon.
576 */
577function noizetier_noisette_initialiser_encapsulation($plugin) {
578
579        // La capsule par défaut est inscrite dans la configuration du plugin.
580        include_spip('inc/config');
581        $defaut_capsule = lire_config("${plugin}/encapsulation_noisette");
582
583        return $defaut_capsule;
584}
585
586
587// -----------------------------------------------------------------------
588// ----------------------------- CONTENEURS ------------------------------
589// -----------------------------------------------------------------------
590
591/**
592 * Vérifie la conformité des index du tableau représentant le conteneur et supprime les index inutiles, si besoin.
593 * Pour le noiZetier, la vérification concerne uniquement les conteneurs non noisette. Dans ce cas, le conteneur
594 * est toujours un squelette, soit générique soit d'un objet donné.
595 *
596 * @package SPIP\NOIZETIER\CONTENEUR\SERVICE
597 *
598 * @param string $plugin
599 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
600 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
601 * @param array  $conteneur
602 *        Tableau associatif descriptif du conteneur dont les index doivent être vérifiés.
603 *
604 * @return array
605 *         Tableau du conteneur dont tous les index sont conformes (`squelette` et éventuellement `objet`, `id_objet`)
606 *         ou tableau vide si non conforme.
607 */
608function noizetier_conteneur_verifier($plugin, $conteneur) {
609
610        // Liste des index autorisés.
611        static $index_conteneur = array('squelette', 'objet', 'id_objet');
612
613        // On vérifie que les index autorisés sont les seuls retournés.
614        $conteneur_verifie = array();
615        if ($conteneur) {
616                // L'index squelette doit toujours être présent.
617                if ((isset($conteneur['squelette']) and $conteneur['squelette'])) {
618                        $conteneur = array_intersect_key($conteneur, array_flip($index_conteneur));
619                        if ((count($conteneur) == 1)
620                        or ((count($conteneur) == 3)
621                                and isset($conteneur['objet'], $conteneur['id_objet'])
622                                and $conteneur['objet']
623                                and intval($conteneur['id_objet']))) {
624                                // Le conteneur coincide avec un squelette de bloc générique ou d'un objet donné.
625                                $conteneur_verifie = $conteneur;
626                        }
627                }
628        }
629
630        return $conteneur_verifie;
631}
632
633/**
634 * Construit un identifiant unique pour le conteneur de noisettes hors les noisettes conteneur.
635 * Pour le noiZetier, un conteneur est toujours un squelette, soit générique soit d'un objet donné.
636 *
637 * @package SPIP\NOIZETIER\CONTENEUR\SERVICE
638 *
639 * @param string $plugin
640 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
641 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
642 * @param array $conteneur
643 *        Tableau associatif descriptif du conteneur. Pour le noiZetier, les seuls index autorisés sont
644 *        `squelette`, `objet` et `id_objet`.
645 *
646 * @return string
647 *         L'identifiant calculé à partir du tableau.
648 */
649function noizetier_conteneur_identifier($plugin, $conteneur) {
650
651        // On initialise l'identifiant à vide.
652        $id_conteneur = '';
653
654        // Les noisettes conteneur ont été identifiées par N-Core, inutile donc de s'en préoccuper.
655        if ($conteneur) {
656                // Le nom du squelette en premier si il existe (normalement toujours).
657                if (!empty($conteneur['squelette'])) {
658                        $id_conteneur .= $conteneur['squelette'];
659                }
660                // L'objet et son id si on est en présence d'un objet.
661                if (!empty($conteneur['objet']) and !empty($conteneur['id_objet']) and intval($conteneur['id_objet'])) {
662                        $id_conteneur .= ($id_conteneur ? '|' : '') . "{$conteneur['objet']}|{$conteneur['id_objet']}";
663                }
664        }
665
666        return $id_conteneur;
667}
668
669/**
670 * Reconstruit le conteneur sous forme de tableau à partir de son identifiant unique (fonction inverse
671 * de `noizetier_conteneur_identifier`).
672 * N-Core ne fournit le conteneur pour les noisettes conteneur.
673 * Pour les autres conteneurs, c'est au noiZetier de calculer le tableau.
674 *
675 * @package SPIP\NOIZETIER\CONTENEUR\SERVICE
676 *
677 * @param string $plugin
678 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
679 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
680 * @param string $id_conteneur
681 *        Identifiant unique du conteneur.
682 *
683 * @return array
684 *        Tableau représentatif du conteneur ou tableau vide en cas d'erreur.
685 */
686function noizetier_conteneur_construire($plugin, $id_conteneur) {
687
688        // Il faut recomposer le tableau du conteneur à partir de son id.
689        // N-Core s'occupe des noisettes conteneur; le noiZetier n'a donc plus qu'à traiter les autres conteneur,
690        // à savoir ses conteneurs spécifiques.
691        $conteneur = array();
692        if ($id_conteneur) {
693                $elements = explode('|', $id_conteneur);
694                if (count($elements) == 1) {
695                        // C'est une page ou une composition : seul l'index squelette est positionné.
696                        $conteneur['squelette'] = $id_conteneur;
697                } elseif (count($elements) == 3) {
698                        // C'est un objet
699                        // -- le type d'objet et son id
700                        $conteneur['objet'] = $elements[1];
701                        $conteneur['id_objet'] = $elements[2];
702                        // -- le squelette
703                        $conteneur['squelette'] = $elements[0];
704                }
705        }
706
707        return $conteneur;
708}
709
710
711/**
712 * Retire, de l'espace de stockage, toutes les noisettes d'un conteneur.
713 * L'imbrication des conteneurs est gérée dans la fonction de service de N-Core.
714 *
715 * @package SPIP\NOIZETIER\CONTENEUR\SERVICE
716 *
717 * @param string       $plugin
718 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
719 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
720 * @param array|string $conteneur
721 *        Tableau descriptif du conteneur ou identifiant du conteneur.
722 *
723 * @return bool
724 *        `true` si le traitement s'est bien déroulé, `false` sinon.
725 */
726function noizetier_conteneur_destocker($plugin, $conteneur) {
727
728        // Initialisation de la sortie.
729        $retour = false;
730
731        // Calcul de l'id du conteneur en fonction du mode d'appel de la fonction.
732        if (is_array($conteneur)) {
733                include_spip('inc/ncore_conteneur');
734                $id_conteneur = conteneur_identifier($plugin, $conteneur);
735        } else {
736                $id_conteneur = $conteneur;
737        }
738
739        if ($id_conteneur) {
740                // Suppression de toutes les noisettes du conteneur.
741                $where = array('id_conteneur=' . sql_quote($id_conteneur), 'plugin=' . sql_quote($plugin));
742                if (sql_delete('spip_noisettes', $where)) {
743                        $retour = true;
744                }
745        }
746
747        return $retour;
748}
Note: See TracBrowser for help on using the repository browser.