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

Last change on this file since 110333 was 110333, checked in by eric@…, 11 months ago

Renommage dans l'API des blocs.
Mise au point de l'API des objets.
Correction des fonctions réversibles de composition/décomposition des conteneurs pour le cas des objets.

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