# -*- coding: utf-8 -*-

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""

kallithea.controllers.admin.repo_groups

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Repository groups controller for Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Mar 23, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import logging

import traceback

import formencode

from formencode import htmlfill

from tg import app_globals, request

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from tg.i18n import ungettext

from webob.exc import HTTPForbidden, HTTPFound, HTTPInternalServerError, HTTPNotFound

from kallithea.controllers import base

from kallithea.lib import webutils

from kallithea.lib.auth import HasPermissionAny, HasRepoGroupPermissionLevel, HasRepoGroupPermissionLevelDecorator, LoginRequired

from kallithea.lib.utils2 import safe_int

from kallithea.lib.webutils import url

from kallithea.model import db, meta

from kallithea.model.forms import RepoGroupForm, RepoGroupPermsForm

from kallithea.model.repo import RepoModel

from kallithea.model.repo_group import RepoGroupModel

from kallithea.model.scm import AvailableRepoGroupChoices, RepoGroupList

log = logging.getLogger(__name__)

class RepoGroupsController(base.BaseController):

    @LoginRequired(allow_default_user=True)

    def _before(self, *args, **kwargs):

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

    def __load_defaults(self, extras=(), exclude=()):

        """extras is used for keeping current parent ignoring permissions

        exclude is used for not moving group to itself TODO: also exclude descendants

        Note: only admin can create top level groups

        """

        repo_groups = AvailableRepoGroupChoices('admin', extras)

        exclude_group_ids = set(rg.group_id for rg in exclude)

        c.repo_groups = [rg for rg in repo_groups

                         if rg[0] not in exclude_group_ids]

    def __load_data(self, group_id):

        """

        Load defaults settings for edit, and update

        :param group_id:

        """

        repo_group = db.RepoGroup.get_or_404(group_id)

        data = repo_group.get_dict()

        data['group_name'] = repo_group.name

        # fill repository group users

        for p in repo_group.repo_group_to_perm:

            data.update({'u_perm_%s' % p.user.username:

                             p.permission.permission_name})

        # fill repository group groups

        for p in repo_group.users_group_to_perm:

            data.update({'g_perm_%s' % p.users_group.users_group_name:

                             p.permission.permission_name})

        return data

    def _revoke_perms_on_yourself(self, form_result):

        _up = [u for u in form_result['perms_updates'] if request.authuser.username == u[0]]

        _new = [u for u in form_result['perms_new'] if request.authuser.username == u[0]]

        if _new and _new[0][1] != 'group.admin' or _up and _up[0][1] != 'group.admin':

            return True

        return False

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

        _list = db.RepoGroup.query(sorted=True).all()

        group_iter = RepoGroupList(_list, perm_level='admin')

        repo_groups_data = []

        _tmpl_lookup = app_globals.mako_lookup

        template = _tmpl_lookup.get_template('data_table/_dt_elements.html')

        def repo_group_name(repo_group_name, children_groups):

            return template.get_def("repo_group_name") \

                .render_unicode(repo_group_name, children_groups, _=_, webutils=webutils, c=c)

        def repo_group_actions(repo_group_id, repo_group_name, gr_count):

            return template.get_def("repo_group_actions") \

                .render_unicode(repo_group_id, repo_group_name, gr_count, _=_, webutils=webutils, c=c,

                        ungettext=ungettext)

        for repo_gr in group_iter:

            children_groups = [g.name for g in repo_gr.parents] + [repo_gr.name]

            repo_count = repo_gr.repositories.count()

            repo_groups_data.append({

                "raw_name": webutils.escape(repo_gr.group_name),

                "group_name": repo_group_name(repo_gr.group_name, children_groups),

                "desc": webutils.escape(repo_gr.group_description),

                "repos": repo_count,

                "owner": repo_gr.owner.username,

                "action": repo_group_actions(repo_gr.group_id, repo_gr.group_name,

                                             repo_count)

            })

        c.data = {

            "sort": None,

            "dir": "asc",

            "records": repo_groups_data

        }

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

    def create(self):

        self.__load_defaults()

        # permissions for can create group based on parent_id are checked

        # here in the Form

        repo_group_form = RepoGroupForm(repo_groups=c.repo_groups)

        form_result = None

        try:

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

            gr = RepoGroupModel().create(

                group_name=form_result['group_name'],

                group_description=form_result['group_description'],

                parent=form_result['parent_group_id'],

                copy_permissions=form_result['group_copy_permissions']

            )

            meta.Session().commit()

            # TODO: in future action_logger(, '', '', '')

        except formencode.Invalid as errors:

            return htmlfill.render(

                base.render('admin/repo_groups/repo_group_add.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8",

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

            webutils.flash(_('Error occurred during creation of repository group %s')

                    % request.POST.get('group_name'), category='error')

            if form_result is None:

                raise

            parent_group_id = form_result['parent_group_id']

            # TODO: maybe we should get back to the main view, not the admin one

            raise HTTPFound(location=url('repos_groups', parent_group=parent_group_id))

        webutils.flash(_('Created repository group %s') % gr.group_name,

                category='success')

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

    def new(self):

        parent_group_id = safe_int(request.GET.get('parent_group') or '-1')

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

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

            pass

        else:

            # we pass in parent group into creation form, thus we know

            # what would be the group, we can check perms here !

            group = db.RepoGroup.get(parent_group_id) if parent_group_id else None

            group_name = group.group_name if group else None

            if HasRepoGroupPermissionLevel('admin')(group_name, 'group create'):

                pass

            else:

                raise HTTPForbidden()

        self.__load_defaults()

        return htmlfill.render(

            base.render('admin/repo_groups/repo_group_add.html'),

            defaults={'parent_group_id': parent_group_id},

            errors={},

            prefix_error=False,

            encoding="UTF-8",

            force_defaults=False)

    @HasRepoGroupPermissionLevelDecorator('admin')

    def update(self, group_name):

        c.repo_group = db.RepoGroup.guess_instance(group_name)

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

                             exclude=[c.repo_group])

        # TODO: kill allow_empty_group - it is only used for redundant form validation!

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

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

            allow_empty_group = True

        elif not c.repo_group.parent_group:

            allow_empty_group = True

        else:

            allow_empty_group = False

        repo_group_form = RepoGroupForm(

            edit=True,

            old_data=c.repo_group.get_dict(),

            repo_groups=c.repo_groups,

            can_create_in_root=allow_empty_group,

        )()

        try:

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

            new_gr = RepoGroupModel().update(group_name, form_result)

            meta.Session().commit()

            webutils.flash(_('Updated repository group %s')

                    % form_result['group_name'], category='success')

            # we now have new name !

            group_name = new_gr.group_name

            # TODO: in future action_logger(, '', '', '')

        except formencode.Invalid as errors:

            c.active = 'settings'

            return htmlfill.render(

                base.render('admin/repo_groups/repo_group_edit.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8",

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

            webutils.flash(_('Error occurred during update of repository group %s')

                    % request.POST.get('group_name'), category='error')

        raise HTTPFound(location=url('edit_repo_group', group_name=group_name))

    @HasRepoGroupPermissionLevelDecorator('admin')

    def delete(self, group_name):

        gr = c.repo_group = db.RepoGroup.guess_instance(group_name)

        parent_group = gr.parent_group

        repos = gr.repositories.all()

        if repos:

            webutils.flash(_('This group contains %s repositories and cannot be '

                      'deleted') % len(repos), category='warning')

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

        children = gr.children.all()

        if children:

            webutils.flash(_('This group contains %s subgroups and cannot be deleted'

                      % (len(children))), category='warning')

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

        try:

            RepoGroupModel().delete(group_name)

            meta.Session().commit()

            webutils.flash(_('Removed repository group %s') % group_name,

                    category='success')

            # TODO: in future action_logger(, '', '', '')

        except Exception:

            log.error(traceback.format_exc())

            webutils.flash(_('Error occurred during deletion of repository group %s')

                    % group_name, category='error')

        if parent_group:

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

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

    def show_by_name(self, group_name):

        """

        This is a proxy that does a lookup group_name -> id, and shows

        the group by id view instead

        """

        group_name = group_name.rstrip('/')

        id_ = db.RepoGroup.get_by_group_name(group_name)

        if id_:

            return self.show(group_name)

        raise HTTPNotFound

    @HasRepoGroupPermissionLevelDecorator('read')

    def show(self, group_name):

        c.active = 'settings'

        c.group = c.repo_group = db.RepoGroup.guess_instance(group_name)

        groups = db.RepoGroup.query(sorted=True).filter_by(parent_group=c.group).all()

        repo_groups_list = self.scm_model.get_repo_groups(groups)

        repos_list = db.Repository.query(sorted=True).filter_by(group=c.group).all()

        c.data = RepoModel().get_repos_as_dict(repos_list,

                                               repo_groups_list=repo_groups_list,

                                               short_name=True)

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

    @HasRepoGroupPermissionLevelDecorator('admin')

    def edit(self, group_name):

        c.active = 'settings'

        c.repo_group = db.RepoGroup.guess_instance(group_name)

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

                             exclude=[c.repo_group])

        defaults = self.__load_data(c.repo_group.group_id)

        return htmlfill.render(

            base.render('admin/repo_groups/repo_group_edit.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

    @HasRepoGroupPermissionLevelDecorator('admin')

    def edit_repo_group_advanced(self, group_name):

        c.active = 'advanced'

        c.repo_group = db.RepoGroup.guess_instance(group_name)

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

    @HasRepoGroupPermissionLevelDecorator('admin')

    def edit_repo_group_perms(self, group_name):

        c.active = 'perms'

        c.repo_group = db.RepoGroup.guess_instance(group_name)

        self.__load_defaults()

        defaults = self.__load_data(c.repo_group.group_id)

        return htmlfill.render(

            base.render('admin/repo_groups/repo_group_edit.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

    @HasRepoGroupPermissionLevelDecorator('admin')

    def update_perms(self, group_name):

# -*- coding: utf-8 -*-

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""

these are form validation classes

http://formencode.org/module-formencode.validators.html

for list of all available validators

we can create our own validators

The table below outlines the options which can be used in a schema in addition to the validators themselves

pre_validators          []     These validators will be applied before the schema

chained_validators      []     These validators will be applied after the schema

allow_extra_fields      False     If True, then it is not an error when keys that aren't associated with a validator are present

filter_extra_fields     False     If True, then keys that aren't associated with a validator are removed

if_key_missing          NoDefault If this is given, then any keys that aren't available but are expected will be replaced with this value (and then validated). This does not override a present .if_missing attribute on validators. NoDefault is a special FormEncode class to mean that no default values has been specified and therefore missing keys shouldn't take a default value.

ignore_key_missing      False     If True, then missing keys will be missing in the result, if the validator doesn't have .if_missing on it already

<name> = formencode.validators.<name of validator>

<name> must equal form name

list=[1,2,3,4,5]

for SELECT use formencode.All(OneOf(list), Int())

"""

import logging

import formencode

from formencode import All

from tg.i18n import ugettext as _

import kallithea

from kallithea.model import validators as v

log = logging.getLogger(__name__)

def LoginForm():

    class _LoginForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        username = v.UnicodeString(

            strip=True,

            min=1,

            not_empty=True,

            messages={

               'empty': _('Please enter a login'),

               'tooShort': _('Enter a value %(min)i characters long or more')}

        )

        password = v.UnicodeString(

            strip=False,

            min=3,

            not_empty=True,

            messages={

                'empty': _('Please enter a password'),

                'tooShort': _('Enter %(min)i characters or more')}

        )

        remember = v.StringBoolean(if_missing=False)

        chained_validators = [v.ValidAuth()]

    return _LoginForm

def PasswordChangeForm(username):

    class _PasswordChangeForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        current_password = v.ValidOldPassword(username)(not_empty=True)

        new_password = All(v.ValidPassword(), v.UnicodeString(strip=False, min=6))

        new_password_confirmation = All(v.ValidPassword(), v.UnicodeString(strip=False, min=6))

        chained_validators = [v.ValidPasswordsMatch('new_password',

                                                    'new_password_confirmation')]

    return _PasswordChangeForm

def UserForm(edit=False, old_data=None):

    old_data = old_data or {}

    class _UserForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        username = All(v.UnicodeString(strip=True, min=1, not_empty=True),

                       v.ValidUsername(edit, old_data))

        if edit:

            new_password = All(

                v.ValidPassword(),

                v.UnicodeString(strip=False, min=6, not_empty=False)

            )

            password_confirmation = All(

                v.ValidPassword(),

                v.UnicodeString(strip=False, min=6, not_empty=False),

            )

            admin = v.StringBoolean(if_missing=False)

            chained_validators = [v.ValidPasswordsMatch('new_password',

                                                        'password_confirmation')]

        else:

            password = All(

                v.ValidPassword(),

                v.UnicodeString(strip=False, min=6, not_empty=True)

            )

            password_confirmation = All(

                v.ValidPassword(),

                v.UnicodeString(strip=False, min=6, not_empty=False)

            )

            chained_validators = [v.ValidPasswordsMatch('password',

                                                        'password_confirmation')]

        active = v.StringBoolean(if_missing=False)

        firstname = v.UnicodeString(strip=True, min=1, not_empty=False)

        lastname = v.UnicodeString(strip=True, min=1, not_empty=False)

        email = All(v.Email(not_empty=True), v.UniqSystemEmail(old_data))

        extern_name = v.UnicodeString(strip=True, if_missing=None)

        extern_type = v.UnicodeString(strip=True, if_missing=None)

    return _UserForm

def UserGroupForm(edit=False, old_data=None, available_members=None):

    old_data = old_data or {}

    available_members = available_members or []

    class _UserGroupForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        users_group_name = All(

            v.UnicodeString(strip=True, min=1, not_empty=True),

            v.ValidUserGroup(edit, old_data)

        )

        user_group_description = v.UnicodeString(strip=True, min=1,

                                                 not_empty=False)

        users_group_active = v.StringBoolean(if_missing=False)

        if edit:

            users_group_members = v.OneOf(

                available_members, hideList=False, testValueList=True,

                if_missing=None, not_empty=False

            )

    return _UserGroupForm

def RepoGroupForm(edit=False, old_data=None, repo_groups=None,

                   can_create_in_root=False):

    old_data = old_data or {}

    repo_groups = repo_groups or []

    repo_group_ids = [rg[0] for rg in repo_groups]

    class _RepoGroupForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        group_name = All(v.UnicodeString(strip=True, min=1, not_empty=True),

                         v.SlugifyName(),

                         v.ValidRegex(msg=_('Name must not contain only digits'))(r'(?!^\d+$)^.+$'))

        group_description = v.UnicodeString(strip=True, min=1,

                                            not_empty=False)

        group_copy_permissions = v.StringBoolean(if_missing=False)

        if edit:

            # FIXME: do a special check that we cannot move a group to one of

            # its children

            pass

        parent_group_id = All(v.CanCreateGroup(can_create_in_root),

                              v.OneOf(repo_group_ids, hideList=False,

                                      testValueList=True,

                                      if_missing=None, not_empty=True),

                              v.Int(min=-1, not_empty=True))

        chained_validators = [v.ValidRepoGroup(edit, old_data)]

    return _RepoGroupForm

def RegisterForm(edit=False, old_data=None):

    class _RegisterForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        username = All(

            v.ValidUsername(edit, old_data),

            v.UnicodeString(strip=True, min=1, not_empty=True)

        )

        password = All(

            v.ValidPassword(),

            v.UnicodeString(strip=False, min=6, not_empty=True)

        )

        password_confirmation = All(

            v.ValidPassword(),

            v.UnicodeString(strip=False, min=6, not_empty=True)

        )

        active = v.StringBoolean(if_missing=False)

        firstname = v.UnicodeString(strip=True, min=1, not_empty=False)

        lastname = v.UnicodeString(strip=True, min=1, not_empty=False)

        email = All(v.Email(not_empty=True), v.UniqSystemEmail(old_data))

        chained_validators = [v.ValidPasswordsMatch('password',

                                                    'password_confirmation')]

    return _RegisterForm

def PasswordResetRequestForm():

    class _PasswordResetRequestForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        email = v.Email(not_empty=True)

    return _PasswordResetRequestForm

def PasswordResetConfirmationForm():

    class _PasswordResetConfirmationForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        email = v.UnicodeString(strip=True, not_empty=True)

        timestamp = v.Number(strip=True, not_empty=True)

        token = v.UnicodeString(strip=True, not_empty=True)

        password = All(v.ValidPassword(), v.UnicodeString(strip=False, min=6))

        password_confirm = All(v.ValidPassword(), v.UnicodeString(strip=False, min=6))

        chained_validators = [v.ValidPasswordsMatch('password',

                                                    'password_confirm')]

    return _PasswordResetConfirmationForm

def RepoForm(edit=False, old_data=None, supported_backends=kallithea.BACKENDS,

             repo_groups=None, landing_revs=None):

    old_data = old_data or {}

    repo_groups = repo_groups or []

    landing_revs = landing_revs or []

    repo_group_ids = [rg[0] for rg in repo_groups]

    class _RepoForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        repo_name = All(v.UnicodeString(strip=True, min=1, not_empty=True),

                        v.SlugifyName())

        repo_group = All(v.CanWriteGroup(old_data),

                         v.OneOf(repo_group_ids, hideList=True),

                         v.Int(min=-1, not_empty=True))

        repo_type = v.OneOf(supported_backends, required=False,

                            if_missing=old_data.get('repo_type'))

        repo_description = v.UnicodeString(strip=True, min=1, not_empty=False)

        repo_private = v.StringBoolean(if_missing=False)

        repo_landing_rev = v.OneOf(landing_revs, hideList=True)

        repo_copy_permissions = v.StringBoolean(if_missing=False)

        clone_uri = All(v.UnicodeString(strip=True, min=1, not_empty=False))

        repo_enable_statistics = v.StringBoolean(if_missing=False)

        repo_enable_downloads = v.StringBoolean(if_missing=False)

        if edit:

            owner = All(v.UnicodeString(not_empty=True), v.ValidRepoUser())

            # Not a real field - just for reference for validation:

            # clone_uri_hidden = v.UnicodeString(if_missing='')

        chained_validators = [v.ValidCloneUri(),

                              v.ValidRepoName(edit, old_data)]

    return _RepoForm

def RepoPermsForm():

    class _RepoPermsForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        chained_validators = [v.ValidPerms(type_='repo')]

    return _RepoPermsForm

def RepoGroupPermsForm(valid_recursive_choices):

    class _RepoGroupPermsForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        recursive = v.OneOf(valid_recursive_choices)

        chained_validators = [v.ValidPerms(type_='repo_group')]

    return _RepoGroupPermsForm

def UserGroupPermsForm():

    class _UserPermsForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        chained_validators = [v.ValidPerms(type_='user_group')]

    return _UserPermsForm

def RepoFieldForm():

    class _RepoFieldForm(formencode.Schema):

        filter_extra_fields = True

        allow_extra_fields = True

        new_field_key = All(v.FieldKey(),

                            v.UnicodeString(strip=True, min=3, not_empty=True))

        new_field_value = v.UnicodeString(not_empty=False, if_missing='')

        new_field_type = v.OneOf(['str', 'unicode', 'list', 'tuple'],

                                 if_missing='str')

        new_field_label = v.UnicodeString(not_empty=False)

        new_field_desc = v.UnicodeString(not_empty=False)

    return _RepoFieldForm

def RepoForkForm(edit=False, old_data=None, supported_backends=kallithea.BACKENDS,

                 repo_groups=None, landing_revs=None):

    old_data = old_data or {}

    repo_groups = repo_groups or []

    landing_revs = landing_revs or []

    repo_group_ids = [rg[0] for rg in repo_groups]

    class _RepoForkForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        repo_name = All(v.UnicodeString(strip=True, min=1, not_empty=True),

                        v.SlugifyName())

        repo_group = All(v.CanWriteGroup(),

                         v.OneOf(repo_group_ids, hideList=True),

                         v.Int(min=-1, not_empty=True))

        repo_type = All(v.ValidForkType(old_data), v.OneOf(supported_backends))

        description = v.UnicodeString(strip=True, min=1, not_empty=True)

        private = v.StringBoolean(if_missing=False)

        copy_permissions = v.StringBoolean(if_missing=False)

        update_after_clone = v.StringBoolean(if_missing=False)

        fork_parent_id = v.UnicodeString()

        chained_validators = [v.ValidForkName(edit, old_data)]

        landing_rev = v.OneOf(landing_revs, hideList=True)

    return _RepoForkForm

def ApplicationSettingsForm():

    class _ApplicationSettingsForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        title = v.UnicodeString(strip=True, not_empty=False)

        realm = v.UnicodeString(strip=True, min=1, not_empty=True)

        ga_code = v.UnicodeString(strip=True, min=1, not_empty=False)

        captcha_public_key = v.UnicodeString(strip=True, min=1, not_empty=False)

        captcha_private_key = v.UnicodeString(strip=True, min=1, not_empty=False)

    return _ApplicationSettingsForm

def ApplicationVisualisationForm():

    class _ApplicationVisualisationForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        show_public_icon = v.StringBoolean(if_missing=False)

        show_private_icon = v.StringBoolean(if_missing=False)

        stylify_metalabels = v.StringBoolean(if_missing=False)

        repository_fields = v.StringBoolean(if_missing=False)

        lightweight_journal = v.StringBoolean(if_missing=False)

        :param group_name:

        """

        if old == new:

            log.debug('skipping group rename')

            return

        log.debug('renaming repository group from %s to %s', old, new)

        old_path = os.path.join(self.repos_path, old)

        new_path = os.path.join(self.repos_path, new)

        log.debug('renaming repos paths from %s to %s', old_path, new_path)

        if os.path.isdir(new_path):

            raise Exception('Was trying to rename to already '

                            'existing dir %s' % new_path)

        shutil.move(old_path, new_path)

    def _delete_group(self, group, force_delete=False):

        """

        Deletes a group from a filesystem

        :param group: instance of group from database

        :param force_delete: use shutil rmtree to remove all objects

        """

        paths = group.full_path.split(kallithea.URL_SEP)

        paths = os.sep.join(paths)

        rm_path = os.path.join(self.repos_path, paths)

        log.info("Removing group %s", rm_path)

        # delete only if that path really exists

        if os.path.isdir(rm_path):

            if force_delete:

                shutil.rmtree(rm_path)

            else:

                # archive that group

                _now = datetime.datetime.now()

                _ms = str(_now.microsecond).rjust(6, '0')

                _d = 'rm__%s_GROUP_%s' % (_now.strftime('%Y%m%d_%H%M%S_' + _ms),

                                          group.name)

                shutil.move(rm_path, os.path.join(self.repos_path, _d))

    def create(self, group_name, group_description, owner, parent=None,

               just_db=False, copy_permissions=False):

        try:

            if kallithea.lib.utils2.repo_name_slug(group_name) != group_name:

                raise Exception('invalid repo group name %s' % group_name)

            owner = db.User.guess_instance(owner)

            parent_group = db.RepoGroup.guess_instance(parent)

            new_repo_group = db.RepoGroup()

            new_repo_group.owner = owner

            new_repo_group.group_description = group_description or group_name

            new_repo_group.parent_group = parent_group

            new_repo_group.group_name = new_repo_group.get_new_name(group_name)

            meta.Session().add(new_repo_group)

            # create an ADMIN permission for owner except if we're super admin,

            # later owner should go into the owner field of groups

            if not owner.is_admin:

                self.grant_user_permission(repo_group=new_repo_group,

                                           user=owner, perm='group.admin')

            if parent_group and copy_permissions:

                # copy permissions from parent

                user_perms = db.UserRepoGroupToPerm.query() \

                    .filter(db.UserRepoGroupToPerm.group == parent_group).all()

                group_perms = db.UserGroupRepoGroupToPerm.query() \

                    .filter(db.UserGroupRepoGroupToPerm.group == parent_group).all()

                for perm in user_perms:

                    # don't copy over the permission for user who is creating

                    # this group, if he is not super admin he get's admin

                    # permission set above

                    if perm.user != owner or owner.is_admin:

                        db.UserRepoGroupToPerm.create(perm.user, new_repo_group, perm.permission)

                for perm in group_perms:

                    db.UserGroupRepoGroupToPerm.create(perm.users_group, new_repo_group, perm.permission)

            else:

                self._create_default_perms(new_repo_group)

            if not just_db:

                # we need to flush here, in order to check if database won't

                # throw any exceptions, create filesystem dirs at the very end

                meta.Session().flush()

                self._create_group(new_repo_group.group_name)

            return new_repo_group

        except Exception:

            log.error(traceback.format_exc())

            raise

    def _update_permissions(self, repo_group, perms_new=None,

                            perms_updates=None, recursive=None,

                            check_perms=True):

        from kallithea.lib.auth import HasUserGroupPermissionLevel

        if not perms_new:

            perms_new = []

        if not perms_updates:

            perms_updates = []

        def _set_perm_user(obj, user, perm):

            if isinstance(obj, db.RepoGroup):

                self.grant_user_permission(repo_group=obj, user=user, perm=perm)

            elif isinstance(obj, db.Repository):

                user = db.User.guess_instance(user)

                # private repos will not allow to change the default permissions

                # using recursive mode

                if obj.private and user.is_default_user:

                    return

                # we set group permission but we have to switch to repo

                # permission

                perm = perm.replace('group.', 'repository.')

                repo.RepoModel().grant_user_permission(

                    repo=obj, user=user, perm=perm

                )

        def _set_perm_group(obj, users_group, perm):

            if isinstance(obj, db.RepoGroup):

                self.grant_user_group_permission(repo_group=obj,

                                                  group_name=users_group,

                                                  perm=perm)

            elif isinstance(obj, db.Repository):

                # we set group permission but we have to switch to repo

                # permission

                perm = perm.replace('group.', 'repository.')

                repo.RepoModel().grant_user_group_permission(

                    repo=obj, group_name=users_group, perm=perm

                )

        # start updates

        updates = []

        log.debug('Now updating permissions for %s in recursive mode:%s',

                  repo_group, recursive)

        for obj in repo_group.recursive_groups_and_repos():

            # iterated obj is an instance of a repos group or repository in

            # that group, recursive option can be: none, repos, groups, all

            if recursive == 'all':

                pass

            elif recursive == 'repos':

                # skip groups, other than this one

                if isinstance(obj, db.RepoGroup) and not obj == repo_group:

                    continue

            elif recursive == 'groups':

                # skip repos

                if isinstance(obj, db.Repository):

                    continue