SPIP-Contrib

SPIP-Contrib

عربي | Deutsch | English | Español | français | italiano | Nederlands

286 Plugins, 197 contribs sur SPIP-Zone, 224 visiteurs en ce moment

Accueil > Squelettes > Tutoriels pour squelettes > Classer les articles par nombre de commentaires

Classer les articles par nombre de commentaires

et plus largement compter le nombre d’éléments liés à chaque objet remonté par la boucle.

28 juin 2008 – par Bernt, bill – commentaires

8 votes

Voir aussi : Le plugin Bonux intègre un critère compteur inspiré de ce code. Bonux est également valable pour SPIP 3 et SPIP 3.1

Origine de cette contribution

Cette contribution est la suite d’un échange sur la liste de discussion. Les codes ont été écrits par bill. Elle a été créée pour classer les articles par nombre de commentaires mais plus largement elle peut servir à compter le nombre d’éléments liés à chaque objet remonté par la boucle.

Nous commencerons par présenter le cas pratique à l’origine du code pour dans un second temps mieux expliquer la démarche.

I. Exemple d’utilisation

Classer les articles par nombre de commentaires peut donner un plus à tous les sites qui font appel à la participation des internautes via les forums des articles et veulent mettre en valeur celle-ci.

Vous allez copier deux fonctions dans votre fichier mes_fonctions.php et utiliser une boucle avec le critère {compteur_publie forum}.

1. Code à copier dans le fichier mes_fonctions.php

  1. function critere_compteur_publie($idb, &$boucles, $crit){
  2. $op='';
  3. $boucle = &$boucles[$idb];
  4. $params = $crit->param;
  5. $type = array_shift($params);
  6. $type = $type[0]->texte;
  7. if(preg_match(',^(\w+)([<>=])([0-9]+)$,',$type,$r)){
  8. $type=$r[1];
  9. $op=$r[2];
  10. $op_val=$r[3];
  11. }
  12. $type_id = 'compt.id_'.$type;
  13. $type_requete = $boucle->type_requete;
  14. $id_table = $boucle->id_table . '.' . $boucle->primary;
  15. $boucle->select[]= 'COUNT('.$type_id.') AS compteur_'.$type;
  16. $boucle->from['compt']="spip_".$type;
  17. $boucle->where[]= array("'='", "'".$id_table."'", "'compt.".$boucle->primary."'");
  18. $boucle->where[]= array("'='", "'compt.statut'" , "'\"publie\"'");
  19. $boucle->group[]=$id_table;
  20. if ($op)
  21. $boucle->having[]= array("'".$op."'", "'compteur_".$type."'",$op_val);
  22.  
  23. }
  24.  
  25. function balise_COMPTEUR_FORUM_dist($p) {
  26. $p->code = '$Pile[$SP][\'compteur_forum\']';
  27. $p->interdire_scripts = false;
  28. return $p;
  29. }

Télécharger

2. Boucle pour classer les articles par nombre de commentaires

  1. <B_m>
  2. #ANCRE_PAGINATION
  3. <BOUCLE_m(ARTICLES){compteur_publie forum>0}{!par compteur_forum}{pagination}>
  4. #TITRE contient #COMPTEUR_FORUM messages<br />
  5. </BOUCLE_m>
  6. #PAGINATION
  7. </B_m>

Télécharger

II. Pour aller plus loin : l’objectif du code

Le but est de créer un critère qui réalise une jointure et compte le nombre d’éléments liés à chaque objet remonté par la boucle.

Il faut donc nommer la table sur laquelle on souhaite réaliser la jointure.

Cette table devra impérativement contenir la clé primaire de la boucle utilisée comme clé étrangère.

On pourra donc typiquement compter le nombre d’article par rubrique, le nombre de mots par groupe ou le nombre de messages d’un article.

Attention : Ce code ne s’applique pas aux relations n<->n, il faut alors utiliser le critère {frequence xxx} du plugin nuage.

  1. function critere_compteur($idb, &$boucles, $crit){
  2. $op='';
  3. $boucle = &$boucles[$idb];
  4. $params = $crit->param;
  5. $type = array_shift($params);
  6. $type = $type[0]->texte;
  7. if(preg_match(',^(\w+)([<>=])([0-9]+)$,',$type,$r)){
  8. $type=$r[1];
  9. $op=$r[2];
  10. $op_val=$r[3];
  11. }
  12. $type_id = 'compt.id_'.$type;
  13. $type_requete = $boucle->type_requete;
  14. $id_table = $boucle->id_table . '.' . $boucle->primary;
  15. $boucle->select[]= 'COUNT('.$type_id.') AS compteur_'.$type;
  16. $boucle->from['compt']="spip_".$type;
  17. $boucle->where[]= array("'='", "'".$id_table."'", "'compt.".$boucle->primary."'");
  18. $boucle->group[]=$id_table;
  19. if ($op)
  20. $boucle->having[]= array("'".$op."'", "'compteur_".$type."'",$op_val);
  21.  
  22. }

