Changeset 107341 in spip-zone


Ignore:
Timestamp:
Nov 4, 2017, 3:09:43 PM (2 years ago)
Author:
eric@…
Message:

Mise à jour des fonctions de service pour suivre les modifications de N-Core.
Renommage du champ squelette en id_conteneur dans la table spip_noizetier.
Mise à jour avec l'API de N-Core de la fonction traiter du formulaire ajouter_noisette.

Location:
_plugins_/noizetier/trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/noizetier/trunk/base/noizetier_tables.php

    r105907 r107341  
    129129                'id_noisette' => 'bigint(21) NOT NULL',
    130130                'plugin'      => "varchar(30) DEFAULT '' NOT NULL",
    131                 'squelette'   => "varchar(255) DEFAULT '' NOT NULL",
     131                'id_conteneur'=> "varchar(255) DEFAULT '' NOT NULL",
    132132                'rang'        => "smallint DEFAULT 1 NOT NULL",
    133133                'type'        => "varchar(127) DEFAULT '' NOT NULL",
     
    145145                'PRIMARY KEY'     => 'id_noisette',
    146146                'KEY plugin'      => 'plugin',
    147                 'KEY squelette'   => 'squelette',
     147                'KEY id_conteneur'=> 'id_conteneur',
    148148                'KEY type'        => 'type',
    149149                'KEY composition' => 'composition',
  • _plugins_/noizetier/trunk/formulaires/ajouter_noisette.php

    r105907 r107341  
    3838        $retour = array();
    3939
    40         // Détermination de l'identifiant de la page ou de l'objet concerné
     40        // Détermination de l'identifiant de la page ou de l'objet concerné et construction du conteneur de la
     41        // noisette
     42        $conteneur = array();
    4143        if (is_array($page)) {
    4244                $identifiant['objet'] = $page['objet'];
    4345                $identifiant['id_objet'] = $page['id_objet'];
    44                 $squelette = "${bloc}/{$identifiant['objet']}{$identifiant['id_objet']}";
     46                $conteneur['squelette'] = "${bloc}";
     47                $conteneur = array_merge($conteneur, $identifiant);
    4548        }
    4649        else {
    4750                $identifiant['page'] = $page;
    48                 $squelette = "${bloc}/${page}";
     51                $conteneur['squelette'] = "${bloc}/${page}";
    4952        }
    5053
     
    5356                        include_spip('inc/ncore_noisette');
    5457                        // Ajout de la noisette en fin de liste pour le squelette concerné.
    55                         if ($id_noisette = noisette_ajouter('noizetier', $noisette, $squelette)) {
     58                        if ($id_noisette = noisette_ajouter('noizetier', $noisette, $conteneur)) {
    5659                                $retour['message_ok'] = _T('info_modification_enregistree');
    5760                                if ($redirect) {
  • _plugins_/noizetier/trunk/ncore/noizetier.php

    r107205 r107341  
    99// -----------------------------------------------------------------------
    1010
     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_noizetier_noisettes`.
     18 *
     19 * @package SPIP\NOIZETIER\NCORE\TYPE_NOISETTE
     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_noisette
     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 */
    1138function noizetier_type_noisette_stocker($plugin, $types_noisettes, $recharger) {
    1239
     
    4370}
    4471
     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\NCORE\TYPE_NOISETTE
     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 */
    4589function noizetier_type_noisette_completer($plugin, $description) {
    4690
     
    62106}
    63107
     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_noizetier_noisettes`.
     113 *
     114 * @package SPIP\NOIZETIER\NCORE\TYPE_NOISETTE
     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 */
    64126function noizetier_type_noisette_decrire($plugin, $noisette) {
    65127
     
    72134}
    73135
     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\NCORE\TYPE_NOISETTE
     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 `[noisette] = information ou description complète`.
     152 */
    74153function noizetier_type_noisette_lister($plugin, $information = '') {
    75154
     
    93172
    94173/**
    95  *
    96  * @package SPIP\NOIZETIER\SERVICE\NOISETTE
    97  *
    98  * @param string $plugin
     174 * Stocke la description d'une nouvelle noisette et calcule son identifiant unique, ou met à jour les paramètres
     175 * d'affichage d'une noisette existante.
     176 *
     177 * @package SPIP\NOIZETIER\NCORE\NOISETTE
     178 *
     179 * @param string $plugin
     180 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
     181 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
    99182 * @param array  $description
     183 *        Description de la noisette. Soit la description ne contient pas l'id de la noisette et c'est un ajout,
     184 *        soit la description contient l'id et c'est une mise à jour.
    100185 *
    101186 * @return int
     187 *        Id de la noisette de type entier ou 0 en cas d'erreur.
    102188 */
    103189function noizetier_noisette_stocker($plugin, $description) {
     
    105191        // Mise à jour en base de données.
    106192        if (empty($description['id_noisette'])) {
    107                 // Compléter la description fournie avec les champs propres au noizetier, à savoir, ceux identifiant
    108                 // la page/composition ou l'objet et le bloc.
    109                 // On parse le squelette pour identifier les données manquantes.
    110                 $complement = squelette_phraser($description['squelette']);
    111                 $description = array_merge($description, $complement);
    112 
     193                // Insertion de la nouvelle noisette.
    113194                $id_noisette = sql_insertq('spip_noizetier', $description);
    114195        } else {
     
    117198                unset($description['id_noisette']);
    118199
    119                 // Mise à jour de la noisette
     200                // Mise à jour de la noisette.
    120201                $where = array('id_noisette=' . $id_noisette);
    121202                if (!sql_updateq('spip_noizetier', $description, $where)) {
     
    134215
    135216/**
    136  *
    137  * @package SPIP\NOIZETIER\SERVICE\NOISETTE
    138  *
    139  * @param string $plugin
     217 * Compléte la description fournie avec les champs propres au noizetier, à savoir, ceux identifiant
     218 * la page/composition ou l'objet et le bloc.
     219 * On parse le squelette pour identifier les données manquantes.
     220 *
     221 * @package SPIP\NOIZETIER\NCORE\NOISETTE
     222 *
     223 * @param string $plugin
     224 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
     225 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
    140226 * @param array  $description
     227 *        Description  par défaut de la noisette.
     228 *
     229 * @return array
     230 *        Description de la noisette complétée avec les champs de type de page, composition, bloc et
     231 *        de l'objet concerné si cela est le cas. Le champ conteneur est lui supprimé car non stocké en
     232 *        base de données.
     233 */
     234function noizetier_noisette_completer($plugin, $description) {
     235
     236        if (!empty($description['conteneur'])) {
     237                //
     238                $complement = array(
     239                        'type'        => '',
     240                        'composition' => '',
     241                        'objet'       => '',
     242                        'id_objet'    => 0,
     243                        'bloc'        => ''
     244                );
     245
     246                // On désérialise le conteneur et après on traite les compléments.
     247                $conteneur = unserialize($description['conteneur']);
     248
     249                if (!empty($conteneur['squelette'])) {
     250                        $squelette = strtolower($conteneur['squelette']);
     251                        $page = basename($squelette);
     252                        $identifiants_page = explode('-', $page, 2);
     253                        if (!empty($identifiants_page[1])) {
     254                                // Forcément une composition
     255                                $complement['type'] = $identifiants_page[0];
     256                                $complement['composition'] = $identifiants_page[1];
     257                        } else {
     258                                // Page ou objet
     259                                if (preg_match(',([a-z_]+)(\d+)$,s', $identifiants_page[0], $identifiants_objet)) {
     260                                        $complement['objet'] = $identifiants_objet[1];
     261                                        $complement['id_objet'] = $identifiants_objet[2];
     262                                } else {
     263                                        $complement['type'] = $identifiants_page[0];
     264                                }
     265                        }
     266
     267                        $bloc = dirname($squelette);
     268                        if ($bloc != '.') {
     269                                $complement['bloc'] = basename($bloc);
     270                        }
     271                        $description = array_merge($description, $complement);
     272
     273                        // On supprime l'index 'conteneur' qui n'est pas utile pour le noiZetier qui utilise uniquement les
     274                        // données de page et d'objet venant d'être ajoutées et l'id du conteneur.
     275                        unset($description['conteneur']);
     276                }
     277        }
     278
     279        return $description;
     280}
     281
     282/**
     283 * Positionne une noisette à un rang différent que celui qu'elle occupe dans le conteneur.
     284 *
     285 * @package SPIP\NOIZETIER\NCORE\NOISETTE
     286 *
     287 * @param string $plugin
     288 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
     289 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
     290 * @param array  $description
     291 *        Description complète de la noisette.
    141292 * @param int    $rang_destination
     293 *        Position à laquelle ranger la noisette au sein du conteneur.
    142294 *
    143295 * @return bool
     296 *        `true` si le traitement s'est bien déroulé, `false` sinon.
    144297 */
    145298function noizetier_noisette_ranger($plugin, $description, $rang_destination) {
    146299
    147300        // Initialisation de la sortie.
    148         $retour = true;
    149 
    150         $where = array('id_noisette=' . intval($description['id_noisette']));
    151         $update = array('rang' => $rang_destination);
    152         if (!sql_updateq('spip_noizetier', $update, $where)) {
    153                 $retour = false;
     301        $retour = false;
     302
     303        if (isset($description['id_noisette']) and ($id = intval($description['id_noisette']))) {
     304                $where = array('id_noisette=' . $id);
     305                $update = array('rang' => $rang_destination);
     306                if (sql_updateq('spip_noizetier', $update, $where)) {
     307                        $retour = true;
     308                }
    154309        }
    155310
     
    158313
    159314/**
    160  *
    161  * @package SPIP\NCORE\SERVICE\NOISETTE
    162  *
    163  * @param        $plugin
    164  * @param        $description
     315 * Retire, de l'espace de stockage, une noisette donnée de son conteneur.
     316 *
     317 * @package SPIP\NOIZETIER\NCORE\NOISETTE
     318 *
     319 * @param string       $plugin
     320 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
     321 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
     322 * @param array|string $description
     323 *        Description complète de la noisette.
    165324 *
    166325 * @return bool
     326 *        `true` si le traitement s'est bien déroulé, `false` sinon.
    167327 */
    168328function noizetier_noisette_destocker($plugin, $description) {
    169329
    170330        // Initialisation de la sortie.
    171         $retour = true;
    172 
    173         // Calcul de la clause where en distinguant la suppression d'une noisette et de toutes les noisettes
    174         // d'une squelette.
    175         // De fait, $description est soit le tableau descriptif de la noisette, soit une chaine représentant le nom du
    176         // squelette et dans ce cas.
    177         if (is_array($description)) {
     331        $retour = false;
     332
     333        // Calcul de la clause where à partir de l'id du conteneur.
     334        if (isset($description['id_noisette'])) {
    178335                $where = array('id_noisette=' . intval($description['id_noisette']));
    179         } else {
    180                 $where = array('squelette=' . sql_quote($description));
    181         }
    182 
    183         // Suppression.
    184         if (!sql_delete('spip_noizetier', $where)) {
    185                 $retour = false;
     336
     337                // Suppression de la noisette.
     338                if (sql_delete('spip_noizetier', $where)) {
     339                        $retour = true;
     340                }
    186341        }
    187342
     
    190345
    191346
    192 
    193 function noizetier_noisette_lister($plugin, $squelette = '', $information = '', $cle = 'rang') {
     347/**
     348 * Renvoie un champ ou toute la description des noisettes d'un conteneur ou de tous les conteneurs.
     349 * Le tableau retourné est indexé soit par identifiant de noisette soit par identifiant du conteneur et rang.
     350 *
     351 * @package SPIP\NOIZETIER\NCORE\NOISETTE
     352 *
     353 * @param string $plugin
     354 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
     355 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
     356 * @param array|string $conteneur
     357 *        Tableau descriptif du conteneur ou identifiant du conteneur ou vide si on souhaite adresser tous les
     358 *        conteneurs.
     359 * @param string $information
     360 *        Identifiant d'un champ de la description d'une type de noisette.
     361 *        Si l'argument est vide, la fonction renvoie les descriptions complètes et si l'argument est
     362 *        un champ invalide la fonction renvoie un tableau vide.
     363 * @param string $cle
     364 *        Champ de la description d'une noisette servant d'index du tableau. En général on utilisera soit `id_noisette`
     365 *        soit `rang`.
     366 *
     367 * @return array
     368 *        Tableau de la liste des informations demandées indexé par identifiant de noisette ou par rang.
     369 */
     370function noizetier_noisette_lister($plugin, $conteneur = array(), $information = '', $cle = 'rang') {
    194371
    195372        // Initialisation du tableau de sortie.
    196373        $noisettes = array();
    197374
     375        // Construction du where et du order by en fonction du conteneur qui est soit un squelette,
     376        // soit un squelette d'un objet donné, soit vide (on veut toutes les noisettes du plugin).
    198377        $where = array('plugin=' . sql_quote($plugin));
    199         if ($squelette) {
    200                 $where[] = 'squelette=' . sql_quote($squelette);
    201         }
    202         $select = $information ? array_merge(array('squelette', 'rang', 'id_noisette'), array($information)) : '*';
    203         $order_by = $cle == 'rang' ? array('squelette', 'rang') : array('id_noisette');
     378        if ($conteneur) {
     379                // On sélectionne le contenant par son identifiant qui est stocké dans la table.
     380                if (is_array($conteneur)) {
     381                        $id_conteneur = noizetier_conteneur_identifier($plugin, $conteneur);
     382                } else {
     383                        $id_conteneur = $conteneur;
     384                }
     385                $where[] = array('id_conteneur=' . sql_quote($id_conteneur));
     386                $order_by = array('rang');
     387        } else {
     388                // On veut toutes les noisettes, on ordonne toujours le tableau résultant par conteneur et par rang dans chaque
     389                // conteneur.
     390                $order_by = array('id_conteneur', 'rang');
     391        }
     392
     393        // Construction du select en fonction des informations à retourner.
     394        $select = $information ? array_merge(array('id_conteneur', 'rang', 'id_noisette'), array($information)) : '*';
    204395
    205396        if ($table_noisettes = sql_allfetsel($select, 'spip_noizetier', $where, '', $order_by)) {
    206                 if ($cle = 'rang') {
     397                if ($cle == 'rang') {
    207398                        // On demande un rangement par rang.
    208                         // Il faut tenir compte du fait que la liste est réduite à un squelette ou pas.
     399                        // Il faut tenir compte du fait que la liste est réduite à un conteneur ou pas.
    209400                        foreach ($table_noisettes as $_noisette) {
    210                                 if ($squelette) {
     401                                if ($conteneur) {
    211402                                        $noisettes[$_noisette['rang']] = $information
    212403                                                ? array($information => $_noisette[$information])
    213404                                                : $_noisette;
    214405                                } else {
    215                                         $noisettes[$_noisette['squelette']][$_noisette['rang']] = $information
     406                                        $noisettes[$_noisette['id_conteneur']][$_noisette['rang']] = $information
    216407                                                ? array($information => $_noisette[$information])
    217408                                                : $_noisette;
     
    230421
    231422
     423/**
     424 * Renvoie la description brute d'une noisette sans traitement typo des champs textuels ni désérialisation
     425 * des champs de type tableau sérialisé.
     426 *
     427 * @package SPIP\NOIZETIER\NCORE\NOISETTE
     428 *
     429 * @param string $plugin
     430 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
     431 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
     432 * @param mixed  $noisette
     433 *        Identifiant de la noisette qui peut prendre soit la forme d'un entier ou d'une chaine unique, soit la forme
     434 *        d'un couple (conteneur, rang).
     435 *
     436 * @return array
     437 *        Tableau de la description du type de noisette. Les champs textuels et les champs de type tableau sérialisé
     438 *        sont retournés en l'état.
     439 */
    232440function noizetier_noisette_decrire($plugin, $noisette) {
    233441
    234442        $description = array();
    235         $where = array();
    236443
    237444        if (!is_array($noisette)) {
     
    240447                // => C'est la méthode optimale pour le stockage noiZetier.
    241448                $where = array('id_noisette=' . intval($noisette));
    242         } elseif (isset($noisette['squelette']) and isset($noisette['rang']) and !empty($meta_noisettes[$noisette['squelette']][$noisette['rang']])) {
    243                 // L'identifiant est un tableau associatif fournissant le squelette et le rang.
    244                 // Comme la meta de N-Core est structurée ainsi c'est la méthode la plus adaptée pour adresser
    245                 // le stockage de N-Core.
    246                 $where = array('squelette=' . sql_quote($noisette['squelette']), 'rang=' . intval($noisette['rang']));
     449        } elseif (isset($noisette['id_conteneur']) and isset($noisette['rang'])) {
     450                // L'identifiant est un tableau associatif fournissant l'id du conteneur et le rang.
     451                $where = array('id_conteneur=' . sql_quote($noisette['id_conteneur']), 'rang=' . intval($noisette['rang']));
     452        } else {
     453                $where = array();
    247454        }
    248455
     
    254461}
    255462
     463
     464// -----------------------------------------------------------------------
     465// ----------------------------- CONTENEURS ------------------------------
     466// -----------------------------------------------------------------------
     467
     468/**
     469 * Construit un identifiant unique pour le conteneur de noisettes.
     470 * Pour le noiZetier, un conteneur est toujours un squelette, soit générique soit d'un objet donné.
     471 *
     472 * @package SPIP\NOIZETIER\NCORE\CONTENEUR
     473 *
     474 * @param string $plugin
     475 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
     476 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
     477 * @param array $conteneur
     478 *        Tableau associatif descriptif du conteneur accueillant la noisette. Un conteneur peut-être un squelette seul
     479 *        ou associé à un contexte d'utilisation et dans ce cas il possède un index `squelette` ou un objet quelconque
     480 *        sans lien avec un squelette. Dans tous les cas, les index, à l'exception de `squelette`, sont spécifiques
     481 *        à l'utilisation qui en est faite par le plugin.
     482 *
     483 * @return string
     484 */
     485function noizetier_conteneur_identifier($plugin, $conteneur) {
     486
     487        // On initialise l'identifiant à vide.
     488        $identifiant = '';
     489
     490        if ($conteneur) {
     491                // Le nom du squelette en premier si il existe (normalement toujours).
     492                if (!empty($conteneur['squelette'])) {
     493                        $identifiant .= $conteneur['squelette'];
     494                }
     495
     496                // L'objet et son id si on est en présence d'un objet.
     497                if (!empty($conteneur['objet']) and !empty($conteneur['id_objet']) and ($id = intval($conteneur['id_objet']))) {
     498                        $identifiant .= ($identifiant ? '|' : '') . "{$conteneur['objet']}|{$conteneur['id_objet']}";
     499                }
     500        }
     501
     502        return $identifiant;
     503}
     504
     505
     506/**
     507 * Retire, de l'espace de stockage, toutes les noisettes d'un conteneur.
     508 *
     509 * @package SPIP\NOIZETIER\NCORE\CONTENEUR
     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|string $conteneur
     515 *        Tableau descriptif du conteneur ou identifiant du conteneur.
     516 *
     517 * @return bool
     518 *        `true` si le traitement s'est bien déroulé, `false` sinon.
     519 */
     520function noizetier_conteneur_destocker($plugin, $conteneur) {
     521
     522        // Initialisation de la sortie.
     523        $retour = false;
     524
     525        // Calcul de l'id du conteneur en fonction du mode d'appel de la fonction.
     526        if (is_array($conteneur)) {
     527                $id_conteneur = noizetier_conteneur_identifier($plugin, $conteneur);
     528        } else {
     529                $id_conteneur = $conteneur;
     530        }
     531
     532        if ($id_conteneur) {
     533                // Suppression de toutes les noisettes du conteneur.
     534                $where = array('id_conteneur=' . sql_quote($id_conteneur));
     535                if (sql_delete('spip_noizetier', $where)) {
     536                        $retour = true;
     537                }
     538        }
     539
     540        return $retour;
     541}
    256542
    257543
     
    264550        return $defaut_ajax;
    265551}
    266 
    267 function squelette_phraser($squelette) {
    268 
    269         $complement = array(
    270                 'type'        => '',
    271                 'composition' => '',
    272                 'objet'       => '',
    273                 'id_objet'    => 0,
    274                 'bloc'        => ''
    275         );
    276 
    277 
    278         if ($squelette) {
    279                 $squelette = strtolower($squelette);
    280                 $page = basename($squelette);
    281                 $identifiants_page = explode('-', $page, 2);
    282                 if (!empty($identifiants_page[1])) {
    283                         // Forcément une composition
    284                         $complement['type'] = $identifiants_page[0];
    285                         $complement['composition'] = $identifiants_page[1];
    286                 } else {
    287                         // Page ou objet
    288                         if (preg_match(',([a-z_]+)(\d+)$,s', $identifiants_page[0], $identifiants_objet)) {
    289                                 $complement['objet'] = $identifiants_objet[1];
    290                                 $complement['id_objet'] = $identifiants_objet[2];
    291                         } else {
    292                                 $complement['type'] = $identifiants_page[0];
    293                         }
    294                 }
    295 
    296                 $bloc = dirname($squelette);
    297                 if ($bloc != '.') {
    298                         $complement['bloc'] = basename($bloc);
    299                 }
    300         }
    301 
    302         return $complement;
    303 }
  • _plugins_/noizetier/trunk/noizetier_administrations.php

    r105907 r107341  
    124124        // -- Ajout de la colonne 'squelette'.
    125125        sql_alter("TABLE spip_noisettes ADD plugin varchar(30) DEFAULT '' NOT NULL AFTER id_noisette");
    126         sql_alter("TABLE spip_noisettes ADD squelette varchar(255) DEFAULT '' NOT NULL AFTER plugin");
     126        sql_alter("TABLE spip_noisettes ADD id_conteneur varchar(255) DEFAULT '' NOT NULL AFTER plugin");
    127127        sql_alter("TABLE spip_noisettes ADD balise varchar(6) DEFAULT 'defaut' NOT NULL AFTER parametres");
    128128//      sql_alter("TABLE spip_noisettes ADD maj timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL");
     
    141141        // -- Mise à jour de la valeur par défaut du rang
    142142        sql_alter("TABLE spip_noisettes MODIFY rang smallint DEFAULT 1 NOT NULL");
    143         // -- Création des index détruits précédemment et du nouvel index plugin
     143        // -- Création des index détruits précédemment et des nouveaux index plugin et conteneur
    144144        sql_alter("TABLE spip_noisettes ADD INDEX type (type)");
    145145        sql_alter("TABLE spip_noisettes ADD INDEX composition (composition)");
     
    147147        sql_alter("TABLE spip_noisettes ADD INDEX noisette (noisette)");
    148148        sql_alter("TABLE spip_noisettes ADD INDEX plugin (plugin)");
     149        sql_alter("TABLE spip_noisettes ADD INDEX id_conteneur (id_conteneur)");
    149150        // -- Renommage de la table
    150151        sql_alter("TABLE spip_noisettes RENAME spip_noizetier");
Note: See TracChangeset for help on using the changeset viewer.