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

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

Permettre d'imbriquer plusieurs niveaux de noisettes de type conteneur (2 max).
Cette limitation sera configurable dans une future version.
Prise en compte de l'imbrication dans la visualisation du privé de la liste des noisettes d'un bloc.
Reste à étendre l'imbrication à la compilation dans le public.

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