Changeset 113409 in spip-zone


Ignore:
Timestamp:
Jan 13, 2019, 7:25:04 PM (5 weeks ago)
Author:
root
Message:

On robustifie le traitement des retours de fonction de l'API noisette.
La fonction noisette_ajouter() permet de passer le conteneur en id ou en tableau comme toutes les autres fonctions.
Ajout de la fonction noisette_dupliquer() qui gère la récursivité si la noisette est un conteneur.

Location:
_plugins_/n-core/trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/n-core/trunk/inc/ncore_noisette.php

    r113143 r113409  
    1717 * @api
    1818 * @uses type_noisette_lire()
     19 * @uses ncore_conteneur_verifier()
     20 * @uses ncore_conteneur_identifier()
    1921 * @uses ncore_noisette_completer()
    2022 * @uses ncore_noisette_lister()
     
    2830 *        Identifiant du type de noisette à ajouter au squelette.
    2931 * @param array  $conteneur
    30  *        Tableau associatif descriptif du conteneur accueillant la noisette. Un conteneur peut-être un squelette seul
    31  *        ou associé à un contexte d'utilisation et dans ce cas il possède un index `squelette` ou un objet quelconque
    32  *        sans lien avec un squelette. Dans tous les cas, les index, à l'exception de `squelette`, sont spécifiques
    33  *        à l'utilisation qui en est faite par le plugin.
    34  * @param int    $rang
     32 *        Identifiant du conteneur accueillant la noisette qui prend soit la forme d'un tableau soit celui d'un id.
     33* @param int    $rang
    3534 *        Rang dans le squelette contextualisé où insérer la noisette. Si l'argument n'est pas fourni ou est égal à 0
    3635 *        on insère la noisette en fin de bloc.
     
    6766                include_spip('ncore/ncore');
    6867
     68                // Suivant que le conteneur est passé au format tableau ou id on complète les deux identifiants
     69                $id_conteneur = '';
     70                if (is_array($conteneur)) {
     71                        // -- Vérification des index du conteneur.
     72                        $conteneur = ncore_conteneur_verifier($plugin, $conteneur, $stockage);
     73                        // -- Calcul de l'id
     74                        if ($conteneur) {
     75                                $id_conteneur = ncore_conteneur_identifier($plugin, $conteneur, $stockage);
     76                        }
     77                } elseif (is_string($conteneur)) {
     78                        $id_conteneur = $conteneur;
     79                }
     80
    6981                // On initialise la description de la noisette à ajouter et en particulier on stocke le tableau et l'id du
    7082                // conteneur pour simplifier les traitements par la suite.
    71                 // -- Vérification des index du conteneur.
    72                 $conteneur = ncore_conteneur_verifier($plugin, $conteneur, $stockage);
    73                 if ($conteneur) {
    74                         // -- Calculer l'identifiant du conteneur
    75                         $id_conteneur = ncore_conteneur_identifier($plugin, $conteneur, $stockage);
     83                if ($id_conteneur) {
    7684                        // -- Initialisation par défaut
    7785                        $description = array(
     
    169177
    170178        // Initialisation du retour
    171         $retour = false;
     179        $noisette_parametree = false;
    172180
    173181        // On charge les services de N-Core.
     
    201209
    202210                // La description est prête à être stockée en remplacement de l'existante.
    203                 if ($id_noisette = ncore_noisette_stocker($plugin, $description, $stockage)) {
    204                         $retour = true;
     211                if (ncore_noisette_stocker($plugin, $description, $stockage)) {
     212                        $noisette_parametree = true;
    205213                }
    206214        }
    207215
    208         return $retour;
     216        return $noisette_parametree;
    209217}
    210218
     
    236244
    237245        // Initialisation du retour
    238         $retour = true;
     246        $noisette_supprimee = false;
    239247
    240248        // On charge les services de N-Core.
     
    255263                // Si la noisette est de type conteneur, il faut d'abord vider le conteneur qu'elle représente
    256264                // et ce de façon récursive. La récursivité est gérée par la fonction de service ncore_conteneur_destocker().
     265                $conteneur_destocke = true;
    257266                if ($description['est_conteneur'] == 'oui') {
    258267                        // Inutile de redéfinir un conteneur car la description de la noisette contient les deux champs
    259268                        // essentiels, à savoir, type_noisette et id_noisette.
    260                         ncore_conteneur_destocker($plugin, $description, $stockage);
    261                 }
     269                        $conteneur_destocke = ncore_conteneur_destocker($plugin, $description, $stockage);
     270                }
     271
    262272                // Suppression de la noisette. On passe la description complète ce qui permet à la fonction de
    263273                // destockage de choisir la méthode d'identification la plus adaptée.
    264                 ncore_noisette_destocker($plugin, $description, $stockage);
    265 
    266                 // On récupère les noisettes restant affectées au conteneur sous la forme d'un tableau indexé par rang.
    267                 $autres_noisettes = ncore_noisette_lister(
    268                         $plugin,
    269                         $description['id_conteneur'],
    270                         '',
    271                         'rang_noisette',
    272                         $stockage
    273                 );
    274 
    275                 // Si il reste des noisettes, on tasse d'un rang les noisettes qui suivaient la noisette supprimée.
    276                 if ($autres_noisettes) {
    277                         // On lit les noisettes restantes dans l'ordre décroissant pour éviter d'écraser une noisette.
    278                         ksort($autres_noisettes);
    279                         foreach ($autres_noisettes as $_rang => $_autre_description) {
    280                                 if ($_rang > $description['rang_noisette']) {
    281                                         ncore_noisette_ranger($plugin, $_autre_description, $_autre_description['rang_noisette'] - 1, $stockage);
    282                                 }
    283                         }
     274                if ($conteneur_destocke and ncore_noisette_destocker($plugin, $description, $stockage)) {
     275                        // On récupère les noisettes restant affectées au conteneur sous la forme d'un tableau indexé par rang.
     276                        $autres_noisettes = ncore_noisette_lister(
     277                                $plugin,
     278                                $description['id_conteneur'],
     279                                '',
     280                                'rang_noisette',
     281                                $stockage
     282                        );
     283
     284                        // Si il reste des noisettes, on tasse d'un rang les noisettes qui suivaient la noisette supprimée.
     285                        if ($autres_noisettes) {
     286                                // On lit les noisettes restantes dans l'ordre décroissant pour éviter d'écraser une noisette.
     287                                ksort($autres_noisettes);
     288                                foreach ($autres_noisettes as $_rang => $_autre_description) {
     289                                        if ($_rang > $description['rang_noisette']) {
     290                                                ncore_noisette_ranger($plugin, $_autre_description, $_autre_description['rang_noisette'] - 1, $stockage);
     291                                        }
     292                                }
     293                        }
     294
     295                        $noisette_supprimee = true;
    284296                }
    285297        }
    286298
    287         return $retour;
     299        return $noisette_supprimee;
    288300}
    289301
     
    324336
    325337        // Initialisation de la description en sortie.
    326         $retour = array();
     338        $noisette_lue = array();
    327339
    328340        if (!empty($noisette) and (is_string($noisette) or is_numeric($noisette) or is_array($noisette))) {
     
    372384                                        or (is_array($noisette)
    373385                                                and isset($description_noisette_par_rang[$plugin][$noisette['id_conteneur']][$noisette['rang_noisette']][$information]))) {
    374                                         $retour = is_array($noisette)
     386                                        $noisette_lue = is_array($noisette)
    375387                                                ? $description_noisette_par_rang[$plugin][$noisette['id_conteneur']][$noisette['rang_noisette']][$information]
    376388                                                : $description_noisette_par_id[$plugin][$noisette][$information];
    377389                                } else {
    378                                         $retour = '';
     390                                        $noisette_lue = '';
    379391                                }
    380392                        } else {
    381                                 $retour = is_array($noisette)
     393                                $noisette_lue = is_array($noisette)
    382394                                        ? $description_noisette_par_rang[$plugin][$noisette['id_conteneur']][$noisette['rang_noisette']]
    383395                                        : $description_noisette_par_id[$plugin][$noisette];
     
    386398        }
    387399
    388         return $retour;
     400        return $noisette_lue;
    389401}
    390402
     
    416428 *
    417429 * @return bool
     430 *         Renvoie `false` si la noisette n'est pas déplacée à cause d'une erreur de traitement ou parce que le
     431 *         rang destination est identique au rang origine, sinon `true`.
    418432 */
    419433function noisette_deplacer($plugin, $noisette, $conteneur_destination, $rang_destination, $stockage = '') {
    420434
    421435        // Initialisation du retour
    422         $retour = true;
     436        $noisette_deplacee = false;
    423437
    424438        // On charge les services de N-Core.
     
    438452
    439453                // On détermine l'id du conteneur destination en fonction du mode d'identification fourni par l'argument.
     454                $id_conteneur_destination = '';
    440455                if (is_array($conteneur_destination)) {
     456                        // -- Vérification des index du conteneur.
    441457                        $conteneur_destination = ncore_conteneur_verifier($plugin, $conteneur_destination, $stockage);
    442                         $id_conteneur_destination = ncore_conteneur_identifier(
    443                                 $plugin,
    444                                 $conteneur_destination,
    445                                 $stockage
    446                         );
    447                 } else {
     458                        // -- Calcul de l'id
     459                        if ($conteneur_destination) {
     460                                $id_conteneur_destination = ncore_conteneur_identifier(
     461                                        $plugin,
     462                                        $conteneur_destination,
     463                                        $stockage
     464                                );
     465                        }
     466                } elseif (is_string($conteneur_destination)) {
    448467                        $id_conteneur_destination = $conteneur_destination;
    449468                }
     
    452471                // transférer la noisette en fin du conteneur destination, ce qui est toujours possible.
    453472                // Ensuite on tasse le conteneur d'origine.
    454                 if ($id_conteneur_destination != $id_conteneur_origine) {
    455                         // On recherche le dernier rang utilisé dans le conteneur destination et on se positionne après.
    456                         $rangs = ncore_noisette_lister(
    457                                 $plugin,
    458                                 $id_conteneur_destination,
    459                                 'rang_noisette',
    460                                 'id_noisette',
    461                                 $stockage
    462                         );
    463                         $rang_conteneur_destination = $rangs ? max($rangs) + 1 : 1;
    464 
    465                         // Pour éviter que chaque plugin ait à gérer la profondeur, N-Core calcule la profondeur de la noisette à son
    466                         // nouvel emplacement avant de déplacer celle-ci et la fournit à la fonction de changement de conteneur.
    467                         if (!is_array($conteneur_destination)) {
    468                                 $conteneur_destination = ncore_conteneur_construire($plugin, $id_conteneur_destination, $stockage);
    469                         }
    470                         if (ncore_conteneur_est_noisette($plugin, $conteneur_destination, $stockage)) {
    471                                 $description_conteneur = ncore_noisette_decrire($plugin, $conteneur_destination['id_noisette'], $stockage);
    472                                 $profondeur_destination = $description_conteneur['profondeur'] + 1;
    473                         } else {
    474                                 $profondeur_destination = 0;
    475                         }
    476 
    477                         // On transfère la noisette vers le conteneur destination à la position calculée (max + 1).
    478                         $description = ncore_noisette_changer_conteneur(
    479                                 $plugin,
    480                                 $description,
    481                                 $id_conteneur_destination,
    482                                 $rang_conteneur_destination,
    483                                 $profondeur_destination,
    484                                 $stockage
    485                         );
    486 
    487                         // Il faut maintenant tasser les noisettes du conteneur d'origine qui a perdu une noisette.
    488                         // -- On récupère les noisettes restant affectées au conteneur origine sous la forme d'un tableau
    489                         //    indexé par rang.
    490                         $autres_noisettes = ncore_noisette_lister(
    491                                 $plugin,
    492                                 $id_conteneur_origine,
    493                                 '',
    494                                 'rang_noisette',
    495                                 $stockage
    496                         );
    497 
    498                         // Si il reste des noisettes, on tasse d'un rang les noisettes qui suivaient la noisette supprimée.
    499                         if ($autres_noisettes) {
    500                                 // On lit les noisettes restantes dans l'ordre décroissant pour éviter d'écraser une noisette.
    501                                 ksort($autres_noisettes);
    502                                 foreach ($autres_noisettes as $_rang => $_autre_description) {
    503                                         if ($_rang > $rang_origine) {
    504                                                 ncore_noisette_ranger($plugin, $_autre_description, $_autre_description['rang_noisette'] - 1, $stockage);
    505                                         }
    506                                 }
    507                         }
    508 
    509                         // Le rang origine devient donc le nouveau rang de la noisette dans le conteneur destination.
    510                         $rang_origine = $description['rang_noisette'];
    511                 }
    512 
    513                 // A partir de là, le déplacement est un déplacement à l'intérieur d'un conteneur.
    514                 // Si les rangs origine et destination sont identiques on ne fait rien !
    515                 if ($rang_destination != $rang_origine) {
    516                         // On récupère les noisettes affectées au même conteneur sous la forme d'un tableau indexé par le rang.
    517                         $noisettes = ncore_noisette_lister(
    518                                 $plugin,
    519                                 $description['id_conteneur'],
    520                                 '',
    521                                 'rang_noisette',
    522                                 $stockage
    523                         );
    524 
    525                         // On vérifie que le rang destination est bien compris entre 1 et le rang max, sinon on le force à l'une
    526                         // des bornes.
    527                         $rang_destination = max(1, $rang_destination);
    528                         $rang_max = $noisettes ? max(array_keys($noisettes)) : 0;
    529                         $rang_destination = min($rang_max, $rang_destination);
    530 
    531                         // Suivant la position d'origine et de destination de la noisette déplacée on trie les noisettes
    532                         // du conteneur.
    533                         if ($rang_destination < $rang_origine) {
    534                                 krsort($noisettes);
    535                         } else {
    536                                 ksort($noisettes);
    537                         }
    538 
    539                         // On déplace les noisettes impactées à l'exception de la noisette concernée par le déplacement
    540                         // afin de créer une position libre.
    541                         foreach ($noisettes as $_rang => $_description) {
     473                if ($id_conteneur_destination) {
     474                        if ($id_conteneur_destination != $id_conteneur_origine) {
     475                                // On recherche le dernier rang utilisé dans le conteneur destination et on se positionne après.
     476                                $rangs = ncore_noisette_lister(
     477                                        $plugin,
     478                                        $id_conteneur_destination,
     479                                        'rang_noisette',
     480                                        'id_noisette',
     481                                        $stockage
     482                                );
     483                                $rang_conteneur_destination = $rangs ? max($rangs) + 1 : 1;
     484
     485                                // Pour éviter que chaque plugin ait à gérer la profondeur, N-Core calcule la profondeur de la noisette à son
     486                                // nouvel emplacement avant de déplacer celle-ci et la fournit à la fonction de changement de conteneur.
     487                                if (!is_array($conteneur_destination)) {
     488                                        $conteneur_destination = ncore_conteneur_construire($plugin, $id_conteneur_destination, $stockage);
     489                                }
     490                                if (ncore_conteneur_est_noisette($plugin, $conteneur_destination, $stockage)) {
     491                                        $description_conteneur = ncore_noisette_decrire($plugin, $conteneur_destination['id_noisette'], $stockage);
     492                                        $profondeur_destination = $description_conteneur['profondeur'] + 1;
     493                                } else {
     494                                        $profondeur_destination = 0;
     495                                }
     496
     497                                // On transfère la noisette vers le conteneur destination à la position calculée (max + 1).
     498                                $description = ncore_noisette_changer_conteneur(
     499                                        $plugin,
     500                                        $description,
     501                                        $id_conteneur_destination,
     502                                        $rang_conteneur_destination,
     503                                        $profondeur_destination,
     504                                        $stockage
     505                                );
     506
     507                                // Il faut maintenant tasser les noisettes du conteneur d'origine qui a perdu une noisette.
     508                                // -- On récupère les noisettes restant affectées au conteneur origine sous la forme d'un tableau
     509                                //    indexé par rang.
     510                                $autres_noisettes = ncore_noisette_lister(
     511                                        $plugin,
     512                                        $id_conteneur_origine,
     513                                        '',
     514                                        'rang_noisette',
     515                                        $stockage
     516                                );
     517
     518                                // Si il reste des noisettes, on tasse d'un rang les noisettes qui suivaient la noisette supprimée.
     519                                if ($autres_noisettes) {
     520                                        // On lit les noisettes restantes dans l'ordre décroissant pour éviter d'écraser une noisette.
     521                                        ksort($autres_noisettes);
     522                                        foreach ($autres_noisettes as $_rang => $_autre_description) {
     523                                                if ($_rang > $rang_origine) {
     524                                                        ncore_noisette_ranger($plugin, $_autre_description, $_autre_description['rang_noisette'] - 1, $stockage);
     525                                                }
     526                                        }
     527                                }
     528
     529                                // Le rang origine devient donc le nouveau rang de la noisette dans le conteneur destination.
     530                                $rang_origine = $description['rang_noisette'];
     531                        }
     532
     533                        // A partir de là, le déplacement est un déplacement à l'intérieur d'un conteneur.
     534                        // Si les rangs origine et destination sont identiques on ne fait rien !
     535                        if ($rang_destination != $rang_origine) {
     536                                // On récupère les noisettes affectées au même conteneur sous la forme d'un tableau indexé par le rang.
     537                                $noisettes = ncore_noisette_lister(
     538                                        $plugin,
     539                                        $description['id_conteneur'],
     540                                        '',
     541                                        'rang_noisette',
     542                                        $stockage
     543                                );
     544
     545                                // On vérifie que le rang destination est bien compris entre 1 et le rang max, sinon on le force à l'une
     546                                // des bornes.
     547                                $rang_destination = max(1, $rang_destination);
     548                                $rang_max = $noisettes ? max(array_keys($noisettes)) : 0;
     549                                $rang_destination = min($rang_max, $rang_destination);
     550
     551                                // Suivant la position d'origine et de destination de la noisette déplacée on trie les noisettes
     552                                // du conteneur.
    542553                                if ($rang_destination < $rang_origine) {
    543                                         // On "descend" les noisettes du rang destination au rang origine non compris.
    544                                         if (($_rang >= $rang_destination) and ($_rang < $rang_origine)) {
    545                                                 ncore_noisette_ranger($plugin, $_description, $_rang + 1, $stockage);
    546                                         }
     554                                        krsort($noisettes);
    547555                                } else {
    548                                         // On "remonte" les noisettes du rang destination au rang origine non compris.
    549                                         if (($_rang <= $rang_destination) and ($_rang > $rang_origine)) {
    550                                                 ncore_noisette_ranger($plugin, $_description, $_rang - 1, $stockage);
    551                                         }
    552                                 }
    553                         }
    554 
    555                         // On positionne le rang de la noisette à déplacer au rang destination.
    556                         // On met le rang à zéro pour indiquer que l'emplacement d'origine n'est plus occupé par la
    557                         // noisette et qu'il ne faut pas le supprimer lors du rangement.
    558                         $description['rang_noisette'] = 0;
    559                         ncore_noisette_ranger($plugin, $description, $rang_destination, $stockage);
     556                                        ksort($noisettes);
     557                                }
     558
     559                                // On déplace les noisettes impactées à l'exception de la noisette concernée par le déplacement
     560                                // afin de créer une position libre.
     561                                foreach ($noisettes as $_rang => $_description) {
     562                                        if ($rang_destination < $rang_origine) {
     563                                                // On "descend" les noisettes du rang destination au rang origine non compris.
     564                                                if (($_rang >= $rang_destination) and ($_rang < $rang_origine)) {
     565                                                        ncore_noisette_ranger($plugin, $_description, $_rang + 1, $stockage);
     566                                                }
     567                                        } else {
     568                                                // On "remonte" les noisettes du rang destination au rang origine non compris.
     569                                                if (($_rang <= $rang_destination) and ($_rang > $rang_origine)) {
     570                                                        ncore_noisette_ranger($plugin, $_description, $_rang - 1, $stockage);
     571                                                }
     572                                        }
     573                                }
     574
     575                                // On positionne le rang de la noisette à déplacer au rang destination.
     576                                // On met le rang à zéro pour indiquer que l'emplacement d'origine n'est plus occupé par la
     577                                // noisette et qu'il ne faut pas le supprimer lors du rangement.
     578                                $description['rang_noisette'] = 0;
     579                                if (ncore_noisette_ranger($plugin, $description, $rang_destination, $stockage)) {
     580                                        $noisette_deplacee = true;
     581                                }
     582                        }
    560583                }
    561584        }
    562585
    563         return $retour;
     586        return $noisette_deplacee;
    564587}
     588
     589/**
     590 * Duplique une noisette donnée dans un conteneur destination et, si cette noisette est un conteneur, duplique aussi
     591 * les noisettes contenues de façon récursive.
     592 *
     593 * @api
     594 * @uses ncore_noisette_decrire()
     595 * @uses noisette_ajouter()
     596 * @uses noisette_parametrer()
     597 * @uses ncore_noisette_lister()
     598 *
     599 * @param string       $plugin
     600 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
     601 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
     602 * @param mixed        $noisette
     603 *        Identifiant de la noisette qui peut prendre soit la forme d'un entier ou d'une chaine unique, soit la forme
     604 *        d'un couple (id conteneur, rang).
     605 * @param array|string $conteneur
     606 *        Identifiant du conteneur destination qui prend soit la forme d'un tableau soit celui d'un id.
     607 * @param array        $parametrage
     608 *        Tableau indiquant les champs éditables de la noisette source à copier dans la noisette dupliquée.
     609 * @param string       $stockage
     610 *        Identifiant du service de stockage à utiliser si précisé. Dans ce cas, ni celui du plugin
     611 *        ni celui de N-Core ne seront utilisés. En général, cet identifiant est le préfixe d'un plugin
     612 *        fournissant le service de stockage souhaité.
     613 *
     614 * @return bool
     615 */
     616function noisette_dupliquer($plugin, $noisette, $conteneur, $parametrage = array(), $stockage = '') {
     617
     618        // Initialisation du retour
     619        $noisette_dupliquee = false;
     620
     621        // On charge les services de N-Core.
     622        // Ce sont ces fonctions qui aiguillent ou pas vers un service spécifique du plugin.
     623        include_spip('ncore/ncore');
     624
     625        // L'identifiant d'une noisette peut être fourni de deux façons :
     626        // - par une valeur unique, celle créée lors de l'ajout et qui peut-être un entier (id d'une table SPIP) ou
     627        //   une chaine unique par exemple générée par uniqid().
     628        // - ou par un tableau à deux entrées fournissant le conteneur et le rang dans le conteneur
     629        //   (qui est unique pour un conteneur donné).
     630        if (!empty($noisette) and (is_string($noisette) or is_numeric($noisette) or is_array($noisette))) {
     631                // Avant de dupliquer la noisette on sauvegarde sa description car il faudra utiliser ses paramètres
     632                // d'affichage, d'encapsulation et de style pour la duplication.
     633                $description = ncore_noisette_decrire($plugin, $noisette, $stockage);
     634
     635                // On ajoute la noisette à la fin du conteneur destination : la noisette est créée par défaut.
     636                if ($id_noisette = noisette_ajouter($plugin, $description['type_noisette'], $conteneur, 0, $stockage)) {
     637                        // Suivant le paramétrage demandé on copie les champs idoines de la noisette source.
     638                        if ($parametrage) {
     639                                $modifications = array();
     640                                foreach ($parametrage as $_champ) {
     641                                        if (($description['est_conteneur'] == 'non')
     642                                        or (($description['est_conteneur'] == 'oui') and ($_champ == 'parametres'))) {
     643                                                $modifications[$_champ] = $description[$_champ];
     644                                        }
     645                                }
     646
     647                                if ($modifications) {
     648                                        noisette_parametrer($plugin, $id_noisette, $modifications, array(), $stockage);
     649                                }
     650                        }
     651
     652                        // Si la noisette est de type conteneur, il faut aussi dupliquer les noisettes éventuellement contenues
     653                        // et ce de façon récursive.
     654                        if ($description['est_conteneur'] == 'oui') {
     655                                // On récupère les noisettes incluses dans la noisette origine qui est un conteneur.
     656                                $autres_noisettes = ncore_noisette_lister(
     657                                        $plugin,
     658                                        array('type_noisette' => $description['type_noisette'], 'id_noisette' => $description['id_noisette']),
     659                                        '',
     660                                        'rang_noisette',
     661                                        $stockage
     662                                );
     663
     664                                // Si il reste des noisettes, on tasse d'un rang les noisettes qui suivaient la noisette supprimée.
     665                                if ($autres_noisettes) {
     666                                        // On calcule l'id conteneur de la noisette conteneur venant d'être dupliquée pour y dupliquer les
     667                                        // noisettes incluses.
     668                                        $conteneur_noisette_dupliquee = array(
     669                                                'type_noisette' => $description['type_noisette'],
     670                                                'id_noisette' => $id_noisette
     671                                        );
     672
     673                                        // On lit les noisettes incluses et on appelle la fonction dupliquer récursivement.
     674                                        ksort($autres_noisettes);
     675                                        foreach ($autres_noisettes as $_rang => $_autre_description) {
     676                                                noisette_dupliquer(
     677                                                        $plugin,
     678                                                        $_autre_description['id_noisette'],
     679                                                        $conteneur_noisette_dupliquee,
     680                                                        $parametrage,
     681                                                        $stockage
     682                                                );
     683                                        }
     684                                }
     685                        }
     686
     687                        $noisette_dupliquee = true;
     688                }
     689        }
     690
     691        return $noisette_dupliquee;
     692}
  • _plugins_/n-core/trunk/paquet.xml

    r113160 r113409  
    22        prefix="ncore"
    33        categorie="outil"
    4         version="0.6.4"
     4        version="0.7.0"
    55        etat="dev"
    66        compatibilite="[3.2.0;3.2.*]"
    77        logo="ncore_logo-32.png"
    88>
    9 <!-- Icon : https://www.shareicon.net/3d-interface-shapes-cube-cubes-squares-geometrical-shapes-and-symbols-823704 -->
    109        <nom>N-Core</nom>
    1110        <!-- Un coeur fondant aux noisettes -->
Note: See TracChangeset for help on using the changeset viewer.