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

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

Mise au point des services N-Core du noiZetier avec utilisation systématique de $plugin (parfois redondant).

  • 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                                $squelette = strtolower($conteneur['squelette']);
288
289                                if (!empty($conteneur['objet']) and !empty($conteneur['id_objet']) and ($id = intval($conteneur['id_objet']))) {
290                                        // Objet
291                                        $complement['objet'] = $conteneur['objet'];
292                                        $complement['id_objet'] = $id;
293                                        $complement['bloc'] = $conteneur['squelette'];
294                                } else {
295                                        $page = basename($squelette);
296                                        $identifiants_page = explode('-', $page, 2);
297                                        if (!empty($identifiants_page[1])) {
298                                                // Forcément une composition
299                                                $complement['type'] = $identifiants_page[0];
300                                                $complement['composition'] = $identifiants_page[1];
301                                        } else {
302                                                // Page simple
303                                                $complement['type'] = $identifiants_page[0];
304                                        }
305                                        $bloc = dirname($squelette);
306                                        if ($bloc != '.') {
307                                                $complement['bloc'] = basename($bloc);
308                                        }
309                                }
310                        }
311                }
312
313                // Ajout du complément à la description.
314                $description = array_merge($description, $complement);
315
316                // On supprime l'index 'conteneur' qui n'est pas utile pour le noiZetier qui utilise uniquement les
317                // données de page et d'objet venant d'être ajoutées et l'id du conteneur.
318                unset($description['conteneur']);
319        }
320
321        return $description;
322}
323
324/**
325 * Positionne une noisette à un rang différent que celui qu'elle occupe dans le conteneur.
326 *
327 * @package SPIP\NOIZETIER\NOISETTE\SERVICE
328 *
329 * @param string $plugin
330 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
331 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
332 * @param array  $description
333 *        Description complète de la noisette.
334 * @param int    $rang_destination
335 *        Position à laquelle ranger la noisette au sein du conteneur.
336 *
337 * @return bool
338 *        `true` si le traitement s'est bien déroulé, `false` sinon.
339 */
340function noizetier_noisette_ranger($plugin, $description, $rang_destination) {
341
342        // Initialisation de la sortie.
343        $retour = false;
344
345        if (isset($description['id_noisette']) and ($id = intval($description['id_noisette']))) {
346                $where = array('id_noisette=' . $id, 'plugin=' . sql_quote($plugin));
347                $update = array('rang_noisette' => $rang_destination);
348                if (sql_updateq('spip_noisettes', $update, $where)) {
349                        $retour = true;
350                }
351        }
352
353        return $retour;
354}
355
356/**
357 * Retire, de l'espace de stockage, une noisette donnée de son conteneur.
358 *
359 * @package SPIP\NOIZETIER\NOISETTE\SERVICE
360 *
361 * @param string       $plugin
362 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
363 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
364 * @param array|string $description
365 *        Description complète de la noisette.
366 *
367 * @return bool
368 *        `true` si le traitement s'est bien déroulé, `false` sinon.
369 */
370function noizetier_noisette_destocker($plugin, $description) {
371
372        // Initialisation de la sortie.
373        $retour = false;
374
375        // Calcul de la clause where à partir de l'id du conteneur.
376        if (isset($description['id_noisette'])) {
377                $where = array('id_noisette=' . intval($description['id_noisette']), 'plugin=' . sql_quote($plugin));
378
379                // Suppression de la noisette.
380                if (sql_delete('spip_noisettes', $where)) {
381                        $retour = true;
382                }
383        }
384
385        return $retour;
386}
387
388/**
389 * Renvoie un champ ou toute la description des noisettes d'un conteneur ou de tous les conteneurs.
390 * Le tableau retourné est indexé soit par identifiant de noisette soit par identifiant du conteneur et rang.
391 *
392 * @package SPIP\NOIZETIER\NOISETTE\SERVICE
393 *
394 * @param string $plugin
395 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
396 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
397 * @param array|string $conteneur
398 *        Tableau descriptif du conteneur ou identifiant du conteneur ou vide si on souhaite adresser tous les
399 *        conteneurs.
400 * @param string $information
401 *        Identifiant d'un champ de la description d'une type de noisette.
402 *        Si l'argument est vide, la fonction renvoie les descriptions complètes et si l'argument est
403 *        un champ invalide la fonction renvoie un tableau vide.
404 * @param string $cle
405 *        Champ de la description d'une noisette servant d'index du tableau. En général on utilisera soit `id_noisette`
406 *        soit `rang`.
407 *
408 * @return array
409 *        Tableau de la liste des informations demandées indexé par identifiant de noisette ou par rang.
410 */
411function noizetier_noisette_lister($plugin, $conteneur = array(), $information = '', $cle = 'rang_noisette') {
412
413        // Initialisation du tableau de sortie.
414        $noisettes = array();
415
416        // Construction du where et du order by en fonction du conteneur qui est soit un squelette,
417        // soit un squelette d'un objet donné, soit vide (on veut toutes les noisettes du plugin).
418        $where = array('plugin=' . sql_quote($plugin));
419        if ($conteneur) {
420                // On sélectionne le contenant par son identifiant qui est stocké dans la table.
421                if (is_array($conteneur)) {
422                        $id_conteneur = noizetier_conteneur_identifier($plugin, $conteneur);
423                } else {
424                        $id_conteneur = $conteneur;
425                }
426                $where[] = array('id_conteneur=' . sql_quote($id_conteneur));
427                $order_by = array('rang_noisette');
428        } else {
429                // On veut toutes les noisettes, on ordonne toujours le tableau résultant par conteneur et par rang dans chaque
430                // conteneur.
431                $order_by = array('id_conteneur', 'rang_noisette');
432        }
433
434        // Construction du select en fonction des informations à retourner.
435        $select = $information ? array_merge(array('id_conteneur', 'rang_noisette', 'id_noisette'), array($information)) : '*';
436
437        if ($table_noisettes = sql_allfetsel($select, 'spip_noisettes', $where, '', $order_by)) {
438                if ($cle == 'rang_noisette') {
439                        // On demande un rangement par rang.
440                        // Il faut tenir compte du fait que la liste est réduite à un conteneur ou pas.
441                        foreach ($table_noisettes as $_noisette) {
442                                if ($conteneur) {
443                                        $noisettes[$_noisette['rang_noisette']] = $information
444                                                ? array($information => $_noisette[$information])
445                                                : $_noisette;
446                                } else {
447                                        $noisettes[$_noisette['id_conteneur']][$_noisette['rang_noisette']] = $information
448                                                ? array($information => $_noisette[$information])
449                                                : $_noisette;
450                                }
451                        }
452                } else {
453                        // On demande un rangement par id_noisette
454                        $noisettes = $information
455                                ? array_column($table_noisettes, $information, 'id_noisette')
456                                : array_column($table_noisettes, null, 'id_noisette');
457                }
458        }
459
460        return $noisettes;
461}
462
463
464/**
465 * Renvoie la description brute d'une noisette sans traitement typo des champs textuels ni désérialisation
466 * des champs de type tableau sérialisé.
467 *
468 * @package SPIP\NOIZETIER\NOISETTE\SERVICE
469 *
470 * @param string $plugin
471 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
472 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
473 * @param mixed  $noisette
474 *        Identifiant de la noisette qui peut prendre soit la forme d'un entier ou d'une chaine unique, soit la forme
475 *        d'un couple (conteneur, rang).
476 *
477 * @return array
478 *        Tableau de la description du type de noisette. Les champs textuels et les champs de type tableau sérialisé
479 *        sont retournés en l'état.
480 */
481function noizetier_noisette_decrire($plugin, $noisette) {
482
483        $description = array();
484
485        $where = array('plugin=' . sql_quote($plugin));
486        if (!is_array($noisette)) {
487                // L'identifiant est l'id unique de la noisette. Il faut donc parcourir le tableau pour trouver la
488                // noisette désirée
489                // => C'est la méthode optimale pour le stockage noiZetier.
490                $where[] = 'id_noisette=' . intval($noisette);
491        } elseif (isset($noisette['id_conteneur']) and isset($noisette['rang_noisette'])) {
492                // L'identifiant est un tableau associatif fournissant l'id du conteneur et le rang.
493                $where[] = 'id_conteneur=' . sql_quote($noisette['id_conteneur']);
494                $where[] = 'rang_noisette=' . intval($noisette['rang_noisette']);
495        }
496
497        if ($where) {
498                $description = sql_fetsel('*', 'spip_noisettes', $where);
499        }
500
501        return $description;
502}
503
504
505// -----------------------------------------------------------------------
506// ----------------------------- CONTENEURS ------------------------------
507// -----------------------------------------------------------------------
508
509/**
510 * Construit un identifiant unique pour le conteneur de noisettes.
511 * Pour le noiZetier, un conteneur est toujours un squelette, soit générique soit d'un objet donné ou
512 * une noisette de type conteneur.
513 *
514 * @package SPIP\NOIZETIER\CONTENEUR\SERVICE
515 *
516 * @param string $plugin
517 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
518 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
519 * @param array $conteneur
520 *        Tableau associatif descriptif du conteneur accueillant la noisette. Un conteneur peut-être un squelette seul
521 *        ou associé à un contexte d'utilisation et dans ce cas il possède un index `squelette` ou un objet quelconque
522 *        sans lien avec un squelette. Dans tous les cas, les index, à l'exception de `squelette`, sont spécifiques
523 *        à l'utilisation qui en est faite par le plugin.
524 *
525 * @return string
526 */
527function noizetier_conteneur_identifier($plugin, $conteneur) {
528
529        // On initialise l'identifiant à vide.
530        $identifiant = '';
531
532        if ($conteneur) {
533                // Cas d'une noisette conteneur.
534                if (!empty($conteneur['type_noisette']) and intval($conteneur['id_noisette'])) {
535                        $identifiant = $conteneur['type_noisette'] . '|noisette|' . $conteneur['id_noisette'];
536                } else {
537                        // Le nom du squelette en premier si il existe (normalement toujours).
538                        if (!empty($conteneur['squelette'])) {
539                                $identifiant .= $conteneur['squelette'];
540                        }
541
542                        // L'objet et son id si on est en présence d'un objet.
543                        if (!empty($conteneur['objet']) and !empty($conteneur['id_objet']) and intval($conteneur['id_objet'])) {
544                                $identifiant .= ($identifiant ? '|' : '') . "{$conteneur['objet']}|{$conteneur['id_objet']}";
545                        }
546                }
547        }
548
549        return $identifiant;
550}
551
552
553/**
554 * Retire, de l'espace de stockage, toutes les noisettes d'un conteneur.
555 * L'imbrication des conteneurs est gérée dans la fonction de service de N-Core.
556 *
557 * @package SPIP\NOIZETIER\CONTENEUR\SERVICE
558 *
559 * @param string       $plugin
560 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
561 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
562 * @param array|string $conteneur
563 *        Tableau descriptif du conteneur ou identifiant du conteneur.
564 *
565 * @return bool
566 *        `true` si le traitement s'est bien déroulé, `false` sinon.
567 */
568function noizetier_conteneur_destocker($plugin, $conteneur) {
569
570        // Initialisation de la sortie.
571        $retour = false;
572
573        // Calcul de l'id du conteneur en fonction du mode d'appel de la fonction.
574        if (is_array($conteneur)) {
575                $id_conteneur = noizetier_conteneur_identifier($plugin, $conteneur);
576        } else {
577                $id_conteneur = $conteneur;
578        }
579
580        if ($id_conteneur) {
581                // Suppression de toutes les noisettes du conteneur.
582                $where = array('id_conteneur=' . sql_quote($id_conteneur), 'plugin=' . sql_quote($plugin));
583                if (sql_delete('spip_noisettes', $where)) {
584                        $retour = true;
585                }
586        }
587
588        return $retour;
589}
Note: See TracBrowser for help on using the repository browser.