Changeset 54123 in spip-zone


Ignore:
Timestamp:
Nov 6, 2011, 4:01:45 PM (8 years ago)
Author:
cedric@…
Message:

separer les fonctions de lecture des fonction d'edition des notes, que l'on deplace dans action/editer_notation,
avec support des pipelines usuels pre/post_insertion et pre/post_edition

Location:
_plugins_/notation/trunk
Files:
4 edited
1 copied

Legend:

Unmodified
Added
Removed
  • _plugins_/notation/trunk/action/editer_notation.php

    r54094 r54123  
    1010if (!defined("_ECRIRE_INC_VERSION")) return;
    1111
    12 
    13 /**
    14  * Retourne la configuration de la ponderation (defaut : 30)
    15  * @return int : valeur de ponderation
    16  */
    17 function notation_get_ponderation(){
    18         static $ponderation="";
    19         if (!$ponderation) {
    20                 include_spip('inc/config'); // lire_config
    21                 $ponderation = lire_config('notation/ponderation',30);
    22                 $ponderation = intval($ponderation);
    23                 if ($ponderation < 1) $ponderation = 1;
    24         }
    25         return $ponderation;
    26 }
    27 
    28 
    29 /**
    30  * Nombre d'etoile a afficher en fonction de la configuration
    31  * du plugin. Varie de 1 a 10. Defaut 5.
     12include_spip('base/abstract_sql');
     13
     14/**
     15 * Inserer une nouvelle note
     16 *
     17 * @param string $objet
     18 * @param int $id_objet
     19 * @return int|bool
     20 */
     21function notation_inserer($objet, $id_objet){
     22        $champs = array(
     23                "objet" => $objet,
     24                "id_objet" => $id_objet,
     25                "id_auteur" => 0,
     26                "ip" => "",
     27                "note" => 0,
     28        );
     29
     30        // Envoyer aux plugins
     31        $champs = pipeline('pre_insertion',
     32                array(
     33                        'args' => array(
     34                                'table' => 'spip_notations',
     35                        ),
     36                        'data' => $champs
     37                )
     38        );
     39
     40        $id_notation = sql_insertq("spip_notations", $champs);
     41
     42        pipeline('post_insertion',
     43                array(
     44                        'args' => array(
     45                                'table' => 'spip_notations',
     46                                'id_objet' => $id_notation
     47                        ),
     48                        'data' => $champs
     49                )
     50        );
     51
     52        return $id_notation;
     53}
     54
     55/**
     56 * Modifier une note existante
     57 *
     58 * @param int $id_notation
     59 * @param array $set
     60 * @return bool|string
     61 */
     62function notation_modifier($id_notation, $set=array()) {
     63        include_spip('inc/modifier');
     64        include_spip('inc/filtres');
     65        $c = collecter_requests(
     66                // white list
     67                array('id_auteur','ip','note'),
     68                // black list : on ne peut pas changer sur quoi porte une note
     69                array("objet","id_objet"),
     70                // donnees eventuellement fournies
     71                $set
     72        );
     73
     74        // recuperer l'objet sur lequel porte la notation
     75        $t = sql_fetsel("objet,id_objet", "spip_notations", "id_notation=".intval($id_notation));
     76        if ($err = objet_modifier_champs('notation', $id_notation,
     77                array(),
     78                $c))
     79                return $err;
     80
     81        // mettre a jour les stats
     82        //
     83        // cette action est presque devenue inutile
     84        // comme la table spip_notations_objets
     85        // (qui devrait s'appeler spip_notations_stats plutot !)
     86        // car le critere {notation} permet d'obtenir ces resultats
     87        // totalements a jour...
     88        // Cependant, quelques cas tres particuliers de statistiques
     89        // font que je le laisse encore, comme calculer l'objet le mieux note :
     90        //      <BOUCLE_notes_pond(NOTATIONS_OBJETS){0,10}{!par note_ponderee}>
     91        // qu'il n'est pas possible de traduire dans une boucle NOTATION facilement.
     92        notation_recalculer_total($t['objet'],$t['id_objet']);
     93
     94        // invalider les caches
     95        include_spip('inc/invalideur');
     96        suivre_invalideur("id='notation/".$t['objet']."/".$t['id_objet']."'");
     97
     98        return $err;
     99}
     100
     101/**
     102 * Supprimer une note existante
    32103 *
    33  * @return int : nombre d'etoiles a afficher
    34  */
    35 function notation_get_nb_notes(){
    36         static $nb = "";
    37         if (!$nb) {
    38                 include_spip('inc/config'); // lire_config
    39                 $nb = intval(lire_config('notation/nombre', 5));
    40                 if ($nb < 1) $nb = 5;
    41                 if ($nb > 10) $nb = 10;
    42         }
    43         return $nb;
    44 }
    45 
    46 /**
    47  *  Calcule de la note ponderee
    48  *
    49  * @param float $note : note moyenne obtenue
    50  * @param int $nb : nombre de votes
    51  * @return int : note ponderee en fonction de la configuration du plugin
    52  */
    53 function notation_ponderee($note, $nb){
    54    $note_ponderee = round($note*(1-exp(-5*$nb/notation_get_ponderation())),2);
    55    return $note_ponderee;
    56 }
    57 
    58 
    59 function insert_notation(){
    60         return sql_insertq("spip_notations", array(
    61                         "objet" => "",
    62                         "id_objet" => 0,
    63                         "id_auteur" => 0,
    64                         "ip" => "",
    65                         "note" => 0
    66                         ));
    67 }
    68 
    69 function modifier_notation($id_notation,$c=array()) {
    70         // pipeline pre edition
    71         sql_updateq('spip_notations',$c,'id_notation='.sql_quote($id_notation));
    72         // pipeline post edition
     104 * @param int $id_notation
     105 * @return bool
     106 */
     107function notation_supprimer($id_notation) {
     108        // recuperer l'objet sur lequel porte la notation
     109        $t = sql_fetsel("objet,id_objet", "spip_notations", "id_notation=".intval($id_notation));
     110
     111
     112        // Envoyer aux plugins
     113        $champs = pipeline('pre_edition',
     114                array(
     115                        'args' => array(
     116                                'table' => 'spip_notations',
     117                                'id_objet' => $id_notation,
     118                                'action'=>'supprimer',
     119                        ),
     120                        'data' => array()
     121                )
     122        );
     123
     124        sql_delete('spip_notations','id_notation='.sql_quote($id_notation));
     125       
     126        // Envoyer aux plugins
     127        $champs = pipeline('post_edition',
     128                array(
     129                        'args' => array(
     130                                'table' => 'spip_notations',
     131                                'id_objet' => $id_notation,
     132                                'action'=>'supprimer',
     133                        ),
     134                        'data' => array()
     135                )
     136        );
     137
     138        // mettre a jour les stats
     139        //
     140        // cette action est presque devenue inutile
     141        // comme la table spip_notations_objets
     142        // (qui devrait s'appeler spip_notations_stats plutot !)
     143        // car le critere {notation} permet d'obtenir ces resultats
     144        // totalements a jour...
     145        // Cependant, quelques cas tres particuliers de statistiques
     146        // font que je le laisse encore, comme calculer l'objet le mieux note :
     147        //      <BOUCLE_notes_pond(NOTATIONS_OBJETS){0,10}{!par note_ponderee}>
     148        // qu'il n'est pas possible de traduire dans une boucle NOTATION facilement.
     149        notation_recalculer_total($t['objet'],$t['id_objet']);
     150
     151        // invalider les caches
     152        include_spip('inc/invalideur');
     153        suivre_invalideur("id='notation/".$t['objet']."/".$t['id_objet']."'");
     154
    73155        return true;
    74 
    75 }
    76 
    77 function supprimer_notation($id_notation) {
    78         // pipeline pre edition
    79         sql_delete('spip_notations','id_notation='.sql_quote($id_notation));
    80         // pipeline post edition
    81         return true;
    82 }
    83 
    84 
    85 // je me demande vraiment si tout cela est utile...
    86 // vu que tout peut etre calcule en requete depuis spip_notations
    87 // a peu de choses pres (!)
     156}
     157
     158
     159/**
     160 * je me demande vraiment si tout cela est utile...
     161 * vu que tout peut etre calcule en requete depuis spip_notations
     162 * a peu de choses pres (!)
     163 *
     164 * @param string $objet
     165 * @param int $id_objet
     166 * @return void
     167 */
    88168function notation_recalculer_total($objet,$id_objet){
    89169
     
    131211
    132212
     213/**
     214 * calculer un total pour un objet/id_objet
     215 * @param string $objet
     216 * @param int $id_objet
     217 * @return array
     218 */
    133219function notation_calculer_total($objet, $id_objet){
    134220
     221        include_spip('inc/notation');
    135222        $ponderation = notation_get_ponderation();
    136223
     
    158245}
    159246
     247// pour compat
     248
     249function insert_notation($objet, $id_objet){return notation_inserer($objet, $id_objet);}
     250function modifier_notation($id_notation,$c=array()) {return notation_modifier($id_notation, $c);}
     251function supprimer_notation($id_notation) { return notation_supprimer($id_notation); }
     252
    160253?>
  • _plugins_/notation/trunk/action/supprimer_notation.php

    r52802 r54123  
    99if (!defined("_ECRIRE_INC_VERSION")) return;
    1010
    11 function action_supprimer_notation_dist(){
    12         $securiser_action = charger_fonction('securiser_action','inc');
    13         $id_notation = $securiser_action();
     11function action_supprimer_notation_dist($id_notation=null){
     12        if (is_null($id_notation)){
     13                $securiser_action = charger_fonction('securiser_action','inc');
     14                $id_notation = $securiser_action();
     15        }
    1416
    1517        if ($id_notation = intval($id_notation)){
    16                 include_spip('inc/notation');
    1718                $row = sql_fetsel('objet,id_objet','spip_notations','id_notation='.sql_quote($id_notation));
    18                 supprimer_notation($id_notation);
    19                 notation_recalculer_total($row['objet'],$row['id_objet']);
     19                include_spip('inc/autoriser');
     20                if (autoriser('modifier', 'notation', $id_notation, null, array('objet'=>$row['objet'], 'id_objet'=>$row['id_objet']))){
     21                        include_spip('action/editer_notation');
     22                        notation_supprimer($id_notation);
     23                }
    2024        }
    2125}
  • _plugins_/notation/trunk/formulaires/activer_notes_objet.php

    r46349 r54123  
    5555               
    5656                include_spip('inc/invalideur');
    57                 suivre_invalideur("id='$objet/$id_objet'");
     57                suivre_invalideur("$objet/$id_objet");
    5858        }
    5959               
  • _plugins_/notation/trunk/formulaires/notation.php

    r42226 r54123  
    1111
    1212include_spip('inc/notation');
    13 include_spip('inc/notation_autorisations');
    1413include_spip('base/abstract_sql');
    1514include_spip('inc/session');
     
    109108        session_set('a_vote', true);
    110109
    111         // invalider les caches
    112         include_spip('inc/invalideur');
    113         suivre_invalideur("id='id_notation/$type/$id_objet'");
    114 
    115110        if ($GLOBALS["auteur_session"]) {
    116111                $id_auteur = $GLOBALS['auteur_session']['id_auteur'];
     
    141136        if (!$row){  // Remplir la table de notation
    142137                if ($note!=='-1') // annulation d'un vote -> ne pas creer un id !
    143                         $id_notation = insert_notation();
     138                        $id_notation = notation_inserer($type,$id_objet);
    144139        } else {
    145140                $id_notation = $row['id_notation'];
     
    148143        if ($id_notation){
    149144                if ($note=='-1'){ // annulation d'un vote
    150                         supprimer_notation($id_notation);
     145                        notation_supprimer($id_notation);
    151146                        $id_notation = 0;
    152147                }
     
    154149                        // Modifier la note
    155150                        $c = array(
    156                                 "objet" => $type,
    157                                 "id_objet" => $id_objet,
    158151                                "note" => $note,
    159152                                "id_auteur" => $id_auteur,
    160153                                "ip" => $ip
    161154                        );
    162                         modifier_notation($id_notation,$c);
     155                        notation_modifier($id_notation,$c);
    163156                }
    164157
    165                 // mettre a jour les stats
    166                 //
    167                 // cette action est presque devenue inutile
    168                 // comme la table spip_notations_objets
    169                 // (qui devrait s'appeler spip_notations_stats plutot !)
    170                 // car le critere {notation} permet d'obtenir ces resultats
    171                 // totalements a jour...
    172                 // Cependant, quelques cas tres particuliers de statistiques
    173                 // font que je le laisse encore, comme calculer l'objet le mieux note :
    174                 //      <BOUCLE_notes_pond(NOTATIONS_OBJETS){0,10}{!par note_ponderee}>
    175                 // qu'il n'est pas possible de traduire dans une boucle NOTATION facilement.
    176                 notation_recalculer_total($type,$id_objet);
    177158        }
    178159
  • _plugins_/notation/trunk/inc/notation.php

    r54094 r54123  
    4545
    4646/**
    47  *  Calcule de la note ponderee
     47 * Calcule de la note ponderee
     48 * utilise uniquement pour l'affichage dans la page de configuration
     49 * (vrai calcul en SQL dans action/editer_notation)
    4850 *
    4951 * @param float $note : note moyenne obtenue
     
    5759
    5860
    59 function insert_notation(){
    60         return sql_insertq("spip_notations", array(
    61                         "objet" => "",
    62                         "id_objet" => 0,
    63                         "id_auteur" => 0,
    64                         "ip" => "",
    65                         "note" => 0
    66                         ));
    67 }
    68 
    69 function modifier_notation($id_notation,$c=array()) {
    70         // pipeline pre edition
    71         sql_updateq('spip_notations',$c,'id_notation='.sql_quote($id_notation));
    72         // pipeline post edition
    73         return true;
    74 
    75 }
    76 
    77 function supprimer_notation($id_notation) {
    78         // pipeline pre edition
    79         sql_delete('spip_notations','id_notation='.sql_quote($id_notation));
    80         // pipeline post edition
    81         return true;
    82 }
    83 
    84 
    85 // je me demande vraiment si tout cela est utile...
    86 // vu que tout peut etre calcule en requete depuis spip_notations
    87 // a peu de choses pres (!)
    88 function notation_recalculer_total($objet,$id_objet){
    89 
    90         list($total, $note, $note_ponderee) = notation_calculer_total($objet, $id_objet);
    91 
    92         $objet = objet_type($objet);
    93 
    94         // Mise a jour ou insertion ?
    95         if (!sql_countsel("spip_notations_objets", array(
    96                                 "objet=" . sql_quote($objet),
    97                                 "id_objet=" . sql_quote($id_objet),
    98                                 ))) {
    99                 // Remplir la table de notation des objets
    100                 sql_insertq("spip_notations_objets", array(
    101                         "objet" => $objet,
    102                         "id_objet" => $id_objet,
    103                         "note" => $note,
    104                         "note_ponderee" => $note_ponderee,
    105                         "nombre_votes" => $total
    106                         ));
    107                 include_spip('inc/invalideur');
    108                 suivre_invalideur("notation/$objet/$id_objet");
    109 
    110         } else {
    111                 $anc_note_ponderee = sql_getfetsel('note_ponderee','spip_notations_objets',array(
    112                                 "objet=" . sql_quote($objet),
    113                                 "id_objet=" . sql_quote($id_objet)
    114                         ));
    115                 // Mettre ajour dans les autres cas
    116                 sql_updateq("spip_notations_objets", array(
    117                         "note" => $note,
    118                         "note_ponderee" => $note_ponderee,
    119                         "nombre_votes" => $total),
    120                         array(
    121                                 "objet=" . sql_quote($objet),
    122                                 "id_objet=" . sql_quote($id_objet)
    123                         ));
    124                 // on optimise en n'invalidant que si la notre ponderee change (sinon ca ne se verra pas)
    125                 if (round($anc_note_ponderee)!=$note_ponderee){
    126                         include_spip('inc/invalideur');
    127                         suivre_invalideur("notation/$objet/$id_objet");
    128                 }
    129         }
    130 }
    131 
    132 
    133 function notation_calculer_total($objet, $id_objet){
    134 
    135         $ponderation = notation_get_ponderation();
    136 
    137         // Calculer les moyennes
    138         // cf critere {notation}
    139         $select = array(
    140                 'notations.objet',
    141                 'notations.id_objet',
    142                 'COUNT(notations.note) AS nombre_votes',
    143                 'ROUND(AVG(notations.note),2) AS moyenne',
    144                 // *1.0 pour forcer une division reelle sinon 4/3=1 (sql server, sqlite...)
    145                 'ROUND(AVG(notations.note)*(1-EXP(-5*COUNT(notations.note)*1.0/'.$ponderation.')),2) AS moyenne_ponderee'
    146         );
    147         if (!$row = sql_fetsel(
    148                         $select,
    149                         "spip_notations AS notations",
    150                         array(
    151                                 "notations.objet=". sql_quote(objet_type($objet)),
    152                                 "notations.id_objet=" . sql_quote($id_objet)
    153                         ),'notations.id_objet')) {
    154                 return array(0,0,0);
    155         } else {
    156                 return array($row['nombre_votes'], $row['moyenne'], $row['moyenne_ponderee']);
    157         }
    158 }
    159 
    16061?>
Note: See TracChangeset for help on using the changeset viewer.