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

Last change on this file since 112698 was 112698, checked in by eric@…, 2 years ago

Adaptation du noizetier à la dernière version de N-Core (encapsulation).
Tout n'est pas fonctionnel, il manque encore :

  • un problème de détection de l'input radio balise_noisette dans la config du noizetier (bug Saisies ???)
  • la prise en compte du mode d'encapsulation auto pour cacher la config balise_noisette et la suppression des saisies balise et css dans l'edition d'une noisette.

A tester.

  • Property svn:eol-style set to native
File size: 24.3 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 `nouvelles` 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 éventuellement complétée par le plugin utilisateur.
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 ou `signature`.
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        $from = 'spip_types_noisettes';
164        $where = array('plugin=' . sql_quote($plugin));
165        if ($information) {
166                $select = array('type_noisette', $information);
167        } else {
168                // Tous les champs sauf le timestamp 'maj' sont renvoyés.
169                $trouver_table = charger_fonction('trouver_table', 'base');
170                $table = $trouver_table($from);
171                $select = array_diff(array_keys($table['field']), array('maj'));
172        }
173        if ($types_noisettes = sql_allfetsel($select, $from, $where)) {
174                if ($information) {
175                        $types_noisettes = array_column($types_noisettes, $information, 'type_noisette');
176                } else {
177                        $types_noisettes = array_column($types_noisettes, null, 'type_noisette');
178                }
179        }
180
181        return $types_noisettes;
182}
183
184/**
185 * Renvoie la configuration par défaut de l'ajax à appliquer pour la compilation des noisettes.
186 * Cette information est utilisée si la description YAML d'un type noisette ne contient pas de tag ajax
187 * ou contient un tag ajax à `defaut`.
188 *
189 * @package SPIP\NOIZETIER\TYPE_NOISETTE\SERVICE
190 *
191 * @param string $plugin
192 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
193 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
194 *
195 * @return bool
196 *              `true` si par défaut une noisette est insérée en ajax, `false` sinon.
197 */
198function noizetier_type_noisette_initialiser_ajax($plugin) {
199
200        // La valeur Ajax par défaut est inscrite dans la configuration du plugin.
201        include_spip('inc/config');
202        $defaut_ajax = lire_config("${plugin}/ajax_noisette");
203
204        return $defaut_ajax;
205}
206
207
208// -----------------------------------------------------------------------
209// ----------------------------- NOISETTES -------------------------------
210// -----------------------------------------------------------------------
211
212/**
213 * Stocke la description d'une nouvelle noisette et calcule son identifiant unique, ou met à jour les paramètres
214 * d'affichage d'une noisette existante.
215 *
216 * @package SPIP\NOIZETIER\NOISETTE\SERVICE
217 *
218 * @param string $plugin
219 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noizetier ou
220 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
221 * @param array  $description
222 *        Description de la noisette. Soit la description ne contient pas l'id de la noisette et c'est un ajout,
223 *        soit la description contient l'id et c'est une mise à jour.
224 *
225 * @return int
226 *        Id de la noisette de type entier ou 0 en cas d'erreur.
227 */
228function noizetier_noisette_stocker($plugin, $description) {
229
230        // Mise à jour en base de données.
231        if (empty($description['id_noisette'])) {
232                // On s'assure que la description contient bien le plugin et alors on insère la nouvelle noisette.
233                $id_noisette = 0;
234                if (isset($description['plugin']) and ($description['plugin'] == $plugin)) {
235                        // Insertion de la nouvelle noisette.
236                        $id_noisette = sql_insertq('spip_noisettes', $description);
237                }
238        } else {
239                // On sauvegarde l'id de la noisette et on le retire de la description pour éviter une erreur à l'update.
240                $id_noisette = intval($description['id_noisette']);
241                unset($description['id_noisette']);
242
243                // Mise à jour de la noisette.
244                $where = array('id_noisette=' . $id_noisette, 'plugin=' . sql_quote($plugin));
245                if (!sql_updateq('spip_noisettes', $description, $where)) {
246                        $id_noisette = 0;
247                }
248        }
249
250        if ($id_noisette) {
251                // On invalide le cache si le stockage a fonctionné.
252                include_spip('inc/invalideur');
253                suivre_invalideur("id='noisette/$id_noisette'");
254        }
255
256        return $id_noisette;
257}
258
259/**
260 * Complète la description fournie avec les champs propres au noiZetier, à savoir, ceux identifiant
261 * la page/composition ou l'objet et le bloc.
262 * On parse le squelette pour identifier les données manquantes.
263 *
264 * @package SPIP\NOIZETIER\NOISETTE\SERVICE
265 *
266 * @param string $plugin
267 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
268 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
269 * @param array  $description
270 *        Description  par défaut de la noisette.
271 *
272 * @return array
273 *        Description de la noisette complétée avec les champs de type de page, composition, bloc et
274 *        de l'objet concerné si cela est le cas. Le champ conteneur est lui supprimé car non stocké en
275 *        base de données.
276 */
277function noizetier_noisette_completer($plugin, $description) {
278
279        if (!empty($description['conteneur'])) {
280                //
281                $complement = array(
282                        'type'        => '',
283                        'composition' => '',
284                        'objet'       => '',
285                        'id_objet'    => 0,
286                        'bloc'        => ''
287                );
288
289                // On desérialise le conteneur et après on traite les compléments.
290                $conteneur = unserialize($description['conteneur']);
291
292                // Détermination du complément en fonction du fait que le conteneur soit une noisette ou pas.
293                if (!empty($conteneur['id_noisette']) and ($id_noisette = intval($conteneur['id_noisette']))) {
294                        // -- si le conteneur est une noisette on récupère les informations de son conteneur. Comme les noisettes
295                        //    sont insérées par niveau on duplique forcément les informations du bloc supérieur à chaque imbrication.
296                        //    Il est donc inutile de remonter au bloc racine.
297                        $select = array_keys($complement);
298                        $where = array('id_noisette=' . $id_noisette, 'plugin=' . sql_quote($plugin));
299                        $complement = sql_fetsel($select, 'spip_noisettes', $where);
300                } else {
301                        // -- si le conteneur n'est pas une noisette, le complément se déduit du conteneur lui-même.
302                        if (!empty($conteneur['squelette'])) {
303                                list($bloc, ) = explode('/', $conteneur['squelette']);
304                                if (!empty($conteneur['objet']) and !empty($conteneur['id_objet']) and ($id = intval($conteneur['id_objet']))) {
305                                        // Objet
306                                        $complement['objet'] = $conteneur['objet'];
307                                        $complement['id_objet'] = $id;
308                                        $complement['bloc'] = isset($conteneur['bloc']) ? $conteneur['bloc'] : $bloc;
309                                } else {
310                                        $squelette = strtolower($conteneur['squelette']);
311                                        $page = basename($squelette);
312                                        $identifiants_page = explode('-', $page, 2);
313                                        if (!empty($identifiants_page[1])) {
314                                                // Forcément une composition
315                                                $complement['type'] = $identifiants_page[0];
316                                                $complement['composition'] = $identifiants_page[1];
317                                        } else {
318                                                // Page simple
319                                                $complement['type'] = $identifiants_page[0];
320                                        }
321                                        $complement['bloc'] = isset($conteneur['bloc']) ? $conteneur['bloc'] : $bloc;
322                                }
323                        }
324                }
325
326                // Ajout du complément à la description.
327                $description = array_merge($description, $complement);
328
329                // On supprime l'index 'conteneur' qui n'est pas utile pour le noiZetier qui utilise uniquement les
330                // données de page et d'objet venant d'être ajoutées et l'id du conteneur.
331                unset($description['conteneur']);
332        }
333
334        return $description;
335}
336
337/**
338 * Positionne une noisette à un rang différent que celui qu'elle occupe dans le conteneur.
339 *
340 * @package SPIP\NOIZETIER\NOISETTE\SERVICE
341 *
342 * @param string $plugin
343 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
344 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
345 * @param array  $description
346 *        Description complète de la noisette.
347 * @param int    $rang_destination
348 *        Position à laquelle ranger la noisette au sein du conteneur.
349 *
350 * @return bool
351 *        `true` si le traitement s'est bien déroulé, `false` sinon.
352 */
353function noizetier_noisette_ranger($plugin, $description, $rang_destination) {
354
355        // Initialisation de la sortie.
356        $retour = false;
357
358        if (isset($description['id_noisette']) and ($id = intval($description['id_noisette']))) {
359                $where = array('id_noisette=' . $id, 'plugin=' . sql_quote($plugin));
360                $update = array('rang_noisette' => $rang_destination);
361                if (sql_updateq('spip_noisettes', $update, $where)) {
362                        $retour = true;
363                }
364        }
365
366        return $retour;
367}
368
369/**
370 * Retire, de l'espace de stockage, une noisette donnée de son conteneur.
371 *
372 * @package SPIP\NOIZETIER\NOISETTE\SERVICE
373 *
374 * @param string       $plugin
375 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
376 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
377 * @param array|string $description
378 *        Description complète de la noisette.
379 *
380 * @return bool
381 *        `true` si le traitement s'est bien déroulé, `false` sinon.
382 */
383function noizetier_noisette_destocker($plugin, $description) {
384
385        // Initialisation de la sortie.
386        $retour = false;
387
388        // Calcul de la clause where à partir de l'id du conteneur.
389        if (isset($description['id_noisette'])) {
390                $where = array('id_noisette=' . intval($description['id_noisette']), 'plugin=' . sql_quote($plugin));
391
392                // Suppression de la noisette.
393                if (sql_delete('spip_noisettes', $where)) {
394                        $retour = true;
395                }
396        }
397
398        return $retour;
399}
400
401/**
402 * Renvoie un champ ou toute la description des noisettes d'un conteneur ou de tous les conteneurs.
403 * Le tableau retourné est indexé soit par identifiant de noisette soit par identifiant du conteneur et rang.
404 *
405 * @package SPIP\NOIZETIER\NOISETTE\SERVICE
406 *
407 * @param string $plugin
408 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
409 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
410 * @param array|string $conteneur
411 *        Tableau descriptif du conteneur ou identifiant du conteneur ou vide si on souhaite adresser tous les
412 *        conteneurs.
413 * @param string $information
414 *        Identifiant d'un champ de la description d'une type de noisette.
415 *        Si l'argument est vide, la fonction renvoie les descriptions complètes et si l'argument est
416 *        un champ invalide la fonction renvoie un tableau vide.
417 * @param string $cle
418 *        Champ de la description d'une noisette servant d'index du tableau. En général on utilisera soit `id_noisette`
419 *        soit `rang`.
420 *
421 * @return array
422 *        Tableau de la liste des informations demandées indexé par identifiant de noisette ou par rang.
423 */
424function noizetier_noisette_lister($plugin, $conteneur = array(), $information = '', $cle = 'rang_noisette') {
425
426        // Initialisation du tableau de sortie.
427        $noisettes = array();
428
429        // Construction du where et du order by en fonction du conteneur qui est soit un squelette,
430        // soit un squelette d'un objet donné, soit vide (on veut toutes les noisettes du plugin).
431        $where = array('plugin=' . sql_quote($plugin));
432        if ($conteneur) {
433                // On sélectionne le contenant par son identifiant qui est stocké dans la table.
434                if (is_array($conteneur)) {
435                        $id_conteneur = noizetier_conteneur_identifier($plugin, $conteneur);
436                } else {
437                        $id_conteneur = $conteneur;
438                }
439                $where[] = array('id_conteneur=' . sql_quote($id_conteneur));
440                $order_by = array('rang_noisette');
441        } else {
442                // On veut toutes les noisettes, on ordonne toujours le tableau résultant par conteneur et par rang dans chaque
443                // conteneur.
444                $order_by = array('id_conteneur', 'rang_noisette');
445        }
446
447        // Construction du select en fonction des informations à retourner.
448        $select = $information ? array_merge(array('id_conteneur', 'rang_noisette', 'id_noisette'), array($information)) : '*';
449
450        if ($table_noisettes = sql_allfetsel($select, 'spip_noisettes', $where, '', $order_by)) {
451                if ($cle == 'rang_noisette') {
452                        // On demande un rangement par rang.
453                        // Il faut tenir compte du fait que la liste est réduite à un conteneur ou pas.
454                        foreach ($table_noisettes as $_noisette) {
455                                if ($conteneur) {
456                                        $noisettes[$_noisette['rang_noisette']] = $information
457                                                ? array($information => $_noisette[$information])
458                                                : $_noisette;
459                                } else {
460                                        $noisettes[$_noisette['id_conteneur']][$_noisette['rang_noisette']] = $information
461                                                ? array($information => $_noisette[$information])
462                                                : $_noisette;
463                                }
464                        }
465                } else {
466                        // On demande un rangement par id_noisette
467                        $noisettes = $information
468                                ? array_column($table_noisettes, $information, 'id_noisette')
469                                : array_column($table_noisettes, null, 'id_noisette');
470                }
471        }
472
473        return $noisettes;
474}
475
476
477/**
478 * Renvoie la description brute d'une noisette sans traitement typo des champs textuels ni désérialisation
479 * des champs de type tableau sérialisé.
480 *
481 * @package SPIP\NOIZETIER\NOISETTE\SERVICE
482 *
483 * @param string $plugin
484 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
485 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
486 * @param mixed  $noisette
487 *        Identifiant de la noisette qui peut prendre soit la forme d'un entier ou d'une chaine unique, soit la forme
488 *        d'un couple (conteneur, rang).
489 *
490 * @return array
491 *        Tableau de la description du type de noisette. Les champs textuels et les champs de type tableau sérialisé
492 *        sont retournés en l'état.
493 */
494function noizetier_noisette_decrire($plugin, $noisette) {
495
496        $description = array();
497
498        $where = array('plugin=' . sql_quote($plugin));
499        if (!is_array($noisette)) {
500                // L'identifiant est l'id unique de la noisette. Il faut donc parcourir le tableau pour trouver la
501                // noisette désirée
502                // => C'est la méthode optimale pour le stockage noiZetier.
503                $where[] = 'id_noisette=' . intval($noisette);
504        } elseif (isset($noisette['id_conteneur']) and isset($noisette['rang_noisette'])) {
505                // L'identifiant est un tableau associatif fournissant l'id du conteneur et le rang.
506                $where[] = 'id_conteneur=' . sql_quote($noisette['id_conteneur']);
507                $where[] = 'rang_noisette=' . intval($noisette['rang_noisette']);
508        }
509
510        if ($where) {
511                $description = sql_fetsel('*', 'spip_noisettes', $where);
512        }
513
514        return $description;
515}
516
517/**
518 * Renvoie la configuration par défaut de l'encapsulation d'une noisette en mode non auto.
519 * Cette information est utilisée si le mode d'encapsulation est manuel et si le champ `balise` de la noisette
520 * vaut `defaut`.
521 *
522 * @package SPIP\NOIZETIER\NOISETTE\SERVICE
523 *
524 * @uses ncore_chercher_service()
525 *
526 * @param string $plugin
527 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
528 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
529 *
530 * @return string
531 *              Capsule par defaut qui peut valoir `div` ou `aucune`.
532 */
533function noizetier_noisette_initialiser_capsule($plugin) {
534
535        // La capsule par défaut est inscrite dans la configuration du plugin.
536        include_spip('inc/config');
537        $defaut_capsule = lire_config("${plugin}/balise_noisette");
538
539        return $defaut_capsule;
540}
541
542
543// -----------------------------------------------------------------------
544// ----------------------------- CONTENEURS ------------------------------
545// -----------------------------------------------------------------------
546
547/**
548 * Construit un identifiant unique pour le conteneur de noisettes.
549 * Pour le noiZetier, un conteneur est toujours un squelette, soit générique soit d'un objet donné ou
550 * une noisette de type conteneur.
551 *
552 * @package SPIP\NOIZETIER\CONTENEUR\SERVICE
553 *
554 * @param string $plugin
555 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
556 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
557 * @param array $conteneur
558 *        Tableau associatif descriptif du conteneur accueillant la noisette. Un conteneur peut-être un squelette seul
559 *        ou associé à un contexte d'utilisation et dans ce cas il possède un index `squelette` ou un objet quelconque
560 *        sans lien avec un squelette. Dans tous les cas, les index, à l'exception de `squelette`, sont spécifiques
561 *        à l'utilisation qui en est faite par le plugin.
562 *
563 * @return string
564 */
565function noizetier_conteneur_identifier($plugin, $conteneur) {
566
567        // On initialise l'identifiant à vide.
568        $identifiant = '';
569
570        if ($conteneur) {
571                // Cas d'une noisette conteneur.
572                if (!empty($conteneur['type_noisette']) and intval($conteneur['id_noisette'])) {
573                        $identifiant = $conteneur['type_noisette'] . '|noisette|' . $conteneur['id_noisette'];
574                } else {
575                        // Le nom du squelette en premier si il existe (normalement toujours).
576                        if (!empty($conteneur['squelette'])) {
577                                $identifiant .= $conteneur['squelette'];
578                        }
579
580                        // L'objet et son id si on est en présence d'un objet.
581                        if (!empty($conteneur['objet']) and !empty($conteneur['id_objet']) and intval($conteneur['id_objet'])) {
582                                $identifiant .= ($identifiant ? '|' : '') . "{$conteneur['objet']}|{$conteneur['id_objet']}";
583                        }
584                }
585        }
586
587        return $identifiant;
588}
589
590
591/**
592 * Retire, de l'espace de stockage, toutes les noisettes d'un conteneur.
593 * L'imbrication des conteneurs est gérée dans la fonction de service de N-Core.
594 *
595 * @package SPIP\NOIZETIER\CONTENEUR\SERVICE
596 *
597 * @param string       $plugin
598 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
599 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
600 * @param array|string $conteneur
601 *        Tableau descriptif du conteneur ou identifiant du conteneur.
602 *
603 * @return bool
604 *        `true` si le traitement s'est bien déroulé, `false` sinon.
605 */
606function noizetier_conteneur_destocker($plugin, $conteneur) {
607
608        // Initialisation de la sortie.
609        $retour = false;
610
611        // Calcul de l'id du conteneur en fonction du mode d'appel de la fonction.
612        if (is_array($conteneur)) {
613                $id_conteneur = noizetier_conteneur_identifier($plugin, $conteneur);
614        } else {
615                $id_conteneur = $conteneur;
616        }
617
618        if ($id_conteneur) {
619                // Suppression de toutes les noisettes du conteneur.
620                $where = array('id_conteneur=' . sql_quote($id_conteneur), 'plugin=' . sql_quote($plugin));
621                if (sql_delete('spip_noisettes', $where)) {
622                        $retour = true;
623                }
624        }
625
626        return $retour;
627}
Note: See TracBrowser for help on using the repository browser.