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

Last change on this file since 110247 was 110247, checked in by eric@…, 12 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
RevLine 
[105818]1<?php
2
3if (!defined('_ECRIRE_INC_VERSION')) {
4        return;
5}
6
[107205]7// -----------------------------------------------------------------------
8// ------------------------- TYPES DE NOISETTE ---------------------------
9// -----------------------------------------------------------------------
10
[107341]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 *
[109831]17 * Les types de noisettes sont stockés dans la table `spip_types_noisettes`.
[107341]18 *
[110110]19 * @package SPIP\NOIZETIER\TYPE_NOISETTE\SERVICE
[107341]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.
[109996]24 * @param array  $types_noisettes
[107341]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 */
[105818]38function noizetier_type_noisette_stocker($plugin, $types_noisettes, $recharger) {
39
40        $retour = true;
41
[109831]42        // Mise à jour de la table des noisettes 'spip_types_noisettes'.
43        $from = 'spip_types_noisettes';
[105818]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'])) {
[109831]54                $where[] = sql_in('type_noisette', $types_noisettes['a_effacer']);
[105818]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
[107341]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 *
[110110]77 * @package SPIP\NOIZETIER\TYPE_NOISETTE\SERVICE
[107341]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 */
[107205]89function noizetier_type_noisette_completer($plugin, $description) {
[105930]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'] = '';
[109831]97        $identifiants = explode('-', $description['type_noisette']);
[105930]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}
[107205]107
[107341]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 *
[109831]112 * Le noiZetier lit la description du type de noisette concerné dans la table `spip_types_noisettes`.
[107341]113 *
[110110]114 * @package SPIP\NOIZETIER\TYPE_NOISETTE\SERVICE
[107341]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 */
[109996]126function noizetier_type_noisette_decrire($plugin, $type_noisette) {
[105818]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.
[109996]130        $where = array('plugin=' . sql_quote($plugin), 'type_noisette=' . sql_quote($type_noisette));
[109831]131        $description = sql_fetsel('*', 'spip_types_noisettes', $where);
[105818]132
133        return $description;
134}
135
[107341]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 *
[110110]140 * @package SPIP\NOIZETIER\TYPE_NOISETTE\SERVICE
[107341]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
[109907]151 *        Tableau de la forme `[type_noisette] = information ou description complète`.
[107341]152 */
[105874]153function noizetier_type_noisette_lister($plugin, $information = '') {
[105818]154
[105874]155        $where = array('plugin=' . sql_quote($plugin));
[109831]156        $select = $information ? array('type_noisette', $information) : '*';
157        if ($info_noisettes = sql_allfetsel($select, 'spip_types_noisettes', $where)) {
[105874]158                if ($information) {
[109831]159                        $info_noisettes = array_column($info_noisettes, $information, 'type_noisette');
[105874]160                } else {
[109831]161                        $info_noisettes = array_column($info_noisettes, null, 'type_noisette');
[105818]162                }
163        }
164
165        return $info_noisettes;
166}
167
[109907]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 *
[110110]173 * @package SPIP\NOIZETIER\TYPE_NOISETTE\SERVICE
[109907]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) {
[105818]183
[109907]184        // La valeur Ajax par défaut est inscrite dans la configuration du plugin.
185        include_spip('inc/config');
[110247]186        $defaut_ajax = lire_config("${plugin}/ajax_noisette");
[109907]187
188        return $defaut_ajax;
189}
190
191
[107205]192// -----------------------------------------------------------------------
193// ----------------------------- NOISETTES -------------------------------
194// -----------------------------------------------------------------------
[105818]195
[106404]196/**
[107341]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.
[106404]199 *
[110110]200 * @package SPIP\NOIZETIER\NOISETTE\SERVICE
[106404]201 *
202 * @param string $plugin
[110066]203 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noizetier ou
[107341]204 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
[106404]205 * @param array  $description
[107341]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.
[106404]208 *
209 * @return int
[107341]210 *        Id de la noisette de type entier ou 0 en cas d'erreur.
[106404]211 */
212function noizetier_noisette_stocker($plugin, $description) {
[105874]213
214        // Mise à jour en base de données.
[106404]215        if (empty($description['id_noisette'])) {
[110247]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                }
[106404]222        } else {
[105874]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
[107341]227                // Mise à jour de la noisette.
[110247]228                $where = array('id_noisette=' . $id_noisette, 'plugin=' . sql_quote($plugin));
[109831]229                if (!sql_updateq('spip_noisettes', $description, $where)) {
[105874]230                        $id_noisette = 0;
231                }
232        }
233
[106439]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
[105874]240        return $id_noisette;
241}
242
[106404]243/**
[109831]244 * Complète la description fournie avec les champs propres au noiZetier, à savoir, ceux identifiant
[107341]245 * la page/composition ou l'objet et le bloc.
246 * On parse le squelette pour identifier les données manquantes.
[106404]247 *
[110110]248 * @package SPIP\NOIZETIER\NOISETTE\SERVICE
[106404]249 *
250 * @param string $plugin
[107341]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.
[106404]253 * @param array  $description
[107341]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
[110066]273                // On desérialise le conteneur et après on traite les compléments.
[107341]274                $conteneur = unserialize($description['conteneur']);
275
[110066]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']))) {
[110247]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.
[110066]281                        $select = array_keys($complement);
[110247]282                        $where = array('id_noisette=' . $id_noisette, 'plugin=' . sql_quote($plugin));
[110066]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']);
[107632]288
[110066]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'];
[107341]294                                } else {
[110066]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                                        }
[107341]309                                }
310                        }
[110066]311                }
[107341]312
[110066]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']);
[107341]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 *
[110110]327 * @package SPIP\NOIZETIER\NOISETTE\SERVICE
[107341]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.
[106404]334 * @param int    $rang_destination
[107341]335 *        Position à laquelle ranger la noisette au sein du conteneur.
[106404]336 *
337 * @return bool
[107341]338 *        `true` si le traitement s'est bien déroulé, `false` sinon.
[106404]339 */
[106422]340function noizetier_noisette_ranger($plugin, $description, $rang_destination) {
[106404]341
342        // Initialisation de la sortie.
[107341]343        $retour = false;
[106404]344
[107341]345        if (isset($description['id_noisette']) and ($id = intval($description['id_noisette']))) {
[110247]346                $where = array('id_noisette=' . $id, 'plugin=' . sql_quote($plugin));
[109831]347                $update = array('rang_noisette' => $rang_destination);
348                if (sql_updateq('spip_noisettes', $update, $where)) {
[107341]349                        $retour = true;
350                }
[106404]351        }
352
353        return $retour;
354}
355
356/**
[107341]357 * Retire, de l'espace de stockage, une noisette donnée de son conteneur.
[106404]358 *
[110110]359 * @package SPIP\NOIZETIER\NOISETTE\SERVICE
[106404]360 *
[107341]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.
[106404]366 *
367 * @return bool
[107341]368 *        `true` si le traitement s'est bien déroulé, `false` sinon.
[106404]369 */
[106422]370function noizetier_noisette_destocker($plugin, $description) {
[106404]371
372        // Initialisation de la sortie.
[107341]373        $retour = false;
[106404]374
[107341]375        // Calcul de la clause where à partir de l'id du conteneur.
376        if (isset($description['id_noisette'])) {
[110247]377                $where = array('id_noisette=' . intval($description['id_noisette']), 'plugin=' . sql_quote($plugin));
[106439]378
[107341]379                // Suppression de la noisette.
[109831]380                if (sql_delete('spip_noisettes', $where)) {
[107341]381                        $retour = true;
382                }
[106404]383        }
384
385        return $retour;
386}
387
[107341]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 *
[110110]392 * @package SPIP\NOIZETIER\NOISETTE\SERVICE
[107341]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 */
[109831]411function noizetier_noisette_lister($plugin, $conteneur = array(), $information = '', $cle = 'rang_noisette') {
[106404]412
413        // Initialisation du tableau de sortie.
414        $noisettes = array();
415
[107341]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).
[106404]418        $where = array('plugin=' . sql_quote($plugin));
[107341]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));
[109831]427                $order_by = array('rang_noisette');
[107341]428        } else {
429                // On veut toutes les noisettes, on ordonne toujours le tableau résultant par conteneur et par rang dans chaque
430                // conteneur.
[109831]431                $order_by = array('id_conteneur', 'rang_noisette');
[106404]432        }
433
[107341]434        // Construction du select en fonction des informations à retourner.
[109831]435        $select = $information ? array_merge(array('id_conteneur', 'rang_noisette', 'id_noisette'), array($information)) : '*';
[107341]436
[109831]437        if ($table_noisettes = sql_allfetsel($select, 'spip_noisettes', $where, '', $order_by)) {
438                if ($cle == 'rang_noisette') {
[106404]439                        // On demande un rangement par rang.
[107341]440                        // Il faut tenir compte du fait que la liste est réduite à un conteneur ou pas.
[106404]441                        foreach ($table_noisettes as $_noisette) {
[107341]442                                if ($conteneur) {
[109831]443                                        $noisettes[$_noisette['rang_noisette']] = $information
[106404]444                                                ? array($information => $_noisette[$information])
445                                                : $_noisette;
446                                } else {
[109831]447                                        $noisettes[$_noisette['id_conteneur']][$_noisette['rang_noisette']] = $information
[106404]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
[107341]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 *
[110110]468 * @package SPIP\NOIZETIER\NOISETTE\SERVICE
[107341]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 */
[106422]481function noizetier_noisette_decrire($plugin, $noisette) {
[106404]482
483        $description = array();
484
[110247]485        $where = array('plugin=' . sql_quote($plugin));
[106404]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.
[110247]490                $where[] = 'id_noisette=' . intval($noisette);
[109831]491        } elseif (isset($noisette['id_conteneur']) and isset($noisette['rang_noisette'])) {
[107341]492                // L'identifiant est un tableau associatif fournissant l'id du conteneur et le rang.
[110247]493                $where[] = 'id_conteneur=' . sql_quote($noisette['id_conteneur']);
494                $where[] = 'rang_noisette=' . intval($noisette['rang_noisette']);
[106404]495        }
496
497        if ($where) {
[109831]498                $description = sql_fetsel('*', 'spip_noisettes', $where);
[106404]499        }
500
501        return $description;
502}
503
504
[107341]505// -----------------------------------------------------------------------
506// ----------------------------- CONTENEURS ------------------------------
507// -----------------------------------------------------------------------
[106404]508
[107341]509/**
510 * Construit un identifiant unique pour le conteneur de noisettes.
[110110]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.
[107341]513 *
[110110]514 * @package SPIP\NOIZETIER\CONTENEUR\SERVICE
[107341]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) {
[105818]528
[107341]529        // On initialise l'identifiant à vide.
530        $identifiant = '';
[105818]531
[107341]532        if ($conteneur) {
[110066]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                        }
[107341]541
[110066]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                        }
[107341]546                }
547        }
548
549        return $identifiant;
[105818]550}
[105874]551
552
[107341]553/**
554 * Retire, de l'espace de stockage, toutes les noisettes d'un conteneur.
[110216]555 * L'imbrication des conteneurs est gérée dans la fonction de service de N-Core.
[107341]556 *
[110110]557 * @package SPIP\NOIZETIER\CONTENEUR\SERVICE
[107341]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) {
[105874]569
[107341]570        // Initialisation de la sortie.
571        $retour = false;
[105874]572
[107341]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        }
[105874]579
[107341]580        if ($id_conteneur) {
581                // Suppression de toutes les noisettes du conteneur.
[110247]582                $where = array('id_conteneur=' . sql_quote($id_conteneur), 'plugin=' . sql_quote($plugin));
[109831]583                if (sql_delete('spip_noisettes', $where)) {
[107341]584                        $retour = true;
[105874]585                }
586        }
587
[107341]588        return $retour;
589}
Note: See TracBrowser for help on using the repository browser.