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                                 if (!in_array($opt[$champ],$previsu)) // le statut n'est pas dans ceux definis par la previsu => NIET
 285                                         return false;
 286                         }
 287                 }
 288         return true;
 289 }
 290
 291 /**
 292  * Autorisation de changer de langue un contenu
 293  *
 294  * @param  string $faire Action demandée
 295  * @param  string $type  Type d'objet sur lequel appliquer l'action
 296  * @param  int    $id    Identifiant de l'objet
 297  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 298  * @param  array  $opt   Options de cette autorisation
 299  * @return bool          true s'il a le droit, false sinon
 300 **/
 301 function autoriser_changerlangue_dist($faire, $type, $id, $qui, $opt) {
 302         return autoriser('modifier',$type,$id,$qui,$opt);
 303 }
 304
 305 /**
 306  * Autorisation de changer la date d'un contenu
 307  *
 308  * @param  string $faire Action demandée
 309  * @param  string $type  Type d'objet sur lequel appliquer l'action
 310  * @param  int    $id    Identifiant de l'objet
 311  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 312  * @param  array  $opt   Options de cette autorisation
 313  * @return bool          true s'il a le droit, false sinon
 314 **/
 315 function autoriser_dater_dist($faire, $type, $id, $qui, $opt) {
 316         if (!isset($opt['statut'])){
 317                 $table = table_objet($type);
 318                 $trouver_table = charger_fonction('trouver_table','base');
 319                 $desc = $trouver_table($table);
 320                 if (!$desc)
 321                         return false;
 322                 if (isset($desc['field']['statut'])){
 323                         $statut = sql_getfetsel("statut", $desc['table'], id_table_objet($type)."=".intval($id));
 324                 }
 325                 else
 326                         $statut = 'publie'; // pas de statut => publie
 327         }
 328         else
 329                 $statut = $opt['statut'];
 330
 331         if ($statut == 'publie'
 332          OR ($statut == 'prop' AND $type=='article' AND $GLOBALS['meta']["post_dates"] == "non"))
 333                 return autoriser('modifier', $type, $id);
 334         return false;
 335 }
 336
 337 /**
 338  * Autorisation d'instituer un contenu
 339  *
 340  * C'est à dire de changer son statut ou son parent.
 341  * Par défaut, il faut l'autorisation de modifier le contenu
 342  *
 343  * @param  string $faire Action demandée
 344  * @param  string $type  Type d'objet sur lequel appliquer l'action
 345  * @param  int    $id    Identifiant de l'objet
 346  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 347  * @param  array  $opt   Options de cette autorisation
 348  * @return bool          true s'il a le droit, false sinon
 349 **/
 350 function autoriser_instituer_dist($faire, $type, $id, $qui, $opt) {
 351         return autoriser('modifier',$type,$id,$qui,$opt);
 352 }
 353
 354 /**
 355  * Autorisation de publier dans une rubrique $id
 356  *
 357  * Il faut être administrateur ou administrateur restreint de la rubrique
 358  *
 359  * @param  string $faire Action demandée
 360  * @param  string $type  Type d'objet sur lequel appliquer l'action
 361  * @param  int    $id    Identifiant de l'objet
 362  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 363  * @param  array  $opt   Options de cette autorisation
 364  * @return bool          true s'il a le droit, false sinon
 365 **/
 366 function autoriser_rubrique_publierdans_dist($faire, $type, $id, $qui, $opt) {
 367         return
 368                 ($qui['statut'] == '0minirezo')
 369                 AND (
 370                         !$qui['restreint'] OR !$id
 371                         OR in_array($id, $qui['restreint'])
 372                 );
 373 }
 374
 375  /**
 376  * Autorisation de créer une rubrique
 377  *
 378  * Il faut être administrateur pour pouvoir publier à la racine
 379  *
 380  * @param  string $faire Action demandée
 381  * @param  string $type  Type d'objet sur lequel appliquer l'action
 382  * @param  int    $id    Identifiant de l'objet
 383  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 384  * @param  array  $opt   Options de cette autorisation
 385  * @return bool          true s'il a le droit, false sinon
 386 **/
 387 function autoriser_rubrique_creer_dist($faire, $type, $id, $qui, $opt) {
 388         return
 389                 ((!$id AND autoriser('defaut',null,null,$qui, $opt))
 390                 OR $id AND autoriser('creerrubriquedans','rubrique', $id, $qui, $opt)
 391                 );
 392 }
 393
 394 /**
 395  * Autorisation de créer une sous rubrique dans une rubrique $id
 396  *
 397  * Il faut être administrateur et pouvoir publier dans la rubrique
 398  *
 399  * @param  string $faire Action demandée
 400  * @param  string $type  Type d'objet sur lequel appliquer l'action
 401  * @param  int    $id    Identifiant de l'objet
 402  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 403  * @param  array  $opt   Options de cette autorisation
 404  * @return bool          true s'il a le droit, false sinon
 405 **/
 406 function autoriser_rubrique_creerrubriquedans_dist($faire, $type, $id, $qui, $opt) {
 407         return
 408                 ($id OR ($qui['statut'] == '0minirezo' AND !$qui['restreint']))
 409                 AND autoriser('voir','rubrique',$id)
 410                 AND autoriser('publierdans','rubrique',$id);
 411 }
 412
 413 /**
 414  * Autorisation de créer un article dans une rubrique $id
 415  *
 416  * Il faut pouvoir voir la rubrique
 417  *
 418  * @param  string $faire Action demandée
 419  * @param  string $type  Type d'objet sur lequel appliquer l'action
 420  * @param  int    $id    Identifiant de l'objet
 421  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 422  * @param  array  $opt   Options de cette autorisation
 423  * @return bool          true s'il a le droit, false sinon
 424 **/
 425 function autoriser_rubrique_creerarticledans_dist($faire, $type, $id, $qui, $opt) {
 426         return
 427                 $id
 428                 AND autoriser('voir','rubrique',$id);
 429 }
 430
 431
 432 /**
 433  * Autorisation de modifier une rubrique $id
 434  *
 435  * Il faut pouvoir publier dans cette rubrique
 436  *
 437  * @param  string $faire Action demandée
 438  * @param  string $type  Type d'objet sur lequel appliquer l'action
 439  * @param  int    $id    Identifiant de l'objet
 440  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 441  * @param  array  $opt   Options de cette autorisation
 442  * @return bool          true s'il a le droit, false sinon
 443 **/
 444 function autoriser_rubrique_modifier_dist($faire, $type, $id, $qui, $opt) {
 445         return
 446                 autoriser('publierdans', 'rubrique', $id, $qui, $opt);
 447 }
 448
 449 /**
 450  * Autorisation de supprimer une rubrique $id
 451  *
 452  * Il faut quelle soit vide (pas d'enfant) et qu'on ait le droit de la modifier
 453  *
 454  * @param  string $faire Action demandée
 455  * @param  string $type  Type d'objet sur lequel appliquer l'action
 456  * @param  int    $id    Identifiant de l'objet
 457  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 458  * @param  array  $opt   Options de cette autorisation
 459  * @return bool          true s'il a le droit, false sinon
 460 **/
 461 function autoriser_rubrique_supprimer_dist($faire, $type, $id, $qui, $opt) {
 462         if (!$id = intval($id))
 463                 return false;
 464
 465         if (sql_countsel('spip_rubriques', "id_parent=".intval($id)))
 466                 return false;
 467
 468         if (sql_countsel('spip_articles', "id_rubrique=".intval($id)." AND (statut<>'poubelle')"))
 469                 return false;
 470
 471         $compte = pipeline('objet_compte_enfants',array('args'=>array('objet'=>'rubrique','id_objet'=>$id),'data'=>array()));
 472         foreach($compte as $objet => $n)
 473                 if ($n)
 474                         return false;
 475
 476         return autoriser('modifier','rubrique',$id);
 477 }
 478
 479
 480 /**
 481  * Autorisation de modifier un article $id
 482  *
 483  * Il faut pouvoir publier dans le parent
 484  * ou, si on change le statut en proposé ou préparation être auteur de l'article
 485  *
 486  * @param  string $faire Action demandée
 487  * @param  string $type  Type d'objet sur lequel appliquer l'action
 488  * @param  int    $id    Identifiant de l'objet
 489  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 490  * @param  array  $opt   Options de cette autorisation
 491  * @return bool          true s'il a le droit, false sinon
 492 **/
 493 function autoriser_article_modifier_dist($faire, $type, $id, $qui, $opt) {
 494         $r = sql_fetsel("id_rubrique,statut", "spip_articles", "id_article=".sql_quote($id));
 495
 496         if (!function_exists('auteurs_article'))
 497                 include_spip('inc/auth'); // pour auteurs_article si espace public
 498
 499         return
 500                 $r
 501                 AND
 502                 (
 503                         autoriser('publierdans', 'rubrique', $r['id_rubrique'], $qui, $opt)
 504                         OR (
 505                                 (!isset($opt['statut']) OR $opt['statut']!=='publie')
 506                                 AND in_array($qui['statut'], array('0minirezo', '1comite'))
 507                                 AND in_array($r['statut'], array('prop','prepa', 'poubelle'))
 508                                 AND auteurs_article($id, "id_auteur=".$qui['id_auteur'])
 509                         )
 510                 );
 511 }
 512
 513  /**
 514  * Autorisation de créer un article
 515  *
 516  * Il faut qu'une rubrique existe et être au moins rédacteur
 517  *
 518  * @param  string $faire Action demandée
 519  * @param  string $type  Type d'objet sur lequel appliquer l'action
 520  * @param  int    $id    Identifiant de l'objet
 521  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 522  * @param  array  $opt   Options de cette autorisation
 523  * @return bool          true s'il a le droit, false sinon
 524 **/
 525 function autoriser_article_creer_dist($faire, $type, $id, $qui, $opt) {
 526         return (sql_countsel('spip_rubriques')>0 AND in_array($qui['statut'], array('0minirezo', '1comite')));
 527 }
 528
 529 /**
 530  * Autorisation de voir un article
 531  *
 532  * Il faut être admin ou auteur de l'article, sinon il faut que l'article
 533  * soit publié ou proposé.
 534  *
 535  * Peut-être appelée sans $id, mais avec un $opt['statut'] pour tester
 536  * la liste des status autorisés en fonction de $qui['statut']
 537  *
 538  * @param  string $faire Action demandée
 539  * @param  string $type  Type d'objet sur lequel appliquer l'action
 540  * @param  int    $id    Identifiant de l'objet
 541  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 542  * @param  array  $opt   Options de cette autorisation
 543  * @return bool          true s'il a le droit, false sinon
 544  */
 545 function autoriser_article_voir_dist($faire, $type, $id, $qui, $opt){
 546         if ($qui['statut'] == '0minirezo') return true;
 547         // cas des articles : depend du statut de l'article et de l'auteur
 548         if (isset($opt['statut']))
 549                 $statut = $opt['statut'];
 550         else {
 551                 if (!$id) return false;
 552                 $statut = sql_getfetsel("statut", "spip_articles", "id_article=".intval($id));
 553         }
 554
 555         return
 556                 // si on est pas auteur de l'article,
 557                 // seuls les propose et publies sont visibles
 558                 in_array($statut, array('prop', 'publie'))
 559                 // sinon si on est auteur, on a le droit de le voir, evidemment !
 560                 OR
 561                 ($id AND $qui['id_auteur']
 562                      AND (function_exists('auteurs_article') OR include_spip('inc/auth'))
 563                      AND auteurs_article($id, "id_auteur=".$qui['id_auteur']));
 564 }
 565
 566
 567 /**
 568  * Autorisation de voir un objet
 569  *
 570  * Tout est visible par défaut, sauf les auteurs où il faut au moins être rédacteur.
 571  *
 572  * @param  string $faire Action demandée
 573  * @param  string $type  Type d'objet sur lequel appliquer l'action
 574  * @param  int    $id    Identifiant de l'objet
 575  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 576  * @param  array  $opt   Options de cette autorisation
 577  * @return bool          true s'il a le droit, false sinon
 578 **/
 579 function autoriser_voir_dist($faire, $type, $id, $qui, $opt) {
 580         # securite, mais on aurait pas du arriver ici !
 581         if (function_exists($f='autoriser_'.$type.'_voir') OR function_exists($f='autoriser_'.$type.'_voir_dist')){
 582                 return $f($faire, $type, $id, $qui, $opt);
 583         }
 584
 585         if ($qui['statut'] == '0minirezo') return true;
 586         // admins et redacteurs peuvent voir un auteur
 587         if ($type == 'auteur')
 588                 return in_array($qui['statut'], array('0minirezo', '1comite'));
 589         // sinon par defaut tout est visible
 590         // sauf cas particuliers traites separemment (ie article)
 591         return true;
 592 }
 593
 594
 595 /**
 596  * Autorisation de webmestre
 597  *
 598  * Est-on webmestre ? Signifie qu'on n'a même pas besoin de passer par ftp
 599  * pour modifier les fichiers, cf. notamment inc/admin
 600  *
 601  * Soit la liste des webmestres est définie via une constante _ID_WEBMESTRES,
 602  * soit on regarde l'état "webmestre" de l'auteur
 603  *
 604  * @param  string $faire Action demandée
 605  * @param  string $type  Type d'objet sur lequel appliquer l'action
 606  * @param  int    $id    Identifiant de l'objet
 607  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 608  * @param  array  $opt   Options de cette autorisation
 609  * @return bool          true s'il a le droit, false sinon
 610 **/
 611 function autoriser_webmestre_dist($faire, $type, $id, $qui, $opt) {
 612         return
 613                 (defined('_ID_WEBMESTRES')?
 614                         in_array($qui['id_auteur'], explode(':', _ID_WEBMESTRES))
 615                         :$qui['webmestre']=='oui')
 616                 AND $qui['statut'] == '0minirezo'
 617                 AND !$qui['restreint']
 618                 ;
 619 }
 620
 621 /**
 622  * Autorisation Configurer le site
 623  *
 624  * Il faut être administrateur complet
 625  *
 626  * @param  string $faire Action demandée
 627  * @param  string $type  Type d'objet sur lequel appliquer l'action
 628  * @param  int    $id    Identifiant de l'objet
 629  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 630  * @param  array  $opt   Options de cette autorisation
 631  * @return bool          true s'il a le droit, false sinon
 632 **/
 633 function autoriser_configurer_dist($faire, $type, $id, $qui, $opt) {
 634         return
 635                 $qui['statut'] == '0minirezo'
 636                 AND !$qui['restreint']
 637                 ;
 638 }
 639
 640 /**
 641  * Autorisation de sauvegarder la base de données
 642  *
 643  * Il faut être administrateur (y compris restreint)
 644  *
 645  * @param  string $faire Action demandée
 646  * @param  string $type  Type d'objet sur lequel appliquer l'action
 647  * @param  int    $id    Identifiant de l'objet
 648  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 649  * @param  array  $opt   Options de cette autorisation
 650  * @return bool          true s'il a le droit, false sinon
 651 **/
 652 function autoriser_sauvegarder_dist($faire, $type, $id, $qui, $opt) {
 653         return
 654                 $qui['statut'] == '0minirezo'
 655                 ;
 656 }
 657
 658 /**
 659  * Autorisation d'effacer la base de données
 660  *
 661  * Il faut être webmestre
 662  *
 663  * @param  string $faire Action demandée
 664  * @param  string $type  Type d'objet sur lequel appliquer l'action
 665  * @param  int    $id    Identifiant de l'objet
 666  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 667  * @param  array  $opt   Options de cette autorisation
 668  * @return bool          true s'il a le droit, false sinon
 669 **/
 670 function autoriser_detruire_dist($faire, $type, $id, $qui, $opt) {
 671         return
 672                 autoriser('webmestre', null, null, $qui, $opt);
 673 }
 674
 675 /**
 676  * Autorisation de prévisialiser un auteur
 677  *
 678  * Il faut être administrateur ou que l'auteur à prévisualiser
 679  * ait au moins publié un article
 680  *
 681  * @param  string $faire Action demandée
 682  * @param  string $type  Type d'objet sur lequel appliquer l'action
 683  * @param  int    $id    Identifiant de l'objet
 684  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 685  * @param  array  $opt   Options de cette autorisation
 686  * @return bool          true s'il a le droit, false sinon
 687 **/
 688 function autoriser_auteur_previsualiser_dist($faire, $type, $id, $qui, $opt) {
 689         // les admins peuvent "previsualiser" une page auteur
 690         if ($qui['statut'] == '0minirezo'
 691                 AND !$qui['restreint']) return true;
 692         // "Voir en ligne" si l'auteur a un article publie
 693         $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));
 694         return $n ? true : false;
 695 }
 696
 697 /**
 698  * Autorisation de créer un auteur
 699  *
 700  * Il faut être administrateur (restreint compris).
 701  *
 702  * @note
 703  *     Seuls les administrateurs complets ont accès à tous les
 704  *     champs du formulaire d'édition d'un auteur. À la création
 705  *     d'un auteur, son statut est 'poubelle'. C'est l'autorisation
 706  *     de modifier qui permet de changer les informations sensibles
 707  *     (statut, login, pass, etc.) à l'institution.
 708  *
 709  * @see auteur_inserer()
 710  * @see auteur_instituer()
 711  * @see autoriser_auteur_modifier_dist()
 712  *
 713  * @param  string $faire Action demandée
 714  * @param  string $type  Type d'objet sur lequel appliquer l'action
 715  * @param  int    $id    Identifiant de l'objet
 716  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 717  * @param  array  $opt   Options de cette autorisation
 718  * @return bool          true s'il a le droit, false sinon
 719 **/
 720 function autoriser_auteur_creer_dist($faire, $type, $id, $qui, $opt) {
 721         return ($qui['statut'] == '0minirezo');
 722 }
 723
 724
 725 /**
 726  * Autorisation de modifier un auteur
 727  *
 728  * Attention tout depend de ce qu'on veut modifier. Il faut être au moins
 729  * rédacteur, mais on ne peut pas promouvoir (changer le statut) un auteur
 730  * avec des droits supérieurs au sien.
 731  *
 732  * @param  string $faire Action demandée
 733  * @param  string $type  Type d'objet sur lequel appliquer l'action
 734  * @param  int    $id    Identifiant de l'objet
 735  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 736  * @param  array  $opt   Options de cette autorisation
 737  * @return bool          true s'il a le droit, false sinon
 738 **/
 739 function autoriser_auteur_modifier_dist($faire, $type, $id, $qui, $opt) {
 740
 741         // Ni admin ni redacteur => non
 742         if (!in_array($qui['statut'], array('0minirezo', '1comite')))
 743                 return false;
 744
 745         // Un redacteur peut modifier ses propres donnees mais ni son login/email
 746         // ni son statut (qui sont le cas echeant passes comme option)
 747         if ($qui['statut'] == '1comite') {
 748                 if ($opt['webmestre'])
 749                         return false;
 750                 elseif ($opt['statut'] OR $opt['restreintes'] OR $opt['email'])
 751                         return false;
 752                 elseif ($id == $qui['id_auteur'])
 753                         return true;
 754                 else
 755                         return false;
 756         }
 757
 758         // Un admin restreint peut modifier/creer un auteur non-admin mais il
 759         // n'a le droit ni de le promouvoir admin, ni de changer les rubriques
 760         if ($qui['restreint']) {
 761                 if ($opt['webmestre'])
 762                         return false;
 763                 elseif ($opt['statut'] == '0minirezo' OR $opt['restreintes'])
 764                         return false;
 765                 else {
 766                         if ($id == $qui['id_auteur']) {
 767                                 if ($opt['statut'])
 768                                         return false;
 769                                 else
 770                                         return true;
 771                         }
 772                         else if ($id_auteur = intval($id)) {
 773                                 $t = sql_fetsel("statut", "spip_auteurs", "id_auteur=$id_auteur");
 774                                 if ($t AND $t['statut'] != '0minirezo')
 775                                         return true;
 776                                 else
 777                                         return false;
 778                         }
 779                         // id = 0 => creation
 780                         else
 781                                 return true;
 782                 }
 783         }
 784
 785         // Un admin complet fait ce qu'elle veut
 786         // sauf se degrader
 787         if ($id == $qui['id_auteur'] && $opt['statut'])
 788                 return false;
 789         // et toucher au statut webmestre si il ne l'est pas lui meme
 790         // ou si les webmestres sont fixes par constante (securite)
 791         elseif (isset($opt['webmestre']) AND $opt['webmestre'] AND (defined('_ID_WEBMESTRES') OR !autoriser('webmestre')))
 792                 return false;
 793         // et modifier un webmestre si il ne l'est pas lui meme
 794         elseif (intval($id) AND autoriser('webmestre','',0,$id) AND !autoriser('webmestre'))
 795                 return false;
 796         else
 797                 return true;
 798 }
 799
 800
 801 /**
 802  * Autorisation d'associer un auteur sur un objet
 803  *
 804  * Il faut pouvoir modifier l'objet en question
 805  *
 806  * @param  string $faire Action demandée
 807  * @param  string $type  Type d'objet sur lequel appliquer l'action
 808  * @param  int    $id    Identifiant de l'objet
 809  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 810  * @param  array  $opt   Options de cette autorisation
 811  * @return bool          true s'il a le droit, false sinon
 812 **/
 813 function autoriser_associerauteurs_dist($faire, $type, $id, $qui, $opt){
 814         return autoriser('modifier', $type, $id, $qui, $opt);
 815 }
 816
 817
 818 /**
 819  * Autorisation d'upload FTP
 820  *
 821  * Il faut être administrateur.
 822  *
 823  * @param  string $faire Action demandée
 824  * @param  string $type  Type d'objet sur lequel appliquer l'action
 825  * @param  int    $id    Identifiant de l'objet
 826  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 827  * @param  array  $opt   Options de cette autorisation
 828  * @return bool          true s'il a le droit, false sinon
 829 **/
 830 function autoriser_chargerftp_dist($faire, $type, $id, $qui, $opt) {
 831         return $qui['statut'] == '0minirezo';
 832 }
 833
 834 /**
 835  * Autorisation d'activer le mode debug
 836  *
 837  * Il faut être administrateur.
 838  *
 839  * @param  string $faire Action demandée
 840  * @param  string $type  Type d'objet sur lequel appliquer l'action
 841  * @param  int    $id    Identifiant de l'objet
 842  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 843  * @param  array  $opt   Options de cette autorisation
 844  * @return bool          true s'il a le droit, false sinon
 845 **/
 846 function autoriser_debug_dist($faire, $type, $id, $qui, $opt) {
 847         return $qui['statut'] == '0minirezo';
 848 }
 849
 850 /**
 851  * Liste les rubriques d'un auteur
 852  *
 853  * Renvoie la liste des rubriques liées à cet auteur, independamment de son
 854  * statut (pour les admins restreints, il faut donc aussi vérifier statut)
 855  *
 856  * Mémorise le resultat dans un tableau statique indéxé par les id_auteur.
 857  * On peut reinitialiser un élément en passant un 2e argument non vide
 858  *
 859  * @param int  $id_auteur Identifiant de l'auteur
 860  * @param bool $raz       Recalculer le résultat connu pour cet auteur
 861  * @return array          Liste des rubriques
 862 **/
 863 function liste_rubriques_auteur($id_auteur, $raz=false) {
 864         static $restreint = array();
 865
 866         if (!$id_auteur = intval($id_auteur)) return array();
 867         if ($raz) unset($restreint[$id_auteur]);
 868         elseif (isset($restreint[$id_auteur])) return $restreint[$id_auteur];
 869
 870         $rubriques = array();
 871         if (
 872                 (!isset($GLOBALS['meta']['version_installee']) OR $GLOBALS['meta']['version_installee']>16428)
 873           AND $r = sql_allfetsel('id_objet', 'spip_auteurs_liens', "id_auteur=".intval($id_auteur)." AND objet='rubrique' AND id_objet!=0")
 874           AND count($r)) {
 875                 $r = array_map('reset',$r);
 876
 877                 // recuperer toute la branche, au format chaine enumeration
 878                 include_spip('inc/rubriques');
 879                 $r = calcul_branche_in($r);
 880                 $r = explode(',',$r);
 881
 882                 // passer les rubriques en index, elimine les doublons
 883                 $r = array_flip($r);
 884                 // recuperer les index seuls
 885                 $r = array_keys($r);
 886                 // combiner pour avoir un tableau id_rubrique=>id_rubrique
 887                 // est-ce vraiment utile ? (on preserve la forme donnee par le code precedent)
 888                 $rubriques = array_combine($r,$r);
 889         }
 890
 891         // Affecter l'auteur session le cas echeant
 892         if ($GLOBALS['visiteur_session']['id_auteur'] == $id_auteur)
 893                 $GLOBALS['visiteur_session']['restreint'] = $rubriques;
 894
 895
 896         return $restreint[$id_auteur] = $rubriques;
 897 }
 898
 899 /**
 900  * Autorisation de modifier l'URL d'un objet
 901  *
 902  * Il faut pouvoir modifier l'objet.
 903  *
 904  * @param  string $faire Action demandée
 905  * @param  string $type  Type d'objet sur lequel appliquer l'action
 906  * @param  int    $id    Identifiant de l'objet
 907  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 908  * @param  array  $opt   Options de cette autorisation
 909  * @return bool          true s'il a le droit, false sinon
 910 **/
 911 function autoriser_modifierurl_dist($faire, $type, $id, $qui, $opt) {
 912         return autoriser('modifier', $type, $id, $qui, $opt);
 913 }
 914
 915 /**
 916  * Autorisation de prévisualiser une rubrique
 917  *
 918  * Il faut pouvoir prévisualiser.
 919  *
 920  * @param  string $faire Action demandée
 921  * @param  string $type  Type d'objet sur lequel appliquer l'action
 922  * @param  int    $id    Identifiant de l'objet
 923  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 924  * @param  array  $opt   Options de cette autorisation
 925  * @return bool          true s'il a le droit, false sinon
 926 **/
 927 function autoriser_rubrique_previsualiser_dist($faire,$type,$id,$qui,$opt){
 928         return autoriser('previsualiser');
 929 }
 930
 931 /**
 932  * Autorisation d'iconifier une rubrique (mettre un logo)
 933  *
 934  * Il faut pouvoir publier dans la rubrique.
 935  *
 936  * @param  string $faire Action demandée
 937  * @param  string $type  Type d'objet sur lequel appliquer l'action
 938  * @param  int    $id    Identifiant de l'objet
 939  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 940  * @param  array  $opt   Options de cette autorisation
 941  * @return bool          true s'il a le droit, false sinon
 942 **/
 943 function autoriser_rubrique_iconifier_dist($faire,$type,$id,$qui,$opt){
 944         return autoriser('publierdans', 'rubrique', $id, $qui, $opt);
 945 }
 946
 947 /**
 948  * Autorisation d'iconifier un auteur (mettre un logo)
 949  *
 950  * Il faut un administrateur ou que l'auteur soit celui qui demande l'autorisation
 951  *
 952  * @param  string $faire Action demandée
 953  * @param  string $type  Type d'objet sur lequel appliquer l'action
 954  * @param  int    $id    Identifiant de l'objet
 955  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 956  * @param  array  $opt   Options de cette autorisation
 957  * @return bool          true s'il a le droit, false sinon
 958 **/
 959 function autoriser_auteur_iconifier_dist($faire,$type,$id,$qui,$opt){
 960  return (($id == $qui['id_auteur']) OR
 961                 (($qui['statut'] == '0minirezo') AND !$qui['restreint']));
 962 }
 963
 964 /**
 965  * Autorisation d'iconifier un objet (mettre un logo)
 966  *
 967  * Il faut pouvoir modifier l'objet
 968  *
 969  * @param  string $faire Action demandée
 970  * @param  string $type  Type d'objet sur lequel appliquer l'action
 971  * @param  int    $id    Identifiant de l'objet
 972  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 973  * @param  array  $opt   Options de cette autorisation
 974  * @return bool          true s'il a le droit, false sinon
 975 **/
 976 function autoriser_iconifier_dist($faire,$type,$id,$qui,$opt){
 977         // par defaut, on a le droit d'iconifier si on a le droit de modifier
 978         return autoriser('modifier', $type, $id, $qui, $opt);
 979 }
 980
 981
 982 /**
 983  * Autorisation OK
 984  *
 985  * Autorise toujours !
 986  * Fonction sans surprise pour permettre les tests.
 987  *
 988  * @param  string $faire Action demandée
 989  * @param  string $type  Type d'objet sur lequel appliquer l'action
 990  * @param  int    $id    Identifiant de l'objet
 991  * @param  array  $qui   Description de l'auteur demandant l'autorisation
 992  * @param  array  $opt   Options de cette autorisation
 993  * @return bool          true
 994 **/
 995 function autoriser_ok_dist($faire, $type, $id, $qui, $opt) { return true; }
 996
 997 /**
 998  * Autorisation NIET
 999  *
1000  * Refuse toujours !
1001  * Fonction sans surprise pour permettre les tests.
1002  *
1003  * @param  string $faire Action demandée
1004  * @param  string $type  Type d'objet sur lequel appliquer l'action
1005  * @param  int    $id    Identifiant de l'objet
1006  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1007  * @param  array  $opt   Options de cette autorisation
1008  * @return bool          false
1009 **/
1010 function autoriser_niet_dist($faire, $type, $id, $qui, $opt) { return false; }
1011
1012 /**
1013  * Autorisation de réparer la base de données
1014  *
1015  * Il faut pouvoir la détruire (et ne pas être en cours de réinstallation)
1016  *
1017  * @param  string $faire Action demandée
1018  * @param  string $type  Type d'objet sur lequel appliquer l'action
1019  * @param  int    $id    Identifiant de l'objet
1020  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1021  * @param  array  $opt   Options de cette autorisation
1022  * @return bool          false
1023 **/
1024 function autoriser_base_reparer_dist($faire, $type, $id, $qui, $opt) {
1025         if (!autoriser('detruire') OR _request('reinstall'))
1026                 return false;
1027
1028         return true;
1029 }
1030
1031 /**
1032  * Autorisation de voir l'onglet infosperso
1033  *
1034  * Toujours OK
1035  *
1036  * @param  string $faire Action demandée
1037  * @param  string $type  Type d'objet sur lequel appliquer l'action
1038  * @param  int    $id    Identifiant de l'objet
1039  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1040  * @param  array  $opt   Options de cette autorisation
1041  * @return bool          true s'il a le droit, false sinon
1042 **/
1043 function autoriser_infosperso_onglet_dist($faire,$type,$id,$qui,$opt) {
1044         return true;
1045 }
1046
1047 /**
1048  * Autorisation de voir l'onglet configurerlangage
1049  *
1050  * Toujours OK
1051  *
1052  * @param  string $faire Action demandée
1053  * @param  string $type  Type d'objet sur lequel appliquer l'action
1054  * @param  int    $id    Identifiant de l'objet
1055  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1056  * @param  array  $opt   Options de cette autorisation
1057  * @return bool          true s'il a le droit, false sinon
1058 **/
1059 function autoriser_configurerlangage_onglet_dist($faire,$type,$id,$qui,$opt) {
1060         return true;
1061 }
1062
1063 /**
1064  * Autorisation de voir l'onglet configurerpreferences
1065  *
1066  * Toujours OK
1067  *
1068  * @param  string $faire Action demandée
1069  * @param  string $type  Type d'objet sur lequel appliquer l'action
1070  * @param  int    $id    Identifiant de l'objet
1071  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1072  * @param  array  $opt   Options de cette autorisation
1073  * @return bool          true s'il a le droit, false sinon
1074 **/
1075 function autoriser_configurerpreferences_onglet_dist($faire,$type,$id,$qui,$opt) {
1076         return true;
1077 }
1078
1079 /**
1080  * Autorisation de voir le menu auteurs
1081  *
1082  * Toujours OK
1083  *
1084  * @param  string $faire Action demandée
1085  * @param  string $type  Type d'objet sur lequel appliquer l'action
1086  * @param  int    $id    Identifiant de l'objet
1087  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1088  * @param  array  $opt   Options de cette autorisation
1089  * @return bool          true s'il a le droit, false sinon
1090 **/
1091 function autoriser_auteurs_menu_dist($faire, $type, $id, $qui, $opt){return true;}
1092
1093 /**
1094  * Autorisation de voir le menu articles
1095  *
1096  * Toujours OK
1097  *
1098  * @param  string $faire Action demandée
1099  * @param  string $type  Type d'objet sur lequel appliquer l'action
1100  * @param  int    $id    Identifiant de l'objet
1101  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1102  * @param  array  $opt   Options de cette autorisation
1103  * @return bool          true s'il a le droit, false sinon
1104 **/
1105 function autoriser_articles_menu_dist($faire, $type, $id, $qui, $opt){return true;}
1106
1107 /**
1108  * Autorisation de voir le menu rubriques
1109  *
1110  * Toujours OK
1111  *
1112  * @param  string $faire Action demandée
1113  * @param  string $type  Type d'objet sur lequel appliquer l'action
1114  * @param  int    $id    Identifiant de l'objet
1115  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1116  * @param  array  $opt   Options de cette autorisation
1117  * @return bool          true s'il a le droit, false sinon
1118 **/
1119 function autoriser_rubriques_menu_dist($faire, $type, $id, $qui, $opt){return true;}
1120
1121 /**
1122  * Autorisation de voir le menu articlecreer
1123  *
1124  * Il faut au moins une rubrique présente.
1125  *
1126  * @param  string $faire Action demandée
1127  * @param  string $type  Type d'objet sur lequel appliquer l'action
1128  * @param  int    $id    Identifiant de l'objet
1129  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1130  * @param  array  $opt   Options de cette autorisation
1131  * @return bool          true s'il a le droit, false sinon
1132 **/
1133 function autoriser_articlecreer_menu_dist($faire, $type, $id, $qui, $opt){
1134         return verifier_table_non_vide();
1135 }
1136
1137 /**
1138  * Autorisation de voir le menu auteurcreer
1139  *
1140  * Il faut pouvoir créer un auteur !
1141  *
1142  * @see autoriser_auteur_creer_dist()
1143  *
1144  * @param  string $faire Action demandée
1145  * @param  string $type  Type d'objet sur lequel appliquer l'action
1146  * @param  int    $id    Identifiant de l'objet
1147  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1148  * @param  array  $opt   Options de cette autorisation
1149  * @return bool          true s'il a le droit, false sinon
1150 **/
1151 function autoriser_auteurcreer_menu_dist($faire, $type, $id, $qui, $opt) {
1152         return autoriser('creer', 'auteur', $id, $qui, $opt);
1153 }
1154
1155 /**
1156  * Autorisation de voir le menu suiviedito
1157  *
1158  * Il faut être administrateur (y compris restreint).
1159  *
1160  * @param  string $faire Action demandée
1161  * @param  string $type  Type d'objet sur lequel appliquer l'action
1162  * @param  int    $id    Identifiant de l'objet
1163  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1164  * @param  array  $opt   Options de cette autorisation
1165  * @return bool          true s'il a le droit, false sinon
1166 **/
1167 function autoriser_suiviedito_menu_dist($faire, $type, $id, $qui, $opt){
1168         return $qui['statut']=='0minirezo';
1169 }
1170
1171 /**
1172  * Autorisation de voir le menu synchro
1173  *
1174  * Il faut être administrateur (y compris restreint).
1175  *
1176  * @param  string $faire Action demandée
1177  * @param  string $type  Type d'objet sur lequel appliquer l'action
1178  * @param  int    $id    Identifiant de l'objet
1179  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1180  * @param  array  $opt   Options de cette autorisation
1181  * @return bool          true s'il a le droit, false sinon
1182 **/
1183 function autoriser_synchro_menu_dist($faire, $type, $id, $qui, $opt){
1184         return $qui['statut']=='0minirezo';
1185 }
1186
1187 /**
1188  * Autorisation de purger la queue de travaux
1189  *
1190  * Il faut être webmestre.
1191  *
1192  * @param  string $faire Action demandée
1193  * @param  string $type  Type d'objet sur lequel appliquer l'action
1194  * @param  int    $id    Identifiant de l'objet
1195  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1196  * @param  array  $opt   Options de cette autorisation
1197  * @return bool          true s'il a le droit, false sinon
1198 **/
1199 function autoriser_queue_purger_dist($faire, $type, $id, $qui, $opt){
1200         return autoriser('webmestre');
1201 }
1202
1203
1204 /**
1205  * Autorisation l'échafaudage de squelettes en Z
1206  *
1207  * Il faut être dans l'espace privé (et authentifié),
1208  * sinon il faut être webmestre (pas de fuite d'informations publiées)
1209  *
1210  * @param  string $faire Action demandée
1211  * @param  string $type  Type d'objet sur lequel appliquer l'action
1212  * @param  int    $id    Identifiant de l'objet
1213  * @param  array  $qui   Description de l'auteur demandant l'autorisation
1214  * @param  array  $opt   Options de cette autorisation
1215  * @return bool          true s'il a le droit, false sinon
1216 **/
1217 function autoriser_echafauder_dist($faire, $type, $id, $qui, $opt){
1218         if (test_espace_prive())
1219                 return intval($qui['id_auteur'])?true:false;
1220         else
1221                 return autoriser('webmestre','',$id,$qui,$opt);
1222 }
1223
1224
1225 /**
1226  * Lister les auteurs d'un article
1227  *
1228  * Fonction générique utilisée par plusieurs autorisations
1229  *
1230  * @param int $id_article Identifiant de l'article
1231  * @param string $cond    Condition en plus dans le where de la requête
1232  * @return array|bool
1233  *     - array : liste des id_auteur trouvés
1234  *     - false : serveur SQL indisponible
1235  */
1236 function auteurs_article($id_article, $cond='')
1237 {
1238         return sql_allfetsel("id_auteur", "spip_auteurs_liens", "objet='article' AND id_objet=$id_article". ($cond ? " AND $cond" : ''));
1239 }
1240
1241
1242 /**
1243  * Tester si on est admin restreint sur une rubrique donnée
1244  *
1245  * Fonction générique utilisee dans des autorisations ou assimilée
1246  *
1247  * @param int $id_rubrique  Identifiant de la rubrique
1248  * @return bool             true si administrateur de cette rubrique, false sinon.
1249  */
1250 function acces_restreint_rubrique($id_rubrique) {
1251         global $connect_id_rubrique;
1252
1253         return (isset($connect_id_rubrique[$id_rubrique]));
1254 }
1255
1256
1257 /**
1258  * Verifier qu'il existe au moins un parent
1259  *
1260  * Fonction utilisee dans des autorisations des boutons / menus du prive des objets enfants (articles, breves, sites)
1261  *
1262  * @param string $table         la table a verifier
1263  * @return bool             true si un parent existe
1264  */
1265 function verifier_table_non_vide($table='spip_rubriques') {
1266         static $done = array();
1267         if (!isset($done[$table]))
1268                  $done[$table] = sql_countsel($table)>0;
1269         return $done[$table];
1270 }
1271
1272 /**
1273  * Une autorisation determiner la possibilite de s'inscire pour un statut et un id_rubrique,
1274  * a l'aide de la liste globale des statuts (tableau mode => nom du mode)
1275  * Utile pour le formulaire d'inscription.
1276  * Par defaut, seuls 6forum et 1comite possibles, les autres sont en false
1277  * pour un nouveau mode il suffit de definir l'autorisation specifique
1278  *
1279  * @param $faire
1280  * @param $quoi
1281  *   statut auteur demande
1282  * @param $id
1283  *   id_rubrique eventuel (pas utilise ici, utilise dans des usages persos)
1284  * @param $qui
1285  * @param $opt
1286  * @return bool
1287  */
1288 function autoriser_inscrireauteur_dist($faire, $quoi, $id, $qui, $opt){
1289
1290         $s = array_search($quoi, $GLOBALS['liste_des_statuts']);
1291         switch ($s) {
1292
1293                 case 'info_redacteurs' :
1294                   return ($GLOBALS['meta']['accepter_inscriptions'] == 'oui');
1295
1296                 case 'info_visiteurs' :
1297                   return ($GLOBALS['meta']['accepter_visiteurs'] == 'oui' OR $GLOBALS['meta']['forums_publics'] == 'abo');
1298
1299         }
1300
1301         return false;
1302 }
1303 ?>