Télécharger

La requête générée par la boucle contiendra donc une jointure et un champ « count ».

La syntaxe à utiliser est la suivante :

  1. <BOUCLE_X(XXX){compteur yyy>0}{!par compteur_yyy}>

On peut utiliser le compteur comme critère de tri, mais pour pouvoir afficher le nombre d’element yyy liés à chaque objet XXX, il faudra définir la balise :

  1. function balise_COMPTEUR_YYY_dist($p) {
  2. $p->code = '$Pile[$SP][\'compteur_yyy\']';
  3. $p->interdire_scripts = false;
  4. return $p;
  5. }

Télécharger

Par exemple, on pourra chercher les 3 groupes de mots contenant le plus de mots :

  1. <BOUCLE_G(GROUPES_MOTS){compteur mots>0}{!par compteur_mots}{0,3}>

ou les rubriques ne contenant moins de 10 articles :

  1. <BOUCLE_R(RUBRIQUES){compteur articles<10}{par compteur_articles}>

NB : Pour réaliser le critère {compteur_publie forum}, nous avons en ajouté $boucle->where[]= array("'='", "'compt.statut'" , "'\"publie\"'");.

On filtre les statuts des objets comptés pour ne prendre en compte que ceux ayant un statut publié. Ce critère n’est donc applicable qu’aux objets ayant un statut et ne pourra donc pas s’utiliser sur les groupes de mots pour compter les mots.

Dernière modification de cette page le 30 décembre 2015

Retour en haut de la page

