Critères {precedent} et {suivant}

Le plugin « Critère précédent / suivant » pour SPIP 2.1 est une expérimentation permettant de trouver, dans une boucle donnée, l’élément suivant ou l’élément précédent. Cet usage est principalement utile pour créer des navigations par rubrique ou par thème (mots-clés).

Expérimentation

Notez avant toute chose que les critères proposés sont fonctionnels, mais expérimentaux. Nous serions preneurs de retours d’utilisation et de tests de temps de calcul des pages utilisant ces critères par rapport aux boucles que vous utilisez habituellement pour réaliser ces navigations.

Utilisation

Imaginons que nous sommes dans une boucle ARTICLES dont l’identifiant d’article est connu :

<BOUCLE_article_en_cours(ARTICLES){id_article}>
 
</BOUCLE_article_en_cours>

Nous pouvons à l’intérieur réaliser une boucle sur tous les articles de la même rubrique, classés par date :

<BOUCLE_article_en_cours(ARTICLES){id_article}>
	<BOUCLE_articles_rubrique(ARTICLES){id_rubrique}{!par date}>
	#TITRE <br/>
	</BOUCLE_articles_rubrique>
	<br/>
</BOUCLE_article_en_cours>

Si l’on veut seulement l’article précédent de la même rubrique, il suffit d’ajouter le critère {precedent}. De la même façon, si l’on souhaite juste l’article suivant l’article en cours, on ajoute le critère {suivant} :

<BOUCLE_article_en_cours(ARTICLES){id_article}>
	<BOUCLE_article_precedent(ARTICLES) {id_rubrique} {!par date} {precedent}>
	Précédent : #TITRE <br/>
	</BOUCLE_article_precedent>
 
	<BOUCLE_article_suivant(ARTICLES) {id_rubrique} {!par date} {suivant}>
	Suivant : #TITRE <br/>
	</BOUCLE_article_suivant>
	<br/>
</BOUCLE_article_en_cours>

Ces deux critères fonctionnent quels que soient les critères de sélection de la boucle et quel que soit le tri choisi, à partir du moment où la table SQL interrogée a une clé primaire simple (non composée de plusieurs champs). Cela fonctionne donc pour tous les objets standards de SPIP : auteurs, articles, rubriques, documents, mots, etc.

Nécessaire

L’identifiant de la clé primaire de la boucle sur laquelle nous allons appliquer le critère {precedent} ou {suivant} doit être connu dans un élément parent (une boucle parente ou l’environnement du squelette). Sans cet identifiant, on ne peut pas trouver de suivant ou de précédent, cela va de soi.

Principe de fonctionnement

Ces critères {precedent} et {suivant} s’inspirent beaucoup du code du critère pagination de SPIP 2.1, capable de placer le numéro de pagination sur un identifiant d’article donné. Merci Cédric !

Prenons un cas simple :

<BOUCLE_suivant(RUBRIQUES){racine}{!par date} {suivant}>
#TITRE.
</BOUCLE_suivant>

L’action du critère est la suivante :

  1. on va chercher dans les boucles parentes, sinon dans l’environnement, l’identifiant de la boucle connue : ici, la valeur de id_rubrique pour cette boucle RUBRIQUES.
  2. on récupère l’ensemble des résultats répondant aux critères de sélection de la boucle, comme s’il n’y avait pas le critère {suivant}, c’est à dire ici, la liste de toutes les rubriques racines.
  3. la liste est parcourue jusqu’à trouver une entrée de la liste qui a la même valeur que l’identifiant de la boucle : que les id_rubriques soient égaux ici.
  4. on place le curseur de boucle sur l’élément de la liste qui était juste avant dans le cas du critère précédent, ou juste après dans le cas du critère suivant.
  5. on indique qu’il n’y a qu’un seul résultat à cette boucle. La boucle est alors affichée par SPIP.

Le calcul des éléments passe donc par une analyse des résultats de la boucle, ce qui fait que si la boucle d’origine renvoie un grand nombre de résultats, ce calcul peut être long et n’est pas optimisé. Néanmoins, il permet d’avoir des critères génériques pour afficher des éléments précédents et suivants.

Évolution

Une évolution possible est de pouvoir indiquer via un critère, dont le nom est encore à définir, de récupérer non pas 1 élément suivant ou précédent, mais d’indiquer de combien de lignes de résultats on se déplace avant ou après l’identifiant de boucle actif, d’une part, et d’obtenir autant de lignes de résultats que souhaitées.

Si des idées vous naissent :)

Inclusions fournies avec le plugin

Le plugin fournit en exemple une inclusion pour les articles, permettant d’afficher des liens vers les articles précédents et suivants.

