Changeset - c6c30609df33
Parent rev.
Child rev.
[Not reviewed]
stable
0 1 0
Mads Kiilerich (mads) - 5 years ago 2021-01-06 01:27:31
mads@kiilerich.com
Grafted from: 64f8d5482b97
api docstrings: drop the mostly useless :param autodoc
1 file changed with 0 insertions and 257 deletions:
kallithea/controllers/api/api.py
257
0 comments (0 inline, 0 general)
kallithea/controllers/api/api.py
➞
Show inline comments
 
@@ -62,63 +62,53 @@ def store_update(updates, attr, name):
 
        updates[name] = attr
 

			




	
	
	
		
 

			




	
	
	
		
 
def get_user_or_error(userid):

			




	
	
	
		
 
    """

			




	
	
	
		
 
    Get user by id or name or return JsonRPCError if not found

			




	
	
	
		
 

			




	
	
	
		
 
    :param userid:

			




	
	
	
		
 
    """

			




	
	
	
		
 
    user = UserModel().get_user(userid)

			




	
	
	
		
 
    if user is None:

			




	
	
	
		
 
        raise JSONRPCError("user `%s` does not exist" % (userid,))

			




	
	
	
		
 
    return user

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def get_repo_or_error(repoid):

			




	
	
	
		
 
    """

			




	
	
	
		
 
    Get repo by id or name or return JsonRPCError if not found

			




	
	
	
		
 

			




	
	
	
		
 
    :param repoid:

			




	
	
	
		
 
    """

			




	
	
	
		
 
    repo = RepoModel().get_repo(repoid)

			




	
	
	
		
 
    if repo is None:

			




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

			




	
	
	
		
 
    return repo

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def get_repo_group_or_error(repogroupid):

			




	
	
	
		
 
    """

			




	
	
	
		
 
    Get repo group by id or name or return JsonRPCError if not found

			




	
	
	
		
 

			




	
	
	
		
 
    :param repogroupid:

			




	
	
	
		
 
    """

			




	
	
	
		
 
    repo_group = db.RepoGroup.guess_instance(repogroupid)

			




	
	
	
		
 
    if repo_group is None:

			




	
	
	
		
 
        raise JSONRPCError(

			




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

			




	
	
	
		
 
    return repo_group

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def get_user_group_or_error(usergroupid):

			




	
	
	
		
 
    """

			




	
	
	
		
 
    Get user group by id or name or return JsonRPCError if not found

			




	
	
	
		
 

			




	
	
	
		
 
    :param usergroupid:

			




	
	
	
		
 
    """

			




	
	
	
		
 
    user_group = UserGroupModel().get_group(usergroupid)

			




	
	
	
		
 
    if user_group is None:

			




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

			




	
	
	
		
 
    return user_group

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def get_perm_or_error(permid, prefix=None):

			




	
	
	
		
 
    """

			




	
	
	
		
 
    Get permission by id or name or return JsonRPCError if not found

			




	
	
	
		
 

			




	
	
	
		
 
    :param permid:

			




	
	
	
		
 
    """

			




	
	
	
		
 
    perm = db.Permission.get_by_key(permid)

			




	
	
	
		
 
    if perm is None:

			




	
	
	
		
 
        raise JSONRPCError('permission `%s` does not exist' % (permid,))

			




	
	
	
		
 
    if prefix:

			




	
	
	
		
 
        if not perm.permission_name.startswith(prefix):

			




	
	
		
 
@@ -127,14 +117,12 @@ def get_perm_or_error(permid, prefix=Non

			




	
	
	
		
 
    return perm

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def get_gist_or_error(gistid):

			




	
	
	
		
 
    """

			




	
	
	
		
 
    Get gist by id or gist_access_id or return JsonRPCError if not found

			




	
	
	
		
 

			




	
	
	
		
 
    :param gistid:

			




	
	
	
		
 
    """

			




	
	
	
		
 
    gist = GistModel().get_gist(gistid)

			




	
	
	
		
 
    if gist is None:

			




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

			




	
	
	
		
 
    return gist

			




	
	
	
		
 

			




	
	
		
 
@@ -162,17 +150,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
    def pull(self, repoid, clone_uri=None):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        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

			




	
	
	
		
 

			




	
	
	
		
 
        :param repoid: repository name or repository id

			




	
	
	
		
 
        :type repoid: str or int

			




	
	
	
		
 
        :param clone_uri: repository URI to pull from (optional)

			




	
	
	
		
 
        :type clone_uri: str

			




	
	
	
		
 

			




	
	
	
		
 
        OUTPUT::

			




	
	
	
		
 

			




	
	
	
		
 
            id : <id_given_in_input>

			




	
	
	
		
 
            result : {

			




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

			




	
	
	
		
 
                "repository" : "<repository name>"

			




	
	
		
 
@@ -209,16 +192,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Triggers rescan repositories action. If remove_obsolete is set

			




	
	
	
		
 
        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.

			




	
	
	
		
 

			




	
	
	
		
 
        :param remove_obsolete: deletes repositories from

			




	
	
	
		
 
            database that are not found on the filesystem

			




	
	
	
		
 
        :type remove_obsolete: Optional(bool)

			




	
	
	
		
 

			




	
	
	
		
 
        OUTPUT::

			




	
	
	
		
 

			




	
	
	
		
 
            id : <id_given_in_input>

			




	
	
	
		
 
            result : {

			




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

			




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

			




	
	
		
 
@@ -247,15 +226,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
    def invalidate_cache(self, repoid):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        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.

			




	
	
	
		
 

			




	
	
	
		
 
        :param repoid: repository name or repository id

			




	
	
	
		
 
        :type repoid: str or int

			




	
	
	
		
 

			




	
	
	
		
 
        OUTPUT::

			




	
	
	
		
 

			




	
	
	
		
 
            id : <id_given_in_input>

			




	
	
	
		
 
            result : {

			




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

			




	
	
	
		
 
                'repository': <repository name>

			




	
	
		
 
@@ -293,15 +269,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
        Shows IP address as seen from Kallithea server, together with all

			




	
	
	
		
 
        defined IP addresses for given user. If userid is not passed data is

			




	
	
	
		
 
        returned for user who's calling this function.

			




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

			




	
	
	
		
 
        admin rights.

			




	
	
	
		
 

			




	
	
	
		
 
        :param userid: username to show ips for

			




	
	
	
		
 
        :type userid: Optional(str or int)

			




	
	
	
		
 

			




	
	
	
		
 
        OUTPUT::

			




	
	
	
		
 

			




	
	
	
		
 
            id : <id_given_in_input>

			




	
	
	
		
 
            result : {

			




	
	
	
		
 
                         "server_ip_addr" : "<ip_from_client>",

			




	
	
	
		
 
                         "user_ips" : [

			




	
	
		
 
@@ -351,15 +324,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
        Gets a user by username or user_id, Returns empty result if user is

			




	
	
	
		
 
        not found. If userid param is skipped it is set to id of user who is

			




	
	
	
		
 
        calling this method. This command can be executed only using api_key

			




	
	
	
		
 
        belonging to user with admin rights, or regular users that cannot

			




	
	
	
		
 
        specify different userid than theirs

			




	
	
	
		
 

			




	
	
	
		
 
        :param userid: user to get data for

			




	
	
	
		
 
        :type userid: Optional(str or int)

			




	
	
	
		
 

			




	
	
	
		
 
        OUTPUT::

			




	
	
	
		
 

			




	
	
	
		
 
            id : <id_given_in_input>

			




	
	
	
		
 
            result : None if user does not exist or

			




	
	
	
		
 
                     {

			




	
	
	
		
 
                        "user_id" :     "<user_id>",

			




	
	
		
 
@@ -423,31 +393,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
                    extern_type=db.User.DEFAULT_AUTH_TYPE,

			




	
	
	
		
 
                    extern_name=''):

			




	
	
	
		
 
        """

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
        :param username: new username

			




	
	
	
		
 
        :type username: str or int

			




	
	
	
		
 
        :param email: email

			




	
	
	
		
 
        :type email: str

			




	
	
	
		
 
        :param password: password

			




	
	
	
		
 
        :type password: Optional(str)

			




	
	
	
		
 
        :param firstname: firstname

			




	
	
	
		
 
        :type firstname: str

			




	
	
	
		
 
        :param lastname: lastname

			




	
	
	
		
 
        :type lastname: str

			




	
	
	
		
 
        :param active: active

			




	
	
	
		
 
        :type active: Optional(bool)

			




	
	
	
		
 
        :param admin: admin

			




	
	
	
		
 
        :type admin: Optional(bool)

			




	
	
	
		
 
        :param extern_name: name of extern

			




	
	
	
		
 
        :type extern_name: Optional(str)

			




	
	
	
		
 
        :param extern_type: extern_type

			




	
	
	
		
 
        :type extern_type: Optional(str)

			




	
	
	
		
 

			




	
	
	
		
 
        OUTPUT::

			




	
	
	
		
 

			




	
	
	
		
 
            id : <id_given_in_input>

			




	
	
	
		
 
            result : {

			




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

			




	
	
	
		
 
                      "user" : <user_obj>

			




	
	
		
 
@@ -500,33 +451,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
                    active=None, admin=None,

			




	
	
	
		
 
                    extern_type=None, extern_name=None):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        updates given user if such user exists. This command can

			




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

			




	
	
	
		
 

			




	
	
	
		
 
        :param userid: userid to update

			




	
	
	
		
 
        :type userid: str or int

			




	
	
	
		
 
        :param username: new username

			




	
	
	
		
 
        :type username: Optional(str or int)

			




	
	
	
		
 
        :param email: email

			




	
	
	
		
 
        :type email: Optional(str)

			




	
	
	
		
 
        :param password: password

			




	
	
	
		
 
        :type password: Optional(str)

			




	
	
	
		
 
        :param firstname: firstname

			




	
	
	
		
 
        :type firstname: Optional(str)

			




	
	
	
		
 
        :param lastname: lastname

			




	
	
	
		
 
        :type lastname: Optional(str)

			




	
	
	
		
 
        :param active: active

			




	
	
	
		
 
        :type active: Optional(bool)

			




	
	
	
		
 
        :param admin: admin

			




	
	
	
		
 
        :type admin: Optional(bool)

			




	
	
	
		
 
        :param extern_name:

			




	
	
	
		
 
        :type extern_name: Optional(str)

			




	
	
	
		
 
        :param extern_type:

			




	
	
	
		
 
        :type extern_type: Optional(str)

			




	
	
	
		
 

			




	
	
	
		
 
        OUTPUT::

			




	
	
	
		
 

			




	
	
	
		
 
            id : <id_given_in_input>

			




	
	
	
		
 
            result : {

			




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

			




	
	
	
		
 
                      "user" : <user_object>

			




	
	
		
 
@@ -574,15 +504,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
    @HasPermissionAnyDecorator('hg.admin')

			




	
	
	
		
 
    def delete_user(self, userid):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        deletes given user if such user exists. This command can

			




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

			




	
	
	
		
 

			




	
	
	
		
 
        :param userid: user to delete

			




	
	
	
		
 
        :type userid: str or int

			




	
	
	
		
 

			




	
	
	
		
 
        OUTPUT::

			




	
	
	
		
 

			




	
	
	
		
 
            id : <id_given_in_input>

			




	
	
	
		
 
            result : {

			




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

			




	
	
	
		
 
                      "user" : null

			




	
	
		
 
@@ -616,15 +543,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
    def get_user_group(self, usergroupid):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Gets an existing user group. This command can be executed only using api_key

			




	
	
	
		
 
        belonging to user with admin rights or user who has at least

			




	
	
	
		
 
        read access to user group.

			




	
	
	
		
 

			




	
	
	
		
 
        :param usergroupid: id of user_group to edit

			




	
	
	
		
 
        :type usergroupid: str or int

			




	
	
	
		
 

			




	
	
	
		
 
        OUTPUT::

			




	
	
	
		
 

			




	
	
	
		
 
            id : <id_given_in_input>

			




	
	
	
		
 
            result : None if group not exist

			




	
	
	
		
 
                     {

			




	
	
	
		
 
                       "users_group_id" : "<id>",

			




	
	
		
 
@@ -667,21 +591,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
                          owner=None, active=True):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        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

			




	
	
	
		
 

			




	
	
	
		
 
        :param group_name: name of new user group

			




	
	
	
		
 
        :type group_name: str

			




	
	
	
		
 
        :param description: group description

			




	
	
	
		
 
        :type description: Optional(str)

			




	
	
	
		
 
        :param owner: owner of group. If not passed apiuser is the owner

			




	
	
	
		
 
        :type owner: Optional(str or int)

			




	
	
	
		
 
        :param active: group is active

			




	
	
	
		
 
        :type active: Optional(bool)

			




	
	
	
		
 

			




	
	
	
		
 
        OUTPUT::

			




	
	
	
		
 

			




	
	
	
		
 
            id : <id_given_in_input>

			




	
	
	
		
 
            result : {

			




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

			




	
	
	
		
 
                      "user_group" : <user_group_object>

			




	
	
		
 
@@ -722,23 +637,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
                          description=None, owner=None,

			




	
	
	
		
 
                          active=None):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        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

			




	
	
	
		
 

			




	
	
	
		
 
        :param usergroupid: id of user group to update

			




	
	
	
		
 
        :type usergroupid: str or int

			




	
	
	
		
 
        :param group_name: name of new user group

			




	
	
	
		
 
        :type group_name: str

			




	
	
	
		
 
        :param description: group description

			




	
	
	
		
 
        :type description: str

			




	
	
	
		
 
        :param owner: owner of group.

			




	
	
	
		
 
        :type owner: Optional(str or int)

			




	
	
	
		
 
        :param active: group is active

			




	
	
	
		
 
        :type active: Optional(bool)

			




	
	
	
		
 

			




	
	
	
		
 
        OUTPUT::

			




	
	
	
		
 

			




	
	
	
		
 
          id : <id_given_in_input>

			




	
	
	
		
 
          result : {

			




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

			




	
	
	
		
 
            "user_group" : <user_group_object>

			




	
	
		
 
@@ -782,15 +686,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
    def delete_user_group(self, usergroupid):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        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

			




	
	
	
		
 

			




	
	
	
		
 
        :param usergroupid:

			




	
	
	
		
 
        :type usergroupid: str or int

			




	
	
	
		
 

			




	
	
	
		
 
        OUTPUT::

			




	
	
	
		
 

			




	
	
	
		
 
          id : <id_given_in_input>

			




	
	
	
		
 
          result : {

			




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

			




	
	
	
		
 
          }

			




	
	
		
 
@@ -833,17 +734,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
    def add_user_to_user_group(self, usergroupid, userid):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Adds a user to a user group. If user exists in that group success will be

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
        :param usergroupid:

			




	
	
	
		
 
        :type usergroupid: str or int

			




	
	
	
		
 
        :param userid:

			




	
	
	
		
 
        :type userid: str or int

			




	
	
	
		
 

			




	
	
	
		
 
        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>` |

			




	
	
		
 
@@ -890,15 +786,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
    def remove_user_from_user_group(self, usergroupid, userid):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Removes a user from a user group. If user is not in given group success will

			




	
	
	
		
 
        be `false`. This command can be executed only

			




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

			




	
	
	
		
 

			




	
	
	
		
 
        :param usergroupid:

			




	
	
	
		
 
        :param userid:

			




	
	
	
		
 

			




	
	
	
		
 
        OUTPUT::

			




	
	
	
		
 

			




	
	
	
		
 
            id : <id_given_in_input>

			




	
	
	
		
 
            result : {

			




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

			




	
	
	
		
 
                      "msg" : "removed member <username> from user group <groupname> |

			




	
	
		
 
@@ -935,15 +828,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Gets an existing repository by it's name or repository_id. Members will return

			




	
	
	
		
 
        either users_group or user associated to that repository. This command can be

			




	
	
	
		
 
        executed only using api_key belonging to user with admin

			




	
	
	
		
 
        rights or regular user that have at least read access to repository.

			




	
	
	
		
 

			




	
	
	
		
 
        :param repoid: repository name or repository id

			




	
	
	
		
 
        :type repoid: str or int

			




	
	
	
		
 

			




	
	
	
		
 
        OUTPUT::

			




	
	
	
		
 

			




	
	
	
		
 
            id : <id_given_in_input>

			




	
	
	
		
 
            result : {

			




	
	
	
		
 
                        "repo_id" :          "<repo_id>",

			




	
	
	
		
 
                        "repo_name" :        "<reponame>",

			




	
	
		
 
@@ -1079,21 +969,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        returns a list of nodes and it's children in a flat list for a given path

			




	
	
	
		
 
        at given revision. It's possible to specify ret_type to show only `files` or

			




	
	
	
		
 
        `dirs`.  This command can be executed only using api_key belonging to

			




	
	
	
		
 
        user with admin rights or regular user that have at least read access to repository.

			




	
	
	
		
 

			




	
	
	
		
 
        :param repoid: repository name or repository id

			




	
	
	
		
 
        :type repoid: str or int

			




	
	
	
		
 
        :param revision: revision for which listing should be done

			




	
	
	
		
 
        :type revision: str

			




	
	
	
		
 
        :param root_path: path from which start displaying

			




	
	
	
		
 
        :type root_path: str

			




	
	
	
		
 
        :param ret_type: return type 'all|files|dirs' nodes

			




	
	
	
		
 
        :type ret_type: Optional(str)

			




	
	
	
		
 

			




	
	
	
		
 
        OUTPUT::

			




	
	
	
		
 

			




	
	
	
		
 
            id : <id_given_in_input>

			




	
	
	
		
 
            result : [

			




	
	
	
		
 
                      {

			




	
	
	
		
 
                        "name" :        "<name>",

			




	
	
		
 
@@ -1141,34 +1022,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
        parent repository group must exist. For example "foo/bar/baz" require the groups

			




	
	
	
		
 
        "foo" and "bar" (with "foo" as parent), and create "baz" repository with

			




	
	
	
		
 
        "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

			




	
	
	
		
 

			




	
	
	
		
 
        :param repo_name: repository name

			




	
	
	
		
 
        :type repo_name: str

			




	
	
	
		
 
        :param owner: user_id or username

			




	
	
	
		
 
        :type owner: Optional(str)

			




	
	
	
		
 
        :param repo_type: 'hg' or 'git'

			




	
	
	
		
 
        :type repo_type: Optional(str)

			




	
	
	
		
 
        :param description: repository description

			




	
	
	
		
 
        :type description: Optional(str)

			




	
	
	
		
 
        :param private:

			




	
	
	
		
 
        :type private: bool

			




	
	
	
		
 
        :param clone_uri:

			




	
	
	
		
 
        :type clone_uri: str

			




	
	
	
		
 
        :param landing_rev: <rev_type>:<rev>

			




	
	
	
		
 
        :type landing_rev: str

			




	
	
	
		
 
        :param enable_downloads:

			




	
	
	
		
 
        :type enable_downloads: bool

			




	
	
	
		
 
        :param enable_statistics:

			




	
	
	
		
 
        :type enable_statistics: bool

			




	
	
	
		
 
        :param copy_permissions: Copy permission from group that repository is

			




	
	
	
		
 
            being created.

			




	
	
	
		
 
        :type copy_permissions: bool

			




	
	
	
		
 

			




	
	
	
		
 
        OUTPUT::

			




	
	
	
		
 

			




	
	
	
		
 
            id : <id_given_in_input>

			




	
	
	
		
 
            result : {

			




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

			




	
	
	
		
 
                      "success" : true

			




	
	
		
 
@@ -1254,24 +1113,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
                    description=None, private=None,

			




	
	
	
		
 
                    clone_uri=None, landing_rev=None,

			




	
	
	
		
 
                    enable_statistics=None,

			




	
	
	
		
 
                    enable_downloads=None):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Updates repo

			




	
	
	
		
 

			




	
	
	
		
 
        :param repoid: repository name or repository id

			




	
	
	
		
 
        :type repoid: str or int

			




	
	
	
		
 
        :param name:

			




	
	
	
		
 
        :param owner:

			




	
	
	
		
 
        :param group:

			




	
	
	
		
 
        :param description:

			




	
	
	
		
 
        :param private:

			




	
	
	
		
 
        :param clone_uri:

			




	
	
	
		
 
        :param landing_rev:

			




	
	
	
		
 
        :param enable_statistics:

			




	
	
	
		
 
        :param enable_downloads:

			




	
	
	
		
 
        """

			




	
	
	
		
 
        repo = get_repo_or_error(repoid)

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
		
 
@@ -1325,21 +1172,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
        Creates a fork of given repo. In case of using celery this will

			




	
	
	
		
 
        immediately return success message, while fork is going to be created

			




	
	
	
		
 
        asynchronous. This command can be executed only using api_key belonging to

			




	
	
	
		
 
        user with admin rights or regular user that have fork permission, and at least

			




	
	
	
		
 
        read access to forking repository. Regular users cannot specify owner parameter.

			




	
	
	
		
 

			




	
	
	
		
 
        :param repoid: repository name or repository id

			




	
	
	
		
 
        :type repoid: str or int

			




	
	
	
		
 
        :param fork_name:

			




	
	
	
		
 
        :param owner:

			




	
	
	
		
 
        :param description:

			




	
	
	
		
 
        :param copy_permissions:

			




	
	
	
		
 
        :param private:

			




	
	
	
		
 
        :param landing_rev:

			




	
	
	
		
 

			




	
	
	
		
 
        INPUT::

			




	
	
	
		
 

			




	
	
	
		
 
            id : <id_for_response>

			




	
	
	
		
 
            api_key : "<api_key>"

			




	
	
	
		
 
            method :  "fork_repo"

			




	
	
	
		
 
            args :    {

			




	
	
		
 
@@ -1431,17 +1269,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Deletes a repository. This command can be executed only using api_key belonging

			




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

			




	
	
	
		
 
        When `forks` param is set it's possible to detach or delete forks of deleting

			




	
	
	
		
 
        repository

			




	
	
	
		
 

			




	
	
	
		
 
        :param repoid: repository name or repository id

			




	
	
	
		
 
        :type repoid: str or int

			




	
	
	
		
 
        :param forks: `detach` or `delete`, what do do with attached forks for repo

			




	
	
	
		
 
        :type forks: Optional(str)

			




	
	
	
		
 

			




	
	
	
		
 
        OUTPUT::

			




	
	
	
		
 

			




	
	
	
		
 
            id : <id_given_in_input>

			




	
	
	
		
 
            result : {

			




	
	
	
		
 
                      "msg" : "Deleted repository `<reponame>`",

			




	
	
	
		
 
                      "success" : true

			




	
	
		
 
@@ -1484,18 +1317,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
    def grant_user_permission(self, repoid, userid, perm):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Grant permission for user on given repository, or update existing one

			




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

			




	
	
	
		
 
        with admin rights.

			




	
	
	
		
 

			




	
	
	
		
 
        :param repoid: repository name or repository id

			




	
	
	
		
 
        :type repoid: str or int

			




	
	
	
		
 
        :param userid:

			




	
	
	
		
 
        :param perm: (repository.(none|read|write|admin))

			




	
	
	
		
 
        :type perm: str

			




	
	
	
		
 

			




	
	
	
		
 
        OUTPUT::

			




	
	
	
		
 

			




	
	
	
		
 
            id : <id_given_in_input>

			




	
	
	
		
 
            result : {

			




	
	
	
		
 
                      "msg" : "Granted perm: `<perm>` for user: `<username>` in repo: `<reponame>`",

			




	
	
	
		
 
                      "success" : true

			




	
	
		
 
@@ -1528,16 +1355,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
    @HasPermissionAnyDecorator('hg.admin')

			




	
	
	
		
 
    def revoke_user_permission(self, repoid, userid):

			




	
	
	
		
 
        """

			




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

			




	
	
	
		
 
        only using api_key belonging to user with admin rights.

			




	
	
	
		
 

			




	
	
	
		
 
        :param repoid: repository name or repository id

			




	
	
	
		
 
        :type repoid: str or int

			




	
	
	
		
 
        :param userid:

			




	
	
	
		
 

			




	
	
	
		
 
        OUTPUT::

			




	
	
	
		
 

			




	
	
	
		
 
            id : <id_given_in_input>

			




	
	
	
		
 
            result : {

			




	
	
	
		
 
                      "msg" : "Revoked perm for user: `<username>` in repo: `<reponame>`",

			




	
	
	
		
 
                      "success" : true

			




	
	
		
 
@@ -1567,19 +1390,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
    def grant_user_group_permission(self, repoid, usergroupid, perm):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        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.

			




	
	
	
		
 

			




	
	
	
		
 
        :param repoid: repository name or repository id

			




	
	
	
		
 
        :type repoid: str or int

			




	
	
	
		
 
        :param usergroupid: id of usergroup

			




	
	
	
		
 
        :type usergroupid: str or int

			




	
	
	
		
 
        :param perm: (repository.(none|read|write|admin))

			




	
	
	
		
 
        :type perm: str

			




	
	
	
		
 

			




	
	
	
		
 
        OUTPUT::

			




	
	
	
		
 

			




	
	
	
		
 
            id : <id_given_in_input>

			




	
	
	
		
 
            result : {

			




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

			




	
	
	
		
 
                "success" : true

			




	
	
		
 
@@ -1629,16 +1445,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
    # permission check inside

			




	
	
	
		
 
    def revoke_user_group_permission(self, repoid, usergroupid):

			




	
	
	
		
 
        """

			




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

			




	
	
	
		
 
        executed only using api_key belonging to user with admin rights.

			




	
	
	
		
 

			




	
	
	
		
 
        :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

			




	
	
		
 
@@ -1676,15 +1488,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 

			




	
	
	
		
 
    @HasPermissionAnyDecorator('hg.admin')

			




	
	
	
		
 
    def get_repo_group(self, repogroupid):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Returns given repo group together with permissions, and repositories

			




	
	
	
		
 
        inside the group

			




	
	
	
		
 

			




	
	
	
		
 
        :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

			




	
	
		
 
@@ -1726,23 +1535,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
                          parent=None,

			




	
	
	
		
 
                          copy_permissions=False):

			




	
	
	
		
 
        """

			




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

			




	
	
	
		
 
        api_key belonging to user with admin rights.

			




	
	
	
		
 

			




	
	
	
		
 
        :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>

			




	
	
		
 
@@ -1811,15 +1609,12 @@ class ApiController(JSONRPCController):

			




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

			




	
	
	
		
 
                               % (repogroupid,))

			




	
	
	
		
 

			




	
	
	
		
 
    @HasPermissionAnyDecorator('hg.admin')

			




	
	
	
		
 
    def delete_repo_group(self, repogroupid):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        :param repogroupid: name or id of repository group

			




	
	
	
		
 
        :type repogroupid: str or int

			




	
	
	
		
 

			




	
	
	
		
 
        OUTPUT::

			




	
	
	
		
 

			




	
	
	
		
 
          id : <id_given_in_input>

			




	
	
	
		
 
          result : {

			




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

			




	
	
	
		
 
            'repo_group' : null

			




	
	
		
 
@@ -1856,20 +1651,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Grant permission for user on given repository group, or update 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.

			




	
	
	
		
 

			




	
	
	
		
 
        :param repogroupid: name or id of repository group

			




	
	
	
		
 
        :type repogroupid: str or int

			




	
	
	
		
 
        :param userid:

			




	
	
	
		
 
        :param perm: (group.(none|read|write|admin))

			




	
	
	
		
 
        :type perm: str

			




	
	
	
		
 
        :param apply_to_children: 'none', 'repos', 'groups', 'all'

			




	
	
	
		
 
        :type apply_to_children: str

			




	
	
	
		
 

			




	
	
	
		
 
        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

			




	
	
		
 
@@ -1917,19 +1704,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
                                               apply_to_children='none'):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        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.

			




	
	
	
		
 

			




	
	
	
		
 
        :param repogroupid: name or id of repository group

			




	
	
	
		
 
        :type repogroupid: str or int

			




	
	
	
		
 
        :param userid:

			




	
	
	
		
 
        :type userid:

			




	
	
	
		
 
        :param apply_to_children: 'none', 'repos', 'groups', 'all'

			




	
	
	
		
 
        :type apply_to_children: str

			




	
	
	
		
 

			




	
	
	
		
 
        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

			




	
	
		
 
@@ -1978,21 +1758,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Grant permission for user group on given repository group, or update

			




	
	
	
		
 
        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.

			




	
	
	
		
 

			




	
	
	
		
 
        :param repogroupid: name or id of repository group

			




	
	
	
		
 
        :type repogroupid: str or int

			




	
	
	
		
 
        :param usergroupid: id of usergroup

			




	
	
	
		
 
        :type usergroupid: str or int

			




	
	
	
		
 
        :param perm: (group.(none|read|write|admin))

			




	
	
	
		
 
        :type perm: str

			




	
	
	
		
 
        :param apply_to_children: 'none', 'repos', 'groups', 'all'

			




	
	
	
		
 
        :type apply_to_children: str

			




	
	
	
		
 

			




	
	
	
		
 
        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

			




	
	
		
 
@@ -2048,18 +1819,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
            apply_to_children='none'):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        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.

			




	
	
	
		
 

			




	
	
	
		
 
        :param repogroupid: name or id of repository group

			




	
	
	
		
 
        :type repogroupid: str or int

			




	
	
	
		
 
        :param usergroupid:

			




	
	
	
		
 
        :param apply_to_children: 'none', 'repos', 'groups', 'all'

			




	
	
	
		
 
        :type apply_to_children: str

			




	
	
	
		
 

			




	
	
	
		
 
        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

			




	
	
		
 
@@ -2105,29 +1870,23 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
                )

			




	
	
	
		
 
            )

			




	
	
	
		
 

			




	
	
	
		
 
    def get_gist(self, gistid):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Get given gist by id

			




	
	
	
		
 

			




	
	
	
		
 
        :param gistid: id of private or public gist

			




	
	
	
		
 
        :type gistid: str

			




	
	
	
		
 
        """

			




	
	
	
		
 
        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,))

			




	
	
	
		
 
        return gist.get_api_data()

			




	
	
	
		
 

			




	
	
	
		
 
    def get_gists(self, userid=None):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Get all gists for given user. If userid is empty returned gists

			




	
	
	
		
 
        are for user who called the api

			




	
	
	
		
 

			




	
	
	
		
 
        :param userid: user to get gists for

			




	
	
	
		
 
        :type userid: Optional(str or int)

			




	
	
	
		
 
        """

			




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

			




	
	
	
		
 
            # make sure normal user does not pass someone else userid,

			




	
	
	
		
 
            # he is not allowed to do that

			




	
	
	
		
 
            if userid is not None and userid != request.authuser.user_id:

			




	
	
	
		
 
                raise JSONRPCError(

			




	
	
		
 
@@ -2150,25 +1909,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
    def create_gist(self, files, owner=None,

			




	
	
	
		
 
                    gist_type=db.Gist.GIST_PUBLIC, lifetime=-1,

			




	
	
	
		
 
                    description=''):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Creates new Gist

			




	
	
	
		
 

			




	
	
	
		
 
        :param files: files to be added to gist

			




	
	
	
		
 
            {'filename': {'content':'...', 'lexer': null},

			




	
	
	
		
 
             'filename2': {'content':'...', 'lexer': null}}

			




	
	
	
		
 
        :type files: dict

			




	
	
	
		
 
        :param owner: gist owner, defaults to api method caller

			




	
	
	
		
 
        :type owner: Optional(str or int)

			




	
	
	
		
 
        :param gist_type: type of gist 'public' or 'private'

			




	
	
	
		
 
        :type gist_type: Optional(str)

			




	
	
	
		
 
        :param lifetime: time in minutes of gist lifetime

			




	
	
	
		
 
        :type lifetime: Optional(int)

			




	
	
	
		
 
        :param description: gist description

			




	
	
	
		
 
        :type description: str

			




	
	
	
		
 

			




	
	
	
		
 
        OUTPUT::

			




	
	
	
		
 

			




	
	
	
		
 
          id : <id_given_in_input>

			




	
	
	
		
 
          result : {

			




	
	
	
		
 
            "msg" : "created new gist",

			




	
	
	
		
 
            "gist" : <gist_object>

			




	
	
		
 
@@ -2206,15 +1952,12 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 

			




	
	
	
		
 
    # permission check inside

			




	
	
	
		
 
    def delete_gist(self, gistid):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Deletes existing gist

			




	
	
	
		
 

			




	
	
	
		
 
        :param gistid: id of gist to delete

			




	
	
	
		
 
        :type gistid: str

			




	
	
	
		
 

			




	
	
	
		
 
        OUTPUT::

			




	
	
	
		
 

			




	
	
	
		
 
          id : <id_given_in_input>

			




	
	
	
		
 
          result : {

			




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

			




	
	
	
		
 
            "gist" : null

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        Server instance: clio-19230
    
    
        This site is powered by
            Kallithea 0.7.0,
        which is
        © 2010–2025 by various authors & licensed under GPLv3.
            – Support