Changeset 22632 in spip-zone


Ignore:
Timestamp:
Sep 17, 2008, 1:40:45 PM (13 years ago)
Author:
cedric@…
Message:

refonte en profondeur du plugin Acces Restreint version 3 qui repasse en dev
On commence par le code compile qui genere des sous requetes optimisees ou seul la liste des rubriques restreintes apparait explicitement

Location:
_plugins_/_stable_/acces_restreint
Files:
4 added
6 edited
2 moved

Legend:

Unmodified
Added
Removed
  • _plugins_/_stable_/acces_restreint/acces_restreint_fonctions.php

    r22631 r22632  
    11<?php
     2/**
     3 * Plugin Acces Restreint 3.0 pour Spip 2.0
     4 * Licence GPL
     5 *
     6 *
     7 */
    28
    3 // * Acces restreint, plugin pour SPIP * //
    49if (!defined("_ECRIRE_INC_VERSION")) return;
    510
    6 include_spip('base/acces_restreint');
    7 include_spip('inc/acces_restreint');
    8 
    9 //include_spip('inc/acces_restreint');
    10 
    11 // {tout_voir}
    12 function critere_tout_voir_dist($idb, &$boucles, $crit) {
    13         $boucle = &$boucles[$idb];
    14         $boucle->modificateur['tout_voir'] = true;
     11// filtre de securisation des squelettes
     12// utilise avec [(#REM|AccesRestreint_securise_squelette)]
     13// evite divulgation d'info si plugin desactive
     14// par erreur fatale
     15function AccesRestreint_securise_squelette($letexte){
     16        return "";
    1517}
    1618
    17 //
    18 // <BOUCLE(ARTICLES)>
    19 //
    20 function boucle_ARTICLES($id_boucle, &$boucles) {
    21         $boucle = &$boucles[$id_boucle];
    22         if (!isset($boucle->modificateur['tout_voir'])){
    23                 $t = $boucle->id_table . '.id_rubrique';
    24                 $boucle->select = array_merge($boucle->select, array($t)); // pour postgres
    25                 $boucle->where[] = 'AccesRestreint_rubriques_accessibles_where("'.$t.'")';
    26         }
    27         return boucle_ARTICLES_dist($id_boucle, $boucles);
     19// filtre de test pour savoir si l'acces a un article est restreint
     20function AccesRestreint_article_restreint($id_article){
     21        include_spip('inc/acces_restreint_autorisations');
     22        return
     23                @in_array($id_article,
     24                        AccesRestreint_liste_articles_exclus(_DIR_RESTREINT!="")
     25                );
     26}
     27// filtre de test pour savoir si l'acces a une rubrique est restreinte
     28function AccesRestreint_rubrique_restreinte($id_rubrique){
     29        include_spip('inc/acces_restreint_autorisations');
     30        return
     31                @in_array($id_rubrique,
     32                        AccesRestreint_liste_rubriques_exclues(_DIR_RESTREINT!="")
     33                );
    2834}
    2935
    30 //
    31 // <BOUCLE(BREVES)>
    32 //
    33 function boucle_BREVES($id_boucle, &$boucles) {
    34         $boucle = &$boucles[$id_boucle];
    35         if (!isset($boucle->modificateur['tout_voir'])){
    36                 $t = $boucle->id_table . '.id_rubrique';
    37                 $boucle->select = array_merge($boucle->select, array($t)); // pour postgres
    38                 $boucle->where[] = 'AccesRestreint_rubriques_accessibles_where("'.$t.'")';
    39         }
    40         return boucle_BREVES_dist($id_boucle, $boucles);
    41 }
    42 
    43 //
    44 // <BOUCLE(FORUMS)>
    45 //
    46 function boucle_FORUMS($id_boucle, &$boucles) {
    47         $boucle = &$boucles[$id_boucle];
    48         if (!isset($boucle->modificateur['tout_voir'])){
    49                 $t = $boucle->id_table . '.id_rubrique';
    50                 $boucle->select = array_merge($boucle->select, array($t)); // pour postgres
    51                 $boucle->where[] = 'AccesRestreint_rubriques_accessibles_where("'.$t.'")';
    52 
    53                 $t = $boucle->id_table . '.id_article';
    54                 $boucle->select = array_merge($boucle->select, array($t));
    55                 $boucle->where[] = 'AccesRestreint_articles_accessibles_where("'.$t.'")';
    56 
    57                 $t = $boucle->id_table . '.id_breve';
    58                 $boucle->select = array_merge($boucle->select, array($t));
    59                 $boucle->where[] = 'AccesRestreint_breves_accessibles_where("'.$t.'")';
    60         }
    61         return boucle_FORUMS_dist($id_boucle, $boucles);
    62 }
    63 
    64 //
    65 // <BOUCLE(SIGNATURES)>
    66 //
    67 function boucle_SIGNATURES($id_boucle, &$boucles) {
    68         $boucle = &$boucles[$id_boucle];
    69         if (!isset($boucle->modificateur['tout_voir'])) {
    70                 $t = $boucle->id_table . '.id_article';
    71                 $boucle->select = array_merge($boucle->select, array($t));
    72                 $boucle->where[] = 'AccesRestreint_articles_accessibles_where("'.$t.'")';
    73         }
    74         return boucle_SIGNATURES_dist($id_boucle, $boucles);
    75 }
    76 
    77 //
    78 // <BOUCLE(DOCUMENTS)> ; ici la notion d'acces est tres discutable
    79 //
    80 function boucle_DOCUMENTS($id_boucle, &$boucles) {
    81         $boucle = &$boucles[$id_boucle];
    82         if (!isset($boucle->modificateur['tout_voir'])){
    83                 $t = $boucle->id_table . '.' . $boucle->primary;
    84                 $boucle->select = array_merge($boucle->select, array($t));
    85                 $boucle->where[] = 'AccesRestreint_documents_accessibles_where("'.$t.'")';
    86         }
    87         return boucle_DOCUMENTS_dist($id_boucle, $boucles);
    88 }
    89 
    90 //
    91 // <BOUCLE(RUBRIQUES)>
    92 //
    93 function boucle_RUBRIQUES($id_boucle, &$boucles) {
    94         $boucle = &$boucles[$id_boucle];
    95         if (!isset($boucle->modificateur['tout_voir'])){
    96                 $t = $boucle->id_table . '.' . $boucle->primary;
    97                 $boucle->select = array_merge($boucle->select, array($t));
    98                 $boucle->where[] = 'AccesRestreint_rubriques_accessibles_where("'.$t.'")';
    99         }
    100         return boucle_RUBRIQUES_dist($id_boucle, $boucles);
    101 }
    102 
    103 //
    104 // <BOUCLE(HIERARCHIE)>
    105 //
    106 function boucle_HIERARCHIE($id_boucle, &$boucles) {
    107         $boucle = &$boucles[$id_boucle];
    108         if (!isset($boucle->modificateur['tout_voir'])){
    109                 $t = $boucle->id_table . '.' . $boucle->primary;
    110                 $boucle->select = array_merge($boucle->select, array($t));
    111                 $boucle->where[] = 'AccesRestreint_rubriques_accessibles_where("'.$t.'")';
    112         }
    113         return boucle_HIERARCHIE_dist($id_boucle, $boucles);
    114 }
    115 
    116 //
    117 // <BOUCLE(SYNDICATION)>
    118 //
    119 function boucle_SYNDICATION($id_boucle, &$boucles) {
    120         $boucle = &$boucles[$id_boucle];
    121         if (!isset($boucle->modificateur['tout_voir'])){
    122                 $t = $boucle->id_table . '.id_rubrique';
    123                 $boucle->select = array_merge($boucle->select, array($t));
    124                 $boucle->where[] = 'AccesRestreint_rubriques_accessibles_where("'.$t.'")';
    125         }
    126         return boucle_SYNDICATION_dist($id_boucle, $boucles);
    127 }
    128 
    129 //
    130 // <BOUCLE(SYNDIC_ARTICLES)>
    131 //
    132 function boucle_SYNDIC_ARTICLES($id_boucle, &$boucles) {
    133         $boucle = &$boucles[$id_boucle];
    134         if (!isset($boucle->modificateur['tout_voir'])){
    135                 $t = $boucle->id_table . '.' . $boucle->primary;
    136                 $boucle->select = array_merge($boucle->select, array($t));
    137                 $boucle->where[] = 'AccesRestreint_syndic_articles_accessibles_where("'.$t.'")';
    138         }
    139         return boucle_SYNDIC_ARTICLES_dist($id_boucle, $boucles);
    140 }
    141 
    142 //
    143 // <BOUCLE(EVENEMENTS)>
    144 //
    145 function boucle_EVENEMENTS($id_boucle, &$boucles) {
    146         $boucle = &$boucles[$id_boucle];
    147         if (!isset($boucle->modificateur['tout_voir'])){
    148                 $t = $boucle->id_table . '.' . $boucle->primary;
    149                 $boucle->select = array_merge($boucle->select, array($t));
    150                 $boucle->where[] = 'AccesRestreint_evenements_accessibles_where("'.$t.'")';
    151         }
    152         return boucle_EVENEMENTS_dist($id_boucle, $boucles);
    153 }
    154 
    155 
    15636?>
  • _plugins_/_stable_/acces_restreint/acces_restreint_options.php

    r16982 r22632  
    11<?php
     2/**
     3 * Plugin Acces Restreint 3.0 pour Spip 2.0
     4 * Licence GPL
     5 *
     6 *
     7 */
    28
    3 // * Acces restreint, plugin pour SPIP * //
    49if (!defined("_ECRIRE_INC_VERSION")) return;
    510
     
    3035if(!function_exists('autoriser_rubrique_voir')) {
    3136function autoriser_rubrique_voir($faire, $type, $id, $qui, $opt) {
    32         include_spip('inc/acces_restreint');
     37        include_spip('inc/acces_restreint_autorisations');
    3338        static $rub_exclues;
    3439        if (isset($opt['publique']))
    3540                $publique = $opt['publique'];
    3641        else
    37                 $publique = _DIR_RESTREINT!="";
     42                $publique = !test_espace_prive();
    3843        if (!isset($rub_exclues[$publique]) || !is_array($rub_exclues[$publique])) {
    3944                // Si autoriser est appelee pour un autre auteur que l'auteur connecte  ou si pas d'auteur connecte , on passe $id_auteur en parametre
     
    5661                $publique = $opt['publique'];
    5762        else
    58                 $publique = _DIR_RESTREINT!="";
     63                $publique = !test_espace_prive();
    5964        if (!isset($art_exclus[$publique]) || !is_array($art_exclus[$publique])) {
    6065                // Si autoriser est appelee pour un autre auteur que l'auteur connecte  ou si pas d'auteur connecte , on passe $id_auteur en parametre
     
    7782                $publique = $opt['publique'];
    7883        else
    79                 $publique = _DIR_RESTREINT!="";
     84                $publique = !test_espace_prive();
    8085        if (!isset($breves_exclues[$publique]) || !is_array($breves_exclues[$publique])) {
    8186                // Si autoriser est appelee pour un autre auteur que l'auteur connecte  ou si pas d'auteur connecte , on passe $id_auteur en parametre
     
    98103                $publique = $opt['publique'];
    99104        else
    100                 $publique = _DIR_RESTREINT!="";
     105                $publique = !test_espace_prive();
    101106        if (!isset($sites_exclus[$publique]) || !is_array($sites_exclus[$publique])) {
    102107                // Si autoriser est appelee pour un autre auteur que l'auteur connecte  ou si pas d'auteur connecte , on passe $id_auteur en parametre
     
    119124                $publique = $opt['publique'];
    120125        else
    121                 $publique = _DIR_RESTREINT!="";
     126                $publique = !test_espace_prive();
    122127        if (!isset($evenements_exclus[$publique]) || !is_array($evenements_exclus[$publique])) {
    123128                // Si autoriser est appelee pour un autre auteur que l'auteur connecte  ou si pas d'auteur connecte , on passe $id_auteur en parametre
     
    140145                $publique = $opt['publique'];
    141146        else
    142                 $publique = _DIR_RESTREINT!="";
     147                $publique = !test_espace_prive();
    143148        if (!isset($documents_exclus[$publique]) || !is_array($documents_exclus[$publique])) {
    144149                $documents_exclus[$publique] = AccesRestreint_liste_documents_exclus($publique,$qui['id_auteur']);
  • _plugins_/_stable_/acces_restreint/action/autoriser.php

    r17226 r22632  
    44 *  SPIP, Systeme de publication pour l'internet                           *
    55 *                                                                         *
    6  *  Copyright (c) 2001-2007                                                *
     6 *  Copyright (c) 2001-2008                                                *
    77 *  Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James  *
    88 *                                                                         *
     
    2828
    2929        if (!autoriser('voir','document',$arg)
    30                 OR !($res = spip_query("SELECT fichier FROM spip_documents WHERE id_document="._q($arg)))
    31                 OR !($row = spip_fetch_array($res))
     30                OR !($row = sql_fetsel("fichier","spip_documents","id_document=".intval($arg)))
    3231                OR !($file = $row['fichier'])
    3332                OR !(file_exists($file))
  • _plugins_/_stable_/acces_restreint/base/acces_restreint.php

    r15660 r22632  
    11<?php
     2/**
     3 * Plugin Acces Restreint 3.0 pour Spip 2.0
     4 * Licence GPL
     5 *
     6 *
     7 */
    28
    3 // * Acces restreint, plugin pour SPIP * //
    49
    510if (!defined("_ECRIRE_INC_VERSION")) return;
    611
    7 // Les tables :
    8 // 1 table descriptive des zones d'acces
    9 // 2 tables de liens zones<->auteurs et  zones<->rubriques
     12function AccesRestreint_declarer_tables_interfaces($interface){
     13        $interface['tables_jointures']['spip_auteurs'][] = 'zones_auteurs';
     14        $interface['tables_jointures']['spip_zones'][] = 'zones_auteurs';
     15       
     16        $interface['tables_jointures']['spip_rubriques'][] = 'zones_rubriques';
     17        $interface['tables_jointures']['spip_zones'][] = 'zones_rubriques';
     18       
     19        //-- Table des tables ----------------------------------------------------
     20       
     21        $interface['table_des_tables']['zones']='zones';
    1022
    11 global $tables_principales;
    12 global $tables_auxiliaires;
     23        /*if (version_compare($spip_version_code,'1.9250','<')) {
     24                $table_des_tables['zones_rubriques']='zones_rubriques';
     25                $table_des_tables['zones_auteurs']='zones_auteurs';
     26        }*/
     27        return $interface;
     28}
    1329
    14 $spip_zones = array(
    15         "id_zone"       => "bigint(21) NOT NULL",
    16         "titre"         => "varchar(255) NOT NULL",
    17         "descriptif"    => "text NOT NULL",
    18         "publique"      => "ENUM('non', 'oui') DEFAULT 'oui' NOT NULL",
    19         "privee"        => "ENUM('non', 'oui') DEFAULT 'non' NOT NULL",
    20         "maj"           => "TIMESTAMP");
     30function AccesRestreint_declarer_tables_principales($tables_principales){
     31        $spip_zones = array(
     32                "id_zone"       => "bigint(21) NOT NULL",
     33                "titre"         => "varchar(255) NOT NULL",
     34                "descriptif"    => "text NOT NULL",
     35                "publique"      => "ENUM('non', 'oui') DEFAULT 'oui' NOT NULL",
     36                "privee"        => "ENUM('non', 'oui') DEFAULT 'non' NOT NULL",
     37                "maj"           => "TIMESTAMP");
     38       
     39        $spip_zones_key = array(
     40                "PRIMARY KEY" => "id_zone");
     41       
     42        $tables_principales['spip_zones'] = array(
     43                'field' => &$spip_zones,
     44                'key' => &$spip_zones_key);
     45               
     46        return $tables_principales;
     47}
    2148
    22 $spip_zones_key = array(
    23         "PRIMARY KEY" => "id_zone");
    24 
    25 $tables_principales['spip_zones'] = array(
    26         'field' => &$spip_zones,
    27         'key' => &$spip_zones_key);
    28 
    29 $spip_zones_auteurs = array(
    30         "id_zone"       => "bigint(21) NOT NULL",
    31         "id_auteur"     => "bigint(21) NOT NULL");
    32 
    33 $spip_zones_auteurs_key = array(
    34         "PRIMARY KEY"   => "id_zone, id_auteur",
    35         "KEY id_auteur" => "id_auteur");
    36 
    37 $tables_auxiliaires['spip_zones_auteurs'] = array(
    38         'field' => &$spip_zones_auteurs,
    39         'key' => &$spip_zones_auteurs_key);
    40 
    41 $spip_zones_rubriques = array(
    42         "id_zone"       => "bigint(21) NOT NULL",
    43         "id_rubrique"   => "bigint(21) NOT NULL");
    44 
    45 $spip_zones_rubriques_key = array(
    46         "PRIMARY KEY"   => "id_zone, id_rubrique",
    47         "KEY id_rubrique" => "id_rubrique");
    48 
    49 $tables_auxiliaires['spip_zones_rubriques'] = array(
    50         'field' => &$spip_zones_rubriques,
    51         'key' => &$spip_zones_rubriques_key);
    52 
    53 //-- Relations ----------------------------------------------------
    54 
    55 global $tables_jointures;
    56 $tables_jointures['spip_auteurs'][] = 'zones_auteurs';
    57 $tables_jointures['spip_zones'][] = 'zones_auteurs';
    58 
    59 $tables_jointures['spip_rubriques'][] = 'zones_rubriques';
    60 $tables_jointures['spip_zones'][] = 'zones_rubriques';
    61 
    62 //-- Table des tables ----------------------------------------------------
    63 
    64 global $table_des_tables;
    65 $table_des_tables['zones']='zones';
    66 global $spip_version_code;
    67 if (version_compare($spip_version_code,'1.9250','<')) {
    68         $table_des_tables['zones_rubriques']='zones_rubriques';
    69         $table_des_tables['zones_auteurs']='zones_auteurs';
     49function AccesRestreint_declarer_tables_auxiliaires($tables_auxiliaires){
     50        $spip_zones_auteurs = array(
     51                "id_zone"       => "bigint(21) NOT NULL",
     52                "id_auteur"     => "bigint(21) NOT NULL");
     53       
     54        $spip_zones_auteurs_key = array(
     55                "PRIMARY KEY"   => "id_zone, id_auteur",
     56                "KEY id_auteur" => "id_auteur");
     57       
     58        $tables_auxiliaires['spip_zones_auteurs'] = array(
     59                'field' => &$spip_zones_auteurs,
     60                'key' => &$spip_zones_auteurs_key);
     61       
     62        $spip_zones_rubriques = array(
     63                "id_zone"       => "bigint(21) NOT NULL",
     64                "id_rubrique"   => "bigint(21) NOT NULL");
     65       
     66        $spip_zones_rubriques_key = array(
     67                "PRIMARY KEY"   => "id_zone, id_rubrique",
     68                "KEY id_rubrique" => "id_rubrique");
     69       
     70        $tables_auxiliaires['spip_zones_rubriques'] = array(
     71                'field' => &$spip_zones_rubriques,
     72                'key' => &$spip_zones_rubriques_key);
     73        return $tables_auxiliaires;
    7074}
    7175
  • _plugins_/_stable_/acces_restreint/base/acces_restreint_install.php

    r22631 r22632  
    11<?php
    2 
    3 // * Acces restreint, plugin pour SPIP * //
     2/**
     3 * Plugin Acces Restreint 3.0 pour Spip 2.0
     4 * Licence GPL
     5 *
     6 *
     7 */
    48
    59if (!defined("_ECRIRE_INC_VERSION")) return;
    610
    7         include_spip('inc/meta');
    8         include_spip('inc/vieilles_defs');
    9         function AccesRestreint_upgrade($nom_meta_base_version,$version_cible){
    10                 $current_version = 0.0;
    11                 if (   (!isset($GLOBALS['meta'][$nom_meta_base_version]) )
    12                                 || (($current_version = $GLOBALS['meta'][$nom_meta_base_version])!=$version_cible)){
    13                         include_spip('base/acces_restreint');
    14                         if (version_compare($current_version,'0.0','<=')){
    15                                 include_spip('base/create');
    16                                 include_spip('base/abstract_sql');
    17                                 creer_base();
    18                                 // ajout des champs publique/privee si pas existants
    19                                 $desc = spip_abstract_showtable("spip_zones", '', true);
    20                                 if (!isset($desc['field']['publique']))
    21                                         spip_query("ALTER TABLE spip_zones ADD publique ENUM('non', 'oui') DEFAULT 'oui' NOT NULL AFTER descriptif");
    22                                 if (!isset($desc['field']['privee']))
    23                                         spip_query("ALTER TABLE spip_zones ADD privee ENUM('non', 'oui') DEFAULT 'non' NOT NULL AFTER publique");
    24                                 echo "AccesRestreint Install<br/>";
    25                                 ecrire_meta($nom_meta_base_version,$current_version=$version_cible,'non');
    26                         }
    27                         if (version_compare($current_version,'0.2','<')){
    28                                 include_spip('base/create');
    29                                 include_spip('base/abstract_sql');
    30                                 // ajout des champs publique/privee si pas existants
    31                                 $desc = spip_abstract_showtable("spip_zones", '', true);
    32                                 if (!isset($desc['field']['publique']))
    33                                         spip_query("ALTER TABLE spip_zones ADD publique ENUM('non', 'oui') DEFAULT 'oui' NOT NULL AFTER descriptif");
    34                                 if (!isset($desc['field']['privee']))
    35                                         spip_query("ALTER TABLE spip_zones ADD privee ENUM('non', 'oui') DEFAULT 'non' NOT NULL AFTER publique");
    36                                 echo "AccesRestreint@0.2<br />";
    37                                 ecrire_meta($nom_meta_base_version,$current_version='0.2','non');
    38                         }
    39                         if (version_compare($current_version,'0.3','<')){
    40                                 spip_query("ALTER TABLE `zones_auteurs` DROP INDEX `id_zone`");
    41                                 spip_query("ALTER TABLE `zones_auteurs` ADD PRIMARY KEY ( `id_zone` , `id_auteur` )");
    42                                 spip_query("ALTER TABLE `zones_rubriques` DROP INDEX `id_zone`");
    43                                 spip_query("ALTER TABLE `zones_rubriques` ADD PRIMARY KEY ( `id_zone` , `id_rubrique` )");
    44                                 echo "AccesRestreint@0.3<br />";
    45                                 ecrire_meta($nom_meta_base_version,$current_version='0.3','non');
    46                         }
    47                         if (version_compare($current_version,'0.3.0.1','<')){
    48                                 ecrire_meta('creer_htaccess','oui');
    49                                 echo "AccesRestreint@0.3.0.1<br />";
    50                                 ecrire_meta($nom_meta_base_version,$current_version='0.3.0.1','non');
    51                         }
    52                         ecrire_metas();
     11include_spip('inc/meta');
     12/**
     13 * Fonction d'installation, mise a jour de la base
     14 *
     15 * @param unknown_type $nom_meta_base_version
     16 * @param unknown_type $version_cible
     17 */
     18function AccesRestreint_upgrade($nom_meta_base_version,$version_cible){
     19        $current_version = 0.0;
     20        if (   (!isset($GLOBALS['meta'][$nom_meta_base_version]) )
     21                        || (($current_version = $GLOBALS['meta'][$nom_meta_base_version])!=$version_cible)){
     22                include_spip('base/acces_restreint');
     23                if (version_compare($current_version,'0.0','<=')){
     24                        include_spip('base/create');
     25                        include_spip('base/abstract_sql');
     26                        creer_base();
     27                        // ajout des champs publique/privee si pas existants
     28                        $desc = spip_abstract_showtable("spip_zones", '', true);
     29                        if (!isset($desc['field']['publique']))
     30                                sql_alter("TABLE spip_zones ADD publique ENUM('non', 'oui') DEFAULT 'oui' NOT NULL AFTER descriptif");
     31                        if (!isset($desc['field']['privee']))
     32                                sql_alter("TABLE spip_zones ADD privee ENUM('non', 'oui') DEFAULT 'non' NOT NULL AFTER publique");
     33                        echo "AccesRestreint Install<br/>";
     34                        ecrire_meta($nom_meta_base_version,$current_version=$version_cible,'non');
     35                }
     36                if (version_compare($current_version,'0.2','<')){
     37                        include_spip('base/create');
     38                        include_spip('base/abstract_sql');
     39                        // ajout des champs publique/privee si pas existants
     40                        $desc = spip_abstract_showtable("spip_zones", '', true);
     41                        if (!isset($desc['field']['publique']))
     42                                sql_alter("TABLE spip_zones ADD publique ENUM('non', 'oui') DEFAULT 'oui' NOT NULL AFTER descriptif");
     43                        if (!isset($desc['field']['privee']))
     44                                sql_alter("TABLE spip_zones ADD privee ENUM('non', 'oui') DEFAULT 'non' NOT NULL AFTER publique");
     45                        echo "AccesRestreint@0.2<br />";
     46                        ecrire_meta($nom_meta_base_version,$current_version='0.2','non');
     47                }
     48                if (version_compare($current_version,'0.3','<')){
     49                        sql_alter("TABLE `zones_auteurs` DROP INDEX `id_zone`");
     50                        sql_alter("TABLE `zones_auteurs` ADD PRIMARY KEY ( `id_zone` , `id_auteur` )");
     51                        sql_alter("TABLE `zones_rubriques` DROP INDEX `id_zone`");
     52                        sql_alter("TABLE `zones_rubriques` ADD PRIMARY KEY ( `id_zone` , `id_rubrique` )");
     53                        echo "AccesRestreint@0.3<br />";
     54                        ecrire_meta($nom_meta_base_version,$current_version='0.3','non');
     55                }
     56                if (version_compare($current_version,'0.3.0.1','<')){
     57                        #ecrire_meta('creer_htaccess','oui');
     58                        echo "AccesRestreint@0.3.0.1<br />";
     59                        ecrire_meta($nom_meta_base_version,$current_version='0.3.0.1','non');
    5360                }
    5461        }
    55        
    56         function AccesRestreint_vider_tables($nom_meta_base_version) {
    57                 spip_query("DROP TABLE spip_zones");
    58                 spip_query("DROP TABLE spip_zones_auteurs");
    59                 spip_query("DROP TABLE spip_zones_rubriques");
    60                 effacer_meta('creer_htaccess');
    61                 effacer_meta($nom_meta_base_version);
    62                 ecrire_metas();
    63         }
     62}
     63
     64/**
     65 * Fonction de desinstallation
     66 *
     67 * @param unknown_type $nom_meta_base_version
     68 */
     69function AccesRestreint_vider_tables($nom_meta_base_version) {
     70        sql_drop_table("spip_zones");
     71        sql_drop_table("spip_zones_auteurs");
     72        sql_drop_table("spip_zones_rubriques");
     73        effacer_meta('creer_htaccess');
     74        effacer_meta($nom_meta_base_version);
     75}
    6476
    6577?>
  • _plugins_/_stable_/acces_restreint/inc/acces_restreint.php

    r22356 r22632  
    11<?php
    2 
    3 // * Acces restreint, plugin pour SPIP * //
     2/**
     3 * Plugin Acces Restreint 3.0 pour Spip 2.0
     4 * Licence GPL
     5 *
     6 *
     7 */
    48
    59if (!defined("_ECRIRE_INC_VERSION")) return;
    610
    7 include_spip('inc/vieilles_defs');
    8 
    911// Liste des zones a laquelle appartient le visiteur, au format '1,2,3'
    1012// Cette fonction est appelee a chaque hit et peut etre completee (pipeline)
     13/**
     14 * Liste des zones a laquelle appartient le visiteur, au format '1,2,3'.
     15 * Cette fonction est appelee a chaque hit et peut etre completee (pipeline)
     16 *
     17 * @param string $zones '1,2,3'
     18 * @param int $id_auteur
     19 * @return string '1,2,3'
     20 */
    1121function AccesRestreint_liste_zones_autorisees($zones='', $id_auteur=NULL) {
    1222        $id = NULL;
     
    2838}
    2939
    30 // liste des rubriques contenues dans une zone, directement
    31 // pour savoir quelles rubriques on peut decocher
    32 // si id_zone = 0 : toutes les rub en acces restreint
     40/**
     41 * liste des rubriques contenues dans une zone, directement.
     42 * pour savoir quelles rubriques on peut decocher
     43 * si id_zone = '' : toutes les rub en acces restreint
     44 *
     45 * @param int/string $id_zone
     46 * @return array
     47 */
    3348function AccesRestreint_liste_contenu_zone_rub_direct($id_zone){
    3449        $liste_rubriques=array();
    3550        // liste des rubriques directement liees a la zone
    36         $query = "SELECT zr.id_rubrique FROM spip_zones_rubriques AS zr INNER JOIN spip_zones AS z ON zr.id_zone=z.id_zone";
     51        $where = array();
    3752        if (is_numeric($id_zone))
    38                 $query.=" WHERE zr.id_zone=".$id_zone;
    39         else
    40                 $query .= " WHERE $id_zone";
    41         $s = spip_query($query);
    42         while ($row = spip_fetch_array($s))
    43                 $liste_rubriques[$row['id_rubrique']]=1;
    44         return array_keys($liste_rubriques);
     53                $where[] = "id_zone=".intval($id_zone);
     54        elseif ($id_zone)
     55                $where[] = $id_zone;
     56        include_spip('base/abstract_sql');
     57        $liste_rubriques = sql_allfetsel('id_rubrique','spip_zones_rubriques AS zr INNER JOIN spip_zones AS z ON zr.id_zone=z.id_zone',$where);
     58        $liste_rubriques = array_map('reset',$liste_rubriques);
     59        $liste_rubriques = array_unique($liste_rubriques);
     60        return $liste_rubriques;
    4561}
    4662
    4763// liste des rubriques contenues dans une zone, directement ou par heritage
     64/**
     65 * liste des rubriques contenues dans une zone, directement ou par heritage.
     66 *
     67 * @param int/string $id_zone
     68 * @return array
     69 */
    4870function AccesRestreint_liste_contenu_zone_rub($id_zone){
    4971        include_spip('inc/rubriques');
    50         if ($rubs = AccesRestreint_liste_contenu_zone_rub_direct($id_zone))
    51                 return explode(',', calcul_branche(join(',', $rubs)));
    52         else
    53                 return array();
     72        $liste_rubriques = AccesRestreint_liste_contenu_zone_rub_direct($id_zone);
     73        $liste_rubriques = calcul_branche_in(join(',',$liste_rubriques));
     74        $liste_rubriques = explode(',',$liste_rubriques);
     75        return $liste_rubriques;
    5476}
    5577
    56 // liste des zones a laquelle appartient un auteur
     78/**
     79 * Lister les zones auxquelles un auteur appartient
     80 *
     81 * @param int $id_auteur
     82 * @return array
     83 */
    5784function AccesRestreint_liste_zones_appartenance_auteur($id_auteur){
    58         $liste_zones=array();
    59         $s = spip_query("SELECT id_zone FROM spip_zones_auteurs WHERE id_auteur="._q($id_auteur));
    60         while ($row = spip_fetch_array($s))
    61                         $liste_zones[]=$row['id_zone'];
    62         return $liste_zones;
     85        static $liste_zones = array();
     86        if (!isset($liste_zones[$id_auteur])){
     87                include_spip('base/abstract_sql');
     88                $liste_zones[$id_auteur] = sql_allfetsel("id_zone","spip_zones_auteurs","id_auteur=".intval($id_auteur));
     89                $liste_zones[$id_auteur] = array_map('reset',$liste_zones[$id_auteur]);
     90        }
     91        return $liste_zones[$id_auteur];
    6392}
    6493
    65 // test si un auteur appartient a une zone
     94/**
     95 * Verifier si un auteur appartient a une zone.
     96 * utilise la fonction precedente qui met en cache son resultat
     97 * on optimise en fonction de l'hypothese que le nombre de zones est toujours reduit
     98 *
     99 * @param unknown_type $id_zone
     100 * @param unknown_type $id_auteur
     101 * @return unknown
     102 */
    66103function AccesRestreint_test_appartenance_zone_auteur($id_zone,$id_auteur){
    67         $s = spip_query("SELECT id_zone FROM spip_zones_auteurs WHERE id_auteur="._q($id_auteur)." AND id_zone="._q($id_zone));
    68         if ($row = spip_fetch_array($s))
    69                 return true;
    70         return false;
     104        return in_array($id_zone,AccesRestreint_liste_zones_appartenance_auteur($id_auteur));
    71105}
    72106
    73 // liste des auteurs contenus dans une zone
     107/**
     108 * liste des auteurs contenus dans une zone
     109 *
     110 * @param int $id_zone
     111 * @return array
     112 */
    74113function AccesRestreint_liste_contenu_zone_auteur($id_zone) {
    75114        $liste_auteurs=array();
    76         $id_zone = intval($id_zone);
    77         // liste des rubriques directement liees a la zone
    78         $s = spip_query("SELECT id_auteur FROM spip_zones_auteurs WHERE id_zone=$id_zone");
    79         while ($row=spip_fetch_array($s))
    80                 $liste_auteurs[] = $row['id_auteur'];
     115        include_spip('base/abstract_sql');
     116        $liste_auteurs = sql_allfetsel("id_auteur","spip_zones_auteurs","id_zone=".intval($id_zone));
     117        $liste_auteurs = array_map('reset',$liste_auteurs);
    81118        return $liste_auteurs;
    82119}
    83120
    84 // fonctions de filtrage rubrique
    85 // plus performant a priori : liste des rubriques exclues uniquement
    86 // -> condition NOT IN
    87 // Cette fonction renvoie la liste des rubriques interdites
    88 // au visiteur courant
    89 // d'ou le recours a $GLOBALS['AccesRestreint_zones_autorisees']
     121/**
     122 * fonctions de filtrage rubrique
     123 * -> condition NOT IN
     124 * Cette fonction renvoie la liste des rubriques interdites
     125 * au visiteur courant
     126 * d'ou le recours a $GLOBALS['AccesRestreint_zones_autorisees']
     127 *
     128 * @param unknown_type $publique
     129 * @param unknown_type $id_auteur
     130 * @return unknown
     131 */
    90132function AccesRestreint_liste_rubriques_exclues($publique=true, $id_auteur=NULL) {
    91133        // cache static
     
    93135        if (!isset($liste_rub_exclues[$publique]) || !is_array($liste_rub_exclues[$publique])) {
    94136
     137                $where = array();
    95138                // Ne selectionner que les zones pertinentes
    96139                if ($publique)
    97                         $cond = "publique='oui'";
     140                        $where[] = "publique='oui'";
    98141                else
    99                         $cond = "privee='oui'";
     142                        $where[] = "privee='oui'";
    100143
    101144                // Si le visiteur est autorise sur certaines zones publiques,
    102145                // on selectionne les rubriques correspondant aux autres zones,
    103                 // sinon on selectionne toutes celles correspondant � une zone.
     146                // sinon on selectionne toutes celles correspondant a une zone.
     147                include_spip('base/abstract_sql');
    104148                if (is_null($id_auteur) AND $GLOBALS['AccesRestreint_zones_autorisees'])
    105                         $cond .= " AND zr.id_zone NOT IN (".$GLOBALS['AccesRestreint_zones_autorisees'].")";
     149                        $where[] = sql_in('zr.id_zone',$GLOBALS['AccesRestreint_zones_autorisees'],'NOT');
    106150                elseif (!is_null($id_auteur))
    107                         if ($zones_autorisees=AccesRestreint_liste_zones_autorisees('',$id_auteur))
    108                                 $cond .= " AND zr.id_zone NOT IN (".$zones_autorisees.")";
     151                        $where[] = sql_in('zr.id_zone',AccesRestreint_liste_zones_autorisees('',$id_auteur),'NOT');
    109152
    110153                $liste_rub_exclues[$publique] = AccesRestreint_liste_contenu_zone_rub($cond);
    111                 $liste_rub_exclues[$publique] = array_unique($liste_rub_exclues[$publique]);
     154                #$liste_rub_exclues[$publique] = array_unique($liste_rub_exclues[$publique]);
    112155        }
    113156        return $liste_rub_exclues[$publique];
     
    115158
    116159
    117 function AccesRestreint_rubriques_accessibles_where($primary){
    118         include_spip('base/abstract_sql');
    119         $liste = AccesRestreint_liste_rubriques_exclues(_DIR_RESTREINT!="");
    120         return calcul_mysql_in($primary, join(",",$liste),"NOT");
    121 }
    122 
    123 
    124         // fonctions de filtrage article
    125         // plus performant a priori : liste des rubriques exclues uniquement
    126         // -> condition NOT IN
    127         function AccesRestreint_liste_articles_exclus($publique=true, $id_auteur=NULL){
    128                 include_spip('base/abstract_sql');
    129                 static $liste_art_exclus=array();
    130                 if (!isset($liste_art_exclus[$publique]) || !is_array($liste_art_exclus[$publique])){
    131                         $liste_art_exclus[$publique] = array();
    132                         $liste_rub = AccesRestreint_liste_rubriques_exclues($publique, $id_auteur);
    133                         $where = calcul_mysql_in('id_rubrique', join(",",$liste_rub));
    134                         $s = spip_query("SELECT id_article FROM spip_articles WHERE $where");
    135                         while ($row = spip_fetch_array($s)){
    136                                 $liste_art_exclus[$publique][] = $row['id_article'];
    137                         }
    138                 }
    139                 return $liste_art_exclus[$publique];
    140         }
    141         function AccesRestreint_articles_accessibles_where($primary){
    142                 include_spip('base/abstract_sql');
    143                 $liste = AccesRestreint_liste_articles_exclus(_DIR_RESTREINT!="");
    144                 return calcul_mysql_in($primary, join(",",$liste),"NOT");
    145         }
    146 
    147         // fonctions de filtrage breves
    148         // plus performant a priori : liste des rubriques exclues uniquement
    149         // -> condition NOT IN
    150         function AccesRestreint_liste_breves_exclues($publique=true, $id_auteur=NULL){
    151                 include_spip('base/abstract_sql');
    152                 static $liste_breves_exclues=array();
    153                 if (!isset($liste_breves_exclues[$publique]) || !is_array($liste_breves_exclues[$publique])){
    154                         $liste_breves_exclues[$publique] = array();
    155                         $liste_rub = AccesRestreint_liste_rubriques_exclues($publique, $id_auteur);
    156                         $where = calcul_mysql_in('id_rubrique', join(",",$liste_rub));
    157                         $s = spip_query("SELECT id_breve FROM spip_breves WHERE $where");
    158                         while ($row = spip_fetch_array($s)){
    159                                 $liste_breves_exclues[$publique][] = $row['id_breve'];
    160                         }
    161                 }
    162                 return $liste_breves_exclues[$publique];
    163         }
    164         function AccesRestreint_breves_accessibles_where($primary){
    165                 include_spip('base/abstract_sql');
    166                 $liste = AccesRestreint_liste_breves_exclues(_DIR_RESTREINT!="");
    167                 return calcul_mysql_in($primary, join(",",$liste),"NOT");
    168         }
    169 
    170         // fonctions de filtrage forums
    171         // plus performant a priori : liste des rubriques exclues uniquement
    172         // -> condition NOT IN
    173         function AccesRestreint_liste_forum_exclus($publique=true, $id_auteur=NULL){
    174                 include_spip('base/abstract_sql');
    175                 static $liste_forum_exclus=array();
    176                 if (!isset($liste_forum_exclus[$publique]) || !is_array($liste_forum_exclus[$publique])){
    177                         $liste_forum_exclus[$publique] = array();
    178                         // rattaches aux rubriques
    179                         $liste_rub = AccesRestreint_liste_rubriques_exclues($publique, $id_auteur);
    180                         $where = calcul_mysql_in('id_rubrique', join(",",$liste_rub));
    181                         // rattaches aux articles
    182                         $liste_art = AccesRestreint_liste_articles_exclus($publique, $id_auteur);
    183                         $where .= " OR " . calcul_mysql_in('id_article', join(",",$liste_art));
    184                         // rattaches aux breves
    185                         $liste_breves = AccesRestreint_liste_breves_exclues($publique, $id_auteur);
    186                         $where .= " OR " . calcul_mysql_in('id_breve', join(",",$liste_art));
    187 
    188                         $s = spip_query("SELECT id_forum FROM spip_forum WHERE $where");
    189                         while ($row = spip_fetch_array($s)){
    190                                 $liste_forum_exclus[$publique][] = $row['id_forum'];
    191                         }
    192                 }
    193                 return $liste_forum_exclus[$publique];
    194         }
    195         function AccesRestreint_forum_accessibles_where($primary){
    196                 include_spip('base/abstract_sql');
    197                 $liste = AccesRestreint_liste_forum_exclus(_DIR_RESTREINT!="");
    198                 return calcul_mysql_in($primary, join(",",$liste),"NOT");
    199         }
    200 
    201         // fonctions de filtrage signatures
    202         // plus performant a priori : liste des rubriques exclues uniquement
    203         // -> condition NOT IN
    204         function AccesRestreint_liste_signatures_exclues($publique=true, $id_auteur=NULL){
    205                 include_spip('base/abstract_sql');
    206                 static $liste_signatures_exclues=array();
    207                 if (!isset($liste_signatures_exclues[$publique]) || !is_array($liste_signatures_exclues[$publique])){
    208                         $liste_signatures_exclues[$publique] = array();
    209                         // rattaches aux articles
    210                         $liste_art = AccesRestreint_liste_articles_exclus($publique, $id_auteur);
    211                         $where = calcul_mysql_in('id_article', join(",",$liste_art));
    212                         $s = spip_query("SELECT id_signature FROM spip_signatures WHERE $where");
    213                         while ($row = spip_fetch_array($s)){
    214                                 $liste_signatures_exclues[$publique][] = $row['id_signature'];
    215                         }
    216                 }
    217                 return $liste_signatures_exclues[$publique];
    218         }
    219         function AccesRestreint_signatures_accessibles_where($primary){
    220                 include_spip('base/abstract_sql');
    221                 $liste = AccesRestreint_liste_signatures_exclues(_DIR_RESTREINT!="");
    222                 return calcul_mysql_in($primary, join(",",$liste),"NOT");
    223         }
    224 
    225         // fonctions de filtrage documents
    226         // plus performant a priori : liste des rubriques exclues uniquement
    227         // -> condition NOT IN
    228         function AccesRestreint_liste_documents_exclus($publique=true, $id_auteur=NULL){
    229                 include_spip('base/abstract_sql');
    230                 static $liste_documents_exclus=array();
    231                 if (!isset($liste_documents_exclus[$publique]) || !is_array($liste_documents_exclus[$publique])){
    232                         $liste_documents_exclus[$publique] = array();
    233                         // rattaches aux articles
    234                         $liste_art = AccesRestreint_liste_articles_exclus($publique, $id_auteur);
    235                         $where = calcul_mysql_in('id_article', join(",",$liste_art));
    236                         $s = spip_query("SELECT id_document FROM spip_documents_articles WHERE $where");
    237                         while ($row = spip_fetch_array($s)){
    238                                 $liste_documents_exclus[$publique][$row['id_document']]=1;
    239                         }
    240                         // rattaches aux rubriques
    241                         $liste_rub = AccesRestreint_liste_rubriques_exclues($publique, $id_auteur);
    242                         $where = calcul_mysql_in('id_rubrique', join(",",$liste_rub));
    243                         $s = spip_query("SELECT id_document FROM spip_documents_rubriques WHERE $where");
    244                         while ($row = spip_fetch_array($s)){
    245                                 $liste_documents_exclus[$publique][$row['id_document']]=1;
    246                         }
    247                         // rattaches aux breves
    248                         $liste_breves = AccesRestreint_liste_breves_exclues($publique, $id_auteur);
    249                         $where = calcul_mysql_in('id_breve', join(",",$liste_breves));
    250                         $s = spip_query("SELECT id_document FROM spip_documents_breves WHERE $where");
    251                         while ($row = spip_fetch_array($s)){
    252                                 $liste_documents_exclus[$publique][$row['id_document']]=1;
    253                         }
    254                         // rattaches aux syndic
    255                         /*$liste_syn = AccesRestreint_liste_syndic_exclus($publique);
    256                         $where = calcul_mysql_in('id_syndic', join(",",$liste_syn));
    257                         $s = spip_query("SELECT id_document FROM spip_documents_syndic WHERE $where");
    258                         while ($row = spip_fetch_array($s)){
    259                                 $liste_documents_exclus[$publique][$row['id_document']]=1;
    260                         }*/
    261                         $liste_documents_exclus[$publique] = array_keys($liste_documents_exclus[$publique]);
    262                 }
    263                 return $liste_documents_exclus[$publique];
    264         }
    265         function AccesRestreint_documents_accessibles_where($primary){
    266                 include_spip('base/abstract_sql');
    267                 $liste = AccesRestreint_liste_documents_exclus(_DIR_RESTREINT!="");
    268                 return calcul_mysql_in($primary, join(",",$liste),"NOT");
    269         }
    270 
    271         // fonctions de filtrage syndic
    272         // plus performant a priori : liste des rubriques exclues uniquement
    273         // -> condition NOT IN
    274         function AccesRestreint_liste_syndic_exclus($publique=true, $id_auteur=NULL){
    275                 include_spip('base/abstract_sql');
    276                 static $liste_syndic_exclus=array();
    277                 if (!isset($liste_syndic_exclus[$publique]) || !is_array($liste_syndic_exclus[$publique])){
    278                         $liste_syndic_exclus[$publique] = array();
    279                         $liste_rub = AccesRestreint_liste_rubriques_exclues($publique, $id_auteur);
    280                         $where = calcul_mysql_in('id_rubrique', join(",",$liste_rub));
    281                         $s = spip_query("SELECT id_syndic FROM spip_syndic WHERE $where");
    282                         while ($row = spip_fetch_array($s)){
    283                                 $liste_syndic_exclus[$publique][] = $row['id_syndic'];
    284                         }
    285                 }
    286                 return $liste_syndic_exclus[$publique];
    287         }
    288         function AccesRestreint_syndic_accessibles_where($primary){
    289                 include_spip('base/abstract_sql');
    290                 $liste = AccesRestreint_liste_syndic_exclus(_DIR_RESTREINT!="");
    291                 return calcul_mysql_in($primary, join(",",$liste),"NOT");
    292         }
    293 
    294         // fonctions de filtrage syndic_articles
    295         // plus performant a priori : liste des rubriques exclues uniquement
    296         // -> condition NOT IN
    297         function AccesRestreint_liste_syndic_articles_exclus($publique=true, $id_auteur=NULL){
    298                 include_spip('base/abstract_sql');
    299                 static $liste_syndic_articles_exclus=array();
    300                 if (!isset($liste_syndic_articles_exclus[$publique]) || !is_array($liste_syndic_articles_exclus[$publique])){
    301                         $liste_syndic_articles_exclus[$publique] = array();
    302                         $liste_syn = AccesRestreint_liste_syndic_exclus($publique, $id_auteur);
    303                         $where = calcul_mysql_in('id_syndic', join(",",$liste_syn));
    304                         $s = spip_query("SELECT id_syndic_article FROM spip_syndic_articles WHERE $where");
    305                         while ($row = spip_fetch_array($s)){
    306                                 $liste_syndic_articles_exclus[$publique][] = $row['id_syndic_article'];
    307                         }
    308                 }
    309                 return $liste_syndic_articles_exclus[$publique];
    310         }
    311         function AccesRestreint_syndic_articles_accessibles_where($primary){
    312                 include_spip('base/abstract_sql');
    313                 $liste = AccesRestreint_liste_syndic_articles_exclus(_DIR_RESTREINT!="");
    314                 return calcul_mysql_in($primary, join(",",$liste),"NOT");
    315         }
    316 
    317         // fonctions de filtrage evenements
    318         // plus performant a priori : liste des rubriques exclues uniquement
    319         // -> condition NOT IN
    320         function AccesRestreint_liste_evenements_exclus($publique=true, $id_auteur=NULL){
    321                 include_spip('base/abstract_sql');
    322                 static $liste_evenements_exclus=array();
    323                 if (!isset($liste_evenements_exclus[$publique]) || !is_array($liste_evenements_exclus[$publique])){
    324                         $liste_evenements_exclus[$publique] = array();
    325                         // rattaches aux articles
    326                         $liste_art = AccesRestreint_liste_articles_exclus($publique, $id_auteur);
    327                         $where = calcul_mysql_in('id_article', join(",",$liste_art));
    328                        
    329                         $s = spip_query("SELECT id_evenement FROM spip_evenements WHERE $where");
    330                         while ($row = spip_fetch_array($s)){
    331                                 $liste_evenements_exclus[$publique][] = $row['id_evenement'];
    332                         }
    333                 }
    334                 return $liste_evenements_exclus[$publique];
    335         }
    336         function AccesRestreint_evenements_accessibles_where($primary){
    337                 include_spip('base/abstract_sql');
    338                 $liste = AccesRestreint_liste_evenements_exclus(_DIR_RESTREINT!="");
    339                 return calcul_mysql_in($primary, join(",",$liste),"NOT");
    340         }
    341 
    342 
    343         // filtre de securisation des squelettes
    344         // utilise avec [(#REM|AccesRestreint_securise_squelette)]
    345         // evite divulgation d'info si plugin desactive
    346         // par erreur fatale
    347         function AccesRestreint_securise_squelette($letexte){
    348                 return "";
    349         }
    350        
    351         // filtre de test pour savoir si l'acces a un article est restreint
    352         function AccesRestreint_article_restreint($id_article){
    353                 return
    354                         @in_array($id_article,
    355                                 AccesRestreint_liste_articles_exclus(_DIR_RESTREINT!="")
    356                         );
    357         }
    358         // filtre de test pour savoir si l'acces a une rubrique est restreinte
    359         function AccesRestreint_rubrique_restreinte($id_rubrique){
    360                 return
    361                         @in_array($id_rubrique,
    362                                 AccesRestreint_liste_rubriques_exclues(_DIR_RESTREINT!="")
    363                         );
    364         }
    365 
    366160?>
  • _plugins_/_stable_/acces_restreint/inc/acces_restreint_gestion.php

    r19591 r22632  
    11<?php
    2 
    3 // * Acces restreint, plugin pour SPIP * //
     2/**
     3 * Plugin Acces Restreint 3.0 pour Spip 2.0
     4 * Licence GPL
     5 *
     6 *
     7 */
     8
    49
    510if (!defined("_ECRIRE_INC_VERSION")) return;
  • _plugins_/_stable_/acces_restreint/plugin.xml

    r22349 r22632  
    11<plugin>
    22        <nom> <!-- Nom du plugin -->
    3         <multi>[fr]Acces Restreint 2.0[es]Acceso restringido 2.0[en]Restricted Access</multi>
     3        <multi>[fr]Acces Restreint 3.0[es]Acceso restringido 3.0[en]Restricted Access</multi>
    44        </nom>
    55        <icon>img_pack/zones-acces-48.png</icon>
     
    1212        </multi>
    1313        </auteur>
    14         <version>0.2</version>
     14        <version>0.3</version>
    1515        <version_base>0.3.0.1</version_base>
    16         <etat>
    17         stable
    18         </etat>
     16        <etat>dev</etat>
    1917        <description>
    2018        <multi>
     
    3735        <lien>http://www.spip-contrib.net/Acces-restreint-V1</lien> <!-- URI de documentation -->
    3836        <options>acces_restreint_options.php</options>
    39         <fonctions>acces_restreint.php</fonctions>
    40         <!-- classe d'implementation : espace de nommage qui prefixera les appels de fonction
    41         sur le mode Rien::
    42         ainsi les fonctions hors espace de nommage ne peuvent etre appelees
    43         ce parametre est obligatoire et doit etre non vide
    44         -->
    45         <prefix>
    46         AccesRestreint
    47         </prefix>
     37        <fonctions>acces_restreint_fonctions.php</fonctions>
     38        <fonctions>public/acces_restreint.php</fonctions>
    4839        <install>inc/acces_restreint_install.php</install>
    4940        <!-- Definitions des fonctions qui s'inserent dans les pipelines -->
     41        <prefix>AccesRestreint</prefix>
     42        <pipeline>
     43                <nom>declarer_tables_interfaces</nom>
     44                <inclure>base/acces_restreint.php</inclure>
     45        </pipeline>
     46        <pipeline>
     47                <nom>declarer_tables_principales</nom>
     48                <inclure>base/acces_restreint.php</inclure>
     49        </pipeline>
     50        <pipeline>
     51                <nom>declarer_tables_auxiliaires</nom>
     52                <inclure>base/acces_restreint.php</inclure>
     53        </pipeline>
     54        <pipeline>
     55                <nom>pre_boucle</nom>
     56                <inlcure>public/acces_restreint.php</inclure>
     57        </pipeline>
     58
     59        <pipeline>
     60                <nom>AccesRestreint_liste_zones_autorisees</nom>
     61                <action>liste_zones_autorisees</action>
     62                <inclure>inc/acces_restreint.php</inclure>
     63        </pipeline>
     64       
    5065        <pipeline>
    5166                <nom>ajouter_boutons</nom>
     
    5772                <inclure>acces_restreint_pipelines.php</inclure>
    5873        </pipeline>
    59         <pipeline>
    60                 <nom>AccesRestreint_liste_zones_autorisees</nom>
    61                 <action>liste_zones_autorisees</action>
    62                 <inclure>inc/acces_restreint.php</inclure>
    63         </pipeline>
    64         <necessite id="SPIP" version='[;1.925)' />
     74       
     75        <necessite id="SPIP" version='[2.0.0 dev;]' />
    6576</plugin>
Note: See TracChangeset for help on using the changeset viewer.