@HasRepoGroupPermissionAnyDecorator('group.admin')

    def update(self, group_name):

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

                             exclude=[c.repo_group])

    @HasRepoGroupPermissionAnyDecorator('group.admin')

    def delete(self, group_name):

        repos = gr.repositories.all()

        if repos:

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

    def show(self, group_name):

        c.active = 'settings'

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

        c.groups = self.scm_model.get_repo_groups(groups)

    def edit(self, group_name):

        c.active = 'settings'

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

                             exclude=[c.repo_group])

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

    @HasRepoGroupPermissionAnyDecorator('group.admin')

    def edit_repo_group_advanced(self, group_name):

        c.active = 'advanced'

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

    @HasRepoGroupPermissionAnyDecorator('group.admin')

    def edit_repo_group_perms(self, group_name):

        c.active = 'perms'

        self.__load_defaults()

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

        :param group_name:

        """

        valid_recursive_choices = ['none', 'repos', 'groups', 'all']

        form_result = RepoGroupPermsForm(valid_recursive_choices)().to_python(request.POST)

        if not request.authuser.is_admin:

    :param repogroupid:

    """

    if repo_group is None:

        raise JSONRPCError(

            'repository group `%s` does not exist' % (repogroupid,))

from kallithea.lib.compat import json, OrderedDict

from kallithea.lib.hooks import log_create_repository

setup_cache_regions(config)  # pragma: no cover

        RepoModel(DBS)._create_filesystem_repo(

            repo_name=repo_name,

            repo_type=repo_type,

            clone_uri=clone_uri,

        )

        repo = Repository.get_by_repo_name(repo_name_full)

        RepoModel(DBS)._create_filesystem_repo(

            repo_name=repo_name,

            repo_type=repo_type,

            clone_uri=source_repo_path,

        )

        repo = Repository.get_by_repo_name(repo_name_full)

    URL_SEPARATOR = Repository.url_sep()

    def _create_default_perms(self, repository, private):

        # create default permission

        default = 'repository.read'

        owner = User.guess_instance(owner)

        fork_of = Repository.guess_instance(fork_of)

        try:

            repo_name = safe_unicode(repo_name)

            description = safe_unicode(description)

        :param perm: Instance of Permission, or permission_name

        """

        repo = Repository.guess_instance(repo)

        permission = Permission.guess_instance(perm)

        # check if we have that permission already

            or user group name

        """

        repo = Repository.guess_instance(repo)

        obj = self.sa.query(UserGroupRepoToPerm) \

            .filter(UserGroupRepoToPerm.repository == repo) \

class RepoGroupModel(BaseModel):

    @LazyProperty

    def repos_path(self):

        """

               just_db=False, copy_permissions=False):

        try:

            owner = User.guess_instance(owner)

            new_repo_group = RepoGroup()

            new_repo_group.owner = owner

            new_repo_group.group_description = group_description or group_name

    def update(self, repo_group, form_data):

        try:

            old_path = repo_group.full_path

            # change properties

            raise

    def delete(self, repo_group, force_delete=False):

        try:

            self.sa.delete(repo_group)

            self._delete_group(repo_group, force_delete)

    def add_permission(self, repo_group, obj, obj_type, perm, recursive):

        from kallithea.model.repo import RepoModel

        perm = Permission.guess_instance(perm)

        for el in repo_group.recursive_groups_and_repos():

        :param recursive: recurse to all children of group

        """

        from kallithea.model.repo import RepoModel

        for el in repo_group.recursive_groups_and_repos():

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

        :param perm: Instance of Permission, or permission_name

        """

        user = User.guess_instance(user)

        permission = Permission.guess_instance(perm)

        :param user: Instance of User, user_id or username

        """

        user = User.guess_instance(user)

        obj = self.sa.query(UserRepoGroupToPerm) \

            or user group name

        :param perm: Instance of Permission, or permission_name

        """

        permission = Permission.guess_instance(perm)

        # check if we have that permission already

        :param group_name: Instance of UserGroup, users_group_id,

            or user group name

        """

        obj = self.sa.query(UserGroupRepoGroupToPerm) \

            .filter(UserGroupRepoGroupToPerm.group == repo_group) \

class UserGroupModel(BaseModel):

    def _create_default_perms(self, user_group):

        # create default permission

        default_perm = 'usergroup.read'

        return UserGroup.get(user_group_id)

    def get_group(self, user_group):

    def get_by_name(self, name, cache=False, case_insensitive=False):

        return UserGroup.get_by_group_name(name, cache, case_insensitive)

    def update(self, user_group, form_data):

        try:

            for k, v in form_data.items():

                if k == 'users_group_members':

        :param user_group:

        :param force:

        """

        try:

            # check if this group is not assigned to repo

            assigned_groups = UserGroupRepoToPerm.query() \

            raise

    def add_user_to_group(self, user_group, user):

        user = User.guess_instance(user)

        for m in user_group.members:

            raise

    def remove_user_from_group(self, user_group, user):

        user = User.guess_instance(user)

        user_group_member = None

            return False

    def has_perm(self, user_group, perm):

        perm = Permission.guess_instance(perm)

        return UserGroupToPerm.query() \

            .filter(UserGroupToPerm.permission == perm).scalar() is not None

    def grant_perm(self, user_group, perm):

        perm = Permission.guess_instance(perm)

        # if this permission is already granted skip it

        return new

    def revoke_perm(self, user_group, perm):

        perm = Permission.guess_instance(perm)

        obj = UserGroupToPerm.query() \

        :param perm: Instance of Permission, or permission_name

        """

        user = User.guess_instance(user)

        permission = Permission.guess_instance(perm)

        :param user: Instance of User, user_id or username

        """

        user = User.guess_instance(user)

        obj = self.sa.query(UserUserGroupToPerm) \

        :param user_group:

        :param perm:

        """

        permission = Permission.guess_instance(perm)

        # forbid assigning same user group to itself

        if target_user_group == user_group:

        :param target_user_group:

        :param user_group:

        """

        obj = self.sa.query(UserGroupUserGroupToPerm) \

            .filter(UserGroupUserGroupToPerm.target_user_group == target_user_group) \