Changeset 7726 in spip-zone


Ignore:
Timestamp:
Dec 2, 2006, 2:52:42 PM (12 years ago)
Author:
cy_altern@…
Message:

oups ! un petit conflit de versions résolu (ça m'apprendra à bosser sur 3 machines différentes à la fois!)

Location:
_plugins_/_stable_/acces_groupes
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/_stable_/acces_groupes/inc/accesgroupes_boucles.php

    r6847 r7726  
    66
    77
     8// {tout_voir} pour afficher toutes les rubriques même les protégées
     9function critere_tout_voir_dist($idb, &$boucles, $crit) {
     10        $boucle = &$boucles[$idb];
     11        $boucle->modificateur['tout_voir'] = true;
     12}
     13
     14
    815// <BOUCLE(ARTICLES)>
    916  function boucle_ARTICLES($id_boucle, &$boucles) {
     
    1118                $id_table = $boucle->id_table;
    1219       
    13                 $t = $boucle->id_table . '.' . $boucle->primary;
    14                 if (!in_array($t, $boucles[$id_boucle]->select))
    15                   $boucle->select[]= $t; # pour postgres, neuneu ici
    16        
    17                 $boucle->hash = '
    18                 // ACCES RESTREINT
    19                 $acces_where = accesgroupes_articles_accessibles_where("'.$t.'");
    20                 ' . $boucle->hash ;
    21        
    22                 // et le filtrage d'acces filtre !
    23                 $boucle->where[] = '$acces_where';
     20                if (!isset($boucle->modificateur['tout_voir'])){
     21                                        $t = $boucle->id_table . '.' . $boucle->primary;
     22                if (!in_array($t, $boucles[$id_boucle]->select))
     23                  $boucle->select[]= $t; # pour postgres, neuneu ici
     24           
     25                $boucle->hash = '
     26                // ACCES RESTREINT
     27                $acces_where = accesgroupes_articles_accessibles_where("'.$t.'");
     28                ' . $boucle->hash ;
     29           
     30                // et le filtrage d'acces filtre !
     31                $boucle->where[] = '$acces_where';
     32                                        }
    2433       
    2534                return boucle_ARTICLES_dist($id_boucle, $boucles);
     
    3140                $id_table = $boucle->id_table;
    3241       
    33                 $t = $boucle->id_table . '.' . $boucle->primary;
    34                 if (!in_array($t, $boucles[$id_boucle]->select))
    35                   $boucle->select[]= $t; # pour postgres, neuneu ici
    36        
    37                 $boucle->hash = '
    38                 // ACCES RESTREINT
    39                 $acces_where = accesgroupes_breves_accessibles_where("'.$t.'");
    40                 ' . $boucle->hash ;
    41        
    42                 // et le filtrage d'acces filtre !
    43                 $boucle->where[] = '$acces_where';
     42                if (!isset($boucle->modificateur['tout_voir'])){
     43                                        $t = $boucle->id_table . '.' . $boucle->primary;
     44                if (!in_array($t, $boucles[$id_boucle]->select))
     45                  $boucle->select[]= $t; # pour postgres, neuneu ici
     46           
     47                $boucle->hash = '
     48                // ACCES RESTREINT
     49                $acces_where = accesgroupes_breves_accessibles_where("'.$t.'");
     50                ' . $boucle->hash ;
     51           
     52                // et le filtrage d'acces filtre !
     53                $boucle->where[] = '$acces_where';
     54                                        }
    4455       
    4556                return boucle_BREVES_dist($id_boucle, $boucles);
     
    5061                $boucle = &$boucles[$id_boucle];
    5162                $id_table = $boucle->id_table;
    52                 $t = $boucle->id_table . '.' . $boucle->primary;
    53                 if (!in_array($t, $boucles[$id_boucle]->select))
    54                   $boucle->select[]= $t; # pour postgres, neuneu ici
    55        
    56                 $boucle->hash = '
    57                 // ACCES RESTREINT
    58                 $acces_where = accesgroupes_forums_accessibles_where("'.$t.'");
    59                 ' . $boucle->hash ;
    60        
    61                 // et le filtrage d'acces filtre !
    62                 $boucle->where[] = '$acces_where';
     63                                       
     64                                        if (!isset($boucle->modificateur['tout_voir'])){
     65                $t = $boucle->id_table . '.' . $boucle->primary;
     66                if (!in_array($t, $boucles[$id_boucle]->select))
     67                  $boucle->select[]= $t; # pour postgres, neuneu ici
     68           
     69                $boucle->hash = '
     70                // ACCES RESTREINT
     71                $acces_where = accesgroupes_forums_accessibles_where("'.$t.'");
     72                ' . $boucle->hash ;
     73           
     74                // et le filtrage d'acces filtre !
     75                $boucle->where[] = '$acces_where';
     76                                        }
    6377       
    6478                return boucle_FORUMS_dist($id_boucle, $boucles);
     
    6983                $boucle = &$boucles[$id_boucle];
    7084                $id_table = $boucle->id_table;
    71                 $t = $boucle->id_table . '.' . $boucle->primary;
    72                 if (!in_array($t, $boucles[$id_boucle]->select))
    73                   $boucle->select[]= $t; # pour postgres, neuneu ici
    74        
    75                 $boucle->hash = '
    76                 // ACCES RESTREINT
    77                 $acces_where = accesgroupes_signatures_accessibles_where("'.$t.'");
    78                 ' . $boucle->hash ;
    79        
    80                 // et le filtrage d'acces filtre !
    81                 $boucle->where[] = '$acces_where';
     85                                       
     86                                        if (!isset($boucle->modificateur['tout_voir'])){
     87                $t = $boucle->id_table . '.' . $boucle->primary;
     88                if (!in_array($t, $boucles[$id_boucle]->select))
     89                  $boucle->select[]= $t; # pour postgres, neuneu ici
     90           
     91                $boucle->hash = '
     92                // ACCES RESTREINT
     93                $acces_where = accesgroupes_signatures_accessibles_where("'.$t.'");
     94                ' . $boucle->hash ;
     95           
     96                // et le filtrage d'acces filtre !
     97                $boucle->where[] = '$acces_where';
     98                                        }
    8299       
    83100                return boucle_SIGNATURES_dist($id_boucle, $boucles);
     
    88105                $boucle = &$boucles[$id_boucle];
    89106                $id_table = $boucle->id_table;
    90                 $t = $boucle->id_table . '.' . $boucle->primary;
    91                 if (!in_array($t, $boucles[$id_boucle]->select))
    92                   $boucle->select[]= $t; # pour postgres, neuneu ici
    93        
    94                 $boucle->hash = '
    95                 // ACCES RESTREINT
    96                 $acces_where = accesgroupes_documents_accessibles_where("'.$t.'");
    97                 ' . $boucle->hash ;
    98        
    99                 // et le filtrage d'acces filtre !
    100                 $boucle->where[] = '$acces_where';
     107               
     108                                        if (!isset($boucle->modificateur['tout_voir'])){
     109                                        $t = $boucle->id_table . '.' . $boucle->primary;
     110                if (!in_array($t, $boucles[$id_boucle]->select))
     111                  $boucle->select[]= $t; # pour postgres, neuneu ici
     112           
     113                $boucle->hash = '
     114                // ACCES RESTREINT
     115                $acces_where = accesgroupes_documents_accessibles_where("'.$t.'");
     116                ' . $boucle->hash ;
     117           
     118                // et le filtrage d'acces filtre !
     119                $boucle->where[] = '$acces_where';
     120                                        }
    101121       
    102122                return boucle_DOCUMENTS_dist($id_boucle, $boucles);
     
    108128                $id_table = $boucle->id_table;
    109129       
    110                 $t = $boucle->id_table . '.' . $boucle->primary;
    111                 if (!in_array($t, $boucles[$id_boucle]->select))
    112                   $boucle->select[]= $t; # pour postgres, neuneu ici
    113                 $boucle->hash = '
    114                 // ACCES RESTREINT
    115                 $acces_where = accesgroupes_rubriques_accessibles_where("'.$t.'");
    116                 ' . $boucle->hash ;
    117        
    118                 // et le filtrage d'acces filtre !
    119                 $boucle->where[] = '$acces_where';
     130                if (!isset($boucle->modificateur['tout_voir'])){
     131                                        $t = $boucle->id_table . '.' . $boucle->primary;
     132                if (!in_array($t, $boucles[$id_boucle]->select))
     133                  $boucle->select[]= $t; # pour postgres, neuneu ici
     134                $boucle->hash = '
     135                // ACCES RESTREINT
     136                $acces_where = accesgroupes_rubriques_accessibles_where("'.$t.'");
     137                ' . $boucle->hash ;
     138           
     139                // et le filtrage d'acces filtre !
     140                $boucle->where[] = '$acces_where';
     141                                        }
    120142       
    121143                return boucle_RUBRIQUES_dist($id_boucle, $boucles);
     
    127149                $id_table = $boucle->id_table;
    128150       
    129                 $t = $boucle->id_table . '.' . $boucle->primary;
    130                 if (!in_array($t, $boucles[$id_boucle]->select))
    131                   $boucle->select[]= $t; # pour postgres, neuneu ici
    132        
    133                 $boucle->hash = '
    134                 // ACCES RESTREINT
    135                 $acces_where = accesgroupes_rubriques_accessibles_where("'.$t.'");
    136                 ' . $boucle->hash ;
    137        
    138                 // et le filtrage d'acces filtre !
    139                 $boucle->where[] = '$acces_where';
     151                if (!isset($boucle->modificateur['tout_voir'])){
     152                                        $t = $boucle->id_table . '.' . $boucle->primary;
     153                if (!in_array($t, $boucles[$id_boucle]->select))
     154                  $boucle->select[]= $t; # pour postgres, neuneu ici
     155           
     156                $boucle->hash = '
     157                // ACCES RESTREINT
     158                $acces_where = accesgroupes_rubriques_accessibles_where("'.$t.'");
     159                ' . $boucle->hash ;
     160           
     161                // et le filtrage d'acces filtre !
     162                $boucle->where[] = '$acces_where';
     163                                        }
    140164       
    141165                return boucle_HIERARCHIE_dist($id_boucle, $boucles);
     
    146170                $boucle = &$boucles[$id_boucle];
    147171                $id_table = $boucle->id_table;
    148                 $t = $boucle->id_table . '.' . $boucle->primary;
    149                 if (!in_array($t, $boucles[$id_boucle]->select))
    150                   $boucle->select[]= $t; # pour postgres, neuneu ici
    151        
    152                 $boucle->hash = '
    153                 // ACCES RESTREINT
    154                 $acces_where = accesgroupes_syndics_accessibles_where("'.$t.'");
    155                 ' . $boucle->hash ;
    156        
    157                 // et le filtrage d'acces filtre !
    158                 $boucle->where[] = '$acces_where';
     172                                       
     173                                        if (!isset($boucle->modificateur['tout_voir'])){
     174                $t = $boucle->id_table . '.' . $boucle->primary;
     175                if (!in_array($t, $boucles[$id_boucle]->select))
     176                  $boucle->select[]= $t; # pour postgres, neuneu ici
     177           
     178                $boucle->hash = '
     179                // ACCES RESTREINT
     180                $acces_where = accesgroupes_syndics_accessibles_where("'.$t.'");
     181                ' . $boucle->hash ;
     182           
     183                // et le filtrage d'acces filtre !
     184                $boucle->where[] = '$acces_where';
     185                                        }
    159186       
    160187                return boucle_SYNDICATION_dist($id_boucle, $boucles);
     
    165192                $boucle = &$boucles[$id_boucle];
    166193                $id_table = $boucle->id_table;
    167                 $t = $boucle->id_table . '.' . $boucle->primary;
    168                 if (!in_array($t, $boucles[$id_boucle]->select))
    169                   $boucle->select[]= $t; # pour postgres, neuneu ici
    170        
    171                 $boucle->hash = '
    172                 // ACCES RESTREINT
    173                 $acces_where = accesgroupes_syndic_articles_accessibles_where("'.$t.'");
    174                 ' . $boucle->hash ;
    175        
    176                 // et le filtrage d'acces filtre !
    177                 $boucle->where[] = '$acces_where';
     194                                       
     195                                        if (!isset($boucle->modificateur['tout_voir'])){
     196                $t = $boucle->id_table . '.' . $boucle->primary;
     197                if (!in_array($t, $boucles[$id_boucle]->select))
     198                  $boucle->select[]= $t; # pour postgres, neuneu ici
     199           
     200                $boucle->hash = '
     201                // ACCES RESTREINT
     202                $acces_where = accesgroupes_syndic_articles_accessibles_where("'.$t.'");
     203                ' . $boucle->hash ;
     204           
     205                // et le filtrage d'acces filtre !
     206                $boucle->where[] = '$acces_where';
     207                                        }
    178208       
    179209                return boucle_SYNDIC_ARTICLES_dist($id_boucle, $boucles);
  • _plugins_/_stable_/acces_groupes/inc/accesgroupes_options.php

    r7494 r7726  
    140140
    141141*************************** FIN OLD */
     142
     143// le filtre qui permet d'ajouter une img aux #TITRE des rubriques/articles/breves à accès restreint
     144function accesgroupes_visualise($texte, $id_rub = 0, $image = 'ecrire/img_pack/cadenas-24.gif') {
     145//echo '_DIR_SQUELETTE = '._DIR_SQUELETTE;               
     146                                 if (accesgroupes_verif_acces($id_rub, 'public') == 1 OR accesgroupes_verif_acces($id_rub, 'public') == 2) {
     147                                                return "<img src=\"".$image."\" alt=\""._T('accesgroupes:bloque_rubrique')."\" style=\"border: none; vertical-align: baseline;\"> ".$texte;
     148                                 }
     149                                 else {
     150                                                        return $texte;
     151                                 }
     152}
     153
    142154
    143155
  • _plugins_/_stable_/acces_groupes/plugin.xml

    r7494 r7726  
    88        </auteur>
    99        <version>
    10           1.0.1
     10          1.0.2
    1111        </version>
    1212        <etat>
     
    2222                                        version 0.61 ou 0.7, vous {{DEVEZ}} proc&eacute;der &agrave; la mise &agrave; jour des tables de la base de donn&eacute;es
    2323                                        en utilisant le script [->../plugins/acces_groupes/maj_tables.php] {{AVANT}} d'activer ce plugin !
    24                                        
    25                                         v 1.0.1 : support de exec=articles_versions pour le filtrage de l'espace privé
    2624                                        <br />
    27                                         Ce plugin est compatible avec les versions <strong>1.9.0</strong> et <strong>1.9.1</strong> de spip. Il n’est <strong>pas compatible</strong> avec la version SVN spip 1.9.2 alpha.
     25                                        v 1.0.1 : support de exec=articles_versions pour le filtrage de l'espace priv&eacute;
     26                                        <br />
     27                                        v 1.0.2 : impl&eacute;mentation du crit&egrave;re {{tout_voir}} et du filtre {{accesgroupes_visualise}}
     28                                        pour afficher les contenus restreints aux utilisateurs n'ayant pas acc&egrave;s dans les squelettes
     29                                        <br />
     30                                        Ce plugin est compatible avec les versions <strong>1.9.0</strong> et <strong>1.9.1</strong> de spip.
     31                                        Il n’est <strong>pas compatible</strong> avec la version SVN spip 1.9.2 alpha.
    2832        </description>
    2933        <lien>http://www.spip-contrib.net/Creer-des-groupes-limiter-l-acces</lien> <!-- URI de documentation -->
Note: See TracChangeset for help on using the changeset viewer.