www/plugins-dist/mots/action/editer_mot.php

   1 <?php
   2
   3 /***************************************************************************\
   4  *  SPIP, Systeme de publication pour l'internet                           *
   5  *                                                                         *
   6  *  Copyright (c) 2001-2019                                                *
   7  *  Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James  *
   8  *                                                                         *
   9  *  Ce programme est un logiciel libre distribue sous licence GNU/GPL.     *
  10  *  Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne.   *
  11 \***************************************************************************/
  12
  13 /**
  14  * Gestion de l'action editer_mot
  15  *
  16  * @package SPIP\Mots\Actions
  17  */
  18 if (!defined('_ECRIRE_INC_VERSION')) {
  19         return;
  20 }
  21
  22 include_spip('inc/filtres');
  23
  24 /**
  25  * Action d'édition d'un mot clé dans la base de données dont
  26  * l'identifiant est donné en paramètre de cette fonction ou
  27  * en argument de l'action sécurisée
  28  *
  29  * Si aucun identifiant n'est donné, on crée alors un nouveau mot clé.
  30  *
  31  * @param null|int $arg
  32  *     Identifiant du mot-clé. En absence utilise l'argument
  33  *     de l'action sécurisée.
  34  * @return array
  35  *     Liste (identifiant du mot clé, Texte d'erreur éventuel)
  36  **/
  37 function action_editer_mot_dist($arg = null) {
  38         if (is_null($arg)) {
  39                 $securiser_action = charger_fonction('securiser_action', 'inc');
  40                 $arg = $securiser_action();
  41         }
  42         $id_mot = intval($arg);
  43
  44         $id_groupe = intval(_request('id_groupe'));
  45         if (!$id_mot and $id_groupe) {
  46                 $id_mot = mot_inserer($id_groupe);
  47         }
  48
  49         // Enregistre l'envoi dans la BD
  50         if ($id_mot > 0) {
  51                 $err = mot_modifier($id_mot);
  52         }
  53
  54         return array($id_mot, $err);
  55 }
  56
  57 /**
  58  * Insertion d'un mot dans un groupe
  59  *
  60  * @pipeline_appel pre_insertion
  61  * @pipeline_appel post_insertion
  62  *
  63  * @param int $id_groupe
  64  *     Identifiant du groupe de mot
  65  * @param array|null $set
  66  * @return int|bool
  67  *     Identifiant du nouveau mot clé, false si erreur.
  68  */
  69 function mot_inserer($id_groupe, $set = null) {
  70
  71         $champs = array();
  72         $row = sql_fetsel('titre', 'spip_groupes_mots', 'id_groupe=' . intval($id_groupe));
  73         if ($row) {
  74                 $champs['id_groupe'] = $id_groupe;
  75                 $champs['type'] = $row['titre'];
  76         } else {
  77                 return false;
  78         }
  79
  80         if ($set) {
  81                 $champs = array_merge($champs, $set);
  82         }
  83
  84         // Envoyer aux plugins
  85         $champs = pipeline(
  86                 'pre_insertion',
  87                 array(
  88                         'args' => array(
  89                                 'table' => 'spip_mots',
  90                         ),
  91                         'data' => $champs
  92                 )
  93         );
  94
  95         $id_mot = sql_insertq('spip_mots', $champs);
  96
  97         pipeline(
  98                 'post_insertion',
  99                 array(
 100                         'args' => array(
 101                                 'table' => 'spip_mots',
 102                                 'id_objet' => $id_mot
 103                         ),
 104                         'data' => $champs
 105                 )
 106         );
 107
 108         return $id_mot;
 109 }
 110
 111 /**
 112  * Modifier un mot
 113  *
 114  * @param int $id_mot
 115  *     Identifiant du mot clé à modifier
 116  * @param array|null $set
 117  *     Couples (colonne => valeur) de données à modifier.
 118  *     En leur absence, on cherche les données dans les champs éditables
 119  *     qui ont été postés (via _request())
 120  * @return string|null
 121  *     - Chaîne vide si aucune erreur,
 122  *     - Null si aucun champ n'est à modifier,
 123  *     - Chaîne contenant un texte d'erreur sinon.
 124  */
 125 function mot_modifier($id_mot, $set = null) {
 126         include_spip('inc/modifier');
 127         $c = collecter_requests(
 128                 // white list
 129                 array(
 130                         'titre',
 131                         'descriptif',
 132                         'texte',
 133                         'id_groupe'
 134                 ),
 135                 // black list
 136                 array('id_groupe'),
 137                 // donnees eventuellement fournies
 138                 $set
 139         );
 140
 141         if ($err = objet_modifier_champs(
 142                 'mot',
 143                 $id_mot,
 144                 array(
 145                         'data' => $set,
 146                         'nonvide' => array('titre' => _T('info_sans_titre'))
 147                 ),
 148                 $c
 149         )) {
 150                 return $err;
 151         }
 152
 153         $c = collecter_requests(array('id_groupe', 'type'), array(), $set);
 154         $err = mot_instituer($id_mot, $c);
 155
 156         return $err;
 157 }
 158
 159 /**
 160  * Instituer un mot clé : modifier son groupe parent
 161  *
 162  * @pipeline_appel pre_insertion
 163  * @pipeline_appel post_insertion
 164  *
 165  * @param int $id_mot
 166  *     Identifiant du mot clé
 167  * @param array $c
 168  *     Couples (colonne => valeur) des données à instituer
 169  * @return null|string
 170  *     Null si aucun champ à modifier, chaîne vide sinon.
 171  */
 172 function mot_instituer($id_mot, $c) {
 173         $champs = array();
 174         // regler le groupe
 175         if (isset($c['id_groupe']) or isset($c['type'])) {
 176                 $row = sql_fetsel('titre', 'spip_groupes_mots', 'id_groupe=' . intval($c['id_groupe']));
 177                 if ($row) {
 178                         $champs['id_groupe'] = $c['id_groupe'];
 179                         $champs['type'] = $row['titre'];
 180                 }
 181         }
 182
 183         // Envoyer aux plugins
 184         $champs = pipeline(
 185                 'pre_edition',
 186                 array(
 187                         'args' => array(
 188                                 'table' => 'spip_mots',
 189                                 'id_objet' => $id_mot,
 190                                 'action' => 'instituer',
 191                         ),
 192                         'data' => $champs
 193                 )
 194         );
 195
 196         if (!$champs) {
 197                 return;
 198         }
 199
 200         sql_updateq('spip_mots', $champs, 'id_mot=' . intval($id_mot));
 201
 202         //
 203         // Post-modifications
 204         //
 205
 206         // Invalider les caches
 207         include_spip('inc/invalideur');
 208         suivre_invalideur("id='mot/$id_mot'");
 209
 210         // Pipeline
 211         pipeline(
 212                 'post_edition',
 213                 array(
 214                         'args' => array(
 215                                 'table' => 'spip_mots',
 216                                 'id_objet' => $id_mot,
 217                                 'action' => 'instituer',
 218                         ),
 219                         'data' => $champs
 220                 )
 221         );
 222
 223         // Notifications
 224         if ($notifications = charger_fonction('notifications', 'inc')) {
 225                 $notifications('instituermot', $id_mot,
 226                         array('id_groupe' => $champs['id_groupe'])
 227                 );
 228         }
 229
 230         return ''; // pas d'erreur
 231 }
 232
 233 /**
 234  * Supprimer un mot
 235  *
 236  * @pipeline_appel trig_supprimer_objets_lies
 237  *
 238  * @param int $id_mot
 239  *     Identifiant du mot clé à supprimer
 240  * @return void
 241  */
 242 function mot_supprimer($id_mot) {
 243         sql_delete('spip_mots', 'id_mot=' . intval($id_mot));
 244         mot_dissocier($id_mot, '*');
 245         pipeline(
 246                 'trig_supprimer_objets_lies',
 247                 array(
 248                         array('type' => 'mot', 'id' => $id_mot)
 249                 )
 250         );
 251 }
 252
 253
 254 /**
 255  * Associer un mot à des objets listés sous forme
 256  * `array($objet=>$id_objets,...)`
 257  *
 258  * $id_objets peut lui-même être un scalaire ou un tableau pour une
 259  * liste d'objets du même type
 260  *
 261  * On peut passer optionnellement une qualification du (des) lien(s) qui sera
 262  * alors appliquée dans la foulée. En cas de lot de liens, c'est la
 263  * même qualification qui est appliquée à tous.
 264  *
 265  * @example
 266  *     ```
 267  *     mot_associer(3, array('auteur'=>2));
 268  *     // Ne fonctionnera pas ici car pas de champ 'vu' sur spip_mots_liens :
 269  *     mot_associer(3, array('auteur'=>2), array('vu'=>'oui));
 270  *     ```
 271  *
 272  * @param int $id_mot
 273  *     Identifiant du mot à faire associer
 274  * @param array $objets
 275  *     Description des associations à faire
 276  * @param array $qualif
 277  *     Couples (colonne => valeur) de qualifications à faire appliquer
 278  * @return int|bool
 279  *     Nombre de modifications, false si erreur
 280  */
 281 function mot_associer($id_mot, $objets, $qualif = null) {
 282
 283         include_spip('action/editer_liens');
 284
 285         // si il s'agit d'un groupe avec 'unseul', alors supprimer d'abord les autres
 286         // mots de ce groupe associe a ces objets
 287         $id_groupe = sql_getfetsel('id_groupe', 'spip_mots', 'id_mot=' . intval($id_mot));
 288         if (un_seul_mot_dans_groupe($id_groupe)) {
 289                 $mots_groupe = sql_allfetsel('id_mot', 'spip_mots', 'id_groupe=' . intval($id_groupe));
 290                 $mots_groupe = array_map('reset', $mots_groupe);
 291                 objet_dissocier(array('mot' => $mots_groupe), $objets);
 292         }
 293
 294         return objet_associer(array('mot' => $id_mot), $objets, $qualif);
 295 }
 296
 297
 298 /**
 299  * Dissocier un mot des objets listés sous forme
 300  * `array($objet=>$id_objets,...)`
 301  *
 302  * $id_objets peut lui-même être un scalaire ou un tableau pour une
 303  * liste d'objets du même type
 304  *
 305  * un * pour $id_mot,$objet,$id_objet permet de traiter par lot
 306  *
 307  * @param int $id_mot
 308  *     Identifiant du mot à faire dissocier
 309  * @param array $objets
 310  *     Description des dissociations à faire
 311  * @return int|bool
 312  *     Nombre de modifications, false si erreur
 313  */
 314 function mot_dissocier($id_mot, $objets) {
 315         include_spip('action/editer_liens');
 316
 317         return objet_dissocier(array('mot' => $id_mot), $objets);
 318 }
 319
 320 /**
 321  * Qualifier le lien d'un mot avec les objets listés
 322  * `array($objet=>$id_objets,...)`
 323  *
 324  * $id_objets peut lui-même être un scalaire ou un tableau pour une
 325  * liste d'objets du même type
 326  *
 327  * Une * pour $id_auteur,$objet,$id_objet permet de traiter par lot
 328  *
 329  * @example
 330  *     ```
 331  *     $c = array('vu'=>'oui');
 332  *     ```
 333  *
 334  * @param int $id_mot
 335  *     Identifiant du mot à faire associer
 336  * @param array $objets
 337  *     Description des associations à faire
 338  * @param array $qualif
 339  *     Couples (colonne => valeur) de qualifications à faire appliquer
 340  * @return int|bool
 341  *     Nombre de modifications, false si erreur
 342  */
 343 function mot_qualifier($id_mot, $objets, $qualif) {
 344         include_spip('action/editer_liens');
 345
 346         return objet_qualifier(array('mot' => $id_mot), $objets, $qualif);
 347 }
 348
 349
 350 /**
 351  * Teste si un groupe ne doit avoir qu'un seul mot clé associé
 352  *
 353  * Renvoyer TRUE si le groupe de mot ne doit être associé qu'une fois aux objet
 354  * (maximum un seul mot de ce groupe associé à chaque objet)
 355  *
 356  * @param int $id_groupe
 357  *     Identifiant du groupe de mot clé
 358  * @return bool
 359  *     true si un seul mot doit être lié avec ce groupe, false sinon.
 360  */
 361 function un_seul_mot_dans_groupe($id_groupe) {
 362         return sql_countsel('spip_groupes_mots', "id_groupe=$id_groupe AND unseul='oui'");
 363 }
 364
 365
 366 // Fonctions Dépréciées
 367 // --------------------
 368
 369 /**
 370  * Insertion d'un mot dans un groupe
 371  *
 372  * @deprecated Utiliser mot_inserer()
 373  * @see mot_inserer()
 374  *
 375  * @param int $id_groupe
 376  *     Identifiant du groupe de mot
 377  * @return int|bool
 378  *     Identifiant du nouveau mot clé, false si erreur.
 379  */
 380 function insert_mot($id_groupe) {
 381         return mot_inserer($id_groupe);
 382 }
 383
 384 /**
 385  * Modifier un mot
 386  *
 387  * @deprecated Utiliser mot_modifier()
 388  * @see mot_modifier()
 389  *
 390  * @param int $id_mot
 391  *     Identifiant du mot clé à modifier
 392  * @param array|null $set
 393  *     Couples (colonne => valeur) de données à modifier.
 394  *     En leur absence, on cherche les données dans les champs éditables
 395  *     qui ont été postés
 396  * @return string|null
 397  *     - Chaîne vide si aucune erreur,
 398  *     - Null si aucun champ à modifier,
 399  *     - Chaîne contenant un texte d'erreur sinon.
 400  */
 401 function mots_set($id_mot, $set = null) {
 402         return mot_modifier($id_mot, $set);
 403 }
 404
 405 /**
 406  * Créer une révision d'un mot
 407  *
 408  * @deprecated Utiliser mot_modifier()
 409  * @see mot_modifier()
 410  *
 411  * @param int $id_mot
 412  *     Identifiant du mot clé à modifier
 413  * @param array|null $c
 414  *     Couples (colonne => valeur) de données à modifier.
 415  *     En leur absence, on cherche les données dans les champs éditables
 416  *     qui ont été postés
 417  * @return string|null
 418  *     - Chaîne vide si aucune erreur,
 419  *     - Null si aucun champ à modifier,
 420  *     - Chaîne contenant un texte d'erreur sinon.
 421  */
 422 function revision_mot($id_mot, $c = false) {
 423         return mot_modifier($id_mot, $c);
 424 }