Carnet Wiki

Astuces longues pour SPIP

Version 19 — Novembre 2012 — olivier

  • Partager des données entre plusieurs squelettes inclus (Zpip)
  • ZPIP : faire un inclure de squelette suivant une condition
  • Une boucle qui ne doit être exécutée que dans un certain contexte
  • Afficher la date du jour
  • Jouons avec les dates
  • Exporter au format CSV
  • Extraire les adresses email contenues dans un(des) texte(s)
  • Une fonction pour joliment afficher les variables de #ENV, #GET ou #SESSION
  • Connaître le niveau de profondeur d’une rubrique
  • Les modèles et leur contexte en SPIP3
  • Ne pas transformer en lien cliquable les urls saisies en dur dans un texte
  • Utiliser une boucle DATA pour récupérer des champs en CamelCase sur une base externe

(voir aussi Astuces courtes pour SPIP)


Partager des données entre plusieurs squelettes inclus (Zpip)

Question :
Dans ZPIP, la structure de base est définie à coup d’inclusion de grands blocs logiques du style

  1. ... <div id="contenu">
  2.       <INCLURE{fond=contenu/#ENV{type}, env}>
  3.     </div>
  4.     <div id="navigation">
  5.       <INCLURE{fond=navigation/#ENV{type}, env}>
  6.       <INCLURE{fond=extra/#ENV{type}, env}>
  7.     </div>....

Supposons par exemple que nous soyons dans un contexte « rubrique » http///monsite.fr/spip.php?rubriqueXX et que le squelette contenu/rubrique.html se comporte de manière à afficher l’article n°yy
Comment peut-on transmettre cet id_article dans l’inclusion extra ou dans l’inclusion navigation pour, par exemple, lister les autres articles de la rubrique ? Il faut bien que le squelette appelé connaisse l’id de l’article à exclure que seul contenu/rubrique.html connait !
Pour que extra/rubrique.html ou navigation/rubrique.html puisse tenir compte de la situation, il faut disposer d’un moyen pour leur transmettre cette valeur. Or, seul le squelette appelant peut transmettre une variable...

Réponse :
L’astuce (alambiquée) pour remonter des variables d’un squelette appelé, est d’affecter le résultat sérialisé de ce squelette à une variable tableau dans le squelette appelant :
Dans structure.html :

  1. [(#SET{myvars, [(#INCLURE{fond=vars/#ENV{type}, env})]})]

Dans vars/rubrique.html :

  1. #CACHE{3600}
  2. [(#SET{vars, #ARRAY{
  3.    objet, rubrique,
  4.    id_objet, #ENV{id_rubrique},
  5.    titreRubrique, Rubriques,
  6.    titrePage, #ENV{id_rubrique}?
  7. }})]
  8.  
  9.  
  10. <BOUCLE_rub(RUBRIQUES) {id_rubrique}>
  11.     [(#SET{vars, #GET{vars}|array_merge{#ARRAY{titreRubrique, #TITRE, idRubrique, #ID_RUBRIQUE}}})]
  12. </BOUCLE_rub>
  13.  
  14.  
  15. [(#GET{vars}|serialize)]
  16. #FILTRE{trim}

Puis dans structure.html :
<INCLURE{fond=extra/#ENV{type}, env}>


ZPIP : faire un inclure de squelette suivant une condition

dans le body de ZPIP, charger ou non un INCLURE qui contient #ENV{type}

  1. [(#ID_RUBRIQUE|=={10}|?{
  2.  ''
  3. ,
  4.  <INCLURE{fond=extra/#ENV{type}, env}>
  5. })]

ne fonctionne pas à cause de accolades de #ENV, donc contourner avec

  1. [(#ID_RUBRIQUE|=={10}|non) <INCLURE{fond=extra/#ENV{type}, env}> ]

Une boucle qui ne doit être exécutée que dans un certain contexte

Tout le monde le sait (beaucoup le déplorent) :

  1. [(#ENV{var}|=={val}|oui) <BOUCLE_test(TABLES) {critere}>...</BOUCLE_test> ]

ne fonctionne pas.

En SPIP3, le critère {si ...} permet de définir la condition d’exécution depuis la boucle elle-même.
En SPIP2, il faut utiliser le plugin « bonux » et sa boucle « CONDITION ».

Il existe néanmoins un autre moyen pour arriver à nos fins...

  1. #SET{test, #ENV{truc}|=={coucou}|?{0, 999999}}
  2. <BOUCLE_de_test(TABLES) {id_table > #GET{test}}>
  3. coucou !
  4. </BOUCLE_de_test>

Explications :

  • en premier lieu nous définissons notre test (présence de la variable « truc » dans l’environnement) et nous affectons à une variable « test » la valeur« 0 » ou « 999999 ».
    à ce stade, #GET{test} vaut donc soit « zéro », soit « neuf cent quatre-vingt-dix-neuf mille neuf cent quatre-vingt-dix-neuf ».
  • nous lançons alors la boucle dans laquelle nous demandons que l’« id_table » soit supérieur à notre valeur de test définie juste au-dessus.
    et le tour est joué...

Afficher la date du jour

Dans un squelette, afficher la date du jour (la date courante) n’est pas toujours aisé.
deux variables peuvent entrer en jeu :

  • la date retournée par la boucle dans laquelle on veut afficher notre date du jour
  • une variable nommée date passée en url ou par le biais d’un formulaire

Pour chaque cas, néanmoins, il existe une possibilité d’afficher la date du jour et ce sans que cette date soit tributaire du cache du squelette (ce sera toujours la date courante qui sera affichée)

dans une boucle dont la table possède
un champ date ou date_redac
hors boucle
pas de date ni de date_redac en url
ni passées par formulaire
#ENV{date_redac}
ou
#ENV{date}
#DATE_REDAC
ou
#DATE
variable date passée en url ou par formulaire #ENV{date_redac} #DATE_REDAC
variable date_redac passée en url ou par formulaire #ENV{date} #DATE
variables date et date_redac passées
en url ou par formulaire
définir en début de squelette la date courante avec par exemple :
#SET{cur_date, #VAL{Y-m-d h:i:s}|date}
puis l’utiliser dans le squelette avec :
#GET{cur_date}

Jouons avec les dates

<blockquote class="spip">

voir aussi saisie des dates de publication et de rédaction antérieure (spip 2.0.x et 2.1.x)

</blockquote>

-  La date du prochain jeudi qui suit #DATE :

  1. [(#VAL{Y-m-d}|date{#VAL{next Thursday}|strtotime{#DATE|affdate{U}}})]

-  Le nom du jour de l’avant-veille de #DATE :

  1. [(#VAL{Y-m-d}|date{#VAL{-2 days}|strtotime{#DATE|affdate{U}}}|nom_jour)]

-  La date de lundi prochain :

  1. [(#SET{lundi_prochain, #VAL{Y-m-d 00:00:00}|date{#VAL{next Monday}|strtotime{#DATE|affdate{U}}}})]
  2. #GET{lundi_prochain}

-  La date du dimanche d’après lundi prochain :

  1. [(#SET{dimanche_apres, #VAL{Y-m-d 23:59:59}|date{#VAL{+6days}|strtotime{#GET{lundi_prochain}|affdate{U}}}})]
  2. #GET{dimanche_apres}

-  Afficher le label nouveau ! pour un article publié ou modifié il y a moins de 10 jours :

  1. #SET{periode, -10days}
  2. #TITRE[ (#DATE_MODIF|>{#VAL{Y-m-d H:i:s}|date{#GET{periode}|strtotime}}|oui) nouveau !]

et _fil_ (sur irc) propose encore plus simple :

  1. #TITRE[ (#DATE|strtotime|>{#VAL{-10days}|strtotime}|?{ nouveau !, ''})]

Exporter au format CSV

Triton nous confie un petit exemple qui marche pour MS Excel et openOffice (il y a des particularités d’encodage de caractères) :

  1. #CACHE{0} #HTTP_HEADER{Content-Type: text/csv; charset=windows-1252/Winlatin1} #HTTP_HEADER{Content-Disposition: attachment; filename=inscriptions.csv}
  2. "date"; "nom_participant";"prenom";"paiement effectue"; "tarif_valide"; "promo";"telephone"; "email";"societe"; "nbr_part";"conjoint"; "mobile_dom";"type_paiement"; "souscripteur"
  3. <BOUCLE_les_inscriptions_ouvertes(EVENEMENTS_LESINSCRIPTIONS) {id_evenement} {nbr_part > 0}>"[(#DATE|affdate{'d-m-Y'})]";"[(#NOM_PARTICIPANT|utf8_decode)]";"[(#PRENOM|utf8_decode)]";"[(#VERIFIER_PAIEMENT_INSCRIPTION{#ID_INSCRIPTION}|utf8_decode)]";"[(#TARIF_VALIDE|utf8_decode)]";"[(#PROMO|utf8_decode)]";"[(#TELEPHONE|utf8_decode)]";"[(#EMAIL|utf8_decode)]";"[(#SOCIETE|utf8_decode)]";"[(#NBR_PART|utf8_decode)]";"[(#CONJOINT|utf8_decode)]";"[(#MOBILE_DOM|utf8_decode)]";"[(#TYPE_PAIEMENT|utf8_decode)]";"[(#SOUSCRIPTEUR|utf8_decode)]"
  4. </BOUCLE_les_inscriptions_ouvertes>
  • le http_header indique qu’il s’agit d’un document csv encodé pour MS excel
  • la premiere ligne c’est les têtières (en tete de colonne) du fichier csv
  • La boucle écrit ensuite le contenu ligne par ligne

Il faut, souvent, coller toutes les lignes comme ci-dessus, sinon, on peut, ou pas, se retrouver avec des lignes vides dans le csv....

Si tu colles ça dans un squelette (nommé squelette_cvs), il suffit ensuite d’appeler la page spip.php ?page=squelette_cvs et le navigateur te proposera de sauvegarder le fichier (ici inscriptions.csv - voir le filename au dessus) ou de l’ouvrir avec le logiciel de ton choix....

Après, faut voir à quoi doit servir ton cvs, à être lu directement par une appli type MS/ Open Office (cet exemple) ou à autre chose, import dans une base sql par exemple, auquel cas, il faudra peut-être modifier l’encodage de caractères...

Par ailleurs, paulbe indique qu’il faut d’abord passer les champs par le filtre textebrut avant de les passer à la moulinette de utf8_decode

on peut aussi « jolifier » et simplifier le code (surtout dans la boucle) :

  1. #CACHE{0}
  2. #HTTP_HEADER{Content-Type: text/csv; charset=windows-1252/Winlatin1}
  3. #HTTP_HEADER{Content-Disposition: attachment; filename=inscriptions.csv}
  4.  
  5.  
  6. "ordre"; "date"; "nom_participant"; "prenom"; "paiement effectue"; "tarif_valide"; "promo"; "telephone"; "email"; "societe"; "nbr_part"; "conjoint"; "mobile_dom"; "type_paiement"; "souscripteur"
  7.  
  8.  
  9. <BOUCLE_inscriptions_ouvertes(EVENEMENTS_LESINSCRIPTIONS) {id_evenement} {nbr_part > 0}>#VAL{#COMPTEUR_BOUCLE;"[(#DATE|affdate{'d-m-Y'})]"; "#NOM_PARTICIPANT"; "#PRENOM"; "#VERIFIER_PAIEMENT_INSCRIPTION{#ID_INSCRIPTION}"; "#TARIF_VALIDE"; "#PROMO"; "#TELEPHONE"; "#EMAIL"; "#SOCIETE"; "#NBR_PART"; "#CONJOINT"; "#MOBILE_DOM"; "#TYPE_PAIEMENT"; "#SOUSCRIPTEUR"}|textebrut|utf8_decode)]
  10. </BOUCLE_inscriptions_ouvertes>

l’astuce consiste à ajouter #COMPTEUR_BOUCLE; comme premier champ de #VAL (donc aussi "ordre"; en première ligne de la feuille)

Technique de BoOz

Pour mes exports excel avec des champs utf-8 et des accents j’utilise un squelette

export.xls.html

ici du code avec des lignes et des champs séparés par des tabulations">
  1. #HTTP_HEADER{Content-Type: application/vnd.ms-excel; charset=UTF-16LE}
  2. #HTTP_HEADER{Content-Disposition: attachment; filename=mon_export.xls}
  3.  
  4.  
  5. ici du code avec des lignes et des champs séparés par des tabulations

et aussi dans un fichier export.xls_fonctions.php spécial pour le squelette une fonction de conversion en utf16LE utilisée par Excel (merci Fil)

  1. <?php
  2. include_spip('inc/charsets');
  3. init_mb_string();
  4. ob_start('convert_utf16');
  5. function convert_utf16($txt) {
  6.   return "\xFF\xFE" . mb_convert_encoding(trim($txt), 'UTF-16LE', 'UTF-8');
  7. }
  8. ?>


Extraire les adresses email contenues dans un(des) texte(s)

  1. /**
  2.  * Le filtre extraire_email permet de récuperer toutes les adresses email
  3.  * présentes dans le texte retourné par la balise sur laquelle il s'applique.
  4.  *
  5.  * @param string $texte
  6.  *     l'affichage retourné par la balise
  7.  *             
  8.  * @return array
  9.  *     un tableau dédoublonné des adresses email
  10. **/
  11. function extraire_email($texte) {
  12.     //  /toto@truc.net étant une adresse valide ne pas confondre
  13.     //  avec toto@truc.net dans href="mailto://toto@truc.net"
  14.     $texte = preg_replace(',mailto://,', '', $texte);
  15.  
  16.  
  17. //  contrôle : voir http://tools.ietf.org/html/rfc3696#page-6
  18.     if (preg_match_all(";[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?;ims", $texte, $matches))
  19.         return array_unique($matches[0]);
  20.     return array();
  21. }

Télécharger

exemple d’utilisation dans un squelette :

  1. #SET{res, #ARRAY}
  2. <BOUCLE_art(ARTICLES) {tout}>
  3. [(#SET{res, #GET{res}|array_merge{#TEXTE|extraire_email}})]
  4. </BOUCLE_art>
  5.  
  6.  
  7. [(#GET{res}|foreach)]

Une fonction pour joliment afficher les variables de #ENV, #GET ou #SESSION

Copiée sur la fonction du débugueur debusquer_contexte() (de ecrire/public/debusquer.php), cette fonction est à déposer dans le fichier mes_options.php

  1. /**
  2.  * Une fonction récursive pour joliment afficher #ENV, #GET, #SESSION...
  3.  *    en squelette : [(#ENV|bel_env)], [(#GET|bel_env)], [(#SESSION|bel_env)]
  4.  *    ou encore [(#ARRAY{0,1, a,#SESSION, 1,#ARRAY{x,y}}|bel_env)]
  5.  *
  6.  * @param string|array $env
  7.  *    si une string est passée elle doit être le serialize d'un array
  8.  *
  9.  * @return string
  10.  *    une chaîne html affichant une <table>
  11. **/
  12. function bel_env($env) {
  13.     $env = str_replace(array('"', '&#039;'), array('"', '\''), $env);
  14.     if (is_array($env_tab = @unserialize($env))) {
  15.         $env = $env_tab;
  16.     }
  17.     if (!is_array($env)) {
  18.         return '';
  19.     }
  20.     $style = " style='border:1px solid #ddd;'";
  21.     $res = "<table style='border-collapse:collapse;'>\n";
  22.     foreach ($env as $nom => $val) {
  23.         if (is_array($val) || is_array(@unserialize($val))) {
  24.             $val = bel_env($val);
  25.         }
  26.         else {
  27.             $val = entites_html($val);
  28.         }
  29.         $res .= "<tr>\n<td$style><strong>". entites_html($nom).
  30.                    " : </strong></td><td$style>" .$val. "</td>\n</tr>\n";
  31.     }
  32.     $res .= "</table>";
  33.     return $res;
  34. }

Télécharger

ne reste plus qu’à l’appeler (que l’on soit loggé ou pas) dans un squelette avec :

  1. [(#ENV|bel_env)]

ou encore :

  1. [(#GET|bel_env)]

ou encore :

  1. [(#SESSION|bel_env)]

Connaître le niveau de profondeur d’une rubrique

-  Avec SPIP3 c’est même pas drôle :

  • #PROFONDEUR dans une boucle (RUBRIQUES)
  • #INFO_x{objet, id_objet} en dehors d’une boucle

-  Avec SPIP2.1 deux solutions :

    1. <BOUCLE_niveau(HIERARCHIE) {id_rubrique} {tout}>
    2. </BOUCLE_niveau>
    3.       #SET{niveau,#TOTAL_BOUCLE}
    4. <//B_niveau>

    et on récupère l’info avec un #GET{niveau}

  • une fonction à poser dans squelettes/mes_fonctions.php :
    1. function filtre_profondeur_dist($id_rubrique) {
    2.     $id_rubrique = intval($id_rubrique);
    3.     // sauver les calculs déjà faits
    4.     static $profs = array();
    5.     if (isset($profs[$id_rubrique])) {
    6.       return $profs[$id_rubrique];
    7.     }
    8.     // récupérer le parent.
    9.     $id_parent = sql_getfetsel('id_parent', 'spip_rubriques', 'id_rubrique='.$id_rubrique);
    10.     // pas de parent : id_rubrique n'existe pas
    11.     if (is_null($id_parent)) {
    12.       return '';
    13.     }
    14.     // parent zéro : on est tout en haut (racine)
    15.     if ($id_parent == '') {
    16.       return $profs[$id_rubrique] = 1;
    17.     }
    18.     // sinon, on trouve la profondeur du parent
    19.     $parent = filtre_profondeur_dist($id_parent);
    20.     $profs[$id_rubrique] = ($parent + 1);
    21.     return $profs[$id_rubrique];
    22. }

    Télécharger

    à appeler dans un squelette avec : [(#ID_RUBRIQUE|profondeur)]


Les modèles et leur contexte en SPIP3

En spip2 le contexte d’appel d’un modèle n’était pas connu lors de la compilation de ce modèle. Ainsi un modèle appelé depuis le corps du texte de l’article 18 ne pouvait savoir qu’il était appelé depuis cet article précis.

Cela a changé avec spip3 ; désormais le modèle véhicule le contexte de son objet appelant. Cela veut dire que appelé depuis l’article 18, le modèle intègre la donnée id_article = 18 ; donnée que l’on peut donc utiliser dans le modèle avec :

  • soit #ID_ARTICLE,
  • soit #ENV{id_article},
  • soit encore #ENV{args/id_article}.

Mais plusieurs cas peuvent se présenter :

  • modèle appelé depuis un article sans argument explicite :
    <mon_modele1>
    • #ID_ARTICLE vaudra la valeur id_article de l’article appelant (celui où se trouve l’appel du modèle)
    • #ENV{id_article} vaudra la valeur id_article de l’article appelant (celui où se trouve l’appel du modèle)
    • #ENV{args/id_article} vaudra ’’ (vide)
  • modèle appelé depuis un article avec argument explicite vide :
    <mon_modele1|id_article>
    • #ID_ARTICLE vaudra la valeur id_article de l’article appelant (celui où se trouve l’appel du modèle)
    • #ENV{id_article} vaudra la valeur id_article de l’article appelant (celui où se trouve l’appel du modèle)
    • #ENV{args/id_article} vaudra ’’ (vide)
  • modèle appelé depuis un article avec argument explicite sans valeur :
    <mon_modele1|id_article=>
    • #ID_ARTICLE vaudra ’’ (vide)
    • #ENV{id_article} vaudra ’’ (vide)
    • #ENV{args/id_article} vaudra ’’ (vide)
  • modèle appelé depuis un article avec argument explicite renseigné :
    <mon_modele1|id_article=25>
    • #ID_ARTICLE vaudra la valeur passée en argument : 25
    • #ENV{id_article} vaudra la valeur passée en argument : 25
    • #ENV{args/id_article} vaudra la valeur passée en argument : 25

Et alors ?
Connaissant l’id de l’objet (article, rubrique, mot, site...) depuis lequel notre modèle est appelé, il est désormais possible d’utiliser des boucles utilisant cette information, de telle sorte que le modèle devient ainsi contextuel en affichant des informations dépendantes de son lieu d’appel. Un même modèle appelé depuis plusieurs articles retournera ainsi des informations spécifiques différentes pour chaque article.

Attention toutefois !
Comme désormais l’id de l’objet appelant (id_article, id_rubrique, id_mot...) est toujours transmis au modèle, il devient impossible d’utiliser dans le modèle une boucle avec le critère conditionnel {id_article?} (ou {id_rubrique?}, ou {id_mot?} ...)
L’astuce consistera à utiliser 2 critères dépendants de #ENV{args/id_article} car seul #ENV{args/id_article} nous renseigne sur l’argument « id_article » passé explicitement au modèle.

  1. <BOUCLE_a_cond(ARTICLES) {id_article >= #ENV{args/id_article, 0}} {id_article <= #ENV{args/id_article, 99999999}} {"<br />"}>
  2. #ID_ARTICLE - #TITRE
  3. </BOUCLE_a_cond>

Explications :

  • si #ENV{args/id_article} existe c’est que id_article a été explicitement renseigné dans l’appel du modèle (exemple : <mon_modele1|id_article=25>).
    Dans ce cas, la boucle cherchera id_article >= 25 et id_article <= 25 ; soit (tout le monde aura trouvé) : id_article = 25 ;
  • si #ENV{args/id_article} n’existe pas (id_article n’a pas été explicitement renseigné dans l’appel du modèle : <mon_modele1>), alors la boucle cherchera id_article >= 0 et id_article <= 99999999 ; soit (tout le monde aura trouvé) : tous les articles.

on reproduit bien là le comportement de {id_article?}.


Ne pas transformer en lien cliquable les urls saisies en dur dans un texte

Si l’on veut que ce soit systématique sur l’ensemble du site, il faut ajouter dans un fichier « mes_fonctions.php » à placer dans« squelettes/ » :

  1. define('_EXTRAIRE_LIENS', '//');

Mais on peut aussi vouloir ne réserver ce traitement qu’à certains articles.
Dans une copie de « article.html » que l’on aura placée dans « squelettes/ » on écrira alors :

  1. [(#ID_ARTICLE|=={5}|ou{#ID_ARTICLE|=={62}}|oui)
  2.     [(#EVAL{define('_EXTRAIRE_LIENS', '//')})]
  3. ]
  4. <BOUCLE_principale(ARTICLES) {id_article}>
  5. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1....

ceci pour que sur les seuls articles 5 et 62 les urls saisies directement ne soient pas transformées en lien cliquable. Les urls saisies dans tous les autres articles continuant de recevoir le traitement standard de spip seront donc cliquables.


Utiliser une boucle DATA pour récupérer des champs en CamelCase sur une base externe

SPIP permet d’aller piocher des données dans une base externe (à condition qu’elle ait été déclarée depuis ecrire/?exec=admin_tech).
Il peut arriver que cette base externe contienne des tables dont les champs ont été définis en « CamelCase » (un mélange de minuscules et majuscules, comme par exemple : « NumOrdre »). Dans ce cas, SPIP est incapable d’afficher tant #NUMORDRE que #CHAMP_SQL{NumOrdre} dans la boucle.
Pour remédier à ça, nous fabriquerons une boucle DATA ainsi :

  1. #SET{req, "SELECT table_ext.ChampCamelCase FROM table_ext AS `table_ext`"}
  2. <BOUCLE_test(DATA) {source sql, connecteur:#GET{req}}>
  3.   #VALEUR{ChampCamelCase}<br />
  4. </BOUCLE_test>

Dans ce code, connecteur correspond au nom de la base externe déclarée (on peut le retrouver à partir de ecrire/?exec=admin_tech dans la liste « Bases supplémentaires déjà interrogeables :» ou en parcourant le dossier config/ pour y repérer le fichier de connexion « nom_du connecteur.php »


Retour à la version courante

Toutes les versions