www/plugins/champs_extras3/inc/cextras_autoriser.php

   1 <?php
   2
   3 /**
   4  * Déclaration d'autorisations pour les champs extras
   5  *
   6  * @package SPIP\Cextras\Autorisations
   7 **/
   8
   9 // sécurité
  10 if (!defined("_ECRIRE_INC_VERSION")) return;
  11
  12
  13 /**
  14  * Fonction d'appel pour le pipeline autoriser
  15  * @pipeline autoriser
  16  */
  17 function cextras_autoriser(){}
  18
  19
  20 /**
  21  * Retourne si une saisie peut s'afficher ou non
  22  *
  23  * Teste les options de restrictions de la saisie si il y en a
  24  * et calcule en fonction l'autorisation
  25  *
  26  * @param array $saisie
  27  *     Saisie que l'on traite.
  28  * @param string $action
  29  *     Le type d'action : voir | modifier
  30  * @param string $table
  31  *     La table d'application : spip_articles
  32  * @param int $id
  33  *     Identifiant de la table : 3
  34  * @param array $qui
  35  *     Description de l'auteur en cours
  36  * @param Array $opt
  37  *     Options de l'autorisation
  38  * @return Bool
  39  *     La saisie peut elle s'afficher ?
  40 **/
  41 function champs_extras_restrictions($saisie, $action, $table, $id, $qui, $opt) {
  42         if (!$saisie) {
  43                 return true;
  44         }
  45
  46         if (!isset($saisie['options']['restrictions']) OR !$saisie['options']['restrictions']) {
  47                 return true;
  48         }
  49
  50         if (!in_array($action, array('voir', 'modifier'))) {
  51                 return true;
  52         }
  53
  54         $restrictions = $saisie['options']['restrictions'];
  55
  56         // tester si des options d'autorisations sont definies pour cette saisie
  57         // et les appliquer.
  58         // peut être 'voir' ou 'modifier'
  59                 // dedans peut être par type d'auteur 'webmestre', 'admin'
  60         // peut être par secteur parent.
  61         // peut être par branche parente.
  62         // peut être par groupe parent.
  63
  64         // restriction par type d'auteur
  65         if (isset($restrictions[$action]['auteur']) and $auteur = $restrictions[$action]['auteur']) {
  66                 switch ($auteur) {
  67                         case 'webmestre':
  68                                 if (!autoriser('webmestre')) {
  69                                         return false;
  70                                 }
  71                                 break;
  72                         case 'admin':
  73                                 if ($qui['statut'] != '0minirezo' AND !$qui['restreint']) {
  74                                         return false;
  75                                 }
  76                                 break;
  77                 }
  78         }
  79
  80         // pour les autres autorisations, dès qu'une est valide, on part.
  81         // cela permet de dire que l'on peut restreindre au secteur 1 et à la branche 3,
  82         // branche en dehors du secteur 1
  83         // le cumul des autorisations rendrait impossible cela
  84         unset($restrictions['voir']);
  85         unset($restrictions['modifier']);
  86
  87         // enlever tous les false (0, '')
  88         $restrictions = array_filter($restrictions);
  89
  90         if ($restrictions) {
  91                 foreach ($restrictions as $type => $ids) {
  92                         $ids = explode(':', $ids);
  93                         $cible = rtrim($type, 's');
  94                         $restriction = charger_fonction("restreindre_extras_objet_sur_$cible", "inc", true);
  95
  96                         if ($restriction and $restriction($opt['type'], $opt['id_objet'], $opt, $ids, $cible)) {
  97                                 return true;
  98                         }
  99                 }
 100                 // aucune des restrictions n'a ete validee
 101                 return false;
 102         }
 103
 104         return true;
 105 }
 106
 107 /**
 108  * Autorisation de voir un champ extra
 109  *
 110  * Cherche une autorisation spécifique pour le champ si elle existe
 111  * (autoriser_{objet}_voirextra_{colonne}_dist), sinon applique
 112  * l'autorisation prévue par la description de la saisie
 113  *
 114  * @example
 115  *     ```
 116  *     autoriser('voirextra','auteur', $id_auteur,'',
 117  *         array('champ'=>'prenom', 'saisie'=>$saisie, ...));
 118  *     ```
 119  *     Appelle ``autoriser_auteur_voirextra_prenom_dist()`` si la fonction existe...
 120  *
 121  * @param  string $faire Action demandée
 122  * @param  string $type  Type d'objet sur lequel appliquer l'action
 123  * @param  int    $id    Identifiant de l'objet
 124  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 125  * @param  array  $opt   Options de cette autorisation
 126  * @return bool          true s'il a le droit, false sinon
 127 **/
 128 function autoriser_voirextra_dist($faire, $type, $id, $qui, $opt){
 129         if (isset($opt['saisie'])) {
 130                 // tester des fonctions d'autorisations plus precises declarees
 131                 if ($opt['champ']) {
 132                         $f = 'autoriser_' . $opt['type'] . '_voirextra_' . $opt['champ'];
 133                         if (function_exists($f) OR function_exists($f .= '_dist')) {
 134                                 return $f($faire, $type, $id, $qui, $opt);
 135                         }
 136                 }
 137                 return champs_extras_restrictions($opt['saisie'], substr($faire, 0, -5), $opt['table'], $id, $qui, $opt);
 138         }
 139         return true;
 140 }
 141
 142 /**
 143  * Autorisation de modifier un champ extra
 144  *
 145  * Cherche une autorisation spécifique pour le champ si elle existe
 146  * (autoriser_{objet}_modifierextra_{colonne}_dist), sinon applique
 147  * l'autorisation prévue par la description de la saisie
 148  *
 149  * @example
 150  *     ```
 151  *     autoriser('modifierextra','auteur', $id_auteur,'',
 152  *         array('champ'=>'prenom', 'saisie'=>$saisie, ...));
 153  *     ```
 154  *     Appelle ``autoriser_auteur_modifierextra_prenom_dist()`` si elle existe
 155  *
 156  * @param  string $faire Action demandée
 157  * @param  string $type  Type d'objet sur lequel appliquer l'action
 158  * @param  int    $id    Identifiant de l'objet
 159  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 160  * @param  array  $opt   Options de cette autorisation
 161  * @return bool          true s'il a le droit, false sinon
 162 **/
 163 function autoriser_modifierextra_dist($faire, $type, $id, $qui, $opt){
 164         if (isset($opt['saisie'])) {
 165                 // tester des fonctions d'autorisations plus precises declarees
 166                 if ($opt['champ']) {
 167                         $f = 'autoriser_' . $opt['type'] . '_modifierextra_' . $opt['champ'];
 168                         if (function_exists($f) OR function_exists($f .= '_dist')) {
 169                                 return $f($faire, $type, $id, $qui, $opt);
 170                         }
 171                 }
 172                 return champs_extras_restrictions($opt['saisie'], substr($faire, 0, -5), $opt['table'], $id, $qui, $opt);
 173         }
 174         return true;
 175 }
 176
 177
 178
 179 /**
 180  * Fonction d'aide pour créer des autorisations de champs spécifiques
 181  *
 182  * Permet d'indiquer que tels champs extras se limitent à telle ou telle rubrique
 183  * et cela en créant à la volée les fonctions d'autorisations adéquates.
 184  *
 185  * @example
 186  *     ```
 187  *     restreindre_extras('article', array('nom', 'prenom'), array(8, 12));
 188  *     restreindre_extras('site', 'url_doc', 18, true); // recursivement aux sous rubriques
 189  *     ```
 190  *
 191  * @param string $objet
 192  *     Objet possédant les extras
 193  * @param mixed $noms
 194  *     Nom des extras a restreindre
 195  * @param mixed $ids
 196  *     Identifiant (des rubriques par defaut) sur lesquelles s'appliquent les champs
 197  * @param string $cible
 198  *     Type de la fonction de test qui sera appelee, par defaut "rubrique". Peut aussi etre "secteur", "groupe" ou des fonctions definies
 199  * @param bool $recursif
 200  *     Application recursive sur les sous rubriques ? ATTENTION, c'est gourmand en requetes SQL :)
 201  * @return bool
 202  *     true si on a fait quelque chose
 203  */
 204 function restreindre_extras($objet, $noms=array(), $ids=array(), $cible='rubrique', $recursif=false) {
 205         if (!$objet or !$noms or !$ids) {
 206                 return false;
 207         }
 208
 209         if (!is_array($noms)) { $noms = array($noms); }
 210         if (!is_array($ids))  { $ids  = array($ids); }
 211
 212         #$objet = objet_type($objet);
 213         $ids = var_export($ids, true);
 214         $recursif = var_export($recursif, true);
 215
 216         foreach ($noms as $nom) {
 217                 $m = "autoriser_" . $objet . "_modifierextra_" . $nom . "_dist";
 218                 $v = "autoriser_" . $objet . "_voirextra_" . $nom . "_dist";
 219
 220                 $code = "
 221                         if (!function_exists('$m')) {
 222                                 function $m(\$faire, \$quoi, \$id, \$qui, \$opt) {
 223                                         return _restreindre_extras_objet('$objet', \$id, \$opt, $ids, '$cible', $recursif);
 224                                 }
 225                         }
 226                         if (!function_exists('$v')) {
 227                                 function $v(\$faire, \$quoi, \$id, \$qui, \$opt) {
 228                                         return autoriser('modifierextra', \$quoi, \$id, \$qui, \$opt);
 229                                 }
 230                         }
 231                 ";
 232
 233                 # var_dump($code);
 234                 eval($code);
 235         }
 236
 237         return true;
 238 }
 239
 240
 241
 242 /**
 243  * Fonction d'autorisation interne à la fonction restreindre_extras()
 244  *
 245  * Teste si un objet à le droit d'afficher des champs extras
 246  * en fonction de la rubrique (ou autre defini dans la cible)
 247  * dans laquelle il se trouve et des rubriques autorisées
 248  *
 249  * On met en cache pour éviter de plomber le serveur SQL, vu que la plupart du temps
 250  * un hit demandera systématiquement le même objet/id_objet lorsqu'il affiche
 251  * un formulaire.
 252  *
 253  * @param string $objet
 254  *     Objet possédant les extras
 255  * @param int $id_objet
 256  *     Identifiant de l'objet possédant les extras
 257  * @param array $opt
 258  *     Options des autorisations
 259  * @param mixed $ids
 260  *     Identifiant(s) (en rapport avec la cible) sur lesquelles s'appliquent les champs
 261  * @param string $cible
 262  *     Type de la fonction de test qui sera appelee, par defaut "rubrique".
 263  *     Peut aussi etre "secteur", "groupe" ou des fonctions definies
 264  * @param bool $recursif
 265  *     Application recursive sur les sous rubriques ? ATTENTION, c'est
 266  *     gourmand en requetes SQL :)
 267  * @return bool
 268  *     Autorisé ou non
 269 **/
 270 function _restreindre_extras_objet($objet, $id_objet, $opt, $ids, $cible='rubrique', $recursif=false) {
 271         static $autorise = array();
 272
 273         if ( !isset($autorise[$objet]) ) { $autorise[$objet] = array(); }
 274
 275         $cle = $cible . implode('-', $ids);
 276         if (isset($autorise[$objet][$id_objet][$cle])) {
 277                 return $autorise[$objet][$id_objet][$cle];
 278         }
 279
 280         $f = charger_fonction("restreindre_extras_objet_sur_$cible", "inc", true);
 281         if ($f) {
 282                 return $autorise[$objet][$id_objet][$cle] =
 283                         $f($objet, $id_objet, $opt, $ids, $recursif);
 284         }
 285
 286         // pas trouve... on n'affiche pas... Pan !
 287         return $autorise[$objet][$id_objet][$cle] = false;
 288 }
 289
 290
 291 /**
 292  * Fonction d'autorisation interne à la fonction restreindre_extras()
 293  *
 294  * Teste si un objet à le droit d'afficher des champs extras
 295  * en fonction de la rubrique (ou autre defini dans la cible)
 296  * dans laquelle il se trouve et des rubriques autorisées
 297  *
 298  * Le dernier argument donne la colonne à chercher dans l'objet correspondant
 299  *
 300  * @param string $objet
 301  *     Objet possédant les extras
 302  * @param int $id_objet
 303  *     Identifiant de l'objet possédant les extras
 304  * @param array $opt
 305  *     Options des autorisations
 306  * @param mixed $ids
 307  *     Identifiant(s) (en rapport avec la cible) sur lesquelles s'appliquent les champs
 308  * @param bool $_id_cible
 309  *     Nom de la colonne SQL cible (id_rubrique, id_secteur, id_groupe...)
 310  * @return bool|int
 311  *     - true : autorisé,
 312  *     - false : non autorisé,
 313  *     - 0 : incertain.
 314 **/
 315 function _restreindre_extras_objet_sur_cible($objet, $id_objet, $opt, $ids, $_id_cible) {
 316
 317         $id_cible = 0;
 318         if (isset($opt['contexte'][$_id_cible])) {
 319                 $id_cible = intval($opt['contexte'][$_id_cible]);
 320         }
 321
 322         if (!$id_cible) {
 323                 // on tente de le trouver dans la table de l'objet
 324                 $table = table_objet_sql($objet);
 325                 $id_table = id_table_objet($table);
 326                 include_spip('base/objets');
 327                 $desc = lister_tables_objets_sql($table);
 328
 329                 if (isset($desc['field'][$_id_cible])) {
 330                         $id_cible = sql_getfetsel($_id_cible, $table, "$id_table=".sql_quote($id_objet));
 331                 }
 332     }
 333
 334         if (!$id_cible) {
 335                 // on essaie aussi dans le contexte d'appel de la page
 336                 $id_cible = _request($_id_cible);
 337
 338                 // on tente en cas de id_secteur de s'appuyer sur un eventuel id_rubrique
 339                 if (!$id_cible and $_id_cible == 'id_secteur') {
 340                         if ($i = _request('id_rubrique')) {
 341                                 $id_cible = sql_getfetsel('id_secteur', 'spip_rubriques', 'id_rubrique='.sql_quote($i));
 342                         }
 343                 }
 344         }
 345
 346         if (!$id_cible) {
 347                 return array($id_cible, false);
 348         }
 349
 350     if (in_array($id_cible, $ids)) {
 351                 return array($id_cible, true);
 352     }
 353
 354     return array($id_cible, false);
 355 }
 356
 357
 358
 359 /**
 360  * Fonction d'autorisation interne à la fonction restreindre_extras()
 361  * spécifique au test d'appartenance à une branche de rubrique
 362  *
 363  * @note ATTENTION, c'est gourmand en requetes SQL :)
 364  *
 365  * @see inc_restreindre_extras_objet_sur_rubrique_dist()
 366  * @param string $objet
 367  *     Objet possédant les extras
 368  * @param int $id_objet
 369  *     Identifiant de l'objet possédant les extras
 370  * @param array $opt
 371  *     Options des autorisations
 372  * @param mixed $ids
 373  *     Identifiant(s) des branches de rubrique sur lesquelles s'appliquent les champs
 374  * @param bool $recursif
 375  *     Non utilisé
 376  * @return bool
 377  *     Autorisé ou non
 378  */
 379 function inc_restreindre_extras_objet_sur_branche_dist($objet, $id_objet, $opt, $ids, $recursif) {
 380         return inc_restreindre_extras_objet_sur_rubrique_dist($objet, $id_objet, $opt, $ids, true);
 381 }
 382
 383 /**
 384  * Fonction d'autorisation interne à la fonction restreindre_extras()
 385  * spécifique au test d'appartenance à une rubrique
 386  *
 387  * @param string $objet
 388  *     Objet possédant les extras
 389  * @param int $id_objet
 390  *     Identifiant de l'objet possédant les extras
 391  * @param array $opt
 392  *     Options des autorisations
 393  * @param mixed $ids
 394  *     Identifiant(s) des rubriques sur lesquelles s'appliquent les champs
 395  * @param bool $recursif
 396  *     Application récursive sur les sous rubriques ?
 397  *     ATTENTION, c'est gourmand en requetes SQL :)
 398  * @return bool
 399  *     Autorisé ou non
 400  */
 401 function inc_restreindre_extras_objet_sur_rubrique_dist($objet, $id_objet, $opt, $ids, $recursif) {
 402
 403         list($id_rubrique, $ok) = _restreindre_extras_objet_sur_cible($objet, $id_objet, $opt, $ids, 'id_rubrique');
 404
 405         if ($ok) {
 406                 return true;
 407         }
 408
 409         if (!$recursif) {
 410                 return false;
 411         }
 412
 413         // tester si un parent proche existe lorsqu'on ne connait pas la rubrique.
 414         if (!$id_rubrique AND $id_rubrique = _request('id_parent')) {
 415                 if (in_array($id_rubrique, $ids)) {
 416                         return true;
 417                 }
 418         }
 419
 420         // on teste si l'objet est dans une sous rubrique de celles mentionnee...
 421         if ($id_rubrique) {
 422                 $id_parent = $id_rubrique;
 423                 while ($id_parent = sql_getfetsel("id_parent", "spip_rubriques", "id_rubrique=" . sql_quote($id_parent))) {
 424                         if (in_array($id_parent, $ids)) {
 425                                 return true;
 426                         }
 427                 }
 428         }
 429
 430     return false;
 431 }
 432
 433
 434
 435 /**
 436  * Fonction d'autorisation interne à la fonction restreindre_extras()
 437  * spécifique au test d'appartenance à un secteur
 438  *
 439  * @param string $objet
 440  *     Objet possédant les extras
 441  * @param int $id_objet
 442  *     Identifiant de l'objet possédant les extras
 443  * @param array $opt
 444  *     Options des autorisations
 445  * @param mixed $ids
 446  *     Identifiant(s) des secteurs sur lesquelles s'appliquent les champs
 447  * @param bool $recursif
 448  *     Non utilisé
 449  * @return bool
 450  *     Autorisé ou non
 451  */
 452 function inc_restreindre_extras_objet_sur_secteur_dist($objet, $id_objet, $opt, $ids, $recursif=false) {
 453         list($id_secteur, $ok) = _restreindre_extras_objet_sur_cible($objet, $id_objet, $opt, $ids, 'id_secteur');
 454         return $ok;
 455 }
 456
 457
 458
 459 /**
 460  * Fonction d'autorisation interne à la fonction restreindre_extras()
 461  * spécifique au test d'appartenance à un groupe de mot
 462  *
 463  * Alias de groupemot
 464  *
 465  * @see inc_restreindre_extras_objet_sur_groupemot_dist()
 466  * @param string $objet
 467  *     Objet possédant les extras
 468  * @param int $id_objet
 469  *     Identifiant de l'objet possédant les extras
 470  * @param array $opt
 471  *     Options des autorisations
 472  * @param mixed $ids
 473  *     Identifiant(s) des groupes de mots sur lesquelles s'appliquent les champs
 474  * @param bool $recursif
 475  *     True pour appliquer aux branches d'un groupe de mot
 476  *     (avec plugin spécifique groupe de mots arborescents)
 477  * @return bool
 478  *     Autorisé ou non
 479  */
 480 function inc_restreindre_extras_objet_sur_groupe_dist($objet, $id_objet, $opt, $ids, $recursif) {
 481         return inc_restreindre_extras_objet_sur_groupemot_dist($objet, $id_objet, $opt, $ids, $recursif);
 482 }
 483
 484 /**
 485  * Fonction d'autorisation interne à la fonction restreindre_extras()
 486  * spécifique au test d'appartenance à un groupe de mot
 487  *
 488  * @param string $objet
 489  *     Objet possédant les extras
 490  * @param int $id_objet
 491  *     Identifiant de l'objet possédant les extras
 492  * @param array $opt
 493  *     Options des autorisations
 494  * @param mixed $ids
 495  *     Identifiant(s) des groupes de mots sur lesquelles s'appliquent les champs
 496  * @param bool $recursif
 497  *     True pour appliquer aux branches d'un groupe de mot
 498  *     (avec plugin spécifique groupe de mots arborescents)
 499  * @return bool
 500  *     Autorisé ou non
 501  */
 502 function inc_restreindre_extras_objet_sur_groupemot_dist($objet, $id_objet, $opt, $ids, $recursif) {
 503         list($id_groupe, $ok) = _restreindre_extras_objet_sur_cible($objet, $id_objet, $opt, $ids, 'id_groupe');
 504         if ($ok) {
 505                 return true;
 506         }
 507
 508         // on teste si l'objet est dans un sous groupe de celui mentionne...
 509         // sauf qu'il n'existe pas encore de groupe avec id_parent :) - sauf avec plugin
 510         // on desactive cette option si cette colonne est absente
 511         if ($id_groupe and $recursif) {
 512                 $trouver_table = charger_fonction('trouver_table', 'base');
 513                 $desc = $trouver_table("groupes_mots");
 514                 if (isset($desc['field']['id_parent'])) {
 515                         $id_parent = $id_groupe;
 516                         while ($id_parent = sql_getfetsel("id_parent", "spip_groupes_mots", "id_parent=" . sql_quote($id_parent))) {
 517                                 if (in_array($id_parent, $ids)) {
 518                                         return true;
 519                                 }
 520                         }
 521                 }
 522         }
 523
 524     return false;
 525 }
 526
 527 /**
 528  * Fonction d'autorisation interne à la fonction restreindre_extras()
 529  * spécifique au test de la présence d'une composition
 530  *
 531  * @param string $objet
 532  *     Objet possédant les extras
 533  * @param int $id_objet
 534  *     Identifiant de l'objet possédant les extras
 535  * @param array $opt
 536  *     Options des autorisations
 537  * @param mixed $ids
 538  *     Identifiant(s) des compositions sur lesquelles s'appliquent les champs
 539  * @param bool $recursif
 540  *     Inutile, la récursivité est prise en charge par compositions_determiner()
 541  * @return bool
 542  *     Autorisé ou non
 543  */
 544 function inc_restreindre_extras_objet_sur_composition_dist($objet, $id_objet, $opt, $ids, $recursif) {
 545
 546         if (!function_exists('compositions_determiner')) {
 547                 include_spip('compositions_fonctions');
 548         }
 549
 550         if (function_exists('compositions_determiner')) {
 551                 $composition = compositions_determiner($objet, $id_objet);
 552                 return in_array($composition, $ids);
 553         }
 554
 555         return false;
 556 }
 557
 558 ?>