Vos commentaires

  • Le 1er novembre 2011 à 10:41, par Jean Christophe Villeneuve En réponse à : Classer les articles par nombre de commentaires

    Bonjour

    Je viens d’essayer ce script (celui proposé dans le commentaire par Cédric) qui fonctionne parfaitement avec un Spip 2 mais qui ne retourne aucun résultat en Spip3

    Une subtilité de Spip3 que je n’aurais pas capté ?

    Répondre à ce message

  • Le 14 octobre 2008 à 21:45, par Cerdic En réponse à : Classer les articles par nombre de commentaires

    Sur contrib, pour la page auteurs, j’ai generalise la fonction :

    1. function critere_compteur($idb, &$boucles, $crit){
    2. $boucle = &$boucles[$idb];
    3.  
    4. $params = $crit->param;
    5. $table = array_shift($params);
    6. $table = $table[0]->texte;
    7. if(preg_match(',^(\w+)([<>=])([0-9]+)$,',$table,$r)){
    8. $table=$r[1];
    9. $op=$r[2];
    10. $op_val=$r[3];
    11. }
    12. $type = objet_type($table);
    13. $type_id = id_table_objet($type);
    14. $table_sql = table_objet_sql($type);
    15.  
    16. $trouver_table = charger_fonction('trouver_table','base');
    17. $arrivee = array($table, $trouver_table($table, $boucle->sql_serveur));
    18. $depart = array($boucle->id_table,$trouver_table($boucle->id_table, $boucle->sql_serveur));
    19.  
    20. if ($compt = calculer_jointure($boucle,$depart,$arrivee)){
    21.  
    22. $boucle->select[]= "COUNT($compt.$type_id) AS compteur_$table";
    23. if ($op)
    24. $boucle->having[]= array("'".$op."'", "'compteur_".$table."'",$op_val);
    25. }
    26. }
    27.  
    28. function balise_COMPTEUR_dist($p) {
    29. $p->code = '';
    30. if (isset($p->param[0][1][0])
    31. AND $champ = ($p->param[0][1][0]->texte))
    32. return rindex_pile($p, "compteur_$champ", 'compteur');
    33. return $p;
    34. }

    Télécharger

    Ce qui permet d’ecrire simplement la boucle

    1. <BOUCLE_auteurs(AUTEURS){compteur articles}{0,20}{par compteur_articles}{articles.statut=publie}>
    2. #NOM : #ID_AUTEUR : #COMPTEUR{articles} <br />
    3. </BOUCLE_auteurs>

    Télécharger

    • Le 11 février 2010 à 01:18, par Birdy En réponse à : Classer les articles par nombre de commentaires

      Très bon boulot !
      Cependant, attention aux jointures forcées (cf. doc) ; il faut bien spécifier la table du champ de calcul, sinon, (sauf erreur de ma part) ça supprime une des tables défini.
      Par exemple, faire un équivalent SPIP de cette simple requête SQL (requête comptant le nombre d’article associés à chaque mot clé, trié par ce comptage décroissant) :

      SELECT titre, count(id_article) as nombre_articles
      FROM spip_mots_articles NATURAL JOIN spip_mots
      GROUP BY titre
      ORDER BY nombre_articles DESC

      SPIP :

      <BOUCLE_test(MOTS_ARTICLES mots){fusion titre}{!par nombre_articles}>
              #TITRE : [(#EXPRESSION{COUNT(mots_articles.id_article), nombre_articles})]<br/>
      </BOUCLE_test>

      Si on code COUNT(id_article) au lieu de COUNT(mots_articles.id_article) , la requête fini avec FROM spip_mots sans jointure avec l’autre table définie.
      Du coup, SPIP retourne une erreur indiquant que id_article est un champ inconnu.

    • Le 21 avril 2010 à 12:56, par ruben En réponse à : Classer les articles par nombre de commentaires

      Bonjour
      Souhaitant classer les auteurs en fonction du nombre d’article j’ai voulu reprendre ta fonction Cedric, mais elle ne fonctionne pas de mon côté !
      Ça me renvoie une erreur concernant la ligne

      1. $type = objet_type($table);

      Pour info il s’agit d’une installation sur une version spip 1.9.1 (pas mise à jour à cause de beaucoup de modifs et pas mal de fainéantise surtout)

    Répondre à ce message

  • Le 4 juillet 2008 à 03:59, par François Schreuer En réponse à : Classer les articles par nombre de commentaires

    Félicitations, voilà une contrib extrêmement utile qui comble ce qui était jusqu’à présent une lacune de SPIP. Un tout grand merci.

    (soit dit en passant, je pense que ça vaudrait la peine de suggérer l’intégration des critères et balises définis ici dans la distribution officielle de SPIP)

    Répondre à ce message

  • Le 3 juillet 2008 à 05:09, par laurent En réponse à : Classer les articles par nombre de commentaires

    Merci pour ce script très brillant. J’en voit de multiples applications. Cependant quelques petits commentaires sur le code pour un spipeur débutant auraient été bienvennues.

    Je vais essayer de l’utiliser pour faire un tri par nombre d’occurences d’un mot-clé.

    Merci encore
    Laurent

    • Le 3 juillet 2008 à 13:29, par ? En réponse à : Classer les articles par nombre de commentaires

      Ah ben non, pas du tout, pour ca c’est le critère frequence du plugin nuage (+ voir article de James sur le sujet)

      Il faudrait sans doute expliquer un peu mieux la différence relation 1 <-> n / relation n <-> n

      @++

    Répondre à ce message

Répondre à cet article

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 Les choses à faire avant de poser une question (Prolégomènes aux rapports de bugs. )
Ajouter un document

Retour en haut de la page

Ça discute par ici

  • Spip2Spip

    21 février 2008 – 158 commentaires

    Spip2spip permet de synchroniser le contenu de plusieurs sites SPIP entre eux en étendant le principe de la syndication thématique. Les articles d’un SPIP sont récopiés d’un site à l’autre en conservant leur formatage (...)

  • Plugin Duplicator

    3 janvier 2010 – 84 commentaires

    Duplication de rubrique et de ses contenus, et duplication d’articles pour SPIP Fonctionnement Ce plugin permet de dupliquer une rubrique et son contenu depuis l’espace privé en ajoutant un bouton dans la navigation de gauche dans l’espace privé (...)

  • Ferme à SPIP

    3 janvier 2008 – 133 commentaires

    Un petit article synthétique qui explique en quelques mots et captures d’écrans comment faire une « ferme à SPIP » avec le plugin "Mutualisation" à partir d’un nom de domaine principal.

  • Réservation d’événements

    16 mars 2015 – 229 commentaires

    Ce plugin permet d’offrir aux visiteurs de s’inscrire pour un évènement du plugin Agenda et de gérer les réservations enregistrées. Installation Le plugin s’installe comme n’importe quel plugin. il nécessite : Agenda API de vérification (...)

  • Accès Restreint Partiel

    8 septembre 2014 – 22 commentaires

    Voulez-vous masquer une partie du contenu de vos articles aux visiteurs de passage ? et réserver la totalité à certains de vos membres ? Voulez-vous remplacer le contenu occulté par un appel à l’action (pour devenir Membre, bla bla bla...) ? Le (...)

Ça spipe par là