www/ecrire/inc/autoriser.php

   1 <?php
   2
   3 /***************************************************************************\
   4  *  SPIP, Systeme de publication pour l'internet                           *
   5  *                                                                         *
   6  *  Copyright (c) 2001-2014                                                *
   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'API autoriser et fonctions d'autorisations de SPIP
  15  *
  16  * @package SPIP\Autorisations
  17 **/
  18 if (!defined('_ECRIRE_INC_VERSION')) return;
  19
  20 include_spip('base/abstract_sql');
  21
  22 /**
  23  * Tracer les autorisations dans tmp/spip.log pour débug ?
  24  */
  25 defined('_DEBUG_AUTORISER') || define('_DEBUG_AUTORISER', false);
  26
  27 // Constantes surchargeables, cf. plugin autorite
  28
  29 /**
  30  * Gérer les admins restreints ?
  31  *
  32  * @todo une option à activer
  33  */
  34 defined('_ADMINS_RESTREINTS') || define('_ADMINS_RESTREINTS', true);
  35
  36 /** Statut par defaut à la creation */
  37 defined('_STATUT_AUTEUR_CREATION') || define('_STATUT_AUTEUR_CREATION', '1comite');
  38
  39 /** statuts associables a des rubriques (separes par des virgules) */
  40 defined('_STATUT_AUTEUR_RUBRIQUE') || define('_STATUT_AUTEUR_RUBRIQUE', _ADMINS_RESTREINTS ? '0minirezo' : '');
  41
  42 // mes_fonctions peut aussi declarer des autorisations, donc il faut donc le charger
  43 if ($f = find_in_path('mes_fonctions.php')) {
  44         global $dossier_squelettes;
  45         include_once(_ROOT_CWD . $f);
  46 }
  47
  48
  49 if (!function_exists('autoriser')) {
  50 /**
  51  * Autoriser une action
  52  *
  53  * Teste si une personne (par défaut le visiteur en cours) peut effectuer
  54  * une certaine action. Cette fonction est le point d'entrée de toutes
  55  * les autorisations.
  56  *
  57  * La fonction se charge d'appeler des fonctions d'autorisations spécifiques
  58  * aux actions demandées si elles existent. Elle cherche donc les fonctions
  59  * dans cet ordre :
  60  * - autoriser_{type}_{faire}, sinon avec _dist
  61  * - autoriser_{type}, sinon avec _dist
  62  * - autoriser_{faire}, sinon avec _dist
  63  * - autoriser_{defaut}, sinon avec _dist
  64  *
  65  * Seul le premier argument est obligatoire
  66  *
  67  * @api
  68  * @see autoriser_dist()
  69  *
  70  * @param string $faire
  71  *   une action ('modifier', 'publier'...)
  72  * @param string $type
  73  *   type d'objet ou nom de table ('article')
  74  * @param int $id
  75  *   id de l'objet sur lequel on veut agir
  76  * @param null|int|array $qui
  77  *   - si null on prend alors visiteur_session
  78  *   - un id_auteur (on regarde dans la base)
  79  *   - un tableau auteur complet, y compris [restreint]
  80  * @param null|array $opt
  81  *   options sous forme de tableau associatif
  82  * @return bool
  83  *   true si la personne peut effectuer l'action
  84  */
  85         function autoriser($faire, $type='', $id=0, $qui = NULL, $opt = NULL) {
  86                 // Charger les fonctions d'autorisation supplementaires
  87                 static $pipe;
  88                 if (!isset($pipe)) { $pipe = 1; pipeline('autoriser'); }
  89
  90                 $args = func_get_args();
  91                 return call_user_func_array('autoriser_dist', $args);
  92         }
  93 }
  94
  95
  96 /**
  97  * Autoriser une action
  98  *
  99  * Voir autoriser() pour une description complète
 100  *
 101  * @see autoriser()
 102  *
 103  * @param string $faire
 104  *   une action ('modifier', 'publier'...)
 105  * @param string $type
 106  *   type d'objet ou nom de table ('article')
 107  * @param int $id
 108  *   id de l'objet sur lequel on veut agir
 109  * @param null|int|array $qui
 110  *   si null on prend alors visiteur_session
 111  *   un id_auteur (on regarde dans la base)
 112  *   un tableau auteur complet, y compris [restreint]
 113  * @param null|array $opt
 114  *   options sous forme de tableau associatif
 115  * @return bool
 116  *   true si la personne peut effectuer l'action
 117  */
 118 function autoriser_dist($faire, $type='', $id=0, $qui = NULL, $opt = NULL) {
 119
 120         // Qui ? visiteur_session ?
 121         // si null ou '' (appel depuis #AUTORISER) on prend l'auteur loge
 122         if ($qui === NULL OR $qui==='')
 123           $qui = $GLOBALS['visiteur_session'] ? $GLOBALS['visiteur_session'] : array('statut' => '', 'id_auteur' =>0, 'webmestre' => 'non');
 124         elseif (is_numeric($qui)) {
 125                 $qui = sql_fetsel("*", "spip_auteurs", "id_auteur=".$qui);
 126         }
 127
 128         // Admins restreints, on construit ici (pas generique mais...)
 129         // le tableau de toutes leurs rubriques (y compris les sous-rubriques)
 130         if (_ADMINS_RESTREINTS AND is_array($qui)) {
 131                 $qui['restreint'] = isset($qui['id_auteur']) ? liste_rubriques_auteur($qui['id_auteur']) : array();
 132         }
 133
 134         if (_DEBUG_AUTORISER) spip_log("autoriser $faire $type $id (" . (isset($qui['nom']) ? $qui['nom'] : '') . ") ?");
 135
 136         // passer par objet_type pour avoir les alias
 137         // et supprimer les _
 138         $type = str_replace('_','',  strncmp($type,"_",1)==0?$type:objet_type($type,false));
 139
 140         // Si une exception a ete decretee plus haut dans le code, l'appliquer
 141         if (isset($GLOBALS['autoriser_exception'][$faire][$type][$id])
 142         AND autoriser_exception($faire,$type,$id,'verifier'))
 143                 return true;
 144
 145         // Chercher une fonction d'autorisation
 146         // Dans l'ordre on va chercher autoriser_type_faire[_dist], autoriser_type[_dist],
 147         // autoriser_faire[_dist], autoriser_defaut[_dist]
 148         $fonctions = $type
 149                 ? array (
 150                         'autoriser_'.$type.'_'.$faire,
 151                         'autoriser_'.$type.'_'.$faire.'_dist',
 152                         'autoriser_'.$type,
 153                         'autoriser_'.$type.'_dist',
 154                         'autoriser_'.$faire,
 155                         'autoriser_'.$faire.'_dist',
 156                         'autoriser_defaut',
 157                         'autoriser_defaut_dist'
 158                 )
 159                 : array (
 160                         'autoriser_'.$faire,
 161                         'autoriser_'.$faire.'_dist',
 162                         'autoriser_defaut',
 163                         'autoriser_defaut_dist'
 164                 );
 165
 166         foreach ($fonctions as $f) {
 167                 if (function_exists($f)) {
 168                         $a = $f($faire,$type,$id,$qui,$opt);
 169                         break;
 170                 }
 171         }
 172
 173         if (_DEBUG_AUTORISER) spip_log("$f($faire,$type,$id," . (isset($qui['nom']) ? $qui['nom'] : '') . "): ".($a?'OK':'niet'));
 174
 175         return $a;
 176 }
 177
 178 // une globale pour aller au plus vite dans la fonction generique ci dessus
 179 $GLOBALS['autoriser_exception']=array();
 180
 181 /**
 182  * Accorder une autorisation exceptionnel pour le hit en cours, ou la revoquer
 183  *
 184  * http://doc.spip.org/@autoriser_exception
 185  *
 186  * @param string $faire   Action demandée
 187  * @param string $type    Type d'objet sur lequel appliquer l'action
 188  * @param int    $id      Identifiant de l'objet
 189  * @param bool $autoriser accorder (true) ou revoquer (false)
 190  * @return bool
 191  */
 192 function autoriser_exception($faire,$type,$id,$autoriser=true){
 193         // une static innaccessible par url pour verifier que la globale est positionnee a bon escient
 194         static $autorisation;
 195         if ($autoriser==='verifier')
 196                         return isset($autorisation[$faire][$type][$id]);
 197         if ($autoriser===true)
 198                 $GLOBALS['autoriser_exception'][$faire][$type][$id] = $autorisation[$faire][$type][$id] = true;
 199         if ($autoriser===false) {
 200                 unset($GLOBALS['autoriser_exception'][$faire][$type][$id]);
 201                 unset($autorisation[$faire][$type][$id]);
 202         }
 203         return false;
 204 }
 205
 206
 207 /**
 208  * Autorisation par defaut
 209  *
 210  * Les admins complets OK, les autres non
 211  *
 212  * @param  string $faire Action demandée
 213  * @param  string $type  Type d'objet sur lequel appliquer l'action
 214  * @param  int    $id    Identifiant de l'objet
 215  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 216  * @param  array  $opt   Options de cette autorisation
 217  * @return bool          true s'il a le droit, false sinon
 218 **/
 219 function autoriser_defaut_dist($faire, $type, $id, $qui, $opt) {
 220         return
 221                 $qui['statut'] == '0minirezo'
 222                 AND !$qui['restreint'];
 223 }
 224
 225
 226 /**
 227  * Autorisation d'accès è l'espace privé ?
 228  *
 229  * @param  string $faire Action demandée
 230  * @param  string $type  Type d'objet sur lequel appliquer l'action
 231  * @param  int    $id    Identifiant de l'objet
 232  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 233  * @param  array  $opt   Options de cette autorisation
 234  * @return bool          true s'il a le droit, false sinon
 235 **/
 236 function autoriser_ecrire_dist($faire, $type, $id, $qui, $opt) {
 237         return in_array($qui['statut'], array('0minirezo', '1comite'));
 238 }
 239
 240 /**
 241  * Autorisation de créer un contenu
 242  *
 243  * Accordée par defaut ceux qui accèdent à l'espace privé,
 244  * peut-être surchargée au cas par cas
 245  *
 246  * @param  string $faire Action demandée
 247  * @param  string $type  Type d'objet sur lequel appliquer l'action
 248  * @param  int    $id    Identifiant de l'objet
 249  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 250  * @param  array  $opt   Options de cette autorisation
 251  * @return bool          true s'il a le droit, false sinon
 252 **/
 253 function autoriser_creer_dist($faire, $type, $id, $qui, $opt) {
 254         return in_array($qui['statut'], array('0minirezo', '1comite'));
 255 }
 256
 257 /**
 258  * Autorisation de prévisualiser un contenu
 259  *
 260  * @param  string $faire Action demandée
 261  * @param  string $type  Type d'objet sur lequel appliquer l'action
 262  * @param  int    $id    Identifiant de l'objet
 263  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 264  * @param  array  $opt   Options de cette autorisation
 265  * @return bool          true s'il a le droit, false sinon
 266 **/
 267 function autoriser_previsualiser_dist($faire, $type, $id, $qui, $opt) {
 268         // si auteur pas autorise, NIET
 269         if (strpos($GLOBALS['meta']['preview'], ",". $qui['statut'] .",")===false)
 270                 return false;
 271         // si pas de type et statut fourni, c'est une autorisation generale => OK
 272         if (!$type)
 273                 return true;
 274
 275         include_spip('base/objets');
 276         $infos = lister_tables_objets_sql(table_objet_sql($type));
 277         if (isset($infos['statut']))
 278                 foreach($infos['statut'] as $c){
 279                         if (isset($c['publie'])){
 280                                 if (!isset($c['previsu'])) return false; // pas de previsu definie => NIET
 281                                 $champ = $c['champ'];
 282                                 if (!isset($opt[$champ])) return false; // pas de champ passe a la demande => NIET
 283                                 $previsu = explode(',',$c['previsu']);
 284                                 // regarder si ce statut est autorise pour l'auteur
 285                                 if (in_array($opt[$champ]."/auteur",$previsu)){
 286                                         if (!sql_countsel("spip_auteurs_liens","id_auteur=".intval($qui['id_auteur'])." AND objet=".sql_quote($type)." AND id_objet=".intval($id)))
 287                                                 return false;  // pas auteur de cet objet => NIET
 288                                 }
 289                                 elseif (!in_array($opt[$champ],$previsu)) // le statut n'est pas dans ceux definis par la previsu => NIET
 290                                         return false;
 291                         }
 292                 }
 293         return true;
 294 }
 295
 296 /**
 297  * Autorisation de changer de langue un contenu
 298  *
 299  * @param  string $faire Action demandée
 300  * @param  string $type  Type d'objet sur lequel appliquer l'action
 301  * @param  int    $id    Identifiant de l'objet
 302  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 303  * @param  array  $opt   Options de cette autorisation
 304  * @return bool          true s'il a le droit, false sinon
 305 **/
 306 function autoriser_changerlangue_dist($faire, $type, $id, $qui, $opt) {
 307         return autoriser('modifier',$type,$id,$qui,$opt);
 308 }
 309
 310 /**
 311  * Autorisation de changer la date d'un contenu
 312  *
 313  * @param  string $faire Action demandée
 314  * @param  string $type  Type d'objet sur lequel appliquer l'action
 315  * @param  int    $id    Identifiant de l'objet
 316  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 317  * @param  array  $opt   Options de cette autorisation
 318  * @return bool          true s'il a le droit, false sinon
 319 **/
 320 function autoriser_dater_dist($faire, $type, $id, $qui, $opt) {
 321         if (!isset($opt['statut'])){
 322                 $table = table_objet($type);
 323                 $trouver_table = charger_fonction('trouver_table','base');
 324                 $desc = $trouver_table($table);
 325                 if (!$desc)
 326                         return false;
 327                 if (isset($desc['field']['statut'])){
 328                         $statut = sql_getfetsel("statut", $desc['table'], id_table_objet($type)."=".intval($id));
 329                 }
 330                 else
 331                         $statut = 'publie'; // pas de statut => publie
 332         }
 333         else
 334                 $statut = $opt['statut'];
 335
 336         if ($statut == 'publie'
 337          OR ($statut == 'prop' AND $type=='article' AND $GLOBALS['meta']["post_dates"] == "non"))
 338                 return autoriser('modifier', $type, $id);
 339         return false;
 340 }
 341
 342 /**
 343  * Autorisation d'instituer un contenu
 344  *
 345  * C'est à dire de changer son statut ou son parent.
 346  * Par défaut, il faut l'autorisation de modifier le contenu
 347  *
 348  * @param  string $faire Action demandée
 349  * @param  string $type  Type d'objet sur lequel appliquer l'action
 350  * @param  int    $id    Identifiant de l'objet
 351  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 352  * @param  array  $opt   Options de cette autorisation
 353  * @return bool          true s'il a le droit, false sinon
 354 **/
 355 function autoriser_instituer_dist($faire, $type, $id, $qui, $opt) {
 356         return autoriser('modifier',$type,$id,$qui,$opt);
 357 }
 358
 359 /**
 360  * Autorisation de publier dans une rubrique $id
 361  *
 362  * Il faut être administrateur ou administrateur restreint de la rubrique
 363  *
 364  * @param  string $faire Action demandée
 365  * @param  string $type  Type d'objet sur lequel appliquer l'action
 366  * @param  int    $id    Identifiant de l'objet
 367  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 368  * @param  array  $opt   Options de cette autorisation
 369  * @return bool          true s'il a le droit, false sinon
 370 **/
 371 function autoriser_rubrique_publierdans_dist($faire, $type, $id, $qui, $opt) {
 372         return
 373                 ($qui['statut'] == '0minirezo')
 374                 AND (
 375                         !$qui['restreint'] OR !$id
 376                         OR in_array($id, $qui['restreint'])
 377                 );
 378 }
 379
 380  /**
 381  * Autorisation de créer une rubrique
 382  *
 383  * Il faut être administrateur pour pouvoir publier à la racine
 384  *
 385  * @param  string $faire Action demandée
 386  * @param  string $type  Type d'objet sur lequel appliquer l'action
 387  * @param  int    $id    Identifiant de l'objet
 388  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 389  * @param  array  $opt   Options de cette autorisation
 390  * @return bool          true s'il a le droit, false sinon
 391 **/
 392 function autoriser_rubrique_creer_dist($faire, $type, $id, $qui, $opt) {
 393         return
 394                 ((!$id AND autoriser('defaut',null,null,$qui, $opt))
 395                 OR $id AND autoriser('creerrubriquedans','rubrique', $id, $qui, $opt)
 396                 );
 397 }
 398
 399 /**
 400  * Autorisation de créer une sous rubrique dans une rubrique $id
 401  *
 402  * Il faut être administrateur et pouvoir publier dans la rubrique
 403  *
 404  * @param  string $faire Action demandée
 405  * @param  string $type  Type d'objet sur lequel appliquer l'action
 406  * @param  int    $id    Identifiant de l'objet
 407  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 408  * @param  array  $opt   Options de cette autorisation
 409  * @return bool          true s'il a le droit, false sinon
 410 **/
 411 function autoriser_rubrique_creerrubriquedans_dist($faire, $type, $id, $qui, $opt) {
 412         return
 413                 ($id OR ($qui['statut'] == '0minirezo' AND !$qui['restreint']))
 414                 AND autoriser('voir','rubrique',$id)
 415                 AND autoriser('publierdans','rubrique',$id);
 416 }
 417
 418 /**
 419  * Autorisation de créer un article dans une rubrique $id
 420  *
 421  * Il faut pouvoir voir la rubrique
 422  *
 423  * @param  string $faire Action demandée
 424  * @param  string $type  Type d'objet sur lequel appliquer l'action
 425  * @param  int    $id    Identifiant de l'objet
 426  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 427  * @param  array  $opt   Options de cette autorisation
 428  * @return bool          true s'il a le droit, false sinon
 429 **/
 430 function autoriser_rubrique_creerarticledans_dist($faire, $type, $id, $qui, $opt) {
 431         return
 432                 $id
 433                 AND autoriser('voir','rubrique',$id)
 434                 AND autoriser('creer', 'article');
 435 }
 436
 437
 438 /**
 439  * Autorisation de modifier une rubrique $id
 440  *
 441  * Il faut pouvoir publier dans cette rubrique
 442  *
 443  * @param  string $faire Action demandée
 444  * @param  string $type  Type d'objet sur lequel appliquer l'action
 445  * @param  int    $id    Identifiant de l'objet
 446  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 447  * @param  array  $opt   Options de cette autorisation
 448  * @return bool          true s'il a le droit, false sinon
 449 **/
 450 function autoriser_rubrique_modifier_dist($faire, $type, $id, $qui, $opt) {
 451         return
 452                 autoriser('publierdans', 'rubrique', $id, $qui, $opt);
 453 }
 454
 455 /**
 456  * Autorisation de supprimer une rubrique $id
 457  *
 458  * Il faut quelle soit vide (pas d'enfant) et qu'on ait le droit de la modifier
 459  *
 460  * @param  string $faire Action demandée
 461  * @param  string $type  Type d'objet sur lequel appliquer l'action
 462  * @param  int    $id    Identifiant de l'objet
 463  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 464  * @param  array  $opt   Options de cette autorisation
 465  * @return bool          true s'il a le droit, false sinon
 466 **/
 467 function autoriser_rubrique_supprimer_dist($faire, $type, $id, $qui, $opt) {
 468         if (!$id = intval($id))
 469                 return false;
 470
 471         if (sql_countsel('spip_rubriques', "id_parent=".intval($id)))
 472                 return false;
 473
 474         if (sql_countsel('spip_articles', "id_rubrique=".intval($id)." AND (statut<>'poubelle')"))
 475                 return false;
 476
 477         $compte = pipeline('objet_compte_enfants',array('args'=>array('objet'=>'rubrique','id_objet'=>$id),'data'=>array()));
 478         foreach($compte as $objet => $n)
 479                 if ($n)
 480                         return false;
 481
 482         return autoriser('modifier','rubrique',$id);
 483 }
 484
 485
 486 /**
 487  * Autorisation de modifier un article $id
 488  *
 489  * Il faut pouvoir publier dans le parent
 490  * ou, si on change le statut en proposé ou préparation être auteur de l'article
 491  *
 492  * @param  string $faire Action demandée
 493  * @param  string $type  Type d'objet sur lequel appliquer l'action
 494  * @param  int    $id    Identifiant de l'objet
 495  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 496  * @param  array  $opt   Options de cette autorisation
 497  * @return bool          true s'il a le droit, false sinon
 498 **/
 499 function autoriser_article_modifier_dist($faire, $type, $id, $qui, $opt) {
 500         $r = sql_fetsel("id_rubrique,statut", "spip_articles", "id_article=".sql_quote($id));
 501
 502         if (!function_exists('auteurs_article'))
 503                 include_spip('inc/auth'); // pour auteurs_article si espace public
 504
 505         return
 506                 $r
 507                 AND
 508                 (
 509                         autoriser('publierdans', 'rubrique', $r['id_rubrique'], $qui, $opt)
 510                         OR (
 511                                 (!isset($opt['statut']) OR $opt['statut']!=='publie')
 512                                 AND in_array($qui['statut'], array('0minirezo', '1comite'))
 513                                 AND in_array($r['statut'], array('prop','prepa', 'poubelle'))
 514                                 AND auteurs_article($id, "id_auteur=".$qui['id_auteur'])
 515                         )
 516                 );
 517 }
 518
 519  /**
 520  * Autorisation de créer un article
 521  *
 522  * Il faut qu'une rubrique existe et être au moins rédacteur
 523  *
 524  * @param  string $faire Action demandée
 525  * @param  string $type  Type d'objet sur lequel appliquer l'action
 526  * @param  int    $id    Identifiant de l'objet
 527  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 528  * @param  array  $opt   Options de cette autorisation
 529  * @return bool          true s'il a le droit, false sinon
 530 **/
 531 function autoriser_article_creer_dist($faire, $type, $id, $qui, $opt) {
 532         return (sql_countsel('spip_rubriques')>0 AND in_array($qui['statut'], array('0minirezo', '1comite')));
 533 }
 534
 535 /**
 536  * Autorisation de voir un article
 537  *
 538  * Il faut être admin ou auteur de l'article, sinon il faut que l'article
 539  * soit publié ou proposé.
 540  *
 541  * Peut-être appelée sans $id, mais avec un $opt['statut'] pour tester
 542  * la liste des status autorisés en fonction de $qui['statut']
 543  *
 544  * @param  string $faire Action demandée
 545  * @param  string $type  Type d'objet sur lequel appliquer l'action
 546  * @param  int    $id    Identifiant de l'objet
 547  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 548  * @param  array  $opt   Options de cette autorisation
 549  * @return bool          true s'il a le droit, false sinon
 550  */
 551 function autoriser_article_voir_dist($faire, $type, $id, $qui, $opt){
 552         if ($qui['statut'] == '0minirezo') return true;
 553         // cas des articles : depend du statut de l'article et de l'auteur
 554         if (isset($opt['statut']))
 555                 $statut = $opt['statut'];
 556         else {
 557                 if (!$id) return false;
 558                 $statut = sql_getfetsel("statut", "spip_articles", "id_article=".intval($id));
 559         }
 560
 561         return
 562                 // si on est pas auteur de l'article,
 563                 // seuls les propose et publies sont visibles
 564                 in_array($statut, array('prop', 'publie'))
 565                 // sinon si on est auteur, on a le droit de le voir, evidemment !
 566                 OR
 567                 ($id AND $qui['id_auteur']
 568                      AND (function_exists('auteurs_article') OR include_spip('inc/auth'))
 569                      AND auteurs_article($id, "id_auteur=".$qui['id_auteur']));
 570 }
 571
 572
 573 /**
 574  * Autorisation de voir un objet
 575  *
 576  * Tout est visible par défaut, sauf les auteurs où il faut au moins être rédacteur.
 577  *
 578  * @param  string $faire Action demandée
 579  * @param  string $type  Type d'objet sur lequel appliquer l'action
 580  * @param  int    $id    Identifiant de l'objet
 581  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 582  * @param  array  $opt   Options de cette autorisation
 583  * @return bool          true s'il a le droit, false sinon
 584 **/
 585 function autoriser_voir_dist($faire, $type, $id, $qui, $opt) {
 586         # securite, mais on aurait pas du arriver ici !
 587         if (function_exists($f='autoriser_'.$type.'_voir') OR function_exists($f='autoriser_'.$type.'_voir_dist')){
 588                 return $f($faire, $type, $id, $qui, $opt);
 589         }
 590
 591         if ($qui['statut'] == '0minirezo') return true;
 592         // admins et redacteurs peuvent voir un auteur
 593         if ($type == 'auteur')
 594                 return in_array($qui['statut'], array('0minirezo', '1comite'));
 595         // sinon par defaut tout est visible
 596         // sauf cas particuliers traites separemment (ie article)
 597         return true;
 598 }
 599
 600
 601 /**
 602  * Autorisation de webmestre
 603  *
 604  * Est-on webmestre ? Signifie qu'on n'a même pas besoin de passer par ftp
 605  * pour modifier les fichiers, cf. notamment inc/admin
 606  *
 607  * Soit la liste des webmestres est définie via une constante _ID_WEBMESTRES,
 608  * soit on regarde l'état "webmestre" de l'auteur
 609  *
 610  * @param  string $faire Action demandée
 611  * @param  string $type  Type d'objet sur lequel appliquer l'action
 612  * @param  int    $id    Identifiant de l'objet
 613  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 614  * @param  array  $opt   Options de cette autorisation
 615  * @return bool          true s'il a le droit, false sinon
 616 **/
 617 function autoriser_webmestre_dist($faire, $type, $id, $qui, $opt) {
 618         return
 619                 (defined('_ID_WEBMESTRES')?
 620                         in_array($qui['id_auteur'], explode(':', _ID_WEBMESTRES))
 621                         :$qui['webmestre']=='oui')
 622                 AND $qui['statut'] == '0minirezo'
 623                 AND !$qui['restreint']
 624                 ;
 625 }
 626
 627 /**
 628  * Autorisation Configurer le site
 629  *
 630  * Il faut être administrateur complet
 631  *
 632  * @param  string $faire Action demandée
 633  * @param  string $type  Type d'objet sur lequel appliquer l'action
 634  * @param  int    $id    Identifiant de l'objet
 635  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 636  * @param  array  $opt   Options de cette autorisation
 637  * @return bool          true s'il a le droit, false sinon
 638 **/
 639 function autoriser_configurer_dist($faire, $type, $id, $qui, $opt) {
 640         return
 641                 $qui['statut'] == '0minirezo'
 642                 AND !$qui['restreint']
 643                 ;
 644 }
 645
 646 /**
 647  * Autorisation de sauvegarder la base de données
 648  *
 649  * Il faut être administrateur (y compris restreint)
 650  *
 651  * @param  string $faire Action demandée
 652  * @param  string $type  Type d'objet sur lequel appliquer l'action
 653  * @param  int    $id    Identifiant de l'objet
 654  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 655  * @param  array  $opt   Options de cette autorisation
 656  * @return bool          true s'il a le droit, false sinon
 657 **/
 658 function autoriser_sauvegarder_dist($faire, $type, $id, $qui, $opt) {
 659         return
 660                 $qui['statut'] == '0minirezo'
 661                 ;
 662 }
 663
 664 /**
 665  * Autorisation d'effacer la base de données
 666  *
 667  * Il faut être webmestre
 668  *
 669  * @param  string $faire Action demandée
 670  * @param  string $type  Type d'objet sur lequel appliquer l'action
 671  * @param  int    $id    Identifiant de l'objet
 672  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 673  * @param  array  $opt   Options de cette autorisation
 674  * @return bool          true s'il a le droit, false sinon
 675 **/
 676 function autoriser_detruire_dist($faire, $type, $id, $qui, $opt) {
 677         return
 678                 autoriser('webmestre', null, null, $qui, $opt);
 679 }
 680
 681 /**
 682  * Autorisation de prévisialiser un auteur
 683  *
 684  * Il faut être administrateur ou que l'auteur à prévisualiser
 685  * ait au moins publié un article
 686  *
 687  * @param  string $faire Action demandée
 688  * @param  string $type  Type d'objet sur lequel appliquer l'action
 689  * @param  int    $id    Identifiant de l'objet
 690  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 691  * @param  array  $opt   Options de cette autorisation
 692  * @return bool          true s'il a le droit, false sinon
 693 **/
 694 function autoriser_auteur_previsualiser_dist($faire, $type, $id, $qui, $opt) {
 695         // les admins peuvent "previsualiser" une page auteur
 696         if ($qui['statut'] == '0minirezo'
 697                 AND !$qui['restreint']) return true;
 698         // "Voir en ligne" si l'auteur a un article publie
 699         $n = sql_fetsel('A.id_article', 'spip_auteurs_liens AS L LEFT JOIN spip_articles AS A ON (L.objet=\'article\' AND L.id_objet=A.id_article)', "A.statut='publie' AND L.id_auteur=".sql_quote($id));
 700         return $n ? true : false;
 701 }
 702
 703 /**
 704  * Autorisation de créer un auteur
 705  *
 706  * Il faut être administrateur (restreint compris).
 707  *
 708  * @note
 709  *     Seuls les administrateurs complets ont accès à tous les
 710  *     champs du formulaire d'édition d'un auteur. À la création
 711  *     d'un auteur, son statut est 'poubelle'. C'est l'autorisation
 712  *     de modifier qui permet de changer les informations sensibles
 713  *     (statut, login, pass, etc.) à l'institution.
 714  *
 715  * @see auteur_inserer()
 716  * @see auteur_instituer()
 717  * @see autoriser_auteur_modifier_dist()
 718  *
 719  * @param  string $faire Action demandée
 720  * @param  string $type  Type d'objet sur lequel appliquer l'action
 721  * @param  int    $id    Identifiant de l'objet
 722  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 723  * @param  array  $opt   Options de cette autorisation
 724  * @return bool          true s'il a le droit, false sinon
 725 **/
 726 function autoriser_auteur_creer_dist($faire, $type, $id, $qui, $opt) {
 727         return ($qui['statut'] == '0minirezo');
 728 }
 729
 730
 731 /**
 732  * Autorisation de modifier un auteur
 733  *
 734  * Attention tout depend de ce qu'on veut modifier. Il faut être au moins
 735  * rédacteur, mais on ne peut pas promouvoir (changer le statut) un auteur
 736  * avec des droits supérieurs au sien.
 737  *
 738  * @param  string $faire Action demandée
 739  * @param  string $type  Type d'objet sur lequel appliquer l'action
 740  * @param  int    $id    Identifiant de l'objet
 741  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 742  * @param  array  $opt   Options de cette autorisation
 743  * @return bool          true s'il a le droit, false sinon
 744 **/
 745 function autoriser_auteur_modifier_dist($faire, $type, $id, $qui, $opt) {
 746
 747         // Ni admin ni redacteur => non
 748         if (!in_array($qui['statut'], array('0minirezo', '1comite')))
 749                 return false;
 750
 751         // Un redacteur peut modifier ses propres donnees mais ni son login/email
 752         // ni son statut (qui sont le cas echeant passes comme option)
 753         if ($qui['statut'] == '1comite') {
 754                 if ($opt['webmestre'])
 755                         return false;
 756                 elseif ($opt['statut'] OR $opt['restreintes'] OR $opt['email'])
 757                         return false;
 758                 elseif ($id == $qui['id_auteur'])
 759                         return true;
 760                 else
 761                         return false;
 762         }
 763
 764         // Un admin restreint peut modifier/creer un auteur non-admin mais il
 765         // n'a le droit ni de le promouvoir admin, ni de changer les rubriques
 766         if ($qui['restreint']) {
 767                 if ($opt['webmestre'])
 768                         return false;
 769                 elseif ($opt['statut'] == '0minirezo' OR $opt['restreintes'])
 770                         return false;
 771                 else {
 772                         if ($id == $qui['id_auteur']) {
 773                                 if ($opt['statut'])
 774                                         return false;
 775                                 else
 776                                         return true;
 777                         }
 778                         else if ($id_auteur = intval($id)) {
 779                                 $t = sql_fetsel("statut", "spip_auteurs", "id_auteur=$id_auteur");
 780                                 if ($t AND $t['statut'] != '0minirezo')
 781                                         return true;
 782                                 else
 783                                         return false;
 784                         }
 785                         // id = 0 => creation
 786                         else
 787                                 return true;
 788                 }
 789         }
 790
 791         // Un admin complet fait ce qu'elle veut
 792         // sauf se degrader
 793         if ($id == $qui['id_auteur'] && $opt['statut'])
 794                 return false;
 795         // et toucher au statut webmestre si il ne l'est pas lui meme
 796         // ou si les webmestres sont fixes par constante (securite)
 797         elseif (isset($opt['webmestre']) AND $opt['webmestre'] AND (defined('_ID_WEBMESTRES') OR !autoriser('webmestre')))
 798                 return false;
 799         // et modifier un webmestre si il ne l'est pas lui meme
 800         elseif (intval($id) AND autoriser('webmestre','',0,$id) AND !autoriser('webmestre'))
 801                 return false;
 802         else
 803                 return true;
 804 }
 805
 806
 807 /**
 808  * Autorisation d'associer un auteur sur un objet
 809  *
 810  * Il faut pouvoir modifier l'objet en question
 811  *
 812  * @param  string $faire Action demandée
 813  * @param  string $type  Type d'objet sur lequel appliquer l'action
 814  * @param  int    $id    Identifiant de l'objet
 815  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 816  * @param  array  $opt   Options de cette autorisation
 817  * @return bool          true s'il a le droit, false sinon
 818 **/
 819 function autoriser_associerauteurs_dist($faire, $type, $id, $qui, $opt){
 820         return autoriser('modifier', $type, $id, $qui, $opt);
 821 }
 822
 823
 824 /**
 825  * Autorisation d'upload FTP
 826  *
 827  * Il faut être administrateur.
 828  *
 829  * @param  string $faire Action demandée
 830  * @param  string $type  Type d'objet sur lequel appliquer l'action
 831  * @param  int    $id    Identifiant de l'objet
 832  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 833  * @param  array  $opt   Options de cette autorisation
 834  * @return bool          true s'il a le droit, false sinon
 835 **/
 836 function autoriser_chargerftp_dist($faire, $type, $id, $qui, $opt) {
 837         return $qui['statut'] == '0minirezo';
 838 }
 839
 840 /**
 841  * Autorisation d'activer le mode debug
 842  *
 843  * Il faut être administrateur.
 844  *
 845  * @param  string $faire Action demandée
 846  * @param  string $type  Type d'objet sur lequel appliquer l'action
 847  * @param  int    $id    Identifiant de l'objet
 848  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 849  * @param  array  $opt   Options de cette autorisation
 850  * @return bool          true s'il a le droit, false sinon
 851 **/
 852 function autoriser_debug_dist($faire, $type, $id, $qui, $opt) {
 853         return $qui['statut'] == '0minirezo';
 854 }
 855
 856 /**
 857  * Liste les rubriques d'un auteur
 858  *
 859  * Renvoie la liste des rubriques liées à cet auteur, independamment de son
 860  * statut (pour les admins restreints, il faut donc aussi vérifier statut)
 861  *
 862  * Mémorise le resultat dans un tableau statique indéxé par les id_auteur.
 863  * On peut reinitialiser un élément en passant un 2e argument non vide
 864  *
 865  * @param int  $id_auteur Identifiant de l'auteur
 866  * @param bool $raz       Recalculer le résultat connu pour cet auteur
 867  * @return array          Liste des rubriques
 868 **/
 869 function liste_rubriques_auteur($id_auteur, $raz=false) {
 870         static $restreint = array();
 871
 872         if (!$id_auteur = intval($id_auteur)) return array();
 873         if ($raz) unset($restreint[$id_auteur]);
 874         elseif (isset($restreint[$id_auteur])) return $restreint[$id_auteur];
 875
 876         $rubriques = array();
 877         if (
 878                 (!isset($GLOBALS['meta']['version_installee']) OR $GLOBALS['meta']['version_installee']>16428)
 879           AND $r = sql_allfetsel('id_objet', 'spip_auteurs_liens', "id_auteur=".intval($id_auteur)." AND objet='rubrique' AND id_objet!=0")
 880           AND count($r)) {
 881                 $r = array_map('reset',$r);
 882
 883                 // recuperer toute la branche, au format chaine enumeration
 884                 include_spip('inc/rubriques');
 885                 $r = calcul_branche_in($r);
 886                 $r = explode(',',$r);
 887
 888                 // passer les rubriques en index, elimine les doublons
 889                 $r = array_flip($r);
 890                 // recuperer les index seuls
 891                 $r = array_keys($r);
 892                 // combiner pour avoir un tableau id_rubrique=>id_rubrique
 893                 // est-ce vraiment utile ? (on preserve la forme donnee par le code precedent)
 894                 $rubriques = array_combine($r,$r);
 895         }
 896
 897         // Affecter l'auteur session le cas echeant
 898         if (isset($GLOBALS['visiteur_session']['id_auteur'])
 899           AND $GLOBALS['visiteur_session']['id_auteur'] == $id_auteur)
 900                 $GLOBALS['visiteur_session']['restreint'] = $rubriques;
 901
 902
 903         return $restreint[$id_auteur] = $rubriques;
 904 }
 905
 906 /**
 907  * Autorisation de modifier l'URL d'un objet
 908  *
 909  * Il faut pouvoir modifier l'objet.
 910  *
 911  * @param  string $faire Action demandée
 912  * @param  string $type  Type d'objet sur lequel appliquer l'action
 913  * @param  int    $id    Identifiant de l'objet
 914  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 915  * @param  array  $opt   Options de cette autorisation
 916  * @return bool          true s'il a le droit, false sinon
 917 **/
 918 function autoriser_modifierurl_dist($faire, $type, $id, $qui, $opt) {
 919         return autoriser('modifier', $type, $id, $qui, $opt);
 920 }
 921
 922 /**
 923  * Autorisation de prévisualiser une rubrique
 924  *
 925  * Il faut pouvoir prévisualiser.
 926  *
 927  * @param  string $faire Action demandée
 928  * @param  string $type  Type d'objet sur lequel appliquer l'action
 929  * @param  int    $id    Identifiant de l'objet
 930  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 931  * @param  array  $opt   Options de cette autorisation
 932  * @return bool          true s'il a le droit, false sinon
 933 **/
 934 function autoriser_rubrique_previsualiser_dist($faire,$type,$id,$qui,$opt){
 935         return autoriser('previsualiser');
 936 }
 937
 938 /**
 939  * Autorisation d'iconifier une rubrique (mettre un logo)
 940  *
 941  * Il faut pouvoir publier dans la rubrique.
 942  *
 943  * @param  string $faire Action demandée
 944  * @param  string $type  Type d'objet sur lequel appliquer l'action
 945  * @param  int    $id    Identifiant de l'objet
 946  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 947  * @param  array  $opt   Options de cette autorisation
 948  * @return bool          true s'il a le droit, false sinon
 949 **/
 950 function autoriser_rubrique_iconifier_dist($faire,$type,$id,$qui,$opt){
 951         return autoriser('publierdans', 'rubrique', $id, $qui, $opt);
 952 }
 953
 954 /**
 955  * Autorisation d'iconifier un auteur (mettre un logo)
 956  *
 957  * Il faut un administrateur ou que l'auteur soit celui qui demande l'autorisation
 958  *
 959  * @param  string $faire Action demandée
 960  * @param  string $type  Type d'objet sur lequel appliquer l'action
 961  * @param  int    $id    Identifiant de l'objet
 962  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 963  * @param  array  $opt   Options de cette autorisation
 964  * @return bool          true s'il a le droit, false sinon
 965 **/
 966 function autoriser_auteur_iconifier_dist($faire,$type,$id,$qui,$opt){
 967  return (($id == $qui['id_auteur']) OR
 968                 (($qui['statut'] == '0minirezo') AND !$qui['restreint']));
 969 }
 970
 971 /**
 972  * Autorisation d'iconifier un objet (mettre un logo)
 973  *
 974  * Il faut pouvoir modifier l'objet
 975  *
 976  * @param  string $faire Action demandée
 977  * @param  string $type  Type d'objet sur lequel appliquer l'action
 978  * @param  int    $id    Identifiant de l'objet
 979  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 980  * @param  array  $opt   Options de cette autorisation
 981  * @return bool          true s'il a le droit, false sinon
 982 **/
 983 function autoriser_iconifier_dist($faire,$type,$id,$qui,$opt){
 984         // par defaut, on a le droit d'iconifier si on a le droit de modifier
 985         return autoriser('modifier', $type, $id, $qui, $opt);
 986 }
 987
 988
 989 /**
 990  * Autorisation OK
 991  *
 992  * Autorise toujours !
 993  * Fonction sans surprise pour permettre les tests.
 994  *
 995  * @param  string $faire Action demandée
 996  * @param  string $type  Type d'objet sur lequel appliquer l'action
 997  * @param  int    $id    Identifiant de l'objet
 998  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 999  * @param  array  $opt   Options de cette autorisation
1000  * @return bool          true
1001 **/
1002 function autoriser_ok_dist($faire, $type, $id, $qui, $opt) { return true; }
1003
1004 /**
1005  * Autorisation NIET
1006  *
1007  * Refuse toujours !
1008  * Fonction sans surprise pour permettre les tests.
1009  *
1010  * @param  string $faire Action demandée
1011  * @param  string $type  Type d'objet sur lequel appliquer l'action
1012  * @param  int    $id    Identifiant de l'objet
1013  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1014  * @param  array  $opt   Options de cette autorisation
1015  * @return bool          false
1016 **/
1017 function autoriser_niet_dist($faire, $type, $id, $qui, $opt) { return false; }
1018
1019 /**
1020  * Autorisation de réparer la base de données
1021  *
1022  * Il faut pouvoir la détruire (et ne pas être en cours de réinstallation)
1023  *
1024  * @param  string $faire Action demandée
1025  * @param  string $type  Type d'objet sur lequel appliquer l'action
1026  * @param  int    $id    Identifiant de l'objet
1027  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1028  * @param  array  $opt   Options de cette autorisation
1029  * @return bool          false
1030 **/
1031 function autoriser_base_reparer_dist($faire, $type, $id, $qui, $opt) {
1032         if (!autoriser('detruire') OR _request('reinstall'))
1033                 return false;
1034
1035         return true;
1036 }
1037
1038 /**
1039  * Autorisation de voir l'onglet infosperso
1040  *
1041  * Toujours OK
1042  *
1043  * @param  string $faire Action demandée
1044  * @param  string $type  Type d'objet sur lequel appliquer l'action
1045  * @param  int    $id    Identifiant de l'objet
1046  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1047  * @param  array  $opt   Options de cette autorisation
1048  * @return bool          true s'il a le droit, false sinon
1049 **/
1050 function autoriser_infosperso_dist($faire,$type,$id,$qui,$opt) {
1051         return true;
1052 }
1053
1054 /**
1055  * Autorisation de voir le formulaire configurer_langage
1056  *
1057  * Toujours OK
1058  *
1059  * @param  string $faire Action demandée
1060  * @param  string $type  Type d'objet sur lequel appliquer l'action
1061  * @param  int    $id    Identifiant de l'objet
1062  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1063  * @param  array  $opt   Options de cette autorisation
1064  * @return bool          true s'il a le droit, false sinon
1065 **/
1066 function autoriser_langage_configurer_dist($faire,$type,$id,$qui,$opt) {
1067         return true;
1068 }
1069
1070 /**
1071  * Autorisation de voir l'onglet configurerlangage
1072  *
1073  * Calquée sur l'autorisation de voir le formulaire configurer_langage
1074  *
1075  * @param  string $faire Action demandée
1076  * @param  string $type  Type d'objet sur lequel appliquer l'action
1077  * @param  int    $id    Identifiant de l'objet
1078  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1079  * @param  array  $opt   Options de cette autorisation
1080  * @return bool          true s'il a le droit, false sinon
1081 **/
1082 function autoriser_configurerlangage_dist($faire,$type,$id,$qui,$opt) {
1083         return autoriser('configurer', '_langage', $id, $qui, $opt);
1084 }
1085
1086 /**
1087  * Autorisation de voir le formulaire configurer_preferences
1088  *
1089  * Toujours OK
1090  *
1091  * @param  string $faire Action demandée
1092  * @param  string $type  Type d'objet sur lequel appliquer l'action
1093  * @param  int    $id    Identifiant de l'objet
1094  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1095  * @param  array  $opt   Options de cette autorisation
1096  * @return bool          true s'il a le droit, false sinon
1097 **/
1098 function autoriser_preferences_configurer_dist($faire,$type,$id,$qui,$opt) {
1099         return true;
1100 }
1101
1102 /**
1103  * Autorisation de voir l'onglet configurerpreferences
1104  *
1105  * Calquée sur l'autorisation de voir le formulaire configurer_preferences
1106  *
1107  * @param  string $faire Action demandée
1108  * @param  string $type  Type d'objet sur lequel appliquer l'action
1109  * @param  int    $id    Identifiant de l'objet
1110  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1111  * @param  array  $opt   Options de cette autorisation
1112  * @return bool          true s'il a le droit, false sinon
1113 **/
1114 function autoriser_configurerpreferences_dist($faire,$type,$id,$qui,$opt) {
1115         return autoriser('configurer', '_preferences', $id, $qui, $opt);
1116 }
1117
1118 /**
1119  * Autorisation de voir le menu auteurs
1120  *
1121  * Toujours OK
1122  *
1123  * @param  string $faire Action demandée
1124  * @param  string $type  Type d'objet sur lequel appliquer l'action
1125  * @param  int    $id    Identifiant de l'objet
1126  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1127  * @param  array  $opt   Options de cette autorisation
1128  * @return bool          true s'il a le droit, false sinon
1129 **/
1130 function autoriser_auteurs_menu_dist($faire, $type, $id, $qui, $opt){return true;}
1131
1132 /**
1133  * Autorisation de voir le menu articles
1134  *
1135  * Toujours OK
1136  *
1137  * @param  string $faire Action demandée
1138  * @param  string $type  Type d'objet sur lequel appliquer l'action
1139  * @param  int    $id    Identifiant de l'objet
1140  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1141  * @param  array  $opt   Options de cette autorisation
1142  * @return bool          true s'il a le droit, false sinon
1143 **/
1144 function autoriser_articles_menu_dist($faire, $type, $id, $qui, $opt){return true;}
1145
1146 /**
1147  * Autorisation de voir le menu rubriques
1148  *
1149  * Toujours OK
1150  *
1151  * @param  string $faire Action demandée
1152  * @param  string $type  Type d'objet sur lequel appliquer l'action
1153  * @param  int    $id    Identifiant de l'objet
1154  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1155  * @param  array  $opt   Options de cette autorisation
1156  * @return bool          true s'il a le droit, false sinon
1157 **/
1158 function autoriser_rubriques_menu_dist($faire, $type, $id, $qui, $opt){return true;}
1159
1160 /**
1161  * Autorisation de voir le menu articlecreer
1162  *
1163  * Il faut au moins une rubrique présente.
1164  *
1165  * @param  string $faire Action demandée
1166  * @param  string $type  Type d'objet sur lequel appliquer l'action
1167  * @param  int    $id    Identifiant de l'objet
1168  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1169  * @param  array  $opt   Options de cette autorisation
1170  * @return bool          true s'il a le droit, false sinon
1171 **/
1172 function autoriser_articlecreer_menu_dist($faire, $type, $id, $qui, $opt){
1173         return verifier_table_non_vide();
1174 }
1175
1176 /**
1177  * Autorisation de voir le menu auteurcreer
1178  *
1179  * Il faut pouvoir créer un auteur !
1180  *
1181  * @see autoriser_auteur_creer_dist()
1182  *
1183  * @param  string $faire Action demandée
1184  * @param  string $type  Type d'objet sur lequel appliquer l'action
1185  * @param  int    $id    Identifiant de l'objet
1186  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1187  * @param  array  $opt   Options de cette autorisation
1188  * @return bool          true s'il a le droit, false sinon
1189 **/
1190 function autoriser_auteurcreer_menu_dist($faire, $type, $id, $qui, $opt) {
1191         return autoriser('creer', 'auteur', $id, $qui, $opt);
1192 }
1193
1194 /**
1195  * Autorisation de voir le menu suiviedito
1196  *
1197  * Il faut être administrateur (y compris restreint).
1198  *
1199  * @param  string $faire Action demandée
1200  * @param  string $type  Type d'objet sur lequel appliquer l'action
1201  * @param  int    $id    Identifiant de l'objet
1202  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1203  * @param  array  $opt   Options de cette autorisation
1204  * @return bool          true s'il a le droit, false sinon
1205 **/
1206 function autoriser_suiviedito_menu_dist($faire, $type, $id, $qui, $opt){
1207         return $qui['statut']=='0minirezo';
1208 }
1209
1210 /**
1211  * Autorisation de voir le menu synchro
1212  *
1213  * Il faut être administrateur (y compris restreint).
1214  *
1215  * @param  string $faire Action demandée
1216  * @param  string $type  Type d'objet sur lequel appliquer l'action
1217  * @param  int    $id    Identifiant de l'objet
1218  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1219  * @param  array  $opt   Options de cette autorisation
1220  * @return bool          true s'il a le droit, false sinon
1221 **/
1222 function autoriser_synchro_menu_dist($faire, $type, $id, $qui, $opt){
1223         return $qui['statut']=='0minirezo';
1224 }
1225
1226 /**
1227  * Autorisation de purger la queue de travaux
1228  *
1229  * Il faut être webmestre.
1230  *
1231  * @param  string $faire Action demandée
1232  * @param  string $type  Type d'objet sur lequel appliquer l'action
1233  * @param  int    $id    Identifiant de l'objet
1234  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1235  * @param  array  $opt   Options de cette autorisation
1236  * @return bool          true s'il a le droit, false sinon
1237 **/
1238 function autoriser_queue_purger_dist($faire, $type, $id, $qui, $opt){
1239         return autoriser('webmestre');
1240 }
1241
1242
1243 /**
1244  * Autorisation l'échafaudage de squelettes en Z
1245  *
1246  * Il faut être dans l'espace privé (et authentifié),
1247  * sinon il faut être webmestre (pas de fuite d'informations publiées)
1248  *
1249  * @param  string $faire Action demandée
1250  * @param  string $type  Type d'objet sur lequel appliquer l'action
1251  * @param  int    $id    Identifiant de l'objet
1252  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1253  * @param  array  $opt   Options de cette autorisation
1254  * @return bool          true s'il a le droit, false sinon
1255 **/
1256 function autoriser_echafauder_dist($faire, $type, $id, $qui, $opt){
1257         if (test_espace_prive())
1258                 return intval($qui['id_auteur'])?true:false;
1259         else
1260                 return autoriser('webmestre','',$id,$qui,$opt);
1261 }
1262
1263
1264 /**
1265  * Lister les auteurs d'un article
1266  *
1267  * Fonction générique utilisée par plusieurs autorisations
1268  *
1269  * @param int $id_article Identifiant de l'article
1270  * @param string $cond    Condition en plus dans le where de la requête
1271  * @return array|bool
1272  *     - array : liste des id_auteur trouvés
1273  *     - false : serveur SQL indisponible
1274  */
1275 function auteurs_article($id_article, $cond='')
1276 {
1277         return sql_allfetsel("id_auteur", "spip_auteurs_liens", "objet='article' AND id_objet=$id_article". ($cond ? " AND $cond" : ''));
1278 }
1279
1280
1281 /**
1282  * Tester si on est admin restreint sur une rubrique donnée
1283  *
1284  * Fonction générique utilisee dans des autorisations ou assimilée
1285  *
1286  * @param int $id_rubrique  Identifiant de la rubrique
1287  * @return bool             true si administrateur de cette rubrique, false sinon.
1288  */
1289 function acces_restreint_rubrique($id_rubrique) {
1290         global $connect_id_rubrique;
1291
1292         return (isset($connect_id_rubrique[$id_rubrique]));
1293 }
1294
1295
1296 /**
1297  * Verifier qu'il existe au moins un parent
1298  *
1299  * Fonction utilisee dans des autorisations des boutons / menus du prive des objets enfants (articles, breves, sites)
1300  *
1301  * @param string $table         la table a verifier
1302  * @return bool             true si un parent existe
1303  */
1304 function verifier_table_non_vide($table='spip_rubriques') {
1305         static $done = array();
1306         if (!isset($done[$table]))
1307                  $done[$table] = sql_countsel($table)>0;
1308         return $done[$table];
1309 }
1310
1311 /**
1312  * Une autorisation determiner la possibilite de s'inscire pour un statut et un id_rubrique,
1313  * a l'aide de la liste globale des statuts (tableau mode => nom du mode)
1314  * Utile pour le formulaire d'inscription.
1315  * Par defaut, seuls 6forum et 1comite possibles, les autres sont en false
1316  * pour un nouveau mode il suffit de definir l'autorisation specifique
1317  *
1318  * @param $faire
1319  * @param $quoi
1320  *   statut auteur demande
1321  * @param $id
1322  *   id_rubrique eventuel (pas utilise ici, utilise dans des usages persos)
1323  * @param $qui
1324  * @param $opt
1325  * @return bool
1326  */
1327 function autoriser_inscrireauteur_dist($faire, $quoi, $id, $qui, $opt){
1328
1329         $s = array_search($quoi, $GLOBALS['liste_des_statuts']);
1330         switch ($s) {
1331
1332                 case 'info_redacteurs' :
1333                   return ($GLOBALS['meta']['accepter_inscriptions'] == 'oui');
1334
1335                 case 'info_visiteurs' :
1336                   return ($GLOBALS['meta']['accepter_visiteurs'] == 'oui' OR $GLOBALS['meta']['forums_publics'] == 'abo');
1337
1338         }
1339
1340         return false;
1341 }
1342 ?>