:type apiuser: AuthUser

        :param repoid: repository name or repository id

        :type repoid: str or int

        :param usergroupid:

        OUTPUT::

            id : <id_given_in_input>

            result: {

                      "msg" : "Revoked perm for group: `<usersgroupname>` in repo: `<reponame>`",

                      "success": true

                    }

            error:  null

        """

        repo = get_repo_or_error(repoid)

        user_group = get_user_group_or_error(usergroupid)

        if not HasPermissionAnyApi('hg.admin')(user=apiuser):

            # check if we have admin permission for this repo !

            _perms = ('repository.admin',)

            if not HasRepoPermissionAnyApi(*_perms)(

                    user=apiuser, repo_name=repo.repo_name):

                raise JSONRPCError('repository `%s` does not exist' % (repoid,))

            # check if we have at least read permission for this user group !

            _perms = ('usergroup.read', 'usergroup.write', 'usergroup.admin',)

            if not HasUserGroupPermissionAny(*_perms)(

                    user=apiuser, user_group_name=user_group.users_group_name):

                raise JSONRPCError('user group `%s` does not exist' % (usergroupid,))

        try:

            RepoModel().revoke_user_group_permission(

                repo=repo, group_name=user_group)

            Session().commit()

            return dict(

                msg='Revoked perm for user group: `%s` in repo: `%s`' % (

                    user_group.users_group_name, repo.repo_name

                ),

                success=True

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'failed to edit permission for user group: `%s` in '

                'repo: `%s`' % (

                    user_group.users_group_name, repo.repo_name

                )

            )

    @HasPermissionAnyDecorator('hg.admin')

    def get_repo_group(self, apiuser, repogroupid):

        """

        Returns given repo group together with permissions, and repositories

        inside the group

        :param apiuser: filled automatically from apikey

        :type apiuser: AuthUser

        :param repogroupid: id/name of repository group

        :type repogroupid: str or int

        """

        repo_group = get_repo_group_or_error(repogroupid)

        members = []

        for user in repo_group.repo_group_to_perm:

            perm = user.permission.permission_name

            user = user.user

            user_data = {

                'name': user.username,

                'type': "user",

                'permission': perm

            }

            members.append(user_data)

        for user_group in repo_group.users_group_to_perm:

            perm = user_group.permission.permission_name

            user_group = user_group.users_group

            user_group_data = {

                'name': user_group.users_group_name,

                'type': "user_group",

                'permission': perm

            }

            members.append(user_group_data)

        data = repo_group.get_api_data()

        data["members"] = members

        return data

    @HasPermissionAnyDecorator('hg.admin')

    def get_repo_groups(self, apiuser):

        """

        Returns all repository groups

        :param apiuser: filled automatically from apikey

        :type apiuser: AuthUser

        """

        result = []

            result.append(repo_group.get_api_data())

        return result

    @HasPermissionAnyDecorator('hg.admin')

    def create_repo_group(self, apiuser, group_name, description=Optional(''),

                          owner=Optional(OAttr('apiuser')),

                          parent=Optional(None),

                          copy_permissions=Optional(False)):

        """

        Creates a repository group. This command can be executed only using

        api_key belonging to user with admin rights.

        :param apiuser: filled automatically from apikey

        :type apiuser: AuthUser

        :param group_name:

        :type group_name:

        :param description:

        :type description:

        :param owner:

        :type owner:

        :param parent:

        :type parent:

        :param copy_permissions:

        :type copy_permissions:

        OUTPUT::

          id : <id_given_in_input>

          result : {

              "msg": "created new repo group `<repo_group_name>`"

              "repo_group": <repogroup_object>

          }

          error :  null

        ERROR OUTPUT::

          id : <id_given_in_input>

          result : null

          error :  {

            failed to create repo group `<repogroupid>`

          }

        """

        if RepoGroup.get_by_group_name(group_name):

            raise JSONRPCError("repo group `%s` already exist" % (group_name,))

        if isinstance(owner, Optional):

            owner = apiuser.user_id

        group_description = Optional.extract(description)

        parent_group = Optional.extract(parent)

        if not isinstance(parent, Optional):

            parent_group = get_repo_group_or_error(parent_group)

        copy_permissions = Optional.extract(copy_permissions)

        try:

            repo_group = RepoGroupModel().create(

                group_name=group_name,

                group_description=group_description,

                owner=owner,

                parent=parent_group,

                copy_permissions=copy_permissions

            )

            Session().commit()

            return dict(

                msg='created new repo group `%s`' % group_name,

                repo_group=repo_group.get_api_data()

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to create repo group `%s`' % (group_name,))

    @HasPermissionAnyDecorator('hg.admin')

    def update_repo_group(self, apiuser, repogroupid, group_name=Optional(''),

                          description=Optional(''),

                          owner=Optional(OAttr('apiuser')),

                          parent=Optional(None), enable_locking=Optional(False)):

        repo_group = get_repo_group_or_error(repogroupid)

        updates = {}

        try:

            store_update(updates, group_name, 'group_name')

            store_update(updates, description, 'group_description')

            store_update(updates, owner, 'owner')

            store_update(updates, parent, 'parent_group')

            store_update(updates, enable_locking, 'enable_locking')

            repo_group = RepoGroupModel().update(repo_group, updates)

            Session().commit()

            return dict(

                msg='updated repository group ID:%s %s' % (repo_group.group_id,

                                                           repo_group.group_name),

                repo_group=repo_group.get_api_data()

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to update repository group `%s`'