using api_key belonging to user with admin rights

INPUT::

    id : <id_for_response>

    api_key : "<api_key>"

    method :  "remove_user_from_users_group"

    args:     {

                "group_name" :  "<groupname>",

                "username" :   "<username>"

              }

OUTPUT::

    result: {

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

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

                      User wasn't in group"

            }

    error:  null

get_repo

--------

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.

INPUT::

    id : <id_for_response>

    api_key : "<api_key>"

    method :  "get_repo"

    args:     {

                "repoid" : "<reponame or repo_id>"

              }

OUTPUT::

    result: None if repository does not exist or

            {

                "id" :          "<id>",

                "repo_name" :   "<reponame>"

                "type" :        "<type>",

                "description" : "<description>",

                "members" :     [

                                  { 

                                    "type": "user",

                                    "id" :         "<userid>",

                                    "username" :   "<username>",

                                    "firstname":   "<firstname>",

                                    "lastname" :   "<lastname>",

                                    "email" :      "<email>",

                                    "active" :     "<bool>",

                                    "admin" :      "<bool>",

                                    "ldap" :       "<ldap_dn>",

                                    "permission" : "repository.(read|write|admin)"

                                  },

                                  …

                                  { 

                                    "type": "users_group",

                                    "id" :       "<usersgroupid>",

                                    "name" :     "<usersgroupname>",

                                    "active":    "<bool>",

                                    "permission" : "repository.(read|write|admin)"

                                  },

                                  …

                                ]

            }

    error:  null

get_repos

---------

Lists all existing repositories. 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 :  "get_repos"

    args:     { }

OUTPUT::

    result: [

              {

                "id" :          "<id>",

                "repo_name" :   "<reponame>"

                "type" :        "<type>",

              },

              …

            ]

    error:  null

get_repo_nodes

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

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

INPUT::

    id : <id_for_response>

    api_key : "<api_key>"

    method :  "get_repo_nodes"

    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.

    @HasPermissionAnyDecorator('hg.admin')

    def get_repo(self, apiuser, repoid):

        """"

        Get repository by name

        :param apiuser:

        :param repo_name:

        """

        repo = RepoModel().get_repo(repoid)

        if repo is None:

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

        members = []

        for user in repo.repo_to_perm:

            perm = user.permission.permission_name

            user = user.user

            members.append(

                dict(

                    type="user",

                    id=user.user_id,

                    username=user.username,

                    firstname=user.name,

                    lastname=user.lastname,

                    email=user.email,

                    active=user.active,

                    admin=user.admin,

                    ldap=user.ldap_dn,

                    permission=perm

                )

            )

        for users_group in repo.users_group_to_perm:

            perm = users_group.permission.permission_name

            users_group = users_group.users_group

            members.append(

                dict(

                    type="users_group",

                    id=users_group.users_group_id,

                    name=users_group.users_group_name,

                    active=users_group.users_group_active,

                    permission=perm

                )

            )

        return dict(

            id=repo.repo_id,

            repo_name=repo.repo_name,

            type=repo.repo_type,

            description=repo.description,

            members=members

        )

    @HasPermissionAnyDecorator('hg.admin')

    def get_repos(self, apiuser):

        """"

        Get all repositories

        :param apiuser:

        """

        result = []

            result.append(

                dict(

                )

            )

        return result

    @HasPermissionAnyDecorator('hg.admin')

    def get_repo_nodes(self, apiuser, repo_name, revision, root_path,

                       ret_type='all'):

        """

        returns a list of nodes and it's children

        for a given path at given revision. It's possible to specify ret_type

        to show only files or dirs

        :param apiuser:

        :param repo_name: name of repository

        :param revision: revision for which listing should be done

        :param root_path: path from which start displaying

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

        """

        try:

            _d, _f = ScmModel().get_nodes(repo_name, revision, root_path,

                                          flat=False)

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