Triggers a pull from remote location on given repo. Can be used to

        automatically keep remote repos up to date. This command can be executed

        only using api_key belonging to user with admin rights

        OUTPUT::

            id : <id_given_in_input>

            result : {

                "msg" : "Pulled from `<repository name>`",

                "repository" : "<repository name>"

            }

            error : null

        """

        repo = get_repo_or_error(repoid)

        try:

            ScmModel().pull_changes(repo.repo_name,

                                    request.authuser.username,

                                    request.ip_addr,

                                    clone_uri=clone_uri)

            return dict(

                msg='Pulled from `%s`' % repo.repo_name,

                repository=repo.repo_name

            )

        than also delete repos that are in database but not in the filesystem.

        aka "clean zombies". This command can be executed only using api_key

        belonging to user with admin rights.

        OUTPUT::

            id : <id_given_in_input>

            result : {

                'added': [<added repository name>,...]

                'removed': [<removed repository name>,...]

            }

            error : null

        """

        try:

            rm_obsolete = remove_obsolete

            added, removed = repo2db_mapper(ScmModel().repo_scan(),

                                            remove_obsolete=rm_obsolete)

            return {'added': added, 'removed': removed}

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'Error occurred during rescan repositories action'

            )

        Invalidate cache for repository.

        This command can be executed only using api_key belonging to user with admin

        rights or regular user that have write or admin or write access to repository.

        OUTPUT::

            id : <id_given_in_input>

            result : {

                'msg': Cache for repository `<repository name>` was invalidated,

                'repository': <repository name>

            }

            error : null

        """

        repo = get_repo_or_error(repoid)

        if not HasPermissionAny('hg.admin')():

            if not HasRepoPermissionLevel('write')(repo.repo_name):

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

        try:

            ScmModel().mark_for_invalidation(repo.repo_name)

            return dict(

                msg='Cache for repository `%s` was invalidated' % (repoid,),

                repository=repo.repo_name

            )

        """

        Creates new user. Returns new user object. This command can

        be executed only using api_key belonging to user with admin rights.

        OUTPUT::

            id : <id_given_in_input>

            result : {

                      "msg" : "created new user `<username>`",

                      "user" : <user_obj>

                     }

            error : null

        """

        if db.User.get_by_username(username):

            raise JSONRPCError("user `%s` already exist" % (username,))

        if db.User.get_by_email(email):

            raise JSONRPCError("email `%s` already exist" % (email,))

        try:

            user = UserModel().create_or_update(

                username=username,

                password=password,

                email=email,

        """

        updates given user if such user exists. This command can

        be executed only using api_key belonging to user with admin rights.

        OUTPUT::

            id : <id_given_in_input>

            result : {

                      "msg" : "updated user ID:<userid> <username>",

                      "user" : <user_object>

                     }

            error : null

        """

        user = get_user_or_error(userid)

        # only non optional arguments will be stored in updates

        updates = {}

        try:

            store_update(updates, username, 'username')

            store_update(updates, password, 'password')

            store_update(updates, email, 'email')

            store_update(updates, firstname, 'name')

        """

        deletes given user if such user exists. This command can

        be executed only using api_key belonging to user with admin rights.

        OUTPUT::

            id : <id_given_in_input>

            result : {

                      "msg" : "deleted user ID:<userid> <username>",

                      "user" : null

                     }

            error : null

        """

        user = get_user_or_error(userid)

        try:

            UserModel().delete(userid)

            meta.Session().commit()

            return dict(

                msg='deleted user ID:%s %s' % (user.user_id, user.username),

                user=None

            )

        except Exception:

        Creates new user group. This command can be executed only using api_key

        belonging to user with admin rights or an user who has create user group

        permission

        OUTPUT::

            id : <id_given_in_input>

            result : {

                      "msg" : "created new user group `<groupname>`",

                      "user_group" : <user_group_object>

                     }

            error : null

        """

        if UserGroupModel().get_by_name(group_name):

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

        try:

            if owner is None:

                owner = request.authuser.user_id

            owner = get_user_or_error(owner)

            ug = UserGroupModel().create(name=group_name, description=description,

                                         owner=owner, active=active)

            meta.Session().commit()

        """

        Updates given usergroup.  This command can be executed only using api_key

        belonging to user with admin rights or an admin of given user group

        OUTPUT::

          id : <id_given_in_input>

          result : {

            "msg" : 'updated user group ID:<user group id> <user group name>',

            "user_group" : <user_group_object>

          }

          error : null

        """

        user_group = get_user_group_or_error(usergroupid)

        if not HasPermissionAny('hg.admin')():

            if not HasUserGroupPermissionLevel('admin')(user_group.users_group_name):

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

        if owner is not None:

            owner = get_user_or_error(owner)

        updates = {}

        store_update(updates, group_name, 'users_group_name')

        store_update(updates, description, 'user_group_description')

        """

        Delete given user group by user group id or name.

        This command can be executed only using api_key

        belonging to user with admin rights or an admin of given user group

        OUTPUT::

          id : <id_given_in_input>

          result : {

            "msg" : "deleted user group ID:<user_group_id> <user_group_name>"

          }

          error : null

        """

        user_group = get_user_group_or_error(usergroupid)

        if not HasPermissionAny('hg.admin')():

            if not HasUserGroupPermissionLevel('admin')(user_group.users_group_name):

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

        try:

            UserGroupModel().delete(user_group)

            meta.Session().commit()

            return dict(

                msg='deleted user group ID:%s %s' %

                    (user_group.users_group_id, user_group.users_group_name),

        `false`. This command can be executed only using api_key

        belonging to user with admin rights or an admin of a given user group

        OUTPUT::

            id : <id_given_in_input>

            result : {

                "success" : True|False # depends on if member is in group

                "msg" : "added member `<username>` to a user group `<groupname>` |

                         User is already in that group"

            }

            error : null

        """

        user = get_user_or_error(userid)

        user_group = get_user_group_or_error(usergroupid)

        if not HasPermissionAny('hg.admin')():

            if not HasUserGroupPermissionLevel('admin')(user_group.users_group_name):

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

        try:

            ugm = UserGroupModel().add_user_to_group(user_group, user)

            success = True if ugm is not True else False

            msg = 'added member `%s` to user group `%s`' % (

                user.username, user_group.users_group_name

        "bar" as group. This command can be executed only using api_key

        belonging to user with admin rights or regular user that have create

        repository permission. Regular users cannot specify owner parameter

        OUTPUT::

            id : <id_given_in_input>

            result : {

                      "msg" : "Created new repository `<reponame>`",

                      "success" : true

                     }

            error : null

        """

        group_name = None

        repo_name_parts = repo_name.split('/')

        if len(repo_name_parts) > 1:

            group_name = '/'.join(repo_name_parts[:-1])

            repo_group = db.RepoGroup.get_by_group_name(group_name)

            if repo_group is None:

                raise JSONRPCError("repo group `%s` not found" % group_name)

            if not(HasPermissionAny('hg.admin')() or HasRepoGroupPermissionLevel('write')(group_name)):

                raise JSONRPCError("no permission to create repo in %s" % group_name)

        else:

            if not HasPermissionAny('hg.admin', 'hg.create.repository')():

        Grant permission for user group on given repository, or update

        existing one if found. This command can be executed only using

        api_key belonging to user with admin rights.

        OUTPUT::

            id : <id_given_in_input>

            result : {

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

                "success" : true

            }

            error : null

        """

        repo = get_repo_or_error(repoid)

        perm = get_perm_or_error(perm)

        user_group = get_user_group_or_error(usergroupid)

        if not HasPermissionAny('hg.admin')():

            if not HasRepoPermissionLevel('admin')(repo.repo_name):

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

            if not HasUserGroupPermissionLevel('read')(user_group.users_group_name):

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

        try:

        """

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

        api_key belonging to user with admin rights.

        OUTPUT::

          id : <id_given_in_input>

          result : {

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

              "repo_group" : <repogroup_object>

          }

          error : null

        """

        if db.RepoGroup.get_by_group_name(group_name):

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

        if owner is None:

            owner = request.authuser.user_id

        group_description = description

        parent_group = None

        if parent is not None:

            parent_group = get_repo_group_or_error(parent)

        try:

    @HasPermissionAnyDecorator('hg.admin')

    def delete_repo_group(self, repogroupid):

        """

        OUTPUT::

          id : <id_given_in_input>

          result : {

            'msg' : 'deleted repo group ID:<repogroupid> <repogroupname>

            'repo_group' : null

          }

          error : null

        """

        repo_group = get_repo_group_or_error(repogroupid)

        try:

            RepoGroupModel().delete(repo_group)

            meta.Session().commit()

            return dict(

                msg='deleted repo group ID:%s %s' %

                    (repo_group.group_id, repo_group.group_name),

                repo_group=None

            )

        except Exception:

        one if found. This command can be executed only using api_key belonging

        to user with admin rights, or user who has admin right to given repository

        group.

        OUTPUT::

            id : <id_given_in_input>

            result : {

                      "msg" : "Granted perm: `<perm>` (recursive:<apply_to_children>) for user: `<username>` in repo group: `<repo_group_name>`",

                      "success" : true

                     }

            error : null

        """

        repo_group = get_repo_group_or_error(repogroupid)

        if not HasPermissionAny('hg.admin')():

            if not HasRepoGroupPermissionLevel('admin')(repo_group.group_name):

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

        user = get_user_or_error(userid)

        perm = get_perm_or_error(perm, prefix='group.')

        try:

            RepoGroupModel().add_permission(repo_group=repo_group,

        Revoke permission for user on given repository group. This command can

        be executed only using api_key belonging to user with admin rights, or

        user who has admin right to given repository group.

        OUTPUT::

            id : <id_given_in_input>

            result : {

                      "msg" : "Revoked perm (recursive:<apply_to_children>) for user: `<username>` in repo group: `<repo_group_name>`",

                      "success" : true

                     }

            error : null

        """

        repo_group = get_repo_group_or_error(repogroupid)

        if not HasPermissionAny('hg.admin')():

            if not HasRepoGroupPermissionLevel('admin')(repo_group.group_name):

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

        user = get_user_or_error(userid)

        try:

            RepoGroupModel().delete_permission(repo_group=repo_group,

                                               obj=user,

        existing one if found. This command can be executed only using

        api_key belonging to user with admin rights, or user who has admin

        right to given repository group.

        OUTPUT::

          id : <id_given_in_input>

          result : {

            "msg" : "Granted perm: `<perm>` (recursive:<apply_to_children>) for user group: `<usersgroupname>` in repo group: `<repo_group_name>`",

            "success" : true

          }

          error : null

        """

        repo_group = get_repo_group_or_error(repogroupid)

        perm = get_perm_or_error(perm, prefix='group.')

        user_group = get_user_group_or_error(usergroupid)

        if not HasPermissionAny('hg.admin')():

            if not HasRepoGroupPermissionLevel('admin')(repo_group.group_name):

                raise JSONRPCError(

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

            if not HasUserGroupPermissionLevel('read')(user_group.users_group_name):

                raise JSONRPCError(

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

        Revoke permission for user group on given repository. This command can be

        executed only using api_key belonging to user with admin rights, or

        user who has admin right to given repository group.

        OUTPUT::

            id : <id_given_in_input>

            result : {

                      "msg" : "Revoked perm (recursive:<apply_to_children>) for user group: `<usersgroupname>` in repo group: `<repo_group_name>`",

                      "success" : true

                     }

            error : null

        """

        repo_group = get_repo_group_or_error(repogroupid)

        user_group = get_user_group_or_error(usergroupid)

        if not HasPermissionAny('hg.admin')():

            if not HasRepoGroupPermissionLevel('admin')(repo_group.group_name):

                raise JSONRPCError(

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

            if not HasUserGroupPermissionLevel('read')(user_group.users_group_name):

                raise JSONRPCError(

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

                    description=''):

        """

        Creates new Gist

        OUTPUT::

          id : <id_given_in_input>

          result : {

            "msg" : "created new gist",

            "gist" : <gist_object>

          }

          error : null

        """

        try:

            if owner is None:

                owner = request.authuser.user_id

            owner = get_user_or_error(owner)

            gist = GistModel().create(description=description,

                                      owner=owner,

                                      ip_addr=request.ip_addr,

                                      gist_mapping=files,

                                      gist_type=gist_type,

    def delete_gist(self, gistid):

        """

        Deletes existing gist

        OUTPUT::

          id : <id_given_in_input>

          result : {

            "msg" : "deleted gist ID: <gist_id>",

            "gist" : null

          }

          error : null

        """

        gist = get_gist_or_error(gistid)

        if not HasPermissionAny('hg.admin')():

            if gist.owner_id != request.authuser.user_id:

                raise JSONRPCError('gist `%s` does not exist' % (gistid,))

        try:

            GistModel().delete(gist)

            meta.Session().commit()

            return dict(

                msg='deleted gist ID:%s' % (gist.gist_access_id,),

                gist=None