L’inclusion est inclure/article_precedent_suivant. Il faut absolument lui transmettre un id_article !

<BOUCLE_art(ARTICLES){id_article}>
[(#INCLURE{fond=inclure/article_precedent_suivant,id_article})]
[(#INCLURE{fond=inclure/article_precedent_suivant,id_article,id_rubrique})] // dans la rubrique
[(#INCLURE{fond=inclure/article_precedent_suivant,id_article,id_mot=3})] // ayant le mot 3
[(#INCLURE{fond=inclure/article_precedent_suivant,id_article,id_auteur=8})] // ...
</BOUCLE_art>

Il est possible de mettre du texte à côté des flèches précédent/suivant dans l’inclusion en passant les variables texte_precedent et texte_suivant :

[(#INCLURE{fond=inclure/article_precedent_suivant,id_article,texte_precedent=Article précédent,texte_suivant=Article suivant})]

Si aucune variable n’est définie, il n’y a pas de texte.

Il est également possible de faire varier dynamiquement le sens du tri avec la variable senstri (voir https://www.spip.net/fr_article5530.html).

Discussion

11 discussions

  • Salut,

    Pour ceux qui aurait la flemme d’installer le plugin le critère {where} peu s’avérer utile :

    Dans une boucle article pour avoir l’article suivant par ordre alphabétique :

    <BOUCLE_article_suivant(ARTICLES){where titre > '#TITRE'}{par titre}{0,1}>
       article suivant par titre -> #TITRE
    <BOUCLE_article_suivant>

    Voila :D

    Répondre à ce message

  • 2

    Bonjour,

    Ça fait plusieurs jours que je me casse la tête sur le problème, à savoir d’avoir une pagination Précédent et une pagination Suivante séparé et qui prennent en compte le critère pagination 5. Je vous livre mes résultats.

    squelettes\modeles\pagination_precedent.html

    #ENV*{bloc_ancre}
    #SET{bornes,#ENV{page_courante}|bornes_pagination{#ENV{nombre_pages},10}}
    #SET{premiere, #GET{bornes}|reset}
    #SET{derniere, #GET{bornes}|end}
    #SET{separateur,#ENV{separateur,'|'}}
    #SET{i,#ENV{page_courante}|moins{1}}
    [(#GET{i}|>{0}|?{' '})[
            (#SET{item, #GET{i}|moins{1}|mult{#ENV{pas}} })
            ][(#INCLURE{fond=modeles/paginationitem}{num=#GET{i}}{texte=<:public:page_precedente:>}{separateur=''}{url=#ENV{url}|parametre_url{#ENV{debut},#GET{item}}|ancre_url{#ENV{ancre}}}{page_courante=#ENV{page_courante}}{derniere=#ENV{derniere}})]
            #SET{i,#GET{i}|plus{2}}
            [(#GET{i}|<={#ENV{nombre_pages}}|?{#GET{separateur}})]
    ]

    squelettes\modeles\pagination_suivant.html

    #ENV*{bloc_ancre}
    #SET{bornes,#ENV{page_courante}|bornes_pagination{#ENV{nombre_pages},10}}
    #SET{premiere, #GET{bornes}|reset}
    #SET{derniere, #GET{bornes}|end}
    #SET{separateur,#ENV{separateur,'|'}}
    #SET{i,#ENV{page_courante}|plus{1}}
    [(#GET{i}|<={#ENV{nombre_pages}}|?{' '})[
            (#SET{item, #GET{i}|moins{1}|mult{#ENV{pas}} })
            ][(#INCLURE{fond=modeles/paginationitem}{num=#GET{i}}{texte=<:public:page_suivante:>}{separateur=''}{url=#ENV{url}|parametre_url{#ENV{debut},#GET{item}}|ancre_url{#ENV{ancre}}}{page_courante=#ENV{page_courante}}{derniere=#ENV{derniere}})]
    ]

    et j’ajoute à ma boucle article

      [<p class="pagination">(#PAGINATION{precedent})</p>]  
        
        [<p class="pagination">(#PAGINATION{suivant})</p>]  

    Dans mon cas, voici ce que ça donne :

    <B_article>
            #ANCRE_PAGINATION
            <BOUCLE_articles(ARTICLES){id_mot=37} {par date} {pagination 2}>
            
            </BOUCLE_articles>
        [<p class="pagination">(#PAGINATION)</p>] 
        
        [<p class="pagination">(#PAGINATION{precedent})</p>]  
        
        [<p class="pagination">(#PAGINATION{suivant})</p>]  
    
    </B_articles>
    • Bonjour,
      C’est le type de pagination que je recherchais en alternative à un scroll infini.
      J’ai placé ce script dans mon sommaire, et le plugin dans les articles.
      Tout fonctionne comme il faut, à part à la dernière page, il n’y a pas de lien « page précédente ».
      Si quelqu’un a une solution...

      Merci à vous.

    • ...suite et précision.

      à part à la dernière page, il n’y a pas de lien « page précédente »

      pour le script du message deZaa

    Répondre à ce message

  • Bonjour,

    J’ai mis en place le dispositif « suivant / précédent » sur une rubrique.

    Seulement à droite, j’ai un encadré listant 5 articles suivi de la pagination de la totalité des articles de la rubrique.

    Quand je navigue et que par exemple, je dépasse le 5e article, à droite ça ne bouge pas. Comment synchroniser les deux ?

    Site : http://malle-arts.org/spip.php?article209 (il s’agit du premier article de la rubrique)

    Merci

    Robert

    Répondre à ce message

  • 2

    Bonjour,

    juste une petite suggestion, sans plugin, pour ceux qui voudraient un peu plus de liberté dans les critères (certes via une boucle un peu moins glamour) :

    	<BOUCLE_article(ARTICLES) {id_article}>
     
    		<BOUCLE_posterieur(ARTICLES) {!id_article} {date >= #DATE}{par date, id_article}{0,1}>
    		Suivant : #TITRE <br/>
    		</BOUCLE_posterieur>
     
    		<BOUCLE_anterieur(ARTICLES) {!id_article} {date < #DATE}{par date, id_article}{n-1,n}>
    		Précédent : #TITRE <br/>
    		</BOUCLE_anterieur>	
     
    	</BOUCLE_article>
    • En quoi ça donne plus de liberté ?

    • nestor

      Réponse à retardement...

      Bah je sais pas, par exemple, par rapport aux limitations actuelles du plugin :

      « Une évolution possible est de pouvoir indiquer via un critère, dont le nom est encore à définir, de récupérer non pas 1 élément suivant ou précédent, mais d’indiquer de combien de lignes de résultats on se déplace avant ou après l’identifiant de boucle actif, d’une part, et d’obtenir autant de lignes de résultats que souhaitées.

      Si des idées vous naissent :) »

      Ici :

              <BOUCLE_article(ARTICLES) {id_article}>
       
                      <BOUCLE_deux_apres (ARTICLES) {!id_article} {date >= #DATE}{par date, id_article}{1,2}>
                      Deux résultats après : #TITRE <br/>
                      </BOUCLE_deux_apres>
       
                      <ul>
                      <BOUCLE_deux_a_quatre_avant(ARTICLES) {!id_article} {date < #DATE}{par date, id_article}{n-3,n-1}>
                      <h2>Deux à quatre résultats avant :</h2>
                      <li>#TITRE </li>
                      </BOUCLE_deux_a_quatre_avant>   
                      </ul> 
       
              </BOUCLE_article>

      Mais je ne jetais pas de pavé dans la mare, ce plugin est super !

    Répondre à ce message

  • Bonjour
    je debute avec spip et j’ai du mal a utiliser ce plugin ..
    je l’ai installer
    je ne trouve pas comment bien l’utiliser
    dans mon squelette article je voudrais ajouter un lien suivant precedant qui ne fonctionne que par id et dans la même rubrique c’est possible ?
    mais cela ne fonctionne pas j’ai une erreur de squelette ...
    pouvez-vous m’aider ?
    Merci

    Répondre à ce message

  • Glika Tchu

    Ce plugin semble être chez moi incompatible avec d’autres plugins (version spip 2.1) : installation faite, cela désactive les autres plugins que j’avais installé (social tags, menus déroulants, CFG).

    Répondre à ce message

  • 1

    Bonjour

    Dans le squelette j’ai ajouté :

    <B_art>
    <BOUCLE_art(ARTICLES){id_article}>
    [(#INCLURE{fond=inclure/article_precedent_suivant,id_article,id_rubrique})] 
    </BOUCLE_art>
    </B_art>

    J’ai enlevé //dans la rubrique mais il apparaît quand même . J,ai vidé la cache.
    Voir en ligne un article de http;//www.conceptvirtuel.ca/ogpac

    Répondre à ce message

  • 2

    Bonjour,
    Super, ça marche aussi avec classement par ordre alphabétique ! Merci Matthieu.
    Jean-Baptiste

    • Un exemple de ta boucle fera plaisir à tout le monde :) Tant qu’à faire !

    • et voilà :

      <BOUCLE_article_en_cours(ARTICLES){id_article}>
      <BOUCLE_article_precedent(ARTICLES) {id_rubrique} {par titre} {precedent}>
      Précédent : #TITRE <br/>
      </BOUCLE_article_precedent>
      <BOUCLE_article_suivant(ARTICLES) {id_rubrique} {par titre} {suivant}>
      Suivant : #TITRE <br/>
      </BOUCLE_article_suivant>
      <br/>
      </BOUCLE_article_en_cours>

    Répondre à ce message

  • Imaginons un site multilingue à traduction aléatoire, il est assez complexe de trouver l’article suivant dans notre langue ou non (à défaut dans sa langue originale)

    Le code de l’inclure doit changer pour :

    <BOUCLE_article_precedent(ARTICLES){origine_traduction}{precedent}{!par date}
    	{id_rubrique?}
    	{id_mot?}
    	{id_auteur?}
    	{id_groupe?}>
    	<BOUCLE_trads_precedents(ARTICLES){traduction}{lang}>
    	[<a href="#URL_ARTICLE" rel="prev" class="spip_in prev" title="[(#TITRE|couper{20}|attribut_html)]">(#CHEMIN{images/precedent.png}|image_reduire{20,20}|inserer_attribut{alt,<:csp:alt_lien_prev:>})</a>]
    	</BOUCLE_trads_precedents>
    	</B_trads_precedents>
    	[<a href="#URL_ARTICLE" rel="prev" class="spip_in prev" title="[(#TITRE|couper{20}|attribut_html)]">(#CHEMIN{images/precedent.png}|image_reduire{20,20}|inserer_attribut{alt,<:csp:alt_lien_prev:>})</a>]
    	<//B_trads_precedents>
    </BOUCLE_article_precedent>
    <BOUCLE_article_suivant(ARTICLES){suivant}{origine_traduction} {!par date}
    	{id_rubrique?}
    	{id_mot?}
    	{id_auteur?}
    	{id_groupe?}>
    	<BOUCLE_trads_suivants(ARTICLES){traduction}{lang}>
    		[<a href="#URL_ARTICLE" rel="next" class="spip_in next" title="[(#TITRE|couper{20}|attribut_html)]">(#CHEMIN{images/suivant.png}|image_reduire{20,20}|inserer_attribut{alt,<:csp:alt_lien_next:>})</a>]
    	</BOUCLE_trads_suivants>
    	</B_trads_suivants>
    	[<a href="#URL_ARTICLE" rel="next" class="spip_in next" title="[(#TITRE|couper{20}|attribut_html)]">(#CHEMIN{images/suivant.png}|image_reduire{20,20}|inserer_attribut{alt,<:csp:alt_lien_next:>})</a>]
    	<//B_trads_suivants>
    </BOUCLE_article_suivant>

    Mais cela ne suffit pas, car les critères suivant et précédent ont besoin de connaitre l’id_article original donc l’appel à l’inclure devra par exemple se faire de la sorte dans une boucle articles du squelette parent :

    [(#ID_TRAD|>{0}|oui)#SET{id_article,#ID_TRAD}]
    [(#ID_TRAD|>{0}|non)#SET{id_article,#ID_ARTICLE}]
    [<div class="precedent_suivant">
    	(#INCLURE{fond=inclure/article_precedent_suivant,id_article=#GET{id_article},id_rubrique,lang#LANG})
    </div>]

    Répondre à ce message

  • Une évolution possible est de pouvoir indiquer via un critère, dont le nom est encore à définir, de récupérer non pas 1 élément suivant ou précédent, mais d’indiquer de combien de lignes de résultats on se déplace avant ou après l’identifiant de boucle actif, d’une part, et d’obtenir autant de lignes de résultats que souhaitées.

    Ouaiiis !

    <BOUCLE_precedents(ARTICLES){!par date}{precedent}{0,5}>
    
    <BOUCLE_suivants(ARTICLES){!par date}{suivant}{0,5}>

    Répondre à ce message

Ajouter un commentaire

Qui êtes-vous ?
  • [Se connecter]

Pour afficher votre trombine avec votre message, enregistrez-la d’abord sur gravatar.com (gratuit et indolore) et n’oubliez pas d’indiquer votre adresse e-mail ici.

Ajoutez votre commentaire ici

Ce champ accepte les raccourcis SPIP {{gras}} {italique} -*liste [texte->url] <quote> <code> et le code HTML <q> <del> <ins>. Pour créer des paragraphes, laissez simplement des lignes vides.

Ajouter un document

Suivre les commentaires : RSS 2.0 | Atom

Dernière modification de cette page le 1er novembre 2017