@LoginRequired()

    def index(self):

        not_default_user = not c.authuser.is_default_user

        c.show_private = request.GET.get('private') and not_default_user

        c.show_public = request.GET.get('public') and not_default_user

    @LoginRequired()

    @NotAnonymous()

    def create(self):

        self.__load_defaults()

        gist_form = GistForm([x[0] for x in c.lifetime_values])()

        try:

    @LoginRequired()

    @NotAnonymous()

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

        self.__load_defaults()

        return render('admin/gists/new.html')

    @LoginRequired()

    @NotAnonymous()

    def delete(self, gist_id):

        gist = GistModel().get_gist(gist_id)

        owner = gist.gist_owner == c.authuser.user_id

        if h.HasPermissionAny('hg.admin')() or owner:

    @LoginRequired()

    def show(self, gist_id, revision='tip', format='html', f_path=None):

        c.gist = Gist.get_or_404(gist_id)

        #check if this gist is not expired

    @LoginRequired()

    @NotAnonymous()

    def edit(self, gist_id, format='html'):

        c.gist = Gist.get_or_404(gist_id)

        #check if this gist is not expired

        return json.dumps(repos_data)

    def my_account(self):

        c.active = 'profile'

        self.__load_data()

        c.perm_user = AuthUser(user_id=self.authuser.user_id)

        super(NotificationsController, self).__before__()

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

        c.user = self.authuser

        notif = NotificationModel().query_for_user(self.authuser.user_id,

                                            filter_=request.GET.getall('type'))

        # url('new_notification')

    def update(self, notification_id):

        try:

            no = Notification.get(notification_id)

            owner = all(un.user.user_id == c.authuser.user_id

        raise HTTPBadRequest()

    def delete(self, notification_id):

        try:

            no = Notification.get(notification_id)

            owner = any(un.user.user_id == c.authuser.user_id

        raise HTTPBadRequest()

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

        notification = Notification.get_or_404(notification_id)

        unotification = NotificationModel() \

        return False

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

        _list = RepoGroup.query() \

                    .order_by(func.lower(RepoGroup.group_name)) \

                    .all()

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

    def create(self):

        self.__load_defaults()

        # permissions for can create group based on parent_id are checked

        raise HTTPFound(location=url('repos_group_home', group_name=gr.group_name))

    def new(self):

        if HasPermissionAny('hg.admin')('group create'):

            #we're global admin, we're ok and we can create TOP level groups

            pass

    @HasRepoGroupPermissionAnyDecorator('group.admin')

    def update(self, group_name):

        c.repo_group = RepoGroupModel()._get_repo_group(group_name)

        self.__load_defaults(extras=[c.repo_group.parent_group],

                             exclude=[c.repo_group])

    @HasRepoGroupPermissionAnyDecorator('group.admin')

    def delete(self, group_name):

        gr = c.repo_group = RepoGroupModel()._get_repo_group(group_name)

        repos = gr.repositories.all()

        if repos:

    @HasRepoGroupPermissionAnyDecorator('group.read', 'group.write',

                                         'group.admin')

    def show(self, group_name):

        c.active = 'settings'

        c.group = c.repo_group = RepoGroupModel()._get_repo_group(group_name)

    @HasRepoGroupPermissionAnyDecorator('group.admin')

    def edit(self, group_name):

        c.active = 'settings'

        c.repo_group = RepoGroupModel()._get_repo_group(group_name)

    @HasRepoGroupPermissionAnyDecorator('group.admin')

    def edit_repo_group_advanced(self, group_name):

        c.active = 'advanced'

        c.repo_group = RepoGroupModel()._get_repo_group(group_name)

    @HasRepoGroupPermissionAnyDecorator('group.admin')

    def edit_repo_group_perms(self, group_name):

        c.active = 'perms'

        c.repo_group = RepoGroupModel()._get_repo_group(group_name)

        self.__load_defaults()

    @HasRepoGroupPermissionAnyDecorator('group.admin')

    def delete_perms(self, group_name):

        try:

            obj_type = request.POST.get('obj_type')

            obj_id = None

        return defaults

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

        _list = Repository.query() \

                        .order_by(func.lower(Repository.repo_name)) \

                        .all()

    @NotAnonymous()

    def create(self):

        self.__load_defaults()

        form_result = {}

        task_id = None

    @NotAnonymous()

    def create_repository(self):

        self.__load_defaults()

        if not c.repo_groups:

            raise HTTPForbidden

    @HasRepoPermissionAnyDecorator('repository.admin')

    def update(self, repo_name):

        c.repo_info = self._load_repo(repo_name)

        self.__load_defaults(c.repo_info)

        c.active = 'settings'

    @HasRepoPermissionAnyDecorator('repository.admin')

    def delete(self, repo_name):

        repo_model = RepoModel()

        repo = repo_model.get_by_repo_name(repo_name)

        if not repo:

    @HasRepoPermissionAnyDecorator('repository.admin')

    def edit(self, repo_name):

        defaults = self.__load_data(repo_name)

        c.repo_fields = RepositoryField.query() \

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

    @HasRepoPermissionAnyDecorator('repository.admin')

    def edit_permissions(self, repo_name):

        c.repo_info = self._load_repo(repo_name)

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

    @HasRepoPermissionAnyDecorator('repository.admin')

    def edit_fields(self, repo_name):

        c.repo_info = self._load_repo(repo_name)

        c.repo_fields = RepositoryField.query() \

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

    @HasRepoPermissionAnyDecorator('repository.admin')

    def edit_advanced(self, repo_name):

        c.repo_info = self._load_repo(repo_name)

        c.default_user_id = User.get_default_user().user_id

        c.in_public_journal = UserFollowing.query() \

    @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')

    def toggle_locking(self, repo_name):

        try:

            repo = Repository.get_by_repo_name(repo_name)

    @HasRepoPermissionAnyDecorator('repository.admin')

    def edit_caches(self, repo_name):

        c.repo_info = self._load_repo(repo_name)

        c.active = 'caches'

        if request.POST:

    @HasRepoPermissionAnyDecorator('repository.admin')

    def edit_remote(self, repo_name):

        c.repo_info = self._load_repo(repo_name)

        c.active = 'remote'

        if request.POST:

    @HasRepoPermissionAnyDecorator('repository.admin')

    def edit_statistics(self, repo_name):

        c.repo_info = self._load_repo(repo_name)

        repo = c.repo_info.scm_instance

    @HasPermissionAnyDecorator('hg.admin')

    def settings_vcs(self):

        c.active = 'vcs'

        if request.POST:

            application_form = ApplicationUiSettingsForm()()

    @HasPermissionAnyDecorator('hg.admin')

    def settings_mapping(self):

        c.active = 'mapping'

        if request.POST:

            rm_obsolete = request.POST.get('destroy', False)

    @HasPermissionAnyDecorator('hg.admin')

    def settings_global(self):

        c.active = 'global'

        if request.POST:

            application_form = ApplicationSettingsForm()()

    @HasPermissionAnyDecorator('hg.admin')

    def settings_visual(self):

        c.active = 'visual'

        if request.POST:

            application_form = ApplicationVisualisationForm()()

    @HasPermissionAnyDecorator('hg.admin')

    def settings_email(self):

        c.active = 'email'

        if request.POST:

            test_email = request.POST.get('test_email')

    @HasPermissionAnyDecorator('hg.admin')

    def settings_hooks(self):

        c.active = 'hooks'

        if request.POST:

            if c.visual.allow_custom_hooks_settings:

    @HasPermissionAnyDecorator('hg.admin')

    def settings_search(self):

        c.active = 'search'

        if request.POST:

            repo_location = self._get_hg_ui_settings()['paths_root_path']

    @HasPermissionAnyDecorator('hg.admin')

    def settings_system(self):

        c.active = 'system'

        defaults = Setting.get_app_settings()

    @HasPermissionAnyDecorator('hg.admin')

    def settings_system_update(self):

        import json

        import urllib2

        from kallithea.lib.verlib import NormalizedVersion

        return data

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

        _list = UserGroup.query() \

                        .order_by(func.lower(UserGroup.users_group_name)) \

                        .all()

    @HasPermissionAnyDecorator('hg.admin', 'hg.usergroup.create.true')

    def create(self):

        users_group_form = UserGroupForm()()

        try:

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

    @HasPermissionAnyDecorator('hg.admin', 'hg.usergroup.create.true')

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

        return render('admin/user_groups/user_group_add.html')

    @HasUserGroupPermissionAnyDecorator('usergroup.admin')

    def update(self, id):

        c.user_group = UserGroup.get_or_404(id)

        c.active = 'settings'

        self.__load_data(id)

    @HasUserGroupPermissionAnyDecorator('usergroup.admin')

    def delete(self, id):

        usr_gr = UserGroup.get_or_404(id)

        try:

            UserGroupModel().delete(usr_gr)

    @HasUserGroupPermissionAnyDecorator('usergroup.admin')

    def edit(self, id, format='html'):

        c.user_group = UserGroup.get_or_404(id)

        c.active = 'settings'

        self.__load_data(id)

    @HasUserGroupPermissionAnyDecorator('usergroup.admin')

    def delete_perms(self, id):

        try:

            obj_type = request.POST.get('obj_type')

            obj_id = None

    @HasUserGroupPermissionAnyDecorator('usergroup.admin')

    def update_default_perms(self, id):

        user_group = UserGroup.get_or_404(id)

        try:

        c.EXTERN_TYPE_INTERNAL = kallithea.EXTERN_TYPE_INTERNAL

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

        c.users_list = User.query().order_by(User.username) \

                        .filter(User.username != User.DEFAULT_USER) \

                        .order_by(func.lower(User.username)) \

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

    def create(self):

        c.default_extern_type = auth_internal.KallitheaAuthPlugin.name

        c.default_extern_name = auth_internal.KallitheaAuthPlugin.name

        user_model = UserModel()

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

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

        c.default_extern_type = auth_internal.KallitheaAuthPlugin.name

        c.default_extern_name = auth_internal.KallitheaAuthPlugin.name

        return render('admin/users/user_add.html')

    def update(self, id):

        user_model = UserModel()

        user = user_model.get(id)

        _form = UserForm(edit=True, old_data={'user_id': id,

        raise HTTPFound(location=url('edit_user', id=id))

    def delete(self, id):

        usr = User.get_or_404(id)

        try:

            UserModel().delete(usr)

        return render('admin/users/user_edit.html')

    def edit(self, id, format='html'):

        user = self._get_user_or_raise_if_default(id)

        defaults = user.get_dict()

            force_defaults=False)

    def update_perms(self, id):

        user = self._get_user_or_raise_if_default(id)

        try:

            force_defaults=False)

    def add_email(self, id):

        user = self._get_user_or_raise_if_default(id)

        email = request.POST.get('new_email')

        user_model = UserModel()

        raise HTTPFound(location=url('edit_user_emails', id=id))

    def delete_email(self, id):

        user = self._get_user_or_raise_if_default(id)

        email_id = request.POST.get('del_email_id')

        user_model = UserModel()

            force_defaults=False)

    def add_ip(self, id):

        ip = request.POST.get('new_ip')

        user_model = UserModel()

        raise HTTPFound(location=url('edit_user_ips', id=id))

    def delete_ip(self, id):

        ip_id = request.POST.get('del_ip_id')

        user_model = UserModel()

        user_model.delete_extra_ip(id, ip_id)