Changeset 125403 in spip-zone


Ignore:
Timestamp:
Aug 16, 2020, 6:47:21 PM (8 months ago)
Author:
Eric Lupinacci
Message:

Mise au point du formulaire de vidage des caches : un seul formulaire par plugin.
Correction de la balise #CACHE_LISTE pour prendre en compte le type de cache

Location:
_plugins_/cache/trunk
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/cache/trunk

    • Property subgit:lock:4135f49fb67d452732ea79f398ddf82aa6ab61bd deleted
    • Property subgit:lock:ad57ddfa219641f1f54c039af5d22f1a1411b68e set to 2020-08-16T20:58:07.660
  • _plugins_/cache/trunk/ezcache/ezcache.php

    r125397 r125403  
    414414}
    415415
    416 /**
    417  * Effectue le chargement du formulaire de vidage des caches pour un plugin utilisateur donné.
    418  *
    419  * Le plugin Cache Factory propose une version simplifié du formulaire où tous les fichiers caches
    420  * sont listées par ordre alphabétique sans possibilité de regroupement.
    421  *
    422  * @uses service_cache_chercher()
    423  * @uses cache_repertorier()
    424  *
    425  * @param string $plugin        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier
    426  *                              ou un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
    427  * @param array  $options       Tableau d'options qui peut être fourni par un plugin utilisateur uniquement si celui-ci fait appel
    428  *                              au formulaire. La page cache_vider de Cache Factory n'utilise pas ce paramètre.
    429  *                              Le tableau est passé à la fonction de service de chargement du formulaire uniquement.
    430  * @param array  $configuration Configuration complète des caches du plugin utilisateur lue à partir de la meta de stockage.
    431  *
    432  * @return array Description du cache complétée par un ensemble de données propres au plugin.
    433  */
    434 function ezcache_cache_formulaire_charger($plugin, $options, $configuration) {
    435 
    436         // Stocker le préfixe et le nom du plugin de façon systématique.
    437         $valeurs = array('_prefixe' => $plugin);
    438         $informer = chercher_filtre('info_plugin');
    439         $valeurs['_nom_plugin'] = $informer($plugin, 'nom', true);
    440 
    441         // Stocker le type de cache pour l'afficher dans le titre du formulaire.
    442         $valeurs['_type_cache'] = $configuration['type_cache'];
    443 
    444         // On répertorie les caches pour vérifier qu'ils existent. Si non, on n'appelle aucune fonction spécifique.
    445         $valeurs['_caches'] = array();
    446         $caches = cache_repertorier($plugin, $configuration['type_cache'], array());
    447 
    448         // Le plugin utilisateur peut fournir un service propre pour construire le tableau des valeurs du formulaire.
    449         if ($caches) {
    450                 if ($charger = service_cache_chercher($plugin, 'cache_formulaire_charger')) {
    451                         $valeurs_plugin = $charger($plugin, $options, $configuration);
    452                         if ($valeurs_plugin) {
    453                                 $valeurs = array_merge($valeurs, $valeurs_plugin);
    454                         }
    455                 } else {
    456                         // On présente simplement les fichiers caches en ordre alphabétique en visualisant uniquement
    457                         // le sous-dossuer éventuel et le nom du fichier sans décomposition.
    458                         // On construit un pseudo groupe unique sans titre dont l'id est le préfixe du plugin, ce qui permet de gérer
    459                         // automatiquement les regroupements spécifiques de caches si besoin (par exemple, par services météo pour
    460                         // Rainette).
    461                         $valeurs['_caches'][$plugin] = array(
    462                                 'titre' => '',
    463                                 'liste' => $caches
    464                         );
    465                 }
    466         }
    467 
    468         return $valeurs;
    469 }
    470 
    471416// -----------------------------------------------------------------------
    472417// ----------------- UTILITAIRE PROPRE AU PLUGIN CACHE -------------------
  • _plugins_/cache/trunk/ezcache_fonctions.php

    r125391 r125403  
    99/**
    1010 * Compile la balise `#CACHE_LISTE` qui fournit la liste des caches pour un plugin utilisateur donné
    11  * et conformes aux filtres éventuellement fournis.
     11 * et conformes aux filtres éventuellement fournis. Pour se focaliser sur un type de cache donné du plugin
     12 * il faut le fournir en filtre avec pour critère `type_cache`.
    1213 * La signature de la balise est : `#CACHE_LISTE{plugin[, filtres]}`.
    1314 *
     
    1718 *     ```
    1819 *     #CACHE_LISTE{ezcheck}, renvoie tous les caches du plugin ezcheck
    19  *     #CACHE_LISTE{ezcheck, #ARRAY{objet, repo}}, renvoie les caches du plugin ezcheck dont l'objet est 'repo'
     20 *     #CACHE_LISTE{ezcheck, #ARRAY{type_cache, dashboard}}, renvoie tous les caches du type 'dashboard' du plugin ezcheck
     21 *     #CACHE_LISTE{ezcheck, #ARRAY{type_cache, dashboard, objet, repo}}, renvoie les caches de type dashboard du plugin ezcheck dont l'objet est 'repo'
    2022 *     ```
    2123 *
     
    5658 */
    5759function calculer_liste_cache($plugin, $filtres = array()) {
     60
     61        // Initialisation de la sortie
     62        $caches = array();
     63
     64        // Déterminer si on veut les caches d'un type de cache ou de tous les types de caches du plugin
    5865        include_spip('inc/ezcheck_cache');
     66        if (isset($filtres['type_cache'])) {
     67                // Recherche d'un filtre sur le type de cache
     68                $types_cache = array($filtres['type_cache']);
     69                unset($filtres['type_cache']);
     70        } else {
     71                $configurations = configuration_cache_lire($plugin);
     72                $types_cache = array_keys($configurations);
     73        }
    5974
    60         return cache_repertorier($plugin, $filtres);
     75        foreach ($types_cache as $_type_cache) {
     76                $caches = array_merge($caches, cache_repertorier($plugin, $_type_cache, $filtres));
     77        }
     78
     79        return $caches;
    6180}
  • _plugins_/cache/trunk/formulaires/cache_vider.html

    r125397 r125403  
    1 <div class="formulaire_spip formulaire_vider_cache formulaire_vider_cache_#ENV{_prefixe}_#ENV{_type_cache}" id="#ENV{_prefixe}_#ENV{_type_cache}">
    2 
     1<div class="formulaire_spip formulaire_vider_cache formulaire_vider_cache_#ENV{_prefixe}" id="#ENV{_prefixe}">
    32        <h3 class="titrem">
    4                 <:cache:cache_vider_titre_form{plugin=#ENV{_nom_plugin}}:>&nbsp;(<:cache:cache_vider_type_cache_form{type=#ENV{_type_cache}}:>)
     3                <:cache:cache_vider_titre_form{plugin=#ENV{_nom_plugin}}:>
    54        </h3>
    65
     
    1110        <div>
    1211                #ACTION_FORMULAIRE{#ENV{action}}
     12                <input type="hidden" name="types_cache" value="#ENV{_types_cache}" />
    1313
    14                 [(#CHEMIN{[formulaires/inc-(#ENV{_prefixe})_[(#ENV{_type_cache})_]cache_vider.html]}|oui)
    15                         <INCLURE{fond=formulaires/inc-#ENV{_prefixe}_#ENV{_type_cache}_cache_vider, env} />
     14                [(#CHEMIN{[formulaires/inc-(#ENV{_prefixe})_cache_vider.html]}|oui)
     15                        <INCLURE{fond=formulaires/inc-#ENV{_prefixe}_cache_vider, env} />
    1616                ]
    17                 [(#CHEMIN{[formulaires/inc-(#ENV{_prefixe})_[(#ENV{_type_cache})_]cache_vider.html]}|non)
     17                [(#CHEMIN{[formulaires/inc-(#ENV{_prefixe})_cache_vider.html]}|non)
    1818                        <INCLURE{fond=formulaires/inc-ezcache_cache_vider, env} />
    1919                ]
  • _plugins_/cache/trunk/formulaires/cache_vider.php

    r125397 r125403  
    1313 * le vidage de tout ou partie des fichiers.
    1414 *
    15  * @uses configuration_cache_lire()
    16  * @uses ezcache_cache_formulaire_charger()
     15 * @uses formulaire_cache_charger()
    1716 *
    1817 * @param string $plugin     Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier
    1918 *                           ou un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
    20  * @param string $type_cache Type de cache identifiant la configuration dans la liste des configurations de cache du plugin
    2119 * @param array  $options    Tableau d'options qui peut être fourni par un plugin utilisateur uniquement si celui-ci fait appel
    2220 *                           au formulaire. La page cache_vider de Cache Factory n'utilise pas ce paramètre.
     
    2725 *               - `_caches`    : (affichage) liste des descriptions des caches du plugin rangés par groupes
    2826 */
    29 function formulaires_cache_vider_charger($plugin, $type_cache, $options = array()) {
     27function formulaires_cache_vider_charger($plugin, $options = array()) {
    3028
    31         // Lecture de la configuration des caches du plugin.
     29        // Stocker le préfixe et le nom du plugin de façon systématique.
     30        $valeurs = array('_prefixe' => $plugin);
     31        $informer = chercher_filtre('info_plugin');
     32        $valeurs['_nom_plugin'] = $informer($plugin, 'nom', true);
     33
     34        // Récupérer les configurations de tous les types de cache du plugin et stocker la liste des types de cache
     35        // afin de les fournir en hidden au formulaire.
    3236        include_spip('inc/ezcache_cache');
    33         $configuration = configuration_cache_lire($plugin, $type_cache);
     37        $configurations = configuration_cache_lire($plugin);
     38        $valeurs['_types_cache'] = implode(':', array_keys($configurations));
    3439
    35         // On appelle le service de chargement des variables qui est soit celui par défaut de Cache Factory
    36         // soit celui spécifique au plugin si il existe.
    37         include_spip('ezcache/ezcache');
    38         $valeurs = ezcache_cache_formulaire_charger($plugin, $options, $configuration);
     40        // On boucle sur chaque type de cache pour répertorier les caches existant
     41        $valeurs['_caches'] = array();
     42        foreach ($configurations as $_type_cache => $_configuration) {
     43                // On répertorie les caches pour vérifier qu'ils existent. Si non, on n'appelle aucune fonction spécifique.
     44                $caches = cache_repertorier($plugin, $_type_cache, array());
     45
     46                // Le plugin utilisateur peut fournir un service propre pour construire le tableau des valeurs du formulaire
     47                // pour le type de cache concerné. Les valeurs doivent suivre la structure standard pour l'affichage.
     48                if ($caches) {
     49                        if ($charger = service_cache_chercher($plugin, "${_type_cache}_cache_formulaire_charger")) {
     50                                // Le plugin utilisateur doit présenter le tableau des caches sous la forme :
     51                                // -- ['_caches'][$_type_cache][$groupe] = array('titre', 'liste)
     52                                $valeurs_plugin = $charger($plugin, $options, $_configuration);
     53                                if ($valeurs_plugin) {
     54                                        $valeurs = array_merge($valeurs, $valeurs_plugin);
     55                                }
     56                        } else {
     57                                // On présente simplement les fichiers caches en ordre alphabétique en visualisant uniquement
     58                                // le sous-dossuer éventuel et le nom du fichier sans décomposition.
     59                                // On construit un pseudo groupe unique sans titre dont l'id est le préfixe du plugin, ce qui permet de gérer
     60                                // automatiquement les regroupements spécifiques de caches si besoin (par exemple, par services météo pour
     61                                // Rainette).
     62                                $valeurs['_caches'][$_type_cache][$plugin] = array(
     63                                        'titre' => '',
     64                                        'liste' => $caches
     65                                );
     66                        }
     67                }
     68        }
    3969
    4070        return $valeurs;
     
    4676 * @param string $plugin     Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier
    4777 *                           ou un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
    48  * @param string $type_cache Type de cache identifiant la configuration dans la liste des configurations de cache du plugin
    4978 * @param array  $options    Tableau d'options qui peut être fourni par un plugin utilisateur uniquement si celui-ci fait appel
    5079 *                           au formulaire. La page cache_vider de Cache Factory n'utilise pas ce paramètre.
     
    5382 * @return array Tableau des erreurs qui se limite à la non sélection d'au moins un cache.
    5483 */
    55 function formulaires_cache_vider_verifier($plugin, $type_cache, $options = array()) {
     84function formulaires_cache_vider_verifier($plugin, $options = array()) {
    5685        $erreurs = array();
    5786
    58         $obligatoires = array('caches');
    59         foreach ($obligatoires as $_obligatoire) {
    60                 if (!_request($_obligatoire)) {
    61                         $erreurs[$_obligatoire] = _T('info_obligatoire');
     87        $types_cache = explode(':', _request('types_cache'));
     88        if ($types_cache !== false) {
     89                $caches = array();
     90                foreach ($types_cache as $_type_cache) {
     91                        $caches_type = _request("caches_${_type_cache}");
     92                        if ($caches_type) {
     93                                $caches = array_merge($caches, $caches_type);
     94                        }
     95                }
     96
     97                if (!$caches) {
     98                        $erreurs['message_erreur'] = _T('cache:cache_vider_erreur_nocache');
    6299                }
    63100        }
     
    73110 * @param string $plugin     Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier
    74111 *                           ou un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
    75  * @param string $type_cache Type de cache identifiant la configuration dans la liste des configurations de cache du plugin
    76112 * @param array  $options    Tableau d'options qui peut être fourni par un plugin utilisateur uniquement si celui-ci fait appel
    77113 *                           au formulaire. La page cache_vider de Cache Factory n'utilise pas ce paramètre.
     
    81117 *               editable est toujours à vrai.
    82118 */
    83 function formulaires_cache_vider_traiter($plugin, $type_cache, $options = array()) {
     119function formulaires_cache_vider_traiter($plugin, $options = array()) {
    84120        $retour = array();
    85121
    86122        // On récupère les caches à supprimer
    87         $caches = _request('caches');
     123        $types_cache = explode(':', _request('types_cache'));
     124        if ($types_cache === false) {
     125                $types_cache = array();
     126        }
    88127
    89         // On appelle l'API des caches
     128        // On boucle sur tous les types pour acquérir la liste des caches à supprimer
    90129        include_spip('inc/ezcache_cache');
    91         cache_vider($plugin, $type_cache, $caches);
     130        foreach ($types_cache as $_type_cache) {
     131                // On lit la liste des caches du type concerné
     132                $caches = _request("caches_${_type_cache}");
     133
     134                // On supprimer les caches sélectionnés du type concerné
     135                if ($caches) {
     136                        cache_vider($plugin, $_type_cache, $caches);
     137                }
     138        }
    92139
    93140        $retour['message_ok'] = _T('cache:cache_vider_succes');
  • _plugins_/cache/trunk/formulaires/inc-ezcache_cache_vider.html

    r125402 r125403  
    1 <div class="editer-groupe">
    2 <BOUCLE_groupes(DATA) {source table, #ENV{_caches}}>
    3         <div class="editer editer_caches">
    4                 [<label>(#VAL{cache:cache_vider_label_choix}|_T|unique{#ENV{_prefixe}})</label>]
    5                 [<h4>(#VALEUR{titre})</h4>]
    6                 <BOUCLE_caches(DATA) {source table, #VALEUR{liste}}{par cle}>
    7                         <div class="choix">
    8                                 [(#SET{id, [(#ENV{_prefixe}|concat{_}|uniqid)]})]
    9                                 <input
    10                                         type="checkbox"
    11                                         name="caches[]"
    12                                         class="checkbox checkbox_caches #_groupes:CLE"
    13                                         id="#GET{id}"
    14                                         value="#CLE" />
    15                                 <label for="#GET{id}"[ title="(#VALEUR{nom_cache})"]>
    16                                 [(#CHEMIN{[formulaires/inc-(#ENV{_prefixe})_[(#ENV{_type_cache})_]cache_label.html]}|oui)
    17                                         <INCLURE{fond=formulaires/inc-#ENV{_prefixe}_#ENV{_type_cache}_cache_label, cache=#VALEUR} />
    18                                 ]
    19                                 [(#CHEMIN{[formulaires/inc-(#ENV{_prefixe})_[(#ENV{_type_cache})_]cache_label.html]}|non)
    20                                         [[(#VALEUR{sous_dossier})&nbsp;|&nbsp;](#VALEUR{nom_cache})]
    21                                 ]
    22                                 </label>
    23                         </div>
    24                 </BOUCLE_caches>
     1<BOUCLE_types_cache(DATA) {source table, #ENV{_caches}}>
     2#SET{type_cache, #CLE}
     3<fieldset>
     4        <legend>
     5                <:cache:cache_vider_fieldset_form{type=#GET{type_cache}}:>
     6        </legend>
     7        <div class="editer-groupe">
     8        <BOUCLE_groupes(DATA) {source table, #VALEUR}>
     9                <div class="editer editer_caches">
     10                        [<label>(#VAL{cache:cache_vider_label_choix}|_T|unique{#ENV{_prefixe}})</label>]
     11                        [<h4>(#VALEUR{titre})</h4>]
     12                        <BOUCLE_caches(DATA) {source table, #VALEUR{liste}}{par cle}>
     13                                <div class="choix">
     14                                        [(#SET{id, [(#ENV{_prefixe}|concat{#GET{type_cache}}|uniqid)]})]
     15                                        <input
     16                                                type="checkbox"
     17                                                name="caches_#GET{type_cache}[]"
     18                                                class="checkbox checkbox_caches[ (#GET{type_cache}) ]#_groupes:CLE"
     19                                                id="#GET{id}"
     20                                                value="#CLE" />
     21                                        <label for="#GET{id}"[ title="(#VALEUR{nom_cache})"]>
     22                                        [(#CHEMIN{[formulaires/inc-(#ENV{_prefixe})_[(#GET{type_cache})_]cache_label.html]}|oui)
     23                                                <INCLURE{fond=formulaires/inc-#ENV{_prefixe}_#GET{type_cache}_cache_label, cache=#VALEUR} />
     24                                        ]
     25                                        [(#CHEMIN{[formulaires/inc-(#ENV{_prefixe})_[(#GET{type_cache})_]cache_label.html]}|non)
     26                                                [[(#VALEUR{sous_dossier})&nbsp;|&nbsp;](#VALEUR{nom_cache})]
     27                                        ]
     28                                        </label>
     29                                </div>
     30                        </BOUCLE_caches>
     31                </div>
     32                <div class="action-cocher">
     33                        <a href="#" id="tout-#GET{type_cache}-#CLE"><:cache:cache_vider_cocher_tout:></a><span class="sep"> | </span>
     34                        <a href="#" id="rien-#GET{type_cache}-#CLE"><:cache:cache_vider_cocher_rien:></a>
     35                </div>
     36        </BOUCLE_groupes>
     37                <div class="editer pleine_largeur">
     38                        #BOITE_OUVRIR{'','notice'}
     39                                <p><:cache:cache_vider_notice_aucun:></p>
     40                        #BOITE_FERMER
     41                </div>
     42        <//B_groupes>
    2543        </div>
    26         <div class="action-cocher">
    27                 <a href="#" id="tout_#CLE"><:cache:cache_vider_cocher_tout:></a><span class="sep"> | </span>
    28                 <a href="#" id="rien_#CLE"><:cache:cache_vider_cocher_rien:></a>
    29         </div>
    30 </BOUCLE_groupes>
    31         <div class="editer pleine_largeur">
    32                 #BOITE_OUVRIR{'','notice'}
    33                         <p><:cache:cache_vider_notice_aucun:></p>
    34                 #BOITE_FERMER
    35         </div>
    36 <//B_groupes>
    37 </div>
     44</fieldset>
     45</BOUCLE_types_cache>
     46
    3847[(#REM) <!-- Gestion des liens tout cocher et tout décocher --> ]
    3948<script type="text/javascript">
     
    4150        (function($){
    4251                jQuery(".action-cocher a").click(function(){
    43                         var id = $(this).attr('id').split('_');
     52                        var id = $(this).attr('id').split('-');
    4453                        var action = id[0];
    45                         var groupe = id[1];
    46                         jQuery("input.checkbox.checkbox_caches." + groupe).prop("checked", action === 'tout');
     54                        var type_cache = id[1];
     55                        var groupe = id[2];
     56                        jQuery("input.checkbox.checkbox_caches." + type_cache + "." + groupe).prop("checked", action === 'tout');
    4757                        return false;
    4858                });
  • _plugins_/cache/trunk/lang/cache_fr.php

    r125397 r125403  
    77        // C
    88        'cache_vider_titre_form'      => 'Caches du plugin @plugin@',
    9         'cache_vider_type_cache_form' => 'type de cache «@type@»',
     9        'cache_vider_fieldset_form'   => 'Type de cache «&nbsp;@type@&nbsp;»',
    1010        'cache_vider_titre_page'      => 'Cache Factory',
    1111        'cache_vider_menu'            => 'Vider les caches des plugins',
     
    1313        'cache_vider_notice_aucun'    => 'Aucun cache n\'a encore été créé par le plugin.',
    1414        'cache_vider_succes'          => 'Les caches sélectionnés ont bien été supprimés.',
     15        'cache_vider_erreur_nocache'  => 'Il est obligatoire de sélectionner au moins un cache.',
    1516        'cache_vider_cocher_rien'     => 'Tout décocher',
    1617        'cache_vider_cocher_tout'     => 'Tout cocher',
  • _plugins_/cache/trunk/prive/squelettes/contenu/cache_vider.html

    r125397 r125403  
    22<h1 class="grostitre"><:cache:cache_vider_titre_page:>&nbsp;-&nbsp;<:cache:cache_vider_menu:></h1>
    33
    4 [(#REM) <!-- On boucle sur la meta "cache": par plugin puis par type de cache dans chaque plugin -->]
     4[(#REM) <!-- On boucle sur la meta "cache" pour chaque plugin -->]
    55<BOUCLE_plugins_cache(DATA){source table, #CONFIG{cache}}{par cle}>
    6         <BOUCLE_types_cache(DATA){source table, #VALEUR}{par cle}>
    7         [<div class="ajax">
    8                 (#FORMULAIRE_CACHE_VIDER*{#_plugins_cache:CLE, #CLE})
    9         </div>]
    10         </BOUCLE_types_cache>
     6[<div class="ajax">
     7        (#FORMULAIRE_CACHE_VIDER*{#CLE})
     8</div>]
    119</BOUCLE_plugins_cache>
Note: See TracChangeset for help on using the changeset viewer.