www/ecrire/action/editer_liens.php

   1 <?php
   2
   3 /***************************************************************************\
   4  *  SPIP, Systeme de publication pour l'internet                           *
   5  *                                                                         *
   6  *  Copyright (c) 2001-2017                                                *
   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  * API d'édition de liens
  15  *
  16  * Cette API gère la création, modification et suppressions de liens
  17  * entre deux objets éditoriaux par l'intermédiaire de tables de liaison
  18  * tel que spip_xx_liens.
  19  *
  20  * L'unicité est assurée dans les fonctions sur le trio (id_x, objet, id_objet)
  21  * par défaut, ce qui correspond à la déclaration de clé primaire.
  22  *
  23  * Des rôles peuvent être déclarés pour des liaisons. À ce moment là,
  24  * une colonne spécifique doit être présente dans la table de liens
  25  * et l'unicité est alors assurée sur le quatuor (id_x, objet, id_objet, role)
  26  * et la clé primaire adaptée en conséquence.
  27  *
  28  * @package SPIP\Core\Liens\API
  29  */
  30
  31 if (!defined('_ECRIRE_INC_VERSION')) {
  32         return;
  33 }
  34
  35 // charger la gestion les rôles sur les objets
  36 include_spip('inc/roles');
  37
  38
  39 /**
  40  * Teste l'existence de la table de liaison xxx_liens d'un objet
  41  *
  42  * @api
  43  * @param string $objet
  44  *     Objet à tester
  45  * @return array|bool
  46  *     - false si l'objet n'est pas associable.
  47  *     - array(clé primaire, nom de la table de lien) si associable
  48  */
  49 function objet_associable($objet) {
  50         $trouver_table = charger_fonction('trouver_table', 'base');
  51         $table_sql = table_objet_sql($objet);
  52
  53         $l = "";
  54         if ($primary = id_table_objet($objet)
  55                 and $trouver_table($l = $table_sql . "_liens")
  56                 and !preg_match(',[^\w],', $primary)
  57                 and !preg_match(',[^\w],', $l)
  58         ) {
  59                 return array($primary, $l);
  60         }
  61
  62         spip_log("Objet $objet non associable : ne dispose pas d'une cle primaire $primary OU d'une table liens $l");
  63
  64         return false;
  65 }
  66
  67 /**
  68  * Associer un ou des objets à des objets listés
  69  *
  70  * `$objets_source` et `$objets_lies` sont de la forme
  71  * `array($objet=>$id_objets,...)`
  72  * `$id_objets` peut lui même être un scalaire ou un tableau pour une liste d'objets du même type
  73  * ou de la forme `array("NOT", $id_objets)` pour une sélection par exclusion
  74  *
  75  * Les objets sources sont les pivots qui portent les liens
  76  * et pour lesquels une table spip_xxx_liens existe
  77  * (auteurs, documents, mots)
  78  *
  79  * On peut passer optionnellement une qualification du (des) lien(s) qui sera
  80  * alors appliquée dans la foulée.
  81  * En cas de lot de liens, c'est la même qualification qui est appliquée a tous
  82  *
  83  * @api
  84  * @param array $objets_source
  85  * @param array|string $objets_lies
  86  * @param array $qualif
  87  * @return bool|int
  88  */
  89 function objet_associer($objets_source, $objets_lies, $qualif = null) {
  90         $modifs = objet_traiter_liaisons('lien_insert', $objets_source, $objets_lies, $qualif);
  91
  92         if ($qualif) {
  93                 objet_qualifier_liens($objets_source, $objets_lies, $qualif);
  94         }
  95
  96         return $modifs; // pas d'erreur
  97 }
  98
  99
 100 /**
 101  * Dissocier un (ou des) objet(s)  des objets listés
 102  *
 103  * `$objets_source` et `$objets_lies` sont de la forme
 104  * `array($objet=>$id_objets,...)`
 105  * `$id_objets` peut lui-même être un scalaire ou un tableau pour une liste d'objets du même type
 106  *
 107  * Les objets sources sont les pivots qui portent les liens
 108  * et pour lesquels une table spip_xxx_liens existe
 109  * (auteurs, documents, mots)
 110  *
 111  * un * pour $objet, $id_objet permet de traiter par lot
 112  * seul le type de l'objet source ne peut pas accepter de joker et doit etre explicite
 113  *
 114  * S'il y a des rôles possibles entre les 2 objets, et qu'aucune condition
 115  * sur la colonne du rôle n'est transmise, on ne supprime que les liens
 116  * avec le rôle par défaut. Si on veut supprimer tous les rôles,
 117  * il faut spécifier $cond => array('role' => '*')
 118  *
 119  * @api
 120  * @param array $objets_source
 121  * @param array|string $objets_lies
 122  * @param array|null $cond
 123  *     Condition du where supplémentaires
 124  *
 125  *     À l'exception de l'index 'role' qui permet de sélectionner un rôle
 126  *     ou tous les rôles (*), en s'affranchissant du vrai nom de la colonne.
 127  * @return bool|int
 128  */
 129 function objet_dissocier($objets_source, $objets_lies, $cond = null) {
 130         return objet_traiter_liaisons('lien_delete', $objets_source, $objets_lies, $cond);
 131 }
 132
 133
 134 /**
 135  * Qualifier le lien entre un (ou des) objet(s) et des objets listés
 136  *
 137  * $objets_source et $objets sont de la forme
 138  * array($objet=>$id_objets,...)
 139  * $id_objets peut lui meme etre un scalaire ou un tableau pour une liste d'objets du meme type
 140  *
 141  * Les objets sources sont les pivots qui portent les liens
 142  * et pour lesquels une table spip_xxx_liens existe
 143  * (auteurs, documents, mots)
 144  *
 145  * un * pour $objet,$id_objet permet de traiter par lot
 146  * seul le type de l'objet source ne peut pas accepter de joker et doit etre explicite
 147  *
 148  * @api
 149  * @param array $objets_source
 150  * @param array|string $objets_lies
 151  * @param array $qualif
 152  * @return bool|int
 153  */
 154 function objet_qualifier_liens($objets_source, $objets_lies, $qualif) {
 155         return objet_traiter_liaisons('lien_set', $objets_source, $objets_lies, $qualif);
 156 }
 157
 158
 159 /**
 160  * Trouver les liens entre objets
 161  *
 162  * $objets_source et $objets sont de la forme
 163  * array($objet=>$id_objets,...)
 164  * $id_objets peut lui meme etre un scalaire ou un tableau pour une liste d'objets du meme type
 165  *
 166  * Les objets sources sont les pivots qui portent les liens
 167  * et pour lesquels une table spip_xxx_liens existe
 168  * (auteurs, documents, mots)
 169  *
 170  * un * pour $objet,$id_objet permet de traiter par lot
 171  * seul le type de l'objet source ne peut pas accepter de joker et doit etre explicite
 172  *
 173  * renvoie une liste de tableaux decrivant chaque lien
 174  * dans lequel objet_source et objet_lie sont aussi affectes avec l'id de chaque
 175  * par facilite
 176  * ex :
 177  * array(
 178  *   array('id_document'=>23,'objet'=>'article','id_objet'=>12,'vu'=>'oui',
 179  *         'document'=>23,'article'=>12)
 180  * )
 181  *
 182  * @api
 183  * @param array $objets_source Couples (objets_source => identifiants) (objet qui a la table de lien)
 184  * @param array|string $objets_lies Couples (objets_lies => identifiants)
 185  * @param array|null $cond Condition du where supplémentaires
 186  * @return array
 187  *     Liste des trouvailles
 188  */
 189 function objet_trouver_liens($objets_source, $objets_lies, $cond = null) {
 190         return objet_traiter_liaisons('lien_find', $objets_source, $objets_lies, $cond);
 191 }
 192
 193
 194 /**
 195  * Nettoyer les liens morts vers des objets qui n'existent plus
 196  *
 197  * $objets_source et $objets sont de la forme
 198  * array($objet=>$id_objets,...)
 199  * $id_objets peut lui meme etre un scalaire ou un tableau pour une liste d'objets du meme type
 200  *
 201  * Les objets sources sont les pivots qui portent les liens
 202  * et pour lesquels une table spip_xxx_liens existe
 203  * (auteurs, documents, mots)
 204  *
 205  * un * pour $objet,$id_objet permet de traiter par lot
 206  * seul le type de l'objet source ne peut pas accepter de joker et doit etre explicite
 207  *
 208  * @api
 209  * @param array $objets_source
 210  * @param array|string $objets_lies
 211  * @return int
 212  */
 213 function objet_optimiser_liens($objets_source, $objets_lies) {
 214         return objet_traiter_liaisons('lien_optimise', $objets_source, $objets_lies);
 215 }
 216
 217
 218 /**
 219  * Dupliquer tous les liens entrant ou sortants d'un objet
 220  * vers un autre (meme type d'objet, mais id different)
 221  * si $types est fourni, seuls les liens depuis/vers les types listes seront copies
 222  * si $exclure_types est fourni, les liens depuis/vers les types listes seront ignores
 223  *
 224  * @api
 225  * @param string $objet
 226  * @param int $id_source
 227  * @param int $id_cible
 228  * @param array $types
 229  * @param array $exclure_types
 230  * @return int
 231  *     Nombre de liens copiés
 232  */
 233 function objet_dupliquer_liens($objet, $id_source, $id_cible, $types = null, $exclure_types = null) {
 234         include_spip('base/objets');
 235         $tables = lister_tables_objets_sql();
 236         $n = 0;
 237         foreach ($tables as $table_sql => $infos) {
 238                 if (
 239                         (is_null($types) or in_array($infos['type'], $types))
 240                         and (is_null($exclure_types) or !in_array($infos['type'], $exclure_types))
 241                 ) {
 242                         if (objet_associable($infos['type'])) {
 243                                 $liens = (($infos['type'] == $objet) ?
 244                                         objet_trouver_liens(array($objet => $id_source), '*')
 245                                         :
 246                                         objet_trouver_liens(array($infos['type'] => '*'), array($objet => $id_source)));
 247                                 foreach ($liens as $lien) {
 248                                         $n++;
 249                                         if ($infos['type'] == $objet) {
 250                                                 objet_associer(array($objet => $id_cible), array($lien['objet'] => $lien[$lien['objet']]), $lien);
 251                                         } else {
 252                                                 objet_associer(array($infos['type'] => $lien[$infos['type']]), array($objet => $id_cible), $lien);
 253                                         }
 254                                 }
 255                         }
 256                 }
 257         }
 258
 259         return $n;
 260 }
 261
 262 /**
 263  * Fonctions techniques
 264  * ne pas les appeler directement
 265  */
 266
 267
 268 /**
 269  * Fonction générique qui
 270  * applique une operation de liaison entre un ou des objets et des objets listés
 271  *
 272  * $objets_source et $objets_lies sont de la forme
 273  * array($objet=>$id_objets,...)
 274  * $id_objets peut lui meme etre un scalaire ou un tableau pour une liste d'objets du meme type
 275  *
 276  * Les objets sources sont les pivots qui portent les liens
 277  * et pour lesquels une table spip_xxx_liens existe
 278  * (auteurs, documents, mots)
 279  *
 280  * on peut passer optionnellement une qualification du (des) lien(s) qui sera
 281  * alors appliquee dans la foulee.
 282  * En cas de lot de liens, c'est la meme qualification qui est appliquee a tous
 283  *
 284  * @internal
 285  * @param string $operation
 286  *     Nom de la fonction PHP qui traitera l'opération
 287  * @param array $objets_source
 288  *     Liste de ou des objets source
 289  *     De la forme array($objet=>$id_objets,...), où $id_objets peut lui
 290  *     même être un scalaire ou un tableau pour une liste d'objets du même type
 291  * @param array $objets_lies
 292  *     Liste de ou des objets liés
 293  *     De la forme array($objet=>$id_objets,...), où $id_objets peut lui
 294  *     même être un scalaire ou un tableau pour une liste d'objets du même type
 295  * @param null|array $set
 296  *     Liste de coupels champs valeur, soit array(champs => valeur)
 297  *     En fonction des opérations il peut servir à différentes utilisations
 298  * @return bool|int|array
 299  */
 300 function objet_traiter_liaisons($operation, $objets_source, $objets_lies, $set = null) {
 301         // accepter une syntaxe minimale pour supprimer tous les liens
 302         if ($objets_lies == '*') {
 303                 $objets_lies = array('*' => '*');
 304         }
 305         $modifs = 0; // compter le nombre de modifications
 306         $echec = null;
 307         foreach ($objets_source as $objet => $ids) {
 308                 if ($a = objet_associable($objet)) {
 309                         list($primary, $l) = $a;
 310                         if (!is_array($ids)) {
 311                                 $ids = array($ids);
 312                         } elseif (reset($ids) == "NOT") {
 313                                 // si on demande un array('NOT',...) => recuperer la liste d'ids correspondants
 314                                 $where = lien_where($primary, $ids, '*', '*');
 315                                 $ids = sql_allfetsel($primary, $l, $where);
 316                                 $ids = array_map('reset', $ids);
 317                         }
 318                         foreach ($ids as $id) {
 319                                 $res = $operation($objet, $primary, $l, $id, $objets_lies, $set);
 320                                 if ($res === false) {
 321                                         spip_log("objet_traiter_liaisons [Echec] : $operation sur $objet/$primary/$l/$id", _LOG_ERREUR);
 322                                         $echec = true;
 323                                 } else {
 324                                         $modifs = ($modifs ? (is_array($res) ? array_merge($modifs, $res) : $modifs + $res) : $res);
 325                                 }
 326                         }
 327                 } else {
 328                         $echec = true;
 329                 }
 330         }
 331
 332         return ($echec ? false : $modifs); // pas d'erreur
 333 }
 334
 335
 336 /**
 337  * Sous fonction insertion
 338  * qui traite les liens pour un objet source dont la clé primaire
 339  * et la table de lien sont fournies
 340  *
 341  * $objets et de la forme
 342  * array($objet=>$id_objets,...)
 343  *
 344  * Retourne le nombre d'insertions réalisées
 345  *
 346  * @internal
 347  * @param string $objet_source Objet source de l'insertion (celui qui a la table de liaison)
 348  * @param string $primary Nom de la clé primaire de cet objet
 349  * @param string $table_lien Nom de la table de lien de cet objet
 350  * @param int $id Identifiant de l'objet sur lesquels on va insérer des liaisons
 351  * @param array $objets Liste des liaisons à faire, de la forme array($objet=>$id_objets)
 352  * @param array $qualif
 353  *     Liste des qualifications à appliquer (qui seront faites par lien_set()),
 354  *     dont on cherche un rôle à insérer également.
 355  *     Si l'objet dispose d'un champ rôle, on extrait des qualifications
 356  *     le rôle s'il est présent, sinon on applique le rôle par défaut.
 357  * @return bool|int
 358  *     Nombre d'insertions faites, false si échec.
 359  */
 360 function lien_insert($objet_source, $primary, $table_lien, $id, $objets, $qualif) {
 361         $ins = 0;
 362         $echec = null;
 363         if (is_null($qualif)) {
 364                 $qualif = array();
 365         }
 366
 367         foreach ($objets as $objet => $id_objets) {
 368                 if (!is_array($id_objets)) {
 369                         $id_objets = array($id_objets);
 370                 }
 371
 372                 // role, colonne, where par défaut
 373                 list($role, $colonne_role, $cond) =
 374                         roles_trouver_dans_qualif($objet_source, $objet, $qualif);
 375
 376                 foreach ($id_objets as $id_objet) {
 377                         $objet = ($objet == '*') ? $objet : objet_type($objet); # securite
 378
 379                         $insertions = array(
 380                                 'id_objet' => $id_objet,
 381                                 'objet' => $objet,
 382                                 $primary => $id
 383                         );
 384                         // rôle en plus s'il est défini
 385                         if ($role) {
 386                                 $insertions += array(
 387                                         $colonne_role => $role
 388                                 );
 389                         }
 390                         $args = array(
 391                                 'table_lien' => $table_lien,
 392                                 'objet_source' => $objet_source,
 393                                 'id_objet_source' => $id,
 394                                 'objet' => $objet,
 395                                 'id_objet' => $id_objet,
 396                                 'role' => $role,
 397                                 'colonne_role' => $colonne_role,
 398                                 'action' => 'insert',
 399                         );
 400
 401                         // Envoyer aux plugins
 402                         $insertions = pipeline('pre_edition_lien',
 403                                 array(
 404                                         'args' => $args,
 405                                         'data' => $insertions
 406                                 )
 407                         );
 408                         $args['id_objet'] = $insertions['id_objet'];
 409
 410                         $where = lien_where($primary, $id, $objet, $id_objet, $cond);
 411
 412                         if ($id_objet = intval($insertions['id_objet'])
 413                                 and !sql_getfetsel($primary, $table_lien, $where)
 414                         ) {
 415
 416                                 $e = sql_insertq($table_lien, $insertions);
 417                                 if ($e !== false) {
 418                                         $ins++;
 419                                         lien_propage_date_modif($objet, $id_objet);
 420                                         lien_propage_date_modif($objet_source, $id);
 421                                         // Envoyer aux plugins
 422                                         pipeline('post_edition_lien',
 423                                                 array(
 424                                                         'args' => $args,
 425                                                         'data' => $insertions
 426                                                 )
 427                                         );
 428                                 } else {
 429                                         $echec = true;
 430                                 }
 431                         }
 432                 }
 433         }
 434
 435         return ($echec ? false : $ins);
 436 }
 437
 438 /**
 439  * Fabriquer la condition where en tenant compte des jokers *
 440  *
 441  * @internal
 442  * @param string $primary Nom de la clé primaire
 443  * @param int|string|array $id_source Identifiant de la clé primaire
 444  * @param string $objet Nom de l'objet lié
 445  * @param int|string|array $id_objet Identifiant de l'objet lié
 446  * @param array $cond Conditions par défaut
 447  * @return array                        Liste des conditions
 448  */
 449 function lien_where($primary, $id_source, $objet, $id_objet, $cond = array()) {
 450         if ((!is_array($id_source) and !strlen($id_source))
 451                 or !strlen($objet)
 452                 or (!is_array($id_objet) and !strlen($id_objet))
 453         ) {
 454                 return array("0=1");
 455         } // securite
 456
 457         $not = "";
 458         if (is_array($id_source) and reset($id_source) == "NOT") {
 459                 $not = array_shift($id_source);
 460                 $id_source = reset($id_source);
 461         }
 462
 463         $where = $cond;
 464
 465         if ($id_source !== '*') {
 466                 $where[] = (is_array($id_source) ? sql_in(addslashes($primary), array_map('intval', $id_source),
 467                         $not) : addslashes($primary) . ($not ? "<>" : "=") . intval($id_source));
 468         } elseif ($not) {
 469                 $where[] = "0=1";
 470         } // idiot mais quand meme
 471
 472         $not = "";
 473         if (is_array($id_objet) and reset($id_objet) == "NOT") {
 474                 $not = array_shift($id_objet);
 475                 $id_objet = reset($id_objet);
 476         }
 477
 478         if ($objet !== '*') {
 479                 $where[] = "objet=" . sql_quote($objet);
 480         }
 481         if ($id_objet !== '*') {
 482                 $where[] = (is_array($id_objet) ? sql_in('id_objet', array_map('intval', $id_objet),
 483                         $not) : "id_objet" . ($not ? "<>" : "=") . intval($id_objet));
 484         } elseif ($not) {
 485                 $where[] = "0=1";
 486         } // idiot mais quand meme
 487
 488         return $where;
 489 }
 490
 491 /**
 492  * Sous fonction suppression
 493  * qui traite les liens pour un objet source dont la clé primaire
 494  * et la table de lien sont fournies
 495  *
 496  * $objets et de la forme
 497  * array($objet=>$id_objets,...)
 498  * un * pour $id,$objet,$id_objets permet de traiter par lot
 499  *
 500  * On supprime tous les liens entre les objets indiqués par défaut,
 501  * sauf s'il y a des rôles déclarés entre ces 2 objets, auquel cas on ne
 502  * supprime que les liaisons avec le role déclaré par défaut si rien n'est
 503  * précisé dans $cond. Il faut alors passer $cond=array('role'=>'*') pour
 504  * supprimer tous les roles, ou array('role'=>'un_role') pour un role précis.
 505  *
 506  * @internal
 507  * @param string $objet_source
 508  * @param string $primary
 509  * @param string $table_lien
 510  * @param int $id
 511  * @param array $objets
 512  * @param array|null $cond
 513  *     Conditions where par défaut.
 514  *     Un cas particulier est géré lorsque l'index 'role' est présent (ou absent)
 515  * @return bool|int
 516  */
 517 function lien_delete($objet_source, $primary, $table_lien, $id, $objets, $cond = null) {
 518
 519         $retire = array();
 520         $dels = 0;
 521         $echec = false;
 522         if (is_null($cond)) {
 523                 $cond = array();
 524         }
 525
 526         foreach ($objets as $objet => $id_objets) {
 527                 $objet = ($objet == '*') ? $objet : objet_type($objet); # securite
 528                 if (!is_array($id_objets) or reset($id_objets) == "NOT") {
 529                         $id_objets = array($id_objets);
 530                 }
 531                 foreach ($id_objets as $id_objet) {
 532                         list($cond, $colonne_role, $role) = roles_creer_condition_role($objet_source, $objet, $cond);
 533                         // id_objet peut valoir '*'
 534                         $where = lien_where($primary, $id, $objet, $id_objet, $cond);
 535
 536                         // lire les liens existants pour propager la date de modif
 537                         $select = "$primary,id_objet,objet";
 538                         if ($colonne_role) {
 539                                 $select .= ",$colonne_role";
 540                         }
 541                         $liens = sql_allfetsel($select, $table_lien, $where);
 542
 543                         // iterer sur les liens pour permettre aux plugins de gerer
 544                         foreach ($liens as $l) {
 545
 546                                 $args = array(
 547                                         'table_lien' => $table_lien,
 548                                         'objet_source' => $objet_source,
 549                                         'id_objet_source' => $l[$primary],
 550                                         'objet' => $l['objet'],
 551                                         'id_objet' => $l['id_objet'],
 552                                         'colonne_role' => $colonne_role,
 553                                         'role' => ($colonne_role ? $l[$colonne_role] : ''),
 554                                         'action' => 'delete',
 555                                 );
 556
 557                                 // Envoyer aux plugins
 558                                 $l = pipeline('pre_edition_lien',
 559                                         array(
 560                                                 'args' => $args,
 561                                                 'data' => $l
 562                                         )
 563                                 );
 564                                 $args['id_objet'] = $id_o = $l['id_objet'];
 565
 566                                 if ($id_o = intval($l['id_objet'])) {
 567                                         $where = lien_where($primary, $l[$primary], $l['objet'], $id_o, $cond);
 568                                         $e = sql_delete($table_lien, $where);
 569                                         if ($e !== false) {
 570                                                 $dels += $e;
 571                                                 lien_propage_date_modif($l['objet'], $id_o);
 572                                                 lien_propage_date_modif($objet_source, $l[$primary]);
 573                                         } else {
 574                                                 $echec = true;
 575                                         }
 576                                         $retire[] = array(
 577                                                 'source' => array($objet_source => $l[$primary]),
 578                                                 'lien' => array($l['objet'] => $id_o),
 579                                                 'type' => $l['objet'],
 580                                                 'role' => ($colonne_role ? $l[$colonne_role] : ''),
 581                                                 'id' => $id_o
 582                                         );
 583                                         // Envoyer aux plugins
 584                                         pipeline('post_edition_lien',
 585                                                 array(
 586                                                         'args' => $args,
 587                                                         'data' => $l
 588                                                 )
 589                                         );
 590                                 }
 591                         }
 592                 }
 593         }
 594
 595         pipeline('trig_supprimer_objets_lies', $retire);
 596
 597         return ($echec ? false : $dels);
 598 }
 599
 600
 601 /**
 602  * Sous fonction optimisation
 603  * qui nettoie les liens morts (vers un objet inexistant)
 604  * pour un objet source dont la clé primaire
 605  * et la table de lien sont fournies
 606  *
 607  * $objets et de la forme
 608  * array($objet=>$id_objets,...)
 609  * un * pour $id,$objet,$id_objets permet de traiter par lot
 610  *
 611  * @internal
 612  * @param string $objet_source
 613  * @param string $primary
 614  * @param string $table_lien
 615  * @param int $id
 616  * @param array $objets
 617  * @return bool|int
 618  */
 619 function lien_optimise($objet_source, $primary, $table_lien, $id, $objets) {
 620         include_spip('genie/optimiser');
 621         $echec = false;
 622         $dels = 0;
 623         foreach ($objets as $objet => $id_objets) {
 624                 $objet = ($objet == '*') ? $objet : objet_type($objet); # securite
 625                 if (!is_array($id_objets) or reset($id_objets) == "NOT") {
 626                         $id_objets = array($id_objets);
 627                 }
 628                 foreach ($id_objets as $id_objet) {
 629                         $where = lien_where($primary, $id, $objet, $id_objet);
 630                         # les liens vers un objet inexistant
 631                         $r = sql_select("DISTINCT objet", $table_lien, $where);
 632                         while ($t = sql_fetch($r)) {
 633                                 $type = $t['objet'];
 634                                 $spip_table_objet = table_objet_sql($type);
 635                                 $id_table_objet = id_table_objet($type);
 636                                 $res = sql_select("L.$primary AS id,L.id_objet",
 637                                         // la condition de jointure inclue L.objet='xxx' pour ne joindre que les bonnes lignes
 638                                         // du coups toutes les lignes avec un autre objet ont un id_xxx=NULL puisque LEFT JOIN
 639                                         // il faut les eliminier en repetant la condition dans le where L.objet='xxx'
 640                                         "$table_lien AS L
 641                                                                         LEFT JOIN $spip_table_objet AS O
 642                                                                                 ON (O.$id_table_objet=L.id_objet AND L.objet=" . sql_quote($type) . ")",
 643                                         "L.objet=" . sql_quote($type) . " AND O.$id_table_objet IS NULL");
 644                                 // sur une cle primaire composee, pas d'autres solutions que de virer un a un
 645                                 while ($row = sql_fetch($res)) {
 646                                         $e = sql_delete($table_lien,
 647                                                 array("$primary=" . $row['id'], "id_objet=" . $row['id_objet'], "objet=" . sql_quote($type)));
 648                                         if ($e != false) {
 649                                                 $dels += $e;
 650                                                 spip_log("Entree " . $row['id'] . "/" . $row['id_objet'] . "/$type supprimee dans la table $table_lien",
 651                                                         _LOG_INFO_IMPORTANTE);
 652                                         }
 653                                 }
 654                         }
 655
 656                         # les liens depuis un objet inexistant
 657                         $table_source = table_objet_sql($objet_source);
 658                         // filtrer selon $id, $objet, $id_objet eventuellement fournis
 659                         // (en general '*' pour chaque)
 660                         $where = lien_where("L.$primary", $id, $objet, $id_objet);
 661                         $where[] = "O.$primary IS NULL";
 662                         $res = sql_select("L.$primary AS id",
 663                                 "$table_lien AS L LEFT JOIN $table_source AS O ON L.$primary=O.$primary",
 664                                 $where);
 665                         $dels += optimiser_sansref($table_lien, $primary, $res);
 666                 }
 667         }
 668
 669         return ($echec ? false : $dels);
 670 }
 671
 672
 673 /**
 674  * Sous fonction qualification
 675  * qui traite les liens pour un objet source dont la clé primaire
 676  * et la table de lien sont fournies
 677  *
 678  * $objets et de la forme
 679  * array($objet=>$id_objets,...)
 680  * un * pour $id,$objet,$id_objets permet de traiter par lot
 681  *
 682  * exemple :
 683  * $qualif = array('vu'=>'oui');
 684  *
 685  * @internal
 686  * @param string $objet_source Objet source de l'insertion (celui qui a la table de liaison)
 687  * @param string $primary Nom de la clé primaire de cet objet
 688  * @param string $table_lien Nom de la table de lien de cet objet
 689  * @param int $id Identifiant de l'objet sur lesquels on va insérer des liaisons
 690  * @param array $objets Liste des liaisons à faire, de la forme array($objet=>$id_objets)
 691  * @param array $qualif
 692  *     Liste des qualifications à appliquer.
 693  *
 694  *     Si l'objet dispose d'un champ rôle, on extrait des qualifications
 695  *     le rôle s'il est présent, sinon on applique les qualifications
 696  *     sur le rôle par défaut.
 697  * @return bool|int
 698  *     Nombre de modifications faites, false si échec.
 699  */
 700 function lien_set($objet_source, $primary, $table_lien, $id, $objets, $qualif) {
 701         $echec = null;
 702         $ok = 0;
 703         if (!$qualif) {
 704                 return false;
 705         }
 706         // nettoyer qualif qui peut venir directement d'un objet_trouver_lien :
 707         unset($qualif[$primary]);
 708         unset($qualif[$objet_source]);
 709         if (isset($qualif['objet'])) {
 710                 unset($qualif[$qualif['objet']]);
 711         }
 712         unset($qualif['objet']);
 713         unset($qualif['id_objet']);
 714         foreach ($objets as $objet => $id_objets) {
 715
 716                 // role, colonne, where par défaut
 717                 list($role, $colonne_role, $cond) =
 718                         roles_trouver_dans_qualif($objet_source, $objet, $qualif);
 719
 720                 $objet = ($objet == '*') ? $objet : objet_type($objet); # securite
 721                 if (!is_array($id_objets) or reset($id_objets) == "NOT") {
 722                         $id_objets = array($id_objets);
 723                 }
 724                 foreach ($id_objets as $id_objet) {
 725
 726                         $args = array(
 727                                 'table_lien' => $table_lien,
 728                                 'objet_source' => $objet_source,
 729                                 'id_objet_source' => $id,
 730                                 'objet' => $objet,
 731                                 'id_objet' => $id_objet,
 732                                 'role' => $role,
 733                                 'colonne_role' => $colonne_role,
 734                                 'action' => 'modifier',
 735                         );
 736
 737                         // Envoyer aux plugins
 738                         $qualif = pipeline('pre_edition_lien',
 739                                 array(
 740                                         'args' => $args,
 741                                         'data' => $qualif,
 742                                 )
 743                         );
 744                         $args['id_objet'] = $id_objet;
 745
 746                         $where = lien_where($primary, $id, $objet, $id_objet, $cond);
 747                         $e = sql_updateq($table_lien, $qualif, $where);
 748
 749                         if ($e === false) {
 750                                 $echec = true;
 751                         } else {
 752                                 // Envoyer aux plugins
 753                                 pipeline('post_edition_lien',
 754                                         array(
 755                                                 'args' => $args,
 756                                                 'data' => $qualif
 757                                         )
 758                                 );
 759                                 $ok++;
 760                         }
 761                 }
 762         }
 763
 764         return ($echec ? false : $ok);
 765 }
 766
 767 /**
 768  * Sous fonction trouver
 769  * qui cherche les liens pour un objet source dont la clé primaire
 770  * et la table de lien sont fournies
 771  *
 772  * $objets et de la forme
 773  * array($objet=>$id_objets,...)
 774  * un * pour $id,$objet,$id_objets permet de traiter par lot
 775  *
 776  * Le tableau de condition peut avoir un index 'role' indiquant de
 777  * chercher un rôle précis, ou * pour tous les roles (alors équivalent
 778  * à l'absence de l'index)
 779  *
 780  * @internal
 781  * @param string $objet_source
 782  * @param string $primary
 783  * @param string $table_lien
 784  * @param int $id
 785  * @param array $objets
 786  * @param array|null $cond
 787  *     Condition du where par défaut
 788  *
 789  *     On peut passer un index 'role' pour sélectionner uniquement
 790  *     le role défini dedans (et '*' pour tous les rôles).
 791  * @return array
 792  */
 793 function lien_find($objet_source, $primary, $table_lien, $id, $objets, $cond = null) {
 794         $trouve = array();
 795         foreach ($objets as $objet => $id_objets) {
 796                 $objet = ($objet == '*') ? $objet : objet_type($objet); # securite
 797                 // gerer les roles s'il y en a dans $cond
 798                 list($cond) = roles_creer_condition_role($objet_source, $objet, $cond, true);
 799                 // lien_where prend en charge les $id_objets sous forme int ou array
 800                 $where = lien_where($primary, $id, $objet, $id_objets, $cond);
 801                 $liens = sql_allfetsel('*', $table_lien, $where);
 802                 // ajouter les entrees objet_source et objet cible par convenance
 803                 foreach ($liens as $l) {
 804                         $l[$objet_source] = $l[$primary];
 805                         $l[$objet] = $l['id_objet'];
 806                         $trouve[] = $l;
 807                 }
 808         }
 809
 810         return $trouve;
 811 }
 812
 813 /**
 814  * Propager la date_modif sur les objets dont un lien a été modifié
 815  *
 816  * @internal
 817  * @param string $objet
 818  * @param array|int $ids
 819  */
 820 function lien_propage_date_modif($objet, $ids) {
 821         static $done = array();
 822         $hash = md5($objet . serialize($ids));
 823
 824         // sql_updateq, peut être un rien lent.
 825         // On évite de l'appeler 2 fois sur les mêmes choses
 826         if (isset($done[$hash])) {
 827                 return;
 828         }
 829
 830         $trouver_table = charger_fonction('trouver_table', 'base');
 831
 832         $table = table_objet_sql($objet);
 833         if ($desc = $trouver_table($table)
 834                 and isset($desc['field']['date_modif'])
 835         ) {
 836                 $primary = id_table_objet($objet);
 837                 $where = (is_array($ids) ? sql_in($primary, array_map('intval', $ids)) : "$primary=" . intval($ids));
 838                 sql_updateq($table, array('date_modif' => date('Y-m-d H:i:s')), $where);
 839         }
 840
 841         $done[$hash] = true;
 842 }