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

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

Mise en cohérence du noiZetier avec le dernier commit de N-Core.
On peut donc supprimer la fonction de service qui renvoie le dossier des types de noisettes car c'est le même que N-Core.

  • Property svn:eol-style set to native
File size: 22.3 KB
Line 
1<?php
2
3if (!defined('_ECRIRE_INC_VERSION')) {
4        return;
5}
6
7// -----------------------------------------------------------------------
8// ------------------------- TYPES DE NOISETTE ---------------------------
9// -----------------------------------------------------------------------
10
11/**
12 * Stocke les descriptions des types de noisette en distinguant les types de noisette obsolètes, les types de
13 * noisettes modifiés et les types de noisettes nouveaux.
14 * Chaque description de type de noisette est un tableau associatif dont tous les index possibles - y compris
15 * la signature - sont initialisés quelque soit le contenu du fichier YAML.
16 *
17 * Les types de noisettes sont stockés dans la table `spip_types_noisettes`.
18 *
19 * @package SPIP\NOIZETIER\TYPE_NOISETTE\SERVICE
20 *
21 * @param string $plugin
22 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
23 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
24 * @param array  $types_noisettes
25 *        Tableau associatif à 3 entrées fournissant les descriptions des types de noisettes nouveaux, obsolètes
26 *        et modifiés:
27 *        `a_effacer` : liste des identifiants de type de noisette devenus obsolètes.
28 *        `a_changer` : liste des descriptions des types de noisette dont le fichier YAML a été modifié.
29 *        `a_ajouter` : liste des descriptions des nouveaux types de noisette.
30 *        Si $recharger est à `true`, seul l'index `nouvelles` est fourni dans le tableau $types_noisette.
31 * @param bool   $recharger
32 *        Indique si le chargement en cours est forcé ou pas. Cela permet à la fonction N-Core ou au service
33 *        concerné d'optimiser le traitement sachant que seules les types de noisette nouveaux sont fournis.
34 *
35 * @return bool
36 *        `true` si le traitement s'est bien déroulé, `false` sinon.
37 */
38function noizetier_type_noisette_stocker($plugin, $types_noisettes, $recharger) {
39
40        $retour = true;
41
42        // Mise à jour de la table des noisettes 'spip_types_noisettes'.
43        $from = 'spip_types_noisettes';
44
45        // -- Suppression des 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// -----------------------------------------------------------------------
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                // Insertion de la nouvelle noisette.
217                $id_noisette = sql_insertq('spip_noisettes', $description);
218        } else {
219                // On sauvegarde l'id de la noisette et on le retire de la description pour éviter une erreur à l'update.
220                $id_noisette = intval($description['id_noisette']);
221                unset($description['id_noisette']);
222
223                // Mise à jour de la noisette.
224                $where = array('id_noisette=' . $id_noisette);
225                if (!sql_updateq('spip_noisettes', $description, $where)) {
226                        $id_noisette = 0;
227                }
228        }
229
230        if ($id_noisette) {
231                // On invalide le cache si le stockage a fonctionné.
232                include_spip('inc/invalideur');
233                suivre_invalideur("id='noisette/$id_noisette'");
234        }
235
236        return $id_noisette;
237}
238
239/**
240 * Complète la description fournie avec les champs propres au noiZetier, à savoir, ceux identifiant
241 * la page/composition ou l'objet et le bloc.
242 * On parse le squelette pour identifier les données manquantes.
243 *
244 * @package SPIP\NOIZETIER\NOISETTE\SERVICE
245 *
246 * @param string $plugin
247 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
248 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
249 * @param array  $description
250 *        Description  par défaut de la noisette.
251 *
252 * @return array
253 *        Description de la noisette complétée avec les champs de type de page, composition, bloc et
254 *        de l'objet concerné si cela est le cas. Le champ conteneur est lui supprimé car non stocké en
255 *        base de données.
256 */
257function noizetier_noisette_completer($plugin, $description) {
258
259        if (!empty($description['conteneur'])) {
260                //
261                $complement = array(
262                        'type'        => '',
263                        'composition' => '',
264                        'objet'       => '',
265                        'id_objet'    => 0,
266                        'bloc'        => ''
267                );
268
269                // On desérialise le conteneur et après on traite les compléments.
270                $conteneur = unserialize($description['conteneur']);
271
272                // Détermination du complément en fonction du fait que le conteneur soit une noisette ou pas.
273                if (!empty($conteneur['id_noisette']) and ($id_noisette = intval($conteneur['id_noisette']))) {
274                        // -- si le conteneur est une noisette on récupère les informations de son conteneur qui ne l'est forcément
275                        //    pas (limitation à 1 niveau d'imbrication de noisettes).
276                        $select = array_keys($complement);
277                        $where = array('id_noisette=' . $id_noisette);
278                        $complement = sql_fetsel($select, 'spip_noisettes', $where);
279                } else {
280                        // -- si le conteneur n'est pas une noisette, le complément se déduit du conteneur lui-même.
281                        if (!empty($conteneur['squelette'])) {
282                                $squelette = strtolower($conteneur['squelette']);
283
284                                if (!empty($conteneur['objet']) and !empty($conteneur['id_objet']) and ($id = intval($conteneur['id_objet']))) {
285                                        // Objet
286                                        $complement['objet'] = $conteneur['objet'];
287                                        $complement['id_objet'] = $id;
288                                        $complement['bloc'] = $conteneur['squelette'];
289                                } else {
290                                        $page = basename($squelette);
291                                        $identifiants_page = explode('-', $page, 2);
292                                        if (!empty($identifiants_page[1])) {
293                                                // Forcément une composition
294                                                $complement['type'] = $identifiants_page[0];
295                                                $complement['composition'] = $identifiants_page[1];
296                                        } else {
297                                                // Page simple
298                                                $complement['type'] = $identifiants_page[0];
299                                        }
300                                        $bloc = dirname($squelette);
301                                        if ($bloc != '.') {
302                                                $complement['bloc'] = basename($bloc);
303                                        }
304                                }
305                        }
306                }
307
308                // Ajout du complément à la description.
309                $description = array_merge($description, $complement);
310
311                // On supprime l'index 'conteneur' qui n'est pas utile pour le noiZetier qui utilise uniquement les
312                // données de page et d'objet venant d'être ajoutées et l'id du conteneur.
313                unset($description['conteneur']);
314        }
315
316        return $description;
317}
318
319/**
320 * Positionne une noisette à un rang différent que celui qu'elle occupe dans le conteneur.
321 *
322 * @package SPIP\NOIZETIER\NOISETTE\SERVICE
323 *
324 * @param string $plugin
325 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
326 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
327 * @param array  $description
328 *        Description complète de la noisette.
329 * @param int    $rang_destination
330 *        Position à laquelle ranger la noisette au sein du conteneur.
331 *
332 * @return bool
333 *        `true` si le traitement s'est bien déroulé, `false` sinon.
334 */
335function noizetier_noisette_ranger($plugin, $description, $rang_destination) {
336
337        // Initialisation de la sortie.
338        $retour = false;
339
340        if (isset($description['id_noisette']) and ($id = intval($description['id_noisette']))) {
341                $where = array('id_noisette=' . $id);
342                $update = array('rang_noisette' => $rang_destination);
343                if (sql_updateq('spip_noisettes', $update, $where)) {
344                        $retour = true;
345                }
346        }
347
348        return $retour;
349}
350
351/**
352 * Retire, de l'espace de stockage, une noisette donnée de son conteneur.
353 *
354 * @package SPIP\NOIZETIER\NOISETTE\SERVICE
355 *
356 * @param string       $plugin
357 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
358 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
359 * @param array|string $description
360 *        Description complète de la noisette.
361 *
362 * @return bool
363 *        `true` si le traitement s'est bien déroulé, `false` sinon.
364 */
365function noizetier_noisette_destocker($plugin, $description) {
366
367        // Initialisation de la sortie.
368        $retour = false;
369
370        // Calcul de la clause where à partir de l'id du conteneur.
371        if (isset($description['id_noisette'])) {
372                $where = array('id_noisette=' . intval($description['id_noisette']));
373
374                // Suppression de la noisette.
375                if (sql_delete('spip_noisettes', $where)) {
376                        $retour = true;
377                }
378        }
379
380        return $retour;
381}
382
383/**
384 * Renvoie un champ ou toute la description des noisettes d'un conteneur ou de tous les conteneurs.
385 * Le tableau retourné est indexé soit par identifiant de noisette soit par identifiant du conteneur et rang.
386 *
387 * @package SPIP\NOIZETIER\NOISETTE\SERVICE
388 *
389 * @param string $plugin
390 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
391 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
392 * @param array|string $conteneur
393 *        Tableau descriptif du conteneur ou identifiant du conteneur ou vide si on souhaite adresser tous les
394 *        conteneurs.
395 * @param string $information
396 *        Identifiant d'un champ de la description d'une type de noisette.
397 *        Si l'argument est vide, la fonction renvoie les descriptions complètes et si l'argument est
398 *        un champ invalide la fonction renvoie un tableau vide.
399 * @param string $cle
400 *        Champ de la description d'une noisette servant d'index du tableau. En général on utilisera soit `id_noisette`
401 *        soit `rang`.
402 *
403 * @return array
404 *        Tableau de la liste des informations demandées indexé par identifiant de noisette ou par rang.
405 */
406function noizetier_noisette_lister($plugin, $conteneur = array(), $information = '', $cle = 'rang_noisette') {
407
408        // Initialisation du tableau de sortie.
409        $noisettes = array();
410
411        // Construction du where et du order by en fonction du conteneur qui est soit un squelette,
412        // soit un squelette d'un objet donné, soit vide (on veut toutes les noisettes du plugin).
413        $where = array('plugin=' . sql_quote($plugin));
414        if ($conteneur) {
415                // On sélectionne le contenant par son identifiant qui est stocké dans la table.
416                if (is_array($conteneur)) {
417                        $id_conteneur = noizetier_conteneur_identifier($plugin, $conteneur);
418                } else {
419                        $id_conteneur = $conteneur;
420                }
421                $where[] = array('id_conteneur=' . sql_quote($id_conteneur));
422                $order_by = array('rang_noisette');
423        } else {
424                // On veut toutes les noisettes, on ordonne toujours le tableau résultant par conteneur et par rang dans chaque
425                // conteneur.
426                $order_by = array('id_conteneur', 'rang_noisette');
427        }
428
429        // Construction du select en fonction des informations à retourner.
430        $select = $information ? array_merge(array('id_conteneur', 'rang_noisette', 'id_noisette'), array($information)) : '*';
431
432        if ($table_noisettes = sql_allfetsel($select, 'spip_noisettes', $where, '', $order_by)) {
433                if ($cle == 'rang_noisette') {
434                        // On demande un rangement par rang.
435                        // Il faut tenir compte du fait que la liste est réduite à un conteneur ou pas.
436                        foreach ($table_noisettes as $_noisette) {
437                                if ($conteneur) {
438                                        $noisettes[$_noisette['rang_noisette']] = $information
439                                                ? array($information => $_noisette[$information])
440                                                : $_noisette;
441                                } else {
442                                        $noisettes[$_noisette['id_conteneur']][$_noisette['rang_noisette']] = $information
443                                                ? array($information => $_noisette[$information])
444                                                : $_noisette;
445                                }
446                        }
447                } else {
448                        // On demande un rangement par id_noisette
449                        $noisettes = $information
450                                ? array_column($table_noisettes, $information, 'id_noisette')
451                                : array_column($table_noisettes, null, 'id_noisette');
452                }
453        }
454
455        return $noisettes;
456}
457
458
459/**
460 * Renvoie la description brute d'une noisette sans traitement typo des champs textuels ni désérialisation
461 * des champs de type tableau sérialisé.
462 *
463 * @package SPIP\NOIZETIER\NOISETTE\SERVICE
464 *
465 * @param string $plugin
466 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
467 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
468 * @param mixed  $noisette
469 *        Identifiant de la noisette qui peut prendre soit la forme d'un entier ou d'une chaine unique, soit la forme
470 *        d'un couple (conteneur, rang).
471 *
472 * @return array
473 *        Tableau de la description du type de noisette. Les champs textuels et les champs de type tableau sérialisé
474 *        sont retournés en l'état.
475 */
476function noizetier_noisette_decrire($plugin, $noisette) {
477
478        $description = array();
479
480        if (!is_array($noisette)) {
481                // L'identifiant est l'id unique de la noisette. Il faut donc parcourir le tableau pour trouver la
482                // noisette désirée
483                // => C'est la méthode optimale pour le stockage noiZetier.
484                $where = array('id_noisette=' . intval($noisette));
485        } elseif (isset($noisette['id_conteneur']) and isset($noisette['rang_noisette'])) {
486                // L'identifiant est un tableau associatif fournissant l'id du conteneur et le rang.
487                $where = array('id_conteneur=' . sql_quote($noisette['id_conteneur']), 'rang_noisette=' . intval($noisette['rang_noisette']));
488        } else {
489                $where = array();
490        }
491
492        if ($where) {
493                $description = sql_fetsel('*', 'spip_noisettes', $where);
494        }
495
496        return $description;
497}
498
499
500// -----------------------------------------------------------------------
501// ----------------------------- CONTENEURS ------------------------------
502// -----------------------------------------------------------------------
503
504/**
505 * Construit un identifiant unique pour le conteneur de noisettes.
506 * Pour le noiZetier, un conteneur est toujours un squelette, soit générique soit d'un objet donné ou
507 * une noisette de type conteneur.
508 *
509 * @package SPIP\NOIZETIER\CONTENEUR\SERVICE
510 *
511 * @param string $plugin
512 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
513 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
514 * @param array $conteneur
515 *        Tableau associatif descriptif du conteneur accueillant la noisette. Un conteneur peut-être un squelette seul
516 *        ou associé à un contexte d'utilisation et dans ce cas il possède un index `squelette` ou un objet quelconque
517 *        sans lien avec un squelette. Dans tous les cas, les index, à l'exception de `squelette`, sont spécifiques
518 *        à l'utilisation qui en est faite par le plugin.
519 *
520 * @return string
521 */
522function noizetier_conteneur_identifier($plugin, $conteneur) {
523
524        // On initialise l'identifiant à vide.
525        $identifiant = '';
526
527        if ($conteneur) {
528                // Cas d'une noisette conteneur.
529                if (!empty($conteneur['type_noisette']) and intval($conteneur['id_noisette'])) {
530                        $identifiant = $conteneur['type_noisette'] . '|noisette|' . $conteneur['id_noisette'];
531                } else {
532                        // Le nom du squelette en premier si il existe (normalement toujours).
533                        if (!empty($conteneur['squelette'])) {
534                                $identifiant .= $conteneur['squelette'];
535                        }
536
537                        // L'objet et son id si on est en présence d'un objet.
538                        if (!empty($conteneur['objet']) and !empty($conteneur['id_objet']) and intval($conteneur['id_objet'])) {
539                                $identifiant .= ($identifiant ? '|' : '') . "{$conteneur['objet']}|{$conteneur['id_objet']}";
540                        }
541                }
542        }
543
544        return $identifiant;
545}
546
547
548/**
549 * Retire, de l'espace de stockage, toutes les noisettes d'un conteneur.
550 * L'imbrication des conteneurs est gérée dans la fonction de service de N-Core.
551 *
552 * @package SPIP\NOIZETIER\CONTENEUR\SERVICE
553 *
554 * @param string       $plugin
555 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
556 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
557 * @param array|string $conteneur
558 *        Tableau descriptif du conteneur ou identifiant du conteneur.
559 *
560 * @return bool
561 *        `true` si le traitement s'est bien déroulé, `false` sinon.
562 */
563function noizetier_conteneur_destocker($plugin, $conteneur) {
564
565        // Initialisation de la sortie.
566        $retour = false;
567
568        // Calcul de l'id du conteneur en fonction du mode d'appel de la fonction.
569        if (is_array($conteneur)) {
570                $id_conteneur = noizetier_conteneur_identifier($plugin, $conteneur);
571        } else {
572                $id_conteneur = $conteneur;
573        }
574
575        if ($id_conteneur) {
576                // Suppression de toutes les noisettes du conteneur.
577                $where = array('id_conteneur=' . sql_quote($id_conteneur));
578                if (sql_delete('spip_noisettes', $where)) {
579                        $retour = true;
580                }
581        }
582
583        return $retour;
584}
Note: See TracBrowser for help on using the repository browser.