Ticket #2612: revisedPatch.diff

File revisedPatch.diff, 16.3 kB (added by gkruse@gmail.com, 10 months ago)

Fixed r/w checkboxes

  • svnauthz/model.py

    old new  
    131131         
    132132    def serialize(self): 
    133133        ret=""+ self.member.__str__() + " = " 
     134 
    134135        if (self.r): 
    135136            ret +="r" 
    136137        if (self.w): 

  • svnauthz/admin_ui.py

    old new  
    1  
     1import pkg_resources 
    22from trac.core import * 
    33from trac.perm import PermissionSystem 
    44 
    5 from trac.util import sorted 
     5from trac.util import get_pkginfo, get_module_path, sorted 
    66from trac.config import Option 
    7 from webadmin.web_ui import IAdminPageProvider 
     7from trac.admin.api import IAdminPanelProvider 
    88 
    99from model import * 
    1010from io import * 
    11 from acct_mgr.api import AccountManager 
    1211from trac.web.chrome import ITemplateProvider 
    1312 
    1413from urllib import pathname2url, url2pathname 
    …… 
    2322 
    2423 
    2524class SvnAuthzAdminPage(Component): 
     25    implements(IAdminPanelProvider, ITemplateProvider) 
    2626 
    27     implements(IAdminPageProvider, ITemplateProvider) 
    28  
    2927    def __init__(self): 
    3028        self.authz_file = self.env.config.get("trac", "authz_file") 
    3129        self.authz_module = self.env.config.get("trac", "authz_module_name") 
    3230        if self.authz_module != None and self.authz_module.strip() == "": 
    3331            self.authz_module = None 
    34         self.account_manager = AccountManager(self.env) 
     32     
    3533 
    36     # IAdminPageProvider 
    37     def get_admin_pages(self, req): 
     34    # ITemplateProvider methods 
     35    def get_htdocs_dirs(self): 
     36        return [] 
     37 
     38    def get_templates_dirs(self): 
     39        return [pkg_resources.resource_filename('svnauthz', 'templates')] 
     40 
     41    # IAdminPanelProvider 
     42    def get_admin_panels(self, req): 
    3843        if req.perm.has_permission('TRAC_ADMIN'): 
    3944            yield ('subversion', 'Subversion', 'svnauthz', 'Subversion Access') 
    4045 
    41     def process_admin_request(self, req, cat, page, path_info): 
     46    def render_admin_panel(self, req, cat, page, path_info): 
     47        data = {} 
    4248        perm = PermissionSystem(self.env) 
    4349        self.env.log.debug("SvnAuthzAdminPlugin: cat=%s page=%s path_info=%s" 
    4450                           % (cat, page, path_info)) 
    4551        self.authz = self._get_model(); 
    4652        if req.method == 'POST': 
    4753           if req.args.get('addgroup'): 
    48                self._add_group(req) 
     54               data.update(self._add_group(req)) 
    4955           elif req.args.get('addpath'): 
    50                self._add_path(req) 
     56               data.update(self._add_path(req)) 
    5157           elif req.args.get('addgroupmember'): 
    52                self._add_group_member(req) 
     58               data.update(self._add_group_member(req)) 
    5359           elif req.args.get('removegroupmembers'): 
    54                self._del_group_member(req) 
     60               data.update(self._del_group_member(req)) 
    5561           elif req.args.get('removegroups'): 
    56                self._del_groups(req) 
     62               data.update(self._del_groups(req)) 
    5763           elif req.args.get('removepaths'): 
    58                self._del_paths(req) 
     64               data.update(self._del_paths(req)) 
    5965           elif req.args.get('addpathmember'): 
    60                self._add_path_member(req) 
     66               data.update(self._add_path_member(req)) 
    6167           elif req.args.get('changepathmembers'): 
    62                self._change_path_members(req) 
     68               data.update(self._change_path_members(req)) 
    6369         
    6470        # Handle group and path edit mode handling 
    6571        editgroup = None 
    6672        editpath = None                
    6773        if path_info and path_info.startswith("editgroup/"): 
    68             editgroup = self._edit_group(req, cat, page, path_info) 
     74            editgroup, d = self._edit_group(req, cat, page, path_info) 
     75            data.update(d) 
    6976        elif path_info and path_info.startswith("editpath/"): 
    70             editpath = self._edit_path(req, cat, page, path_info) 
     77            editpath, d = self._edit_path(req, cat, page, path_info) 
     78            data.update(d) 
     79        print data 
    7180 
    7281        paths_disp = [] 
    7382        for repository, path in [(p.get_repo(), p.get_path()) for p in self.authz.get_paths()]: 
    …… 
    8594                                'url' : path_disp_url, 
    8695                                'href': path_disp_href 
    8796                                }) 
    88         req.hdf['paths'] = sorted(paths_disp) 
     97        data['paths'] = sorted(paths_disp) 
    8998         
    9099        groups_disp = [] 
    91100        for group_disp in sorted([g.get_name() for g in self.authz.get_groups()]): 
    …… 
    100109                                 'url': group_disp_url, 
    101110                                 'href': group_disp_href 
    102111                                }) 
    103         req.hdf['groups'] = groups_disp 
     112        data['groups'] = groups_disp 
    104113 
    105114        self._persist_model(self.authz) 
    106115 
    107         return 'admin_authz.cs', None 
     116        return 'admin_authz.html',data  
    108117  
    109     # ITemplateProvider 
    110      
    111     def get_htdocs_dirs(self): 
    112         """Return the absolute path of a directory containing additional 
    113         static resources (such as images, style sheets, etc). 
    114         """ 
    115         return [] 
    116  
    117     def get_templates_dirs(self): 
    118         """Return the absolute path of the directory containing the provided 
    119         ClearSilver templates. 
    120         """ 
    121         from pkg_resources import resource_filename 
    122         return [resource_filename(__name__, 'templates')] 
    123  
    124118    def _add_group(self, req): 
    125119        groupname = req.args.get('groupname') 
    126120        try: 
    127121            self.authz.add_group(Group(groupname, [])) 
     122            return {} 
    128123        except Exception, e: 
    129             req.hdf['addgroup.error'] = e 
     124            return {'addgroup_error' : e} 
    130125         
    131126    def _del_groups(self, req): 
    132127        groups_to_del = req.args.get('selgroup') 
    …… 
    137132                for group in groups_to_del: 
    138133                    self.authz.del_group(url2pathname(group)) 
    139134            else: 
    140                 req.hdf['delgroup.error'] = "Invalid type of group selection"     
     135                return {'delgroup_error' : "Invalid type of group selection"}  
    141136        except Exception, e: 
    142             req.hdf['delgroup.error'] = e 
     137            return {'delgroup_error' : e } 
     138        return {} 
    143139     
    144140    def _del_paths(self, req): 
    145141        paths_to_del = req.args.get('selpath') 
    …… 
    152148                if validpath: 
    153149                    self.authz.del_path(validpath[1], self.authz_module) 
    154150        except Exception, e: 
    155             req.hdf['delpath.error'] = e 
     151            return {'delpath_error' : e } 
    156152 
    157      
     153        return {}  
    158154    def _add_path(self, req): 
    159155        path = req.args.get('path') 
    160156        repository = None 
    161157        try: 
    162158            self.authz.add_path(Path(path, [], self.authz_module)) 
     159            return {} 
    163160        except Exception, e: 
    164             req.hdf['addpath.error'] = e 
     161            return {'addpath_error' :  e} 
    165162 
    166163    def _add_group_member(self, req): 
    167164        editgroup = url2pathname(req.args.get('editgroup')) 
    168165        subject = req.args.get('subject') 
    169166        group = self.authz.find_group(editgroup) 
    170167        if (group == None): 
    171             req.hdf['addgroupmember.error'] = "Group %s does not exist" % editgroup 
    172             return 
     168            return {'addgroupmember_error': "Group %s does not exist" % editgroup } 
    173169        try: 
    174170            member = self._get_member(subject) 
    175171            assert (member != None) 
    176172            group.append(member) 
    177173        except Exception, e: 
    178             req.hdf['addgroupmember.error'] = e 
     174            return {'addgroupmember_error':e}  
     175        return {} 
    179176 
    180177    def _add_path_member(self, req): 
    181178        editpath = url2pathname(req.args.get('editpath')) 
    …… 
    184181        paths = [(p.get_repo(), p.get_path()) for p in self.authz.get_paths()] 
    185182        validpath = self._get_valid_path(paths, editpath) 
    186183        if not validpath: 
    187             req.hdf['changepathmember.error'] = "Not a valid path: %s" % editpath 
    188             return 
     184            return {'changepathmember_error' : "Not a valid path: %s" % editpath} 
    189185        path = validpath[1]         
    190186        path_members = self.authz.find_path(path, self.authz_module) 
    191187         
    …… 
    208204            assert (s != None) 
    209205            path_members.append(PathAcl(s, read, write)) 
    210206        except Exception, e: 
    211             req.hdf['addpathmember.error'] = e 
     207            return {'addpathmember_error' : e } 
     208        return {} 
    212209 
    213210     
    214211    def _del_group_member(self, req): 
    …… 
    216213        members_to_del = req.args.get('selgroupmember') 
    217214        group = self.authz.find_group(editgroup) 
    218215        if not group: 
    219             req.hdf['delgroupmember.error'] = "Group %s does not exist" % editgroup 
    220             return         
     216            return {'delgroupmember_error': "Group %s does not exist" % editgroup } 
    221217        try: 
    222218            if isinstance(members_to_del, types.StringTypes): 
    223219                group.remove(self._get_member(members_to_del)) 
    …… 
    225221                for member in members_to_del: 
    226222                    group.remove(self._get_member(member)) 
    227223            else: 
    228                 req.hdf['delgroupmember.error'] = "Wrong type of selection" 
     224                return {'delgroupmember_error': "Wrong type of selection" } 
    229225        except Exception, e: 
    230             req.hdf['delgroupmember.error'] = e 
     226            return {'delgroupmember_error': e} 
    231227 
     228        return {} 
     229 
    232230    def _change_path_members(self, req): 
    233231        editpath = url2pathname(req.args.get('editpath')) 
    234232        paths = [(p.get_repo(), p.get_path()) for p in self.authz.get_paths()] 
    235233        validpath = self._get_valid_path(paths, editpath) 
    236234        if not validpath: 
    237             req.hdf['changepathmember.error'] = "Not a valid path: %s" % editpath 
    238             return 
     235            return {'changepathmember_error' : "Not a valid path: %s" % editpath } 
    239236        path = validpath[1] 
    240237        members_to_del = req.args.get('selpathmember') 
    241238        member_acls = req.args.get('selpathmember_acl') 
    …… 
    243240         
    244241        if len(path_members) == 0: 
    245242            # Nothing to do 
    246             return 
     243            return {} 
    247244         
    248245        try: 
    249246            if members_to_del != None: 
    250247                if isinstance(members_to_del, types.StringTypes): 
    251248                    members_to_del = [members_to_del] 
    252249                if not isinstance(members_to_del, types.ListType): 
    253                     req.hdf['changepathmember.error'] = "Wrong type of member selection" 
    254                     return 
     250                    return {'changepathmember_error':  "Wrong type of member selection"} 
    255251                for member in members_to_del: 
    256252                    path_members.remove(path_members.find_path_member(self._get_member(member))) 
    257253        except Exception, e: 
    258             req.hdf['changepathmember.error'] = e 
    259             return 
     254            return {'changepathmember_error': e} 
    260255         
    261256        if member_acls == None: 
    262257            member_acls = "" 
    …… 
    277272                    member.set_read(read) 
    278273                    member.set_write(write) 
    279274        except Exception, e: 
    280             req.hdf['changepathmember.error'] = e 
     275            return {'changepathmember_error':e} 
     276        return {} 
    281277     
    282278    def _edit_group(self, req, cat, page, path_info): 
    283279        """ 
    284280            Populates the editgroup.* parts of the hdf 
    285281            @return the value of editgroup.url or None 
    286282        """ 
     283        data = {} 
    287284        editgroup = url2pathname(path_info[path_info.index('/')+1:len(path_info)])             
    288285        group = self.authz.find_group(editgroup) 
     286        print group 
    289287        if group != None: 
    290             req.hdf['editgroup.name'] = editgroup 
    291             req.hdf['editgroup.url'] = pathname2url(editgroup) 
    292             req.hdf['editgroup.members'] = [m.__str__() for m in group] 
     288            data['editgroup_name'] = editgroup 
     289            data['editgroup_url'] = pathname2url(editgroup) 
     290            data['editgroup_members'] = [m.__str__() for m in group] 
    293291             
    294292            # Populate member candidates 
    295293            not_in_list = [m.__str__() for m in group] 
    296294            not_in_list.append("@%s" % editgroup) 
    297295            candidates = self._get_candidate_subjects(not_in_list) 
    298296            if candidates != []: 
    299                 req.hdf['editgroup.candidates'] = candidates 
    300             return req.hdf['editgroup.url'] 
    301         return None 
     297                data['editgroup_candidates'] = candidates 
     298            return data['editgroup_url'], data 
     299        self.env.log.debug("SvnAdminAuthz: Group %s not found." % editgroup) 
     300        return None, {}  
    302301 
     302    def _get_all_users(self): 
     303      """ 
     304      Fetches all users/groups from PermissionSystem 
     305      """ 
     306      perm = PermissionSystem(self.env) 
     307      users = ["*"] 
     308      data = perm.get_all_permissions() 
     309      if not data: 
     310        return [] # we abort here 
     311 
     312      for (subject, action) in data: 
     313        if subject not in users and subject not in ["anonymous", "authenticated"]: 
     314          users.append(subject) 
     315      return users       
     316 
    303317    def _get_candidate_subjects(self, not_in_list = []): 
    304318        candidates = [] 
    305         users = [user for user in self.account_manager.get_users()  
     319        users = [user for user in self._get_all_users()  
    306320                 if user not in not_in_list] 
    307321        candidates += sorted(users) 
    308322        candidates += sorted([group.__str__() for group in self.authz.get_groups()  
    309323                              if group.__str__() not in not_in_list]) 
    310         self.env.log.debug("Candidates:") 
    311         for c in candidates: 
    312             self.env.log.debug("   %s" % c)              
     324        #self.env.log.debug("Candidates:") 
     325        #for c in candidates: 
     326        #    self.env.log.debug("   %s" % c)              
    313327        return candidates 
    314328     
    315329    def _edit_path(self, req, cat, page, path_info): 
    …… 
    317331            Populates the editpath.* parts of the hdf 
    318332            @return the value of editgroup.url or None 
    319333        """ 
     334        data = {} 
    320335        editpath = url2pathname(path_info[path_info.index('/')+1:len(path_info)])             
    321336        paths = [(p.get_repo(), p.get_path()) for p in self.authz.get_paths()] 
    322337        validpath = self._get_valid_path(paths, editpath) 
    323338        if validpath: 
    324             req.hdf['editpath.name'] = self._get_disp_path_name(validpath[0], validpath[1]) 
    325             req.hdf['editpath.url'] = pathname2url(editpath) 
     339            data['editpath_name'] = self._get_disp_path_name(validpath[0], validpath[1]) 
     340            data['editpath_url'] = pathname2url(editpath) 
    326341            pathmembers = self.authz.find_path(validpath[1], validpath[0]) 
    327342            editpath_members = [] 
    328343            for member in pathmembers: 
    …… 
    335350                editpath_members.append({'subject' : member.get_member().__str__(), 
    336351                                         'read' : read, 
    337352                                         'write' : write}) 
    338             req.hdf['editpath.members'] = editpath_members  
     353            data['editpath_members'] = editpath_members  
    339354             
    340355            # Populate member candidates 
    341356            not_in_list = [m.get_member().__str__() for m in pathmembers] 
    342357            candidates = self._get_candidate_subjects(not_in_list) 
    343358            if candidates != []: 
    344                 req.hdf['editpath.candidates'] = candidates 
    345             return req.hdf['editpath.url'] 
    346         return None 
     359               data['editpath_candidates'] = candidates 
     360            return data['editpath_url'], data 
     361        return None, {}  
    347362 
    348363    def _get_valid_path(self, pathlist, path): 
    349364        for repository, pathname in pathlist: 

  • setup.py

    old new  
    33from setuptools import setup, find_packages 
    44 
    55PACKAGE = 'SvnAuthzAdminPlugin' 
    6 VERSION = '0.1' 
     6VERSION = '0.1.2 (Moved to Trac 0.11)' 
    77 
    88setup(  name=PACKAGE, version=VERSION, 
    99        author = 'Gergely Kis', 
    …… 
    1515        package_dir = { 'svnauthz' : 'svnauthz',  
    1616                        'svnauthz_test' : 'svnauthz_test' }, 
    1717        packages = ['svnauthz', 'svnauthz_test' ], 
    18         package_data = { 'svnauthz' : ['templates/*.cs', ]}, 
     18        package_data = { 'svnauthz' : ['templates/*', ]}, 
    1919        entry_points = {'trac.plugins': ['svnauthz.admin_ui = svnauthz.admin_ui', 
    20                                          'svnauthz.SvnAuthzFile = svnauthz.SvnAuthzFile']}, 
    21         install_requires = ['TracWebAdmin', 'TracAccountManager'] 
     20#                                        'svnauthz.SvnAuthzFile = svnauthz.SvnAuthzFile' 
     21                                         ]}, 
     22        zip_safe = False, 
     23        install_requires = [] 
    2224)