Example #1
0
    def process_request(self, req):
        data = {}
        req.perm.require('PROJECT_LIST')

        projects = []

        for project_name in Project.select(self.env):
            project = Project(self.env, project_name)

            # Don't list this environment
            if project.env_path == self.env.path:
                continue

            if project.valid:
                env = project.env

                try:
                    self.log.debug('TracForge: %s', env.path)
                    env_perm = PermissionCache(env, req.authname)
                    #self.log.debug(env_perm.perms)
                    if 'PROJECT_VIEW' in env_perm:
                        projects.append({
                            'name':
                            env.project_name,
                            'description':
                            env.project_description,
                            'href':
                            req.href.projects(project.name),
                        })
                    elif req.perm('tracforge_project', project.name):
                        projects.append({
                            'name':
                            env.project_name,
                            'description':
                            'PROJECT_VIEW permission not granted.',
                        })
                except Exception, e:
                    # Only show errors to admins to prevent excessive disclosure
                    if 'TRACFORGE_ADMIN' in req.perm('tracforge_project',
                                                     project.name):
                        projects.append({
                            'name': env.project_name,
                            'description': e
                        })
                    self.log.debug(
                        'tracforge.dispatch: Unable to load project %s:\n%s',
                        project.name, e)
            else:
                if 'TRACFORGE_ADMIN' in req.perm('tracforge_project',
                                                 project.name):
                    projects.append({
                        'name': project.env_path,
                        'description': project.env.exc,
                    })
                self.log.debug(
                    'tracforge.dispatch: Unable to load project %s:\n%s',
                    project.name, project.env.exc)
Example #2
0
    def render_admin_panel(self, req, cat, page, path_info):
        data = {}
        projects = sorted([(n, Project(self.env, n))
                           for n in Project.select(self.env)])
        projects.insert(0, ('*', Project(self.env, '*')))

        if req.method == 'POST':
            if 'add' in req.args:
                proj = req.args.get('project')
                user = req.args.get('user')
                role = req.args.get('role')
                if proj not in [n for n, p in projects]:
                    raise TracError(_('Invalid project %s'), proj)
                if role not in ('member', 'admin'):
                    raise TracError(_('Invalid role %s'), role)
                Members(self.env, proj)[user] = role
                req.redirect(req.href.admin(cat, page))
            elif 'remove' in req.args:
                db = self.env.get_db_cnx()
                for name, proj in projects:
                    users = req.args.getlist('sel' + name)
                    members = Members(self.env, name, db=db)
                    for user in users:
                        del members[user]
                db.commit()
                req.redirect(req.href.admin(cat, page))

        # projects_data = {}
        # for proj in projects:
        #     projects_data[proj.name] = {
        #         'members': dict(proj.members.iteritems()),
        #         'env_path': proj.env_path, # Need some dummy value to ensure that the headings show up
        #     }
        #
        data['projects'] = projects

        # req.hdf['tracforge.projects.*'] = {
        #     'dummy': 1,
        #     'members': dict(Members(self.env, '*').iteritems()),
        # }
        #req.hdf['tracforge.projects'] = projects_data

        add_stylesheet(req, 'tracforge/css/admin.css')
        return 'admin_tracforge_membership.html', data
Example #3
0
    def match_request(self, req):
        if req.path_info.startswith('/projects/'):
            path_info = req.path_info[10:].lstrip('/')
            if path_info:
                self.log.debug(
                    'TracForgeDispatch: Starting WSGI relaunch for %s (%s)',
                    path_info, req.method)
                self.log.debug('SN = %s PI = %s', req.environ['SCRIPT_NAME'],
                               req.environ['PATH_INFO'])
                project_name = path_info.split('/', 1)[0]
                # Check that we aren't trying to recurse (possible link loop)
                if project_name == os.path.basename(self.env.path):
                    req.redirect(req.href())
                project = Project(self.env, project_name)

                # Assert permissions on the desination environment
                if not project.exists:
                    raise TracError('No such project "%s"', project.name)
                if not project.valid:
                    raise TracError('Project %s is invalid:\n%s', project.name,
                                    project.env.exc)

                # Check that we have permissions in the desired project
                authname = RequestDispatcher(self.env).authenticate(req)
                project_perm = PermissionCache(project.env, authname)
                project_perm.require('PROJECT_LIST')

                start_response = req._start_response
                environ = copy.copy(req.environ)

                # Setup the environment variables
                environ['SCRIPT_NAME'] = req.href.projects(project.name)
                environ['PATH_INFO'] = path_info[len(project.name):]
                environ['trac.env_path'] = project.env_path
                if 'TRAC_ENV' in environ:
                    del environ['TRAC_ENV']
                if 'TRAC_ENV_PARENT_DIR' in environ:
                    del environ['TRAC_ENV_PARENT_DIR']
                if 'trac.env_parent' in environ:
                    del environ['trac.env_parent_dir']
                environ['tracforge_master_link'] = req.href.projects()

                # Remove mod_python options to avoid conflicts
                if 'mod_python.subprocess_env' in environ:
                    del environ['mod_python.subprocess_env']
                if 'mod_python.options' in environ:
                    del environ['mod_python.options']

                req._response = dispatch_request(environ, start_response)
                raise RequestDone