Changeset 115678 in spip-zone


Ignore:
Timestamp:
Jun 15, 2019, 2:51:58 PM (5 weeks ago)
Author:
eric@…
Message:

On supprime l'utilisation de la catégorie dans le formulaire de recherche de plugins.
De fat, on peut supprimer la liste des catégories en globale et la balise SVP_CATEGORIES.
Renommage de la fonction de mise à jour de la catégorie d'un plugin.

Location:
_core_/plugins/svp
Files:
1 deleted
7 edited

Legend:

Unmodified
Added
Removed
  • _core_/plugins/svp/formulaires/charger_plugin.html

    r111773 r115678  
    2727                                                <input type="text" name="phrase" id="phrase" value="#ENV{phrase}" class="text" placeholder="<:svp:placeholder_phrase:>" />
    2828                                        </div>
    29                                         <div class="editer editer_categorie obligatoire[(#ENV{erreurs}|table_valeur{categorie}|oui) erreur]">
    30                                                 <label for="categorie"><:svp:label_critere_categorie:></label>
    31                                                 [<span class="erreur_message">(#ENV{erreurs}|table_valeur{categorie})</span>]
    32                                                 <INCLURE{fond=formulaires/inc-select_categorie, categorie=#ENV{categorie}, env} />
    33                                         </div>
    3429                                        <div class="editer editer_etat obligatoire[(#ENV{erreurs}|table_valeur{etat}|oui) erreur]">
    3530                                                <label for="etat"><:svp:label_critere_etat:></label>
     
    5954                        </fieldset>
    6055
    61                 <p class="boutons recherche"><input type="submit" name="rechercher" class="btn submit" value="<:info_rechercher:>" /></p>
     56                <p class="boutons recherche">
     57                        <input type="submit" name="rechercher" class="btn submit" value="<:info_rechercher:>" />
     58                </p>
    6259                </div>
    6360
    64                 [(#ENV{phrase}|ou{#ENV{depot}}|ou{#ENV{categorie}}|ou{#ENV{etat}|ou{#ENV{doublon}}}|oui)
     61                [(#ENV{phrase}|ou{#ENV{depot}}|ou{#ENV{etat}|ou{#ENV{doublon}}}|oui)
    6562                <div class="liste-plugins">
    6663                        <fieldset>
  • _core_/plugins/svp/formulaires/charger_plugin.php

    r102752 r115678  
    2626        return array(
    2727                'phrase' => _request('phrase'),
    28                 'categorie' => _request('categorie'),
    2928                'etat' => _request('etat'),
    3029                'depot' => _request('depot'),
  • _core_/plugins/svp/inc/svp_depoter_distant.php

    r115671 r115678  
    498498                        $insert_plugin['categorie'] = '';
    499499                        if ($utiliser_categorie) {
    500                                 $insert_plugin['categorie'] = type_plugin_acquerir('categorie', $insert_plugin['prefixe']);
     500                                $insert_plugin['categorie'] = plugin_acquerir_type($insert_plugin['prefixe'], 'categorie');
    501501                        }
    502502
     
    504504                        // du serveur de référentiel de plugins. Sinon, on force le champ à vide.
    505505                        $insert_plugin['tags'] = '';
    506                         if ($utiliser_categorie) {
    507                                 $insert_plugin['tags'] = type_plugin_acquerir('tag', $insert_plugin['prefixe']);
     506                        if ($utiliser_tag) {
     507                                $insert_plugin['tags'] = plugin_acquerir_type($insert_plugin['prefixe'], 'tag');
    508508                        }
    509509                } else {
     
    776776
    777777                $plugin_en_cours = 0;
    778                 $inserts = array();
     778                $inserts = $complements = array();
    779779
    780780                foreach ($resultats as $paquet) {
  • _core_/plugins/svp/inc/svp_depoter_local.php

    r115671 r115678  
    276276                                $le_plugin = $champs['plugin'];
    277277
    278                                 // Mettre le préfixeen majuscule si besoin
     278                                // Mettre le préfixe en majuscule si besoin
    279279                                $prefixe = strtoupper($le_plugin['prefixe']);
    280280
     
    283283                                $le_plugin['categorie'] = '';
    284284                                if ($utiliser_categorie) {
    285                                         $le_plugin['categorie'] = type_plugin_acquerir('categorie', $prefixe);
     285                                        $le_plugin['categorie'] = plugin_acquerir_type($prefixe, 'categorie');
    286286                                }
    287287
     
    289289                                // du serveur de référentiel de plugins. Sinon, on force le champ à vide.
    290290                                $le_plugin['tags'] = '';
    291                                 if ($utiliser_categorie) {
    292                                         $le_plugin['tags'] = type_plugin_acquerir('tag', $prefixe);
     291                                if ($utiliser_tag) {
     292                                        $le_plugin['tags'] = plugin_acquerir_type($prefixe, 'tag');
    293293                                }
    294294
  • _core_/plugins/svp/inc/svp_phraser.php

    r100309 r115678  
    5050define('_SVP_REGEXP_BALISE_MULTIS', '#<multis[^>]*>(.*)</multis>#Uims');
    5151
    52 
    53 // Liste des categories de plugin
    54 # define('_CATEGORIES_PLUGIN', serialize($categories_plugin));
    55 $GLOBALS['categories_plugin'] = array(
    56         'communication',
    57         'edition',
    58         'multimedia',
    59         'navigation',
    60         'date',
    61         'divers',
    62         'auteur',
    63         'statistique',
    64         'performance',
    65         'maintenance',
    66         'outil',
    67         'theme',
    68         'squelette',
    69         'aucune'
    70 );
    7152
    7253/** Liste des balises techniques autorisées dans la balise <spip> */
  • _core_/plugins/svp/inc/svp_typologie.php

    r115671 r115678  
    88
    99if (!defined('_SVP_URL_SERVEUR_TYPOLOGIE')) {
    10         define('_SVP_URL_SERVEUR_TYPOLOGIE', 'http://');
     10        define('_SVP_URL_SERVEUR_TYPOLOGIE', 'https://demopot.smellup.net/http.api/svp/');
    1111}
    1212
     
    1717 * stockée dans un cache mis à jour toutes les 6 heures.
    1818 *
     19 * @param string $prefixe
     20 *        Préfixe du plugin concerné en majuscules.
    1921 * @param string $typologie
    2022 *        Typologie concernée : categorie ou tag.
    21  * @param array  $prefixe
    22  *        Préfixe du plugin concerné en majuscules.
    2323 *
    2424 * @return string
    2525 *        Identifiant de la catégorie ou chaine vide sinon.
    2626 */
    27 function type_plugin_acquerir($typologie, $prefixe) {
     27function plugin_acquerir_type($prefixe, $typologie) {
    2828
    2929        // Utilisation d'une statique pour éviter les requêtes multiples sur le même hit.
     
    3131
    3232        if (!isset($types[$typologie][$prefixe])) {
    33                 // On lit le cache des affeactations plugin-type.
     33                // On lit le cache des affectations plugin-type.
     34                // strpos(_SPIPERIPSUM_EVANGILE_ENDPOINT, $GLOBALS['meta']['adresse_site']) === false)
    3435                $affectations = array();
     36
    3537
    3638                // Si échut on requete le serveur
     
    9092    return $affectations_filtrees;
    9193}
    92 
    93 
    94 /**
    95  * Importe une liste de types appartenant à la même typologie.
    96  *
    97  * @param array  $liste
    98  *        Tableau des catégories présenté comme une arborescence.
    99  *
    100  * @return bool|int
    101  *         Nombre de catégories ajoutées.
    102  */
    103 function type_plugin_importer_liste($typologie, $liste) {
    104 
    105         // Initialisation du nombre de types ajoutés.
    106         $types_ajoutes = 0;
    107 
    108         if ($liste) {
    109                 // Déterminer les informations du groupe typologique.
    110                 include_spip('inc/config');
    111                 $groupe = lire_config("svptype/typologies/${typologie}", array());
    112 
    113                 if ($id_groupe = intval($groupe['id_groupe'])) {
    114                         // Identification des champs acceptables pour un type.
    115                         include_spip('base/objets');
    116                         $description_table = lister_tables_objets_sql('spip_mots');
    117                         $champs = $description_table['field'];
    118 
    119                         include_spip('action/editer_objet');
    120                         include_spip('inc/svptype_mot');
    121                         foreach ($liste as $_type) {
    122                                 // On teste l'existence du type racine :
    123                                 // - si il n'existe pas on le rajoute,
    124                                 // - sinon on ne fait rien.
    125                                 // Dans tous les cas, on réserve l'id.
    126                                 if (!$id_type = mot_lire_id($_type['identifiant'])) {
    127                                         // On insère le type racine (id_parent à 0).
    128                                         $set = array_intersect_key($_type, $champs);
    129                                         $set['id_parent'] = 0;
    130                                         $id_type = objet_inserer('mot', $id_groupe, $set);
    131 
    132                                         // Enregistrement du type ajouté.
    133                                         ++$types_ajoutes;
    134                                 }
    135 
    136                                 // On traite maintenant les sous-types si :
    137                                 // -- le groupe est arborescent
    138                                 // -- il existe des sous-types dans le fichier pour le type racine
    139                                 // -- on est sur que le type racine existe
    140                                 if (($groupe['mots_arborescents'] == 'oui')
    141                                 and isset($_type['sous-types'])
    142                                 and     $id_type) {
    143                                         // On insère les sous-types si ils ne sont pas déjà présentes dans la base.
    144                                         foreach ($_type['sous-types'] as $_sous_type) {
    145                                                 if (!mot_lire_id($_sous_type['identifiant'])) {
    146                                                         // On insère le sous-type feuille sous son parent (un seul niveau permis).
    147                                                         $set = array_intersect_key($_sous_type, $champs);
    148                                                         $set['id_parent'] = $id_type;
    149                                                         if (objet_inserer('mot', $id_groupe, $set)) {
    150                                                                 // Enregistrement du type ajouté.
    151                                                                 ++$types_ajoutes;
    152                                                         }
    153                                                 }
    154                                         }
    155                                 }
    156                         }
    157                 }
    158         }
    159 
    160         return $types_ajoutes;
    161 }
    162 
    163 
    164 /**
    165  * Importe une liste d'affectation type-plugin pour une typologie donnée.
    166  * Le format du fichier est indépendant de la typologie.
    167  *
    168  * @param string $typologie
    169  *        Typologie concernée : categorie ou tag.
    170  * @param array  $affectations
    171  *        Tableau des affectations type-plugin (agnostique vis-à-vis de la typologie).
    172  *
    173  * @return int
    174  *         Nombre d'affectations ajoutées.
    175  */
    176 function type_plugin_importer_affectation($typologie, $affectations) {
    177 
    178         // Initialisation du nombre d'affectations catégorie-plugin ajoutées.
    179         $nb_affectations_ajoutees = 0;
    180 
    181         if ($affectations) {
    182                 // Déterminer les informations du groupe typologique.
    183                 include_spip('inc/config');
    184                 $groupe = lire_config("svptype/typologies/${typologie}", array());
    185 
    186                 if ($id_groupe = intval($groupe['id_groupe'])) {
    187                         // Initialisation d'un enregistrement d'affectation.
    188                         $set = array(
    189                                 'id_groupe' => $id_groupe
    190                         );
    191 
    192                         include_spip('inc/svptype_mot');
    193                         foreach ($affectations as $_affectation) {
    194                                 // On contrôle tout d'abord que l'affectation est correcte :
    195                                 // -- type et préfixe sont renseignés,
    196                                 // -- le type existe dans la base.
    197                                 if (!empty($_affectation['type'])
    198                                 and !empty($_affectation['prefixe'])
    199                                 and ($id_mot = mot_lire_id($_affectation['type']))) {
    200                                         // On vérifie que l'affectation n'existe pas déjà pour la typologie.
    201                                         $where = array(
    202                                                 'id_mot=' . $id_mot,
    203                                                 'prefixe=' . sql_quote($_affectation['prefixe'])
    204                                         );
    205                                         if (!sql_countsel('spip_plugins_typologies', $where)) {
    206                                                 // In fine, on vérifie que le nombre maximal d'affectations pour un plugin n'est pas atteint
    207                                                 // pour la typologie.
    208                                                 $where = array(
    209                                                         'prefixe=' . sql_quote($_affectation['prefixe']),
    210                                                         'id_groupe=' . $id_groupe
    211                                                 );
    212                                                 if (!$groupe['max_affectations']
    213                                                 or (sql_countsel('spip_plugins_typologies', $where) < $groupe['max_affectations'])) {
    214                                                         // On peut insérer la nouvelle affectation
    215                                                         $set['id_mot'] = $id_mot;
    216                                                         $set['prefixe'] = $_affectation['prefixe'];
    217                                                         if (sql_insertq('spip_plugins_typologies', $set)) {
    218                                                                 // Enregistrement de l'ajout de l'affectation.
    219                                                                 ++$nb_affectations_ajoutees;
    220                                                         }
    221                                                 }
    222                                         }
    223                                 }
    224                         }
    225                 }
    226         }
    227 
    228         return $nb_affectations_ajoutees;
    229 }
    230 
    231 
    232 function type_plugin_compter_affectations($typologie, $type) {
    233 
    234         // Initialisations statiques pour les performances.
    235         static $compteurs = array();
    236         static $groupes = array();
    237 
    238         // Déterminer les informations du groupe typologique si il n'est pas encore stocké.
    239         if (!isset($groupes[$typologie])) {
    240                 include_spip('inc/config');
    241                 $groupes[$typologie] = lire_config("svptype/typologies/${typologie}", array());
    242         }
    243 
    244         // Le type est fourni soit sous forme de son identifiant soit de son id.
    245         // On calcule dans tous les cas l'id.
    246         include_spip('inc/svptype_mot');
    247         if (!$id_mot = intval($type)) {
    248                 // On a passé l'identifiant, il faut déterminer l'id du mot.
    249                 $id_mot = mot_lire_id($type);
    250         }
    251 
    252         // Recherche des affectations de plugin. Pour les catégories qui sont arborescentes, il faut distinguer :
    253         // -- les catégories de regroupement comme auteur
    254         // -- et les catégories feuille auxquelles sont attachés les plugins (auteur/extension)
    255         if (!isset($compteurs[$id_mot])) {
    256                 // Initialisation de la condition sur le groupe de mots.
    257                 $where = array('id_groupe=' . intval($groupes[$typologie]['id_groupe']));
    258 
    259                 // Déterminer le mode de recherche suivant que :
    260                 // - la typologie est arborescente ou pas
    261                 // - le type est une racine ou une feuille.
    262                 $profondeur = mot_lire_profondeur($id_mot);
    263                 if (($groupes[$typologie]['mots_arborescents'] == 'oui')
    264                 and ($profondeur == 0)) {
    265                         // La typologie est arborescente et le type est une racine, il faut établir la condition sur les mots
    266                         // feuille de cette racine.
    267                         // -- On recherche les id_mot des feuilles de la racine
    268                         $ids_enfant = mot_lire_enfants($id_mot);
    269                         $where[] = sql_in('id_mot', $ids_enfant);
    270                 } else {
    271                         // La profondeur est > 0, c'est donc une feuille qui peut être affectée à un plugin : on étabit la condition
    272                         // sur le mot lui-même.
    273                         $where[] = 'id_mot=' . $id_mot;
    274                 }
    275 
    276                 $compteurs[$id_mot] = sql_countsel('spip_plugins_typologies', $where);
    277         }
    278 
    279         return $compteurs[$id_mot];
    280 }
    281 
    282 
    283 function type_plugin_construire_selection($typologie, $options = array()) {
    284 
    285         // Déterminer les informations du groupe typologique.
    286         include_spip('inc/config');
    287         $groupe = lire_config("svptype/typologies/${typologie}", array());
    288 
    289         // Vérification des options.
    290         if ($groupe['mots_arborescents'] == 'non') {
    291                 // Seule l'option du titre est acceptée pour cette typologie car les types ne sont pas arborescents.
    292                 $options['niveau_affiche'] = '';
    293                 $options['optgroup'] = '';
    294                 $options['parent'] = '';
    295         } else {
    296                 // Pour les typologies arborescentes, il faut sélectionner les deux niveaux pour que l'option optgroup
    297                 // ait un sens et le niveau feuille pour l'option parent.
    298                 if (!empty($options['niveau_affiche'])) {
    299                         $options['optgroup'] = '';
    300                 }
    301                 if ($options['niveau_affiche'] != 'feuille') {
    302                         $options['parent'] = '';
    303                 }
    304         }
    305 
    306         // Calcul du where en fonction des options :
    307         // - 'niveau_affiche' : si vide, on affiche tout, sinon on affiche un niveau donné.
    308         $where = array('id_groupe=' . intval($groupe['id_groupe']));
    309         if (!empty($options['niveau_affiche'])) {
    310                 $where[] = 'profondeur=' . ($options['niveau_affiche'] == 'racine' ? 0 : 1);
    311         }
    312         // - 'parent' : si non vide, on affiche que les enfants du type parent.
    313         if (!empty($options['parent'])) {
    314                 include_spip('inc/svptype_mot');
    315                 $id_parent = mot_lire_id($options['parent']);
    316                 $where[] = 'id_parent=' . $id_parent;
    317         }
    318 
    319         // Calcul du select en fonction des options :
    320         // - 'option_titre' : si vide on affiche l'identifiant, sinon le titre du type.
    321         $select = array('identifiant', 'profondeur');
    322         if (!empty($options['titre_affiche'])) {
    323                 $select[] = 'titre';
    324         }
    325 
    326         // On récupère l'identifiant et éventuellement le titre des catégories de plugin requises uniquement.
    327         $from = array('spip_mots');
    328         $order_by = array('identifiant');
    329         $types = sql_allfetsel($select, $from, $where, '', $order_by);
    330 
    331         // On formate le tableau en fonction des options.
    332         // -- L'option optgroup a déjà été vérifiée : si elle est encore active, on est en présence
    333         //    d'une arborescence de types à présenter avec optgroup.
    334         //    Sinon, on veut une liste aplatie classée alphabétiquement.
    335         if (!empty($options['optgroup'])) {
    336                 // On retraite le tableau en arborescence conformément à ce qui est attendu par la saisie selection avec
    337                 // optgroup.
    338                 $data = $groupes = array();
    339                 // On initialise les groupes et on réserve l'index afin de pouvoir les reconnaitre lors de la prochaine boucle.
    340                 foreach ($types as $_type) {
    341                         if ($_type['profondeur'] == 0) {
    342                                 $index = empty($options['titre_affiche']) ? $_type['identifiant'] : $_type['titre'];
    343                                 $data[$index] = array();
    344                                 $groupes[$_type['identifiant']] = $index;
    345                         }
    346                 }
    347                 // On ajoute ensuite les enfants dans le groupe parent.
    348                 foreach ($types as $_type) {
    349                         if ($_type['profondeur'] == 1) {
    350                                 // Extraction de l'identifiant du groupe (groupe/xxxx)
    351                                 $identifiants = explode('/', $_type['identifiant']);
    352                                 $index = $groupes[$identifiants[0]];
    353                                 $data[$index][$_type['identifiant']] = empty($options['titre_affiche'])
    354                                         ? $_type['identifiant']
    355                                         : $_type['titre'];
    356                         }
    357                 }
    358         } else {
    359                 // Si on ne veut pas de optgroup, on liste les types dans l'ordre alphabétique.
    360                 // Seule l'option du titre est à considérer.
    361                 $data = !empty($options['titre_affiche'])
    362                         ? array_column($types, 'titre', 'identifiant')
    363                         : array_column($types, 'identifiant', 'identifiant');
    364         }
    365 
    366     return $data;
    367 }
    368 
    369 
    370 function type_plugin_construire_filtre($type) {
    371 
    372         $filtre = '';
    373 
    374         if ($type) {
    375                 // On détermine l'id et la profondeur du type.
    376                 include_spip('inc/svptype_mot');
    377                 if ($id = mot_lire_id($type)) {
    378                         // On détermine la profondeur du type qui est plus fiable que de tester l'existence d'un "/".
    379                         $profondeur = mot_lire_profondeur($id);
    380 
    381                         if ($profondeur == 1) {
    382                                 // Le type est un enfant, on filtre sur son id.
    383                                 $filtre = 'plugins_typologies.id_mot=' . $id;
    384                         } else {
    385                                 // Le type est une racine, on filtre en utilisant son id comme un parent.
    386                                 $filtre = 'id_parent=' . $id;
    387                         }
    388                 }
    389         }
    390 
    391         return $filtre;
    392 }
  • _core_/plugins/svp/svp_fonctions.php

    r114572 r115678  
    500500
    501501/**
    502  * Compile la balise `#SVP_CATEGORIES`
    503  *
    504  * Cette balise retourne un tableau listant chaque type de catégorie
    505  * en index, associé à sa traduction en valeur.
    506  *
    507  * Accepte 2 paramètres :
    508  * 1) le type du tri (ordre_cle ou ordre_alpha)
    509  * 2) une catégorie (dans ce cas, limite le tableau à cette seule catégorie si elle existe)
    510  *
    511  * @example
    512  *     #SVP_CATEGORIES
    513  *     #SVP_CATEGORIES{ordre_alpha}
    514  *     #SVP_CATEGORIES{ordre_cle,auteur}
    515  *
    516  * @balise
    517  * @see calcul_svp_categories()
    518  * @param Champ $p
    519  *     Pile au niveau de la balise
    520  * @return Champ
    521  *     Pile complétée par le code à générer
    522  **/
    523 function balise_SVP_CATEGORIES($p) {
    524         // tri, peut être 'ordre_cle' ou 'ordre_alpha'
    525         if (!$tri = interprete_argument_balise(1, $p)) {
    526                 $tri = "'ordre_cle'";
    527         }
    528         // catégorie (pour n'en prendre qu'une au lieu de toutes)
    529         if (!$categorie = interprete_argument_balise(2, $p)) {
    530                 $categorie = "''";
    531         }
    532         $p->code = 'calcul_svp_categories(' . $tri . ',' . $categorie . ')';
    533 
    534         return $p;
    535 }
    536 
    537 /**
    538  * Retourne un tableau listant chaque type de catégorie
    539  * en index, associé à sa traduction en valeur.
    540  *
    541  * @uses svp_traduire_categorie()
    542  *
    543  * @param string $tri
    544  *     Type de tri (ordre_cle ou ordre_alpha)
    545  * @param string $categorie
    546  *     Restreindre le tableau de retour à cette catégorie si elle existe
    547  * @return array
    548  *     Couples (type de catégorie => Texte de la catégorie)
    549  **/
    550 function calcul_svp_categories($tri = 'ordre_cle', $categorie = '') {
    551 
    552         $retour = array();
    553         include_spip('inc/svp_phraser'); // pour $GLOBALS['categories_plugin']
    554         $svp_categories = $GLOBALS['categories_plugin'];
    555 
    556         if (is_array($svp_categories)) {
    557                 if (($categorie) and in_array($categorie, $svp_categories)) {
    558                         $retour[$categorie] = _T('svp:categorie_' . strtolower($categorie));
    559                 } else {
    560                         if ($tri == 'ordre_alpha') {
    561                                 sort($svp_categories);
    562                                 // On positionne l'absence de categorie en fin du tableau
    563                                 $svp_categories[] = array_shift($svp_categories);
    564                         }
    565                         foreach ($svp_categories as $_alias) {
    566                                 $retour[$_alias] = svp_traduire_categorie($_alias);
    567                         }
    568                 }
    569         }
    570 
    571         return $retour;
    572 }
    573 
    574 
    575 /**
    576502 * Compile la balise `#SVP_BRANCHES_SPIP`
    577503 *
Note: See TracChangeset for help on using the changeset viewer.