super(ReposController, self)._before(*args, **kwargs)

    def _load_repo(self):

        repo_obj = c.db_repo

        if repo_obj is None:

            h.not_mapped_error(c.repo_name)

            raise HTTPFound(location=url('repos'))

        return repo_obj

    def __load_defaults(self, repo=None):

        top_perms = ['hg.create.repository']

        if HasPermissionAny('hg.create.write_on_repogroup.true')():

            repo_group_perm_level = 'write'

        else:

            repo_group_perm_level = 'admin'

        extras = [] if repo is None else [repo.group]

        c.repo_groups = AvailableRepoGroupChoices(top_perms, repo_group_perm_level, extras)

        c.landing_revs_choices, c.landing_revs = ScmModel().get_repo_landing_revs(repo)

    def __load_data(self):

        """

        Load defaults settings for edit, and update

        """

        c.repo_info = self._load_repo()

        self.__load_defaults(c.repo_info)

        defaults = RepoModel()._get_defaults(c.repo_name)

        defaults['clone_uri'] = c.repo_info.clone_uri_hidden # don't show password

        defaults['permanent_url'] = c.repo_info.clone_url(clone_uri_tmpl=c.clone_uri_tmpl, with_id=True)

        return defaults

    def index(self, format='html'):

        repos_list = RepoList(Repository.query(sorted=True).all(), perm_level='admin')

        # the repo list will be filtered to only show repos where the user has read permissions

        repos_data = RepoModel().get_repos_as_dict(repos_list, admin=True)

        # data used to render the grid

        c.data = repos_data

        return render('admin/repos/repos.html')

    @NotAnonymous()

    def create(self):

        self.__load_defaults()

        try:

            # CanWriteGroup validators checks permissions of this POST

            form_result = RepoForm(repo_groups=c.repo_groups,

                                   landing_revs=c.landing_revs_choices)() \

                            .to_python(dict(request.POST))

        except formencode.Invalid as errors:

            log.info(errors)

            return htmlfill.render(

                render('admin/repos/repo_add.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                force_defaults=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            msg = (_('Error creating repository %s')

                   % form_result.get('repo_name'))

            h.flash(msg, category='error')

            raise HTTPFound(location=url('home'))

        raise HTTPFound(location=h.url('repo_creating_home',

                              repo_name=form_result['repo_name_full'],

                              task_id=task_id))

    @NotAnonymous()

    def create_repository(self):

        self.__load_defaults()

        if not c.repo_groups:

            raise HTTPForbidden

        parent_group = request.GET.get('parent_group')

        ## apply the defaults from defaults page

        defaults = Setting.get_default_repo_settings(strip_prefix=True)

        if parent_group:

            prg = RepoGroup.get(parent_group)

            if prg is None or not any(rgc[0] == prg.group_id

                                      for rgc in c.repo_groups):

                raise HTTPForbidden

            defaults.update({'repo_group': parent_group})

        return htmlfill.render(

            render('admin/repos/repo_add.html'),

            defaults=defaults,

            errors={},

            prefix_error=False,

            encoding="UTF-8",

            force_defaults=False)

    @LoginRequired()

    def repo_creating(self, repo_name):

        c.repo = repo_name

        c.task_id = request.GET.get('task_id')

        if not c.repo:

            raise HTTPNotFound()

        return render('admin/repos/repo_creating.html')

    @LoginRequired()

    @jsonify

    def repo_check(self, repo_name):

        c.repo = repo_name

        task_id = request.GET.get('task_id')