www/plugins/accesrestreint_3_5/inc/accesrestreint.php

   1 <?php
   2 /**
   3  * Plugin Acces Restreint 3.0 pour Spip 2.0
   4  * Licence GPL (c) 2006-2008 Cedric Morin
   5  *
   6  */
   7
   8 if (!defined("_ECRIRE_INC_VERSION")) return;
   9
  10 // Liste des zones a laquelle appartient le visiteur, au format '1,2,3'
  11 // Cette fonction est appelee a chaque hit et peut etre completee (pipeline)
  12 /**
  13  * Liste des zones a laquelle appartient le visiteur, au format '1,2,3'.
  14  * Cette fonction est appelee a chaque hit et peut etre completee (pipeline)
  15  *
  16  * @param string $zones '1,2,3'
  17  * @param int $id_auteur
  18  * @return string '1,2,3'
  19  */
  20 function accesrestreint_liste_zones_autorisees($zones='', $id_auteur=NULL) {
  21         $id = NULL;
  22         if (!is_null($id_auteur))
  23                 $id = $id_auteur;
  24         elseif (isset($GLOBALS['visiteur_session']['id_auteur']) && $GLOBALS['visiteur_session']['id_auteur'])
  25                 $id = $GLOBALS['visiteur_session']['id_auteur'];
  26         if (!is_null($id)) {
  27                 $new = accesrestreint_liste_zones_appartenance_auteur($id);
  28                 if ($zones AND $new) {
  29                         $zones = array_unique(array_merge(explode(',',$zones),$new));
  30                         sort($zones);
  31                         $zones = join(',', $zones);
  32                 } else if ($new) {
  33                         $zones = join(',', $new);
  34                 }
  35         }
  36         return $zones;
  37 }
  38
  39 /**
  40  * liste des rubriques contenues dans une zone, directement.
  41  * pour savoir quelles rubriques on peut decocher
  42  * si id_zone = '' : toutes les rub en acces restreint
  43  *
  44  * @param int|string $id_zone
  45  * @return array
  46  */
  47 function accesrestreint_liste_contenu_zone_rub_direct($id_zone){
  48         $liste_rubriques=array();
  49         // liste des rubriques directement liees a la zone
  50         $where = array();
  51         if (is_numeric($id_zone))
  52                 $where[] = "z.id_zone=".intval($id_zone);
  53         elseif ($id_zone)
  54                 $where = $id_zone;
  55
  56         if (is_array($where))
  57                 $where[] = "zr.objet='rubrique'";
  58         else
  59                 $where = "($where) AND zr.objet='rubrique'";
  60
  61         include_spip('base/abstract_sql');
  62         $liste_rubriques = sql_allfetsel('id_objet','spip_zones_liens AS zr INNER JOIN spip_zones AS z ON zr.id_zone=z.id_zone',$where);
  63         $liste_rubriques = array_map('reset',$liste_rubriques);
  64         $liste_rubriques = array_unique($liste_rubriques);
  65         return $liste_rubriques;
  66 }
  67
  68 /**
  69  * liste des rubriques contenues dans une zone, directement ou par heritage.
  70  *
  71  * @param int/string $id_zone
  72  * @return array
  73  */
  74 function accesrestreint_liste_contenu_zone_rub($id_zone){
  75         include_spip('inc/rubriques');
  76         $liste_rubriques = accesrestreint_liste_contenu_zone_rub_direct($id_zone);
  77         if (!count($liste_rubriques))
  78                 return $liste_rubriques;
  79         $liste_rubriques = calcul_branche_in(join(',',$liste_rubriques));
  80         if (!strlen($liste_rubriques))
  81                 return array();
  82         $liste_rubriques = explode(',',$liste_rubriques);
  83         return $liste_rubriques;
  84 }
  85
  86
  87 /**
  88  * liste des rubriques d'une zone et leurs rubriques parentes.
  89  *
  90  * @param int/string $id_zone
  91  * @return array
  92  */
  93 function accesrestreint_liste_parentee_zone_rub($id_zone){
  94         include_spip('inc/rubriques');
  95         $liste_rubriques = accesrestreint_liste_contenu_zone_rub_direct($id_zone);
  96         if (!count($liste_rubriques))
  97                 return $liste_rubriques;
  98
  99         $id = $liste_rubriques;
 100         while ($parents = sql_allfetsel('id_parent', 'spip_rubriques',
 101         sql_in('id_rubrique', $id))) {
 102                 $parents = array_map('array_shift', $parents);
 103                 $parents = array_diff($parents, array(0));
 104                 $id = $parents;
 105                 $liste_rubriques = array_merge($liste_rubriques, $parents);
 106         }
 107
 108         return $liste_rubriques;
 109 }
 110
 111 /**
 112  * Lister les zones auxquelles un auteur appartient
 113  *
 114  * @param int $id_auteur
 115  * @return array
 116  */
 117 function accesrestreint_liste_zones_appartenance_auteur($id_auteur){
 118         static $liste_zones = array();
 119         if (!isset($liste_zones[$id_auteur])){
 120                 include_spip('base/abstract_sql');
 121                 $liste_zones[$id_auteur] = sql_allfetsel("id_zone","spip_zones_liens","objet='auteur' AND id_objet=".intval($id_auteur));
 122                 $liste_zones[$id_auteur] = array_map('reset',$liste_zones[$id_auteur]);
 123         }
 124         return $liste_zones[$id_auteur];
 125 }
 126
 127 /**
 128  * Verifier si un auteur appartient a une zone.
 129  * utilise la fonction precedente qui met en cache son resultat
 130  * on optimise en fonction de l'hypothese que le nombre de zones est toujours reduit
 131  *
 132  * @param unknown_type $id_zone
 133  * @param unknown_type $id_auteur
 134  * @return unknown
 135  */
 136 function accesrestreint_test_appartenance_zone_auteur($id_zone,$id_auteur){
 137         return in_array($id_zone,accesrestreint_liste_zones_appartenance_auteur($id_auteur));
 138 }
 139
 140 /**
 141  * liste des auteurs contenus dans une zone
 142  *
 143  * @param int $id_zone
 144  * @return array
 145  */
 146 function accesrestreint_liste_contenu_zone_auteur($id_zone) {
 147         $liste_auteurs=array();
 148         include_spip('base/abstract_sql');
 149         $liste_auteurs = sql_allfetsel("id_objet","spip_zones_liens","objet='auteur' AND id_zone=".intval($id_zone));
 150         $liste_auteurs = array_map('reset',$liste_auteurs);
 151         return $liste_auteurs;
 152 }
 153
 154 /**
 155  * fonctions de filtrage rubrique
 156  * -> condition NOT IN
 157  * Cette fonction renvoie la liste des rubriques interdites
 158  * au visiteur courant
 159  * d'ou le recours a $GLOBALS['accesrestreint_zones_autorisees']
 160  *
 161  * @param bool $publique Selectionner les rubriques interdites dans l'espace public (true) ou prive (false)
 162  * @param int $id_auteur Identifiant de l'auteur
 163  * @param bool $quelquesoit_visibilite Si true, on ne s'occupe pas de savoir si une zone est restreinte sur le prive ou sur le public.
 164  * @return array
 165  */
 166 function accesrestreint_liste_rubriques_exclues($publique=true, $id_auteur=NULL, $quelquesoit_visibilite = false) {
 167         // cache static
 168         static $liste_rub_exclues = array();
 169         static $liste_rub_inclues = array();
 170         if ($quelquesoit_visibilite) { $publique = 'tout'; }
 171
 172         if (is_null($id_auteur) AND isset($GLOBALS['visiteur_session']['id_auteur']))
 173                 $id_auteur = $GLOBALS['visiteur_session']['id_auteur'];
 174         if (!isset($liste_rub_exclues[$id_auteur][$publique]) || !is_array($liste_rub_exclues[$id_auteur][$publique])) {
 175
 176                 $where = array();
 177                 // Ne selectionner que les zones pertinentes
 178                 if (!$quelquesoit_visibilite) {
 179                         if ($publique)
 180                                 $where[] = "publique='oui'";
 181                         else
 182                                 $where[] = "privee='oui'";
 183                 }
 184
 185                 // Si le visiteur est autorise sur certaines zones publiques,
 186                 // on selectionne les rubriques correspondant aux autres zones,
 187                 // sinon on selectionne toutes celles correspondant a une zone.
 188                 include_spip('base/abstract_sql');
 189                 if ($GLOBALS['accesrestreint_zones_autorisees']
 190                   AND $id_auteur==$GLOBALS['visiteur_session']['id_auteur'])
 191                         $where[] = sql_in('zr.id_zone',$GLOBALS['accesrestreint_zones_autorisees'],'NOT');
 192                 elseif ($id_auteur)
 193                         $where[] = sql_in('zr.id_zone',accesrestreint_liste_zones_autorisees('',$id_auteur),'NOT');
 194
 195                 // liste les rubriques (+branches) des zones dont ne fait pas parti l'auteur
 196                 $liste_rub_exclues[$id_auteur][$publique] = accesrestreint_liste_contenu_zone_rub($where);
 197                 #$liste_rub_exclues[$publique] = array_unique($liste_rub_exclues[$publique]);
 198         }
 199         $final_liste_rub_exclues = $liste_rub_exclues[$id_auteur][$publique];
 200
 201         if (defined("AR_TYPE_RESTRICTION") AND AR_TYPE_RESTRICTION == "faible") {
 202                 // AR_TYPE_RESTRICTION definit le type de restriction pour traiter les elements communs a plusieurs zone
 203                 // Une restriction exclusive (ou forte) donne l'acces aux rubriques restreintes par
 204                 // plusieurs zone aux seuls membres de toutes les zones concernees.
 205                 // Une restriction faible donne acces a une rubrique, meme restreinte par
 206                 // plusieurs zones, aux membres de chaque zone concernee.
 207                 // valeurs : 'faible', 'forte, ou 'exclusive'
 208
 209                 // Autrement dit, si une rubrique 2 est enfant d'une rubrique 1,
 210                 // et qu'il existe une zone 1 (rubrique 1) et une zone 2 (rubrique 2) :
 211                 // - un auteur present dans la zone 1 (uniquement) ne pourra pas voir la rubrique 2
 212                 //   lorsque la restriction est "forte". Il le pourra avec une restriction "faible"
 213                 //
 214                 // - A l'inverse, un auteur present uniquement dans la zone 2 ne pourra pas voir
 215                 //   la rubrique 1 meme si la restriction est "faible" car la parentee n'est pas concernee.
 216                 //   il faut (si souhaite) dans ce cas definir en plus AR_TYPE_RESTRICTION_PARENTEE a "faible"
 217                 //   pour l'autoriser.
 218                 if (!isset($liste_rub_inclues[$id_auteur][$publique]) OR !is_array($liste_rub_inclues[$id_auteur][$publique])) {
 219
 220                         $where = array();
 221                         // Ne selectionner que les zones pertinentes
 222                         if (!$quelquesoit_visibilite) {
 223                                 if ($publique)
 224                                         $where[] = "publique='oui'";
 225                                 else
 226                                         $where[] = "privee='oui'";
 227                         }
 228
 229                         // Calcul des rubriques dans des zones autorisees
 230                         include_spip('base/abstract_sql');
 231                         if ($GLOBALS['accesrestreint_zones_autorisees']
 232                           AND $id_auteur==$GLOBALS['visiteur_session']['id_auteur'])
 233                                 $where[] = sql_in('zr.id_zone',$GLOBALS['accesrestreint_zones_autorisees']);
 234                         elseif ($id_auteur)
 235                                 $where[] = sql_in('zr.id_zone',accesrestreint_liste_zones_autorisees('',$id_auteur));
 236
 237                         // liste les rubriques (+branches) des zones de l'auteur
 238                         $liste_rub_inclues[$id_auteur][$publique] = accesrestreint_liste_contenu_zone_rub($where);
 239
 240                         // pour autoriser la vue des rubriques parentes
 241                         // memes si elles sont restreintes par une autre zone
 242                         if (defined("AR_TYPE_RESTRICTION_PARENTEE") AND AR_TYPE_RESTRICTION_PARENTEE == "faible") {
 243                                 $liste_rub_inclues[$id_auteur][$publique] =
 244                                         array_merge($liste_rub_inclues[$id_auteur][$publique],
 245                                                 accesrestreint_liste_parentee_zone_rub($where));
 246                         }
 247                 }
 248
 249                 // Ne pas exclure les elements qui sont autorises
 250                 $final_liste_rub_exclues = array_diff($final_liste_rub_exclues,
 251                         array_intersect($final_liste_rub_exclues,$liste_rub_inclues[$id_auteur][$publique]));
 252         }
 253
 254         return $final_liste_rub_exclues;
 255 }
 256
 257
 258 ?>