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

            defaults=defaults,

            errors={},

            prefix_error=False,

            encoding="UTF-8",

            force_defaults=False)

    @LoginRequired()

    @NotAnonymous()

    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()

    @NotAnonymous()

    @jsonify

    def repo_check(self, repo_name):

        c.repo = repo_name

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

        if task_id and task_id not in ['None']:

            from kallithea import CELERY_ON

            from celery.result import AsyncResult

            if CELERY_ON:

                task = AsyncResult(task_id)

                if task.failed():

                    raise HTTPInternalServerError(task.traceback)

        repo = Repository.get_by_repo_name(repo_name)

        if repo and repo.repo_state == Repository.STATE_CREATED:

            if repo.clone_uri:

                clone_uri = repo.clone_uri_hidden

                h.flash(_('Created repository %s from %s')

                        % (repo.repo_name, clone_uri), category='success')

            else:

                repo_url = h.link_to(repo.repo_name,

                                     h.url('summary_home',

                                           repo_name=repo.repo_name))

                fork = repo.fork

                if fork:

                    fork_name = fork.repo_name

                    h.flash(h.literal(_('Forked repository %s as %s')

                            % (fork_name, repo_url)), category='success')

                else:

                    h.flash(h.literal(_('Created repository %s') % repo_url),

                            category='success')

            return {'result': True}

        return {'result': False}

    @HasRepoPermissionAllDecorator('repository.admin')

    def update(self, repo_name):

        """

        PUT /repos/repo_name: Update an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="PUT" />

        # Or using helpers:

        #    h.form(url('repo', repo_name=ID),

        #           method='put')

        # url('repo', repo_name=ID)

        c.repo_info = self._load_repo(repo_name)

        c.active = 'settings'

        c.repo_fields = RepositoryField.query()\

            .filter(RepositoryField.repository == c.repo_info).all()

        self.__load_defaults(c.repo_info)

        repo_model = RepoModel()

        changed_name = repo_name

        #override the choices with extracted revisions !

        choices, c.landing_revs = ScmModel().get_repo_landing_revs(repo_name)

        c.landing_revs_choices = choices

        repo = Repository.get_by_repo_name(repo_name)

        old_data = {

            'repo_name': repo_name,

            'repo_group': repo.group.get_dict() if repo.group else {},

            'repo_type': repo.repo_type,

        }

        _form = RepoForm(edit=True, old_data=old_data,

                         repo_groups=c.repo_groups_choices,

                         landing_revs=c.landing_revs_choices)()

        try:

            form_result = _form.to_python(dict(request.POST))

            repo = repo_model.update(repo_name, **form_result)

            ScmModel().mark_for_invalidation(repo_name)

            h.flash(_('Repository %s updated successfully') % repo_name,

                    category='success')

            changed_name = repo.repo_name

            action_logger(self.authuser, 'admin_updated_repo',

                              changed_name, self.ip_addr, self.sa)

            Session().commit()

        except formencode.Invalid, errors:

            defaults = self.__load_data(repo_name)

            defaults.update(errors.value)

            return htmlfill.render(

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

                defaults=defaults,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8",

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('Error occurred during update of repository %s') \

                    % repo_name, category='error')

        return redirect(url('edit_repo', repo_name=changed_name))

    @HasRepoPermissionAllDecorator('repository.admin')

    def delete(self, repo_name):

        """

        DELETE /repos/repo_name: Delete an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="DELETE" />

        # Or using helpers:

        #    h.form(url('repo', repo_name=ID),

        #           method='delete')

        # url('repo', repo_name=ID)

        repo_model = RepoModel()

        repo = repo_model.get_by_repo_name(repo_name)

        if not repo:

            h.not_mapped_error(repo_name)

            return redirect(url('repos'))

        try:

            _forks = repo.forks.count()

            handle_forks = None

            if _forks and request.POST.get('forks'):

                do = request.POST['forks']

                if do == 'detach_forks':

                    handle_forks = 'detach'

                    h.flash(_('Detached %s forks') % _forks, category='success')

                elif do == 'delete_forks':

                    handle_forks = 'delete'

                    h.flash(_('Deleted %s forks') % _forks, category='success')

            repo_model.delete(repo, forks=handle_forks)

            action_logger(self.authuser, 'admin_deleted_repo',

                  repo_name, self.ip_addr, self.sa)

            ScmModel().mark_for_invalidation(repo_name)

            h.flash(_('Deleted repository %s') % repo_name, category='success')

            Session().commit()

        except AttachedForksError:

            h.flash(_('Cannot delete %s it still contains attached forks')

                        % repo_name, category='warning')

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during deletion of %s') % repo_name,

                    category='error')

        if repo.group:

            return redirect(url('repos_group_home', group_name=repo.group.group_name))

        return redirect(url('repos'))

    @HasPermissionAllDecorator('hg.admin')

    def show(self, repo_name, format='html'):

        """GET /repos/repo_name: Show a specific item"""

        # url('repo', repo_name=ID)

    @HasRepoPermissionAllDecorator('repository.admin')

    def edit(self, repo_name):

        """GET /repo_name/settings: Form to edit an existing item"""

        # url('edit_repo', repo_name=ID)

        defaults = self.__load_data(repo_name)

        if 'clone_uri' in defaults:

            del defaults['clone_uri']

        c.repo_fields = RepositoryField.query()\

            .filter(RepositoryField.repository == c.repo_info).all()

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.active = 'settings'

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    @HasRepoPermissionAllDecorator('repository.admin')

    def edit_permissions(self, repo_name):

        """GET /repo_name/settings: Form to edit an existing item"""

        # url('edit_repo', repo_name=ID)

        c.repo_info = self._load_repo(repo_name)

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.user_groups_array = repo_model.get_user_groups_js()

        c.active = 'permissions'

        defaults = RepoModel()._get_defaults(repo_name)

        return htmlfill.render(