args:     {

                "repo_name" : "<reponame>",

                "revision"  : "<revision>",

                "root_path" : "<root_path>",

                "ret_type"  : "<ret_type>" = 'all'

              }

OUTPUT::

    result: [

              {

                "name" :        "<name>"

                "type" :        "<type>",

              },

              …

            ]

    error:  null

create_repo

-----------

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

belonging to user with admin rights.

If repository name contains "/", all needed repository groups will be created.

For example "foo/bar/baz" will create groups "foo", "bar" (with "foo" as parent),

and create "baz" repository with "bar" as group.

INPUT::

    id : <id_for_response>

    api_key : "<api_key>"

    method :  "create_repo"

    args:     {

                "repo_name" :   "<reponame>",

                "owner_name" :  "<ownername>",

                "description" : "<description> = ''",

                "repo_type" :   "<type> = 'hg'",

                "private" :     "<bool> = False",

                "clone_uri" :   "<clone_uri> = None",

              }

OUTPUT::

    result: {

              "id": "<newrepoid>",

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

            }

    error:  null

delete_repo

-----------

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

belonging to user with admin rights.

INPUT::

    id : <id_for_response>

    api_key : "<api_key>"

    method :  "delete_repo"

    args:     {

                "repo_name" :   "<reponame>",

              }

OUTPUT::

    result: {

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

            }

    error:  null

grant_user_permission

---------------------

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.

INPUT::

    id : <id_for_response>

    api_key : "<api_key>"

    method :  "grant_user_permission"

    args:     {

                "repo_name" :  "<reponame>",

                "username" :   "<username>",

                "perm" :       "(repository.(none|read|write|admin))",

              }

OUTPUT::

            _map = {

                'all': _d + _f,

                'files': _f,

                'dirs': _d,

            }

            return _map[ret_type]

        except KeyError:

            raise JSONRPCError('ret_type must be one of %s' % _map.keys())

        except Exception, e:

            raise JSONRPCError(e)

    @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')

    def create_repo(self, apiuser, repo_name, owner_name, description='',

                    repo_type='hg', private=False, clone_uri=None):

        """

        Create repository, if clone_url is given it makes a remote clone

        :param apiuser:

        :param repo_name:

        :param owner_name:

        :param description:

        :param repo_type:

        :param private:

        :param clone_uri:

        """

        try:

            owner = User.get_by_username(owner_name)

            if owner is None:

                raise JSONRPCError('unknown user %s' % owner_name)

            if Repository.get_by_repo_name(repo_name):

                raise JSONRPCError("repo %s already exist" % repo_name)

            groups = repo_name.split(Repository.url_sep())

            real_name = groups[-1]

            # create structure of groups

            group = map_groups(repo_name)

            repo = RepoModel().create(

                dict(

                    repo_name=real_name,

                    repo_name_full=repo_name,

                    description=description,

                    private=private,

                    repo_type=repo_type,

                    repo_group=group.group_id if group else None,

                    clone_uri=clone_uri

            )

            Session.commit()

            return dict(

                id=repo.repo_id,

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to create repository %s' % repo_name)

    @HasPermissionAnyDecorator('hg.admin')

    def delete_repo(self, apiuser, repo_name):

        """

        Deletes a given repository

        :param repo_name:

        """

        if not Repository.get_by_repo_name(repo_name):

            raise JSONRPCError("repo %s does not exist" % repo_name)

        try:

            RepoModel().delete(repo_name)

            Session.commit()

            return dict(

                msg='Deleted repository %s' % repo_name

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to delete repository %s' % repo_name)

    @HasPermissionAnyDecorator('hg.admin')

    def grant_user_permission(self, apiuser, repo_name, username, perm):

        """

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

        if found

        :param repo_name:

        :param username:

        :param perm:

        """

        try:

            repo = Repository.get_by_repo_name(repo_name)

            if repo is None:

                raise JSONRPCError('unknown repository %s' % repo)

            user = User.get_by_username(username)

            if user is None:

                raise JSONRPCError('unknown user %s' % username)

            RepoModel().grant_user_permission(repo=repo, user=user, perm=perm)

            Session.commit()