Changeset 82919 in spip-zone


Ignore:
Timestamp:
Jun 9, 2014, 9:45:17 PM (7 years ago)
Author:
bmarne@…
Message:

La config des modules migre des métas vers la base en reprenant le schéma du noizetier: même schéma de base de données avec en plus un champ "bloc"

  • déclaration des tables
  • fonction de mise à jour du plugin (install de la table + migration des données dans la table)
  • reprise des fonctions utilisées pour le noizetier pour lister les noisettes, mais en prenant en compte:
    • le repertoire noisettes *et* le répertoire modules et ses sous répertoires (compat ascendante pour Mélusine)
    • les noisettes sans YAML sont listées aussi (compat ascendante pour Mélusine)
    • le type de bloc est mémorisé pour les modules (compat ascendante pour Mélusine)
    • le répertoire de la noisette/module est mémorisé pour les inclusions (compat ascendante pour Mélusine et cohabitation noizetier)

Et tout ça en essayant de pas trop marcher sur les pieds du noizetier (compatibilité).

Attention: Ce n'est pas encore répercuté dans les fonctions de déplacement/ajout des modules dans une page: donc ça veut dire que les modifs qui sont faites ne sont pas (encore) répercutées dans la base. => C'est le haut de la TODO list

Location:
_squelettes_/galaxie_melusine/melusine/trunk
Files:
2 added
3 edited

Legend:

Unmodified
Added
Removed
  • _squelettes_/galaxie_melusine/melusine/trunk/melusine_administrations.php

    r66888 r82919  
    1818function melusine_upgrade($nom_meta_base_version, $version_cible) {
    1919        $maj = array();
     20        // On initialise le tableau des
     21        // opération d'installation
     22        $maj['create'] = array();
     23
     24        // Idem pour le schéma 1.1.0
     25        $maj['1.1.0'] = array();
    2026       
    2127
     
    3137        $chemin_conf = $chemin."config_melusine_par_defaut.txt";
    3238        $file = file($chemin_conf);
    33         $maj['create'] = array();
     39
    3440
    3541        include_spip('inc/config');
     
    6672
    6773
    68 
    69 
     74        // Manipulations de fichiers
     75        array_push($maj['create'],array('melusine_preparation_fichiers',array()));
     76
     77        // Mélusine 2 utilise des tables du noizetier
     78        // vérification de la présence du noizetier
     79        include_spip('inc/filtres');
     80        $f = chercher_filtre('info_plugin');
     81        $noiz_actif = $f("noizetier","est_actif");
     82
     83        // Si pas noizetier, on vire la base...
     84        if (!$noiz_actif) {
     85                array_push($maj['create'],array('creer_base'));
     86                array_push($maj['1.1.0'],array('creer_base'));
     87        }
     88
     89        // Migration vers la base de Mélusine 2 qui gère les
     90        // modules comme le noiztier gère les noisettes
     91        array_push($maj['1.1.0'],array('melusine_migration_version_2', array()));
     92
     93
     94        // en attendant une meilleure façon d'installer Mélusine 2
     95        // On utilise l'ancienne façon (Mélusine 1), et on migre ensuite
     96        // en Mélusine 2
     97        array_push($maj['create'],array('melusine_migration_version_2', array()));
     98
     99        // On lance les opérations...
     100        include_spip('base/upgrade');
     101        maj_plugin($nom_meta_base_version, $version_cible, $maj);
     102
     103
     104
     105
     106
     107
     108
     109}
     110
     111
     112/**
     113 * Fonction de désinstallation du plugin.
     114 * Vous devez :
     115 * - nettoyer toutes les données ajoutées par le plugin et son utilisation
     116 * - supprimer les tables et les champs créés par le plugin.
     117**/
     118function melusine_vider_tables($nom_meta_base_version) {
    70119        # quelques exemples
    71120        # (que vous pouvez supprimer !)
    72         #
    73         # $maj['create'] = array(array('creer_base'));
    74         #
    75         # include_spip('inc/config')
    76         # $maj['create'] = array(
    77         #       array('maj_tables', array('spip_xx', 'spip_xx_liens')),
    78         #       array('ecrire_config', array('melusine', array('exemple' => "Texte de l'exemple")))
    79         #);
    80         #
    81         # $maj['1.1.0']  = array(array('sql_alter','TABLE spip_xx RENAME TO spip_yy'));
    82         # $maj['1.2.0']  = array(array('sql_alter','TABLE spip_xx DROP COLUMN id_auteur'));
    83         # $maj['1.3.0']  = array(
    84         #       array('sql_alter','TABLE spip_xx CHANGE numero numero int(11) default 0 NOT NULL'),
    85         #       array('sql_alter','TABLE spip_xx CHANGE texte petit_texte mediumtext NOT NULL default \'\''),
    86         # );
    87         # ...
    88 
    89         include_spip('base/upgrade');
    90         maj_plugin($nom_meta_base_version, $version_cible, $maj);
    91 
     121        # sql_drop_table("spip_xx");
     122        # sql_drop_table("spip_xx_liens");
     123
     124        // vérification de la présence du noizetier
     125        include_spip('inc/filtres');
     126        $f = chercher_filtre('info_plugin');
     127        $noiz_actif = $f("noizetier","est_actif");
     128
     129        // Si pas noizetier, on vire la base...
     130        if (!$noiz_actif) {
     131                sql_drop_table("spip_noisettes");
     132
     133                # Nettoyer les versionnages et forums
     134                sql_delete("spip_versions",              sql_in("objet", array('noisette')));
     135                sql_delete("spip_versions_fragments",    sql_in("objet", array('noisette')));
     136                sql_delete("spip_forum",                 sql_in("objet", array('noisette')));
     137        }
     138
     139
     140        effacer_meta($nom_meta_base_version);
     141}
     142
     143/**
     144 * Fonction de recherche de l'ancien plugin DATICE
     145 *
     146 * @param
     147 *
     148 * @return text renvoie le chemin du plugin DATICE s'il est trouvé ou rien
     149**/
     150function melusine_cherche_chemin_datice() {
     151
     152        $plugin_datice = "datice3/"; //Nom supposé du répertoire du plugin
     153
     154        //chemins supposés possibles
     155        $chemins_possibles_datice = array(_DIR_PLUGINS_AUTO.$plugin_datice,_DIR_PLUGINS.$plugin_datice);
     156
     157        foreach ($chemins_possibles_datice as $chemin_plugin_datice) {
     158                if (file_exists($chemin_plugin_datice."balise/daticeaide.php")) return $chemin_plugin_datice;
     159        }
     160        return ""; // pas trouvé...
     161}
     162/**
     163 * Opérations sur les fichiers nécessaires à l'installation
     164 * de Mélusne
     165 * Notamment pour la MAJ depuis DATICE
     166 *
     167 * @param
     168 *
     169 * @return
     170**/
     171function melusine_preparation_fichiers() {
     172        include_spip('inc/config');
    92173
    93174        //si le fichier logo créteil n'existe pas (1ere install) => création
     
    234315        }
    235316        ecrire_config("melusine_perso_a_deplacer",$a_placer_dans_casier);
    236 
    237 
    238317}
    239318
    240 
    241 /**
    242  * Fonction de désinstallation du plugin.
    243  * Vous devez :
    244  * - nettoyer toutes les données ajoutées par le plugin et son utilisation
    245  * - supprimer les tables et les champs créés par le plugin.
     319/**
     320 * Migration de Mélusine 1 vers Mélusine 2
     321 * (c'est à dire passage d'un système de module centré sur les métas
     322 * à un système proche du noizetier, en base)
     323 *
     324 * @param
     325 *
     326 * @return
    246327**/
    247 function melusine_vider_tables($nom_meta_base_version) {
    248         # quelques exemples
    249         # (que vous pouvez supprimer !)
    250         # sql_drop_table("spip_xx");
    251         # sql_drop_table("spip_xx_liens");
    252 
    253 
    254         effacer_meta($nom_meta_base_version);
     328function melusine_migration_version_2() {
     329        include_spip('inc/config');
     330
     331        // Liste des blocs => casiers dans Mélusine 1
     332        // en prenant en compte les colonnes
     333        // et les types de pages
     334        // modules[type_page][bloc(-col)?] = liste (array) de modules
     335        // le suffixe -col2 ou -col3 concerne les colonnes des content
     336        // pour une meilleure compat avec le noizetier la -col1 n'a pas
     337        // de suffixe
     338
     339        // On différencie les casier du futur bloc content
     340        // (spécifiques d'un type de page)
     341        // de ceux qui constitueront les autres bocs
     342        // (qui devront être répercutés sur chaque type de page)
     343        $liste_casiers__de_content = array('articles','mobil','rubriques','sommaire');
     344
     345        $correspondances_anciens_nouveaux_blocs = array (
     346                        'chemin/effectifs' => 'breadcrumb',
     347                        'footer/effectifs' => 'footer',
     348                        'squelettes/g' => 'aside',
     349                        'squelettes/d' => 'extra'
     350                );
     351        // Pour chaque type de page
     352        $liste_futurs_types_page = array('article','rubrique','sommaire');
     353        foreach($liste_futurs_types_page as $type_page) {
     354                // blocs génériques qui n'existent pas dans Mélusie 1
     355                $modules[$type_page]['nav']= array();
     356                $modules[$type_page]['header']= array();
     357
     358                // On récupère les autres blocs génériques:
     359                foreach($correspondances_anciens_nouveaux_blocs as $anciens => $nouveau) {
     360                        $modules[$type_page][$nouveau] = lire_config("melusine_".$anciens);
     361                       
     362                }
     363
     364                // Passons au bloc content qui peut
     365                // être découpé en colonnes
     366                $effectis = array('effectifs' => '');
     367                $nom_traitement = $type_page."s";
     368
     369                // Sommaire déroge à certaines règles:
     370                // pas de s final
     371                // et éventuellement, deux colonnes
     372                if ($type_page == "sommaire") {
     373                        $nom_traitement = $type_page;
     374                        $effectis = array(
     375                                'x' => "", //pas de suffixe pour la premiere colonne
     376                                'y' => "-col2");
     377                }
     378
     379                // Les modules du futur content
     380                foreach($effectis as $cases => $suffixe_bloc) {
     381                        $modules[$type_page]['content'.$suffixe_bloc] = lire_config("melusine_".$nom_traitement."/".$cases);
     382                }
     383               
     384               
     385               
     386        } // Fin de chaque type de page
     387       
     388
     389        // On va chercher dans chaque casier de bloc
     390        // les infos pour placer dans la BD
     391        // rang, type, bloc, noisette
     392        // et n place toutes les infos dans la BD
     393        include_spip('action/editer_objet');
     394
     395        // Pour chaque type de page...
     396        foreach($modules as $type_page => $blocs) {
     397                // Pour chaque typppe de bloc...
     398                foreach($blocs as $bloc => $liste_modules) {
     399                        // description des noisettes de ce bloc
     400                        $set = array(
     401                                "rang" => 0,
     402                                "type" => $type_page,
     403                                "bloc" => $bloc,
     404                                "noisette" => ""
     405                        );
     406                        //pour chaque noisette...
     407                        foreach($liste_modules as $module) {
     408                                $set['noisette'] = $module;
     409                                $set['rang']++;
     410                               
     411                                // insertion
     412                                $id_noisette = objet_inserer("noisette", $id_parent="",$set);
     413                                if (!$id_noisette)
     414                                        spip_log("Impossible d'insérer le module ".$module." dans le bloc ".$bloc." de la page ".$type_page. "au rang ".$rang);
     415                        }
     416                }
     417
     418               
     419        }
     420        return true;
     421       
     422       
    255423}
    256424
    257 /**
    258  * Fonction de recherche de l'ancien plugin DATICE
    259  *
    260  * @param
    261  *
    262  * @return text renvoie le chemin du plugin DATICE s'il est trouvé ou rien
    263 **/
    264 function melusine_cherche_chemin_datice() {
    265 
    266         $plugin_datice = "datice3/"; //Nom supposé du répertoire du plugin
    267 
    268         //chemins supposés possibles
    269         $chemins_possibles_datice = array(_DIR_PLUGINS_AUTO.$plugin_datice,_DIR_PLUGINS.$plugin_datice);
    270 
    271         foreach ($chemins_possibles_datice as $chemin_plugin_datice) {
    272                 if (file_exists($chemin_plugin_datice."balise/daticeaide.php")) return $chemin_plugin_datice;
    273         }
    274         return ""; // pas trouvé...
    275 }
     425
    276426?>
  • _squelettes_/galaxie_melusine/melusine/trunk/melusine_fonctions.php

    r82753 r82919  
    88
    99if (!defined('_ECRIRE_INC_VERSION')) return;
     10
     11// Les mêmes caches que pour le noizetier:
     12
     13include_spip('inc/filtres');
     14$f = chercher_filtre('info_plugin');
     15$noiz_actif = $f("noizetier","est_actif");
     16
     17// Si pas noizetier, on crée ls constantes
     18if (!$noiz_actif) {
     19        define('_CACHE_AJAX_NOISETTES', 'noisettes_ajax.php');
     20        define('_CACHE_CONTEXTE_NOISETTES', 'noisettes_contextes.php');
     21        define('_CACHE_DESCRIPTIONS_NOISETTES', 'noisettes_descriptions.php');
     22        define('_CACHE_INCLUSIONS_NOISETTES', 'noisettes_inclusions.php');
     23}
    1024
    1125
     
    301315
    302316}
     317
     318// Reprises de plusieurs fonctions du noizetier
     319// TODO il faudra voir à converger vraiment
     320// éventuellement en modificant le noizetier
     321// pour que ses fonctions soient dist et
     322// surchageables
     323
     324/**
     325 * Obtenir les infos de toutes les noisettes disponibles dans les dossiers noisettes/
     326 * C'est un GROS calcul lorsqu'il est a faire.
     327 *
     328 * Issu du Plugin noizetier et modifié pour Mélusine:
     329 * + Prise en compte du répertoire modules
     330 *      et des éventuels sous répertoires
     331 *      Bilan: le calcul est encore plus lourd !
     332 * + Prise en compte des noisettes sans yaml associé
     333 *
     334 * @return array
     335 */
     336function melusine_obtenir_infos_noisettes_direct(){
     337
     338        $liste_noisettes = array();
     339       
     340        // répertoires possibles pour Mélusine
     341        // et necessité d'un examen récursif'
     342        $liste_rep = array(
     343                        "noisettes/" => false,  // Compat noizetier
     344                        "modules/" => true      // Compat Mélusine
     345                );
     346               
     347        $match = "[^-]*[.]html$";
     348
     349        // diff avec noizetier: dans plusieurs répertoires
     350        // et récusrvivement
     351        $liste= array();
     352        foreach($liste_rep as $rep => $recurs) {
     353                $liste = array_merge(
     354                                $liste,
     355                                find_all_in_path(
     356                                        $rep,   // dans plusieurs rép
     357                                        $match,
     358                                        $recurs // récusrvivement ou pas
     359                                )
     360                        );
     361        }
     362               
     363        if (count($liste)){
     364                foreach($liste as $squelette=>$chemin) {
     365                        $noisette = preg_replace(',[.]html$,i', '', $squelette);
     366                        $dossier = str_replace($squelette, '', $chemin);
     367                        // On ne garde que les squelettes ayant un fichier YAML de config
     368                        if (file_exists("$dossier$noisette.yaml")
     369                                AND ($infos_noisette = melusine_charger_infos_noisette_yaml($dossier.$noisette))
     370                        ){
     371                                // diff avec noizetier:
     372                                // le sous-répertoire va être noté pour
     373                                // les inclusions... Il peut être dans
     374                                // modules ou noisettes
     375                                $sous_rep_pos = strrpos($dossier,"modules/");
     376                                if ($sous_rep_pos === false)
     377                                        $sous_rep_pos = strrpos($dossier,"noisettes/");
     378                                $liste_noisettes[$noisette] = array_merge(
     379                                                $infos_noisette,        // compat noizetier
     380                                                array("repertoire" => substr($dossier,$sous_rep_pos))   // On note le sous-rép pour l'inclusion
     381                                        );
     382                        } else {
     383                                // diff avec noizetier:
     384                                // Sans YAML, on garde la noisette
     385                                // avec des infos sommaires
     386                                $bloc = substr($dossier,strrpos($dossier,"modules/")+8,-1);
     387                                $liste_noisettes[$noisette] = array(
     388                                                "nom" => spip_ucfirst(str_replace("_"," ",$noisette)),
     389                                                "parametres" => array(),
     390                                                "contexte" => array(),
     391                                                "ajax" => "non",
     392                                                "inclusion" => "statique",
     393                                                "bloc" => $bloc,        // spécifique de Mélusine
     394                                                "repertoire" => substr($dossier,strrpos($dossier,"modules/",-1))                        // On note le sous-rép pour l'inclusion
     395                                        );
     396                        }
     397                }
     398        }
     399       
     400        // supprimer de la liste les noisettes necissant un plugin qui n'est pas actif
     401        foreach ($liste_noisettes as $noisette => $infos_noisette)
     402                if (isset($infos_noisette['necessite']))
     403                        foreach ($infos_noisette['necessite'] as $plugin)
     404                                if (!defined('_DIR_PLUGIN_'.strtoupper($plugin)))
     405                                        unset($liste_noisettes[$noisette]);
     406
     407        echo "<pre>";
     408        print_r($liste_noisettes);
     409        echo "</pre>";
     410       
     411        return $liste_noisettes;
     412}
     413/**
     414 * Charger les informations contenues dans le YAML d'une noisette
     415 * Issu du Plugin noizetier
     416 *
     417 * @param string $noisette
     418 * @param string $info
     419 * @return array
     420 */
     421function melusine_charger_infos_noisette_yaml($noisette, $info=""){
     422                // on peut appeler avec le nom du squelette
     423                $fichier = preg_replace(',[.]html$,i','',$noisette).".yaml";
     424                include_spip('inc/yaml');
     425                include_spip('inc/texte');
     426                $infos_noisette = array();
     427                if ($infos_noisette = yaml_charger_inclusions(yaml_decode_file($fichier))) {
     428                        if (isset($infos_noisette['nom']))
     429                                $infos_noisette['nom'] = _T_ou_typo($infos_noisette['nom']);
     430                        if (isset($infos_noisette['description']))
     431                                $infos_noisette['description'] = _T_ou_typo($infos_noisette['description']);
     432                        if (isset($infos_noisette['icon']))
     433                                $infos_noisette['icon'] = $infos_noisette['icon'];
     434                               
     435                        if (!isset($infos_noisette['parametres']))
     436                                $infos_noisette['parametres'] = array();
     437                               
     438                        // contexte
     439                        if (!isset($infos_noisette['contexte'])) {
     440                                $infos_noisette['contexte'] = array();
     441                        }
     442                        if (is_string($infos_noisette['contexte'])) {
     443                                $infos_noisette['contexte'] = array($infos_noisette['contexte']);
     444                        }
     445                       
     446                        // ajax
     447                        if (!isset($infos_noisette['ajax'])) {
     448                                $infos_noisette['ajax'] = 'oui';
     449                        }
     450                        // inclusion
     451                        if (!isset($infos_noisette['inclusion'])) {
     452                                $infos_noisette['inclusion'] = 'statique';
     453                        }
     454                }
     455
     456                if (!$info)
     457                        return $infos_noisette;
     458                else
     459                        return isset($infos_noisette[$info]) ? $infos_noisette[$info] : "";
     460}
     461/**
     462 * Lister les noisettes disponibles dans les dossiers noisettes/
     463 * Issu du Plugin noizetier
     464 *
     465 * @staticvar array $liste_noisettes
     466 * @param text $type renvoyer seulement un type de noisettes
     467 * @param text $noisette renvoyer spécifiquement une noisette données
     468 * @return array
     469 */
     470function melusine_lister_noisettes($type='tout'){
     471        static $liste_noisettes = array();
     472        if ($type == 'tout') {
     473                return melusine_obtenir_infos_noisettes();
     474        }
     475        if (isset($liste_noisettes[$type])) {
     476                return $liste_noisettes[$type];
     477        }
     478       
     479        $noisettes = melusine_obtenir_infos_noisettes();
     480        if ($type == '') {
     481                $match = "^[^-]*$";
     482        } else {
     483                $match = $type."-[^-]*$";
     484        }
     485       
     486        foreach($noisettes as $noisette => $description) {
     487                if (preg_match("/$match/", $noisette)) {
     488                        $liste_noisettes[$type][$noisette] = $description;
     489                }
     490        }
     491       
     492        return $liste_noisettes[$type];
     493}
     494
     495
     496/**
     497 * Renvoie les info d'une seule noisette
     498 * Issu du Plugin noizetier
     499 *
     500 * @param text $noisette renvoyer spécifiquement une noisette données
     501 * @return array
     502 */
     503function melusine_info_noisette($noisette) {
     504        $noisettes = melusine_obtenir_infos_noisettes();
     505        return $noisettes[$noisette];
     506}
     507
     508/**
     509 * Obtenir les infos de toutes les noisettes disponibles dans les dossiers noisettes/
     510 * On utilise un cache php pour alleger le calcul.
     511 * Issu du Plugin noizetier
     512 *
     513 * @param
     514 * @return
     515**/
     516function melusine_obtenir_infos_noisettes() {
     517        static $noisettes = false;
     518       
     519        // seulement 1 fois par appel, on lit ou calcule tous les contextes
     520        if ($noisettes === false) {
     521                // lire le cache des descriptions sauvees
     522                lire_fichier_securise(_DIR_CACHE . _CACHE_DESCRIPTIONS_NOISETTES, $noisettes);
     523                $noisettes = @unserialize($noisettes);
     524                // s'il en mode recalcul, on recalcule toutes les descriptions des noisettes trouvees.
     525                // ou si le cache est desactive
     526                if (!$noisettes or (_request('var_mode') == 'recalcul') or (defined('_NO_CACHE') and _NO_CACHE!=0)) {
     527                        $noisettes = melusine_obtenir_infos_noisettes_direct();
     528                        ecrire_fichier_securise(_DIR_CACHE . _CACHE_DESCRIPTIONS_NOISETTES, serialize($noisettes));
     529                }
     530        }
     531       
     532        return $noisettes;
     533}
    303534?>
  • _squelettes_/galaxie_melusine/melusine/trunk/paquet.xml

    r82854 r82919  
    22        prefix="melusine"
    33        categorie="squelette"
    4         version="2.0.2"
     4        version="2.0.3"
    55        etat="dev"
    66        compatibilite="[3.0.4;3.0.*]"
    77        logo="prive/themes/spip/images/melusine-64.png"
    88        documentation="http://datice.ac-creteil.fr/spip"
    9         schema="1.0.0"
     9        schema="1.1.0"
    1010>
    11         <!--
    12                 Paquet généré le 2012-09-27 16:59:32
    13                 (Vous pouvez bien entendu supprimer ces commentaires)
    14         -->
     11
    1512
    1613        <nom>Mélusine</nom>
     
    2320       
    2421       
     22        <pipeline nom="declarer_tables_objets_sql" inclure="base/melusine.php" />
     23        <pipeline nom="declarer_tables_interfaces" inclure="base/melusine.php" />
     24        <pipeline nom="declarer_tables_auxiliaires" inclure="base/melusine.php" />
    2525       
    2626        <pipeline nom="header_prive" inclure="css_prive.php" action="cssprive" />
    27        
    2827        <pipeline nom="affiche_milieu" inclure="melusine_pipelines.php" />
    2928       
    3029        <necessite nom="palette" compatibilite="[3.0.1;]" />
    31 
    3230        <necessite nom="Zcore" compatibilite="[2.3.0;[" />
     31       
     32        <utilise nom="noizetier" />
    3333
    3434
Note: See TracChangeset for help on using the changeset viewer.