…

                                ]

            }

    error:  null

get_repos

---------

Lists all existing repositories. This command can be executed only using api_key

belonging to user with admin rights

INPUT::

    api_key : "<api_key>"

    method :  "get_repos"

    args:     { }

OUTPUT::

    result: [

              {

                "id" :          "<id>",

                "repo_name" :   "<reponame>"

                "type" :        "<type>",

                "description" : "<description>"

              },

              …

            ]

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

    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.

INPUT::

    api_key : "<api_key>"

    method :  "create_repo"

    args:     {

                "repo_name" :   "<reponame>",

                "owner_name" :  "<ownername>",

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

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

                "private" :     "<bool> = False"

              }

OUTPUT::

    result: {

              "id": "<newrepoid>",

              "msg": "Created new 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::

    api_key : "<api_key>"

    method :  "grant_user_permission"

    args:     {

                "repo_name" :  "<reponame>",

                "username" :   "<username>",

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

              }

OUTPUT::

    result: {

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

            }

    error:  null

revoke_user_permission

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

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

only using api_key belonging to user with admin rights.

INPUT::

    api_key : "<api_key>"

    method  : "revoke_user_permission"

    args:     {

                "repo_name" :  "<reponame>",

                "username" :   "<username>",

              }

OUTPUT::

    result: {

              "msg" : "Revoked perm for user: <suername> in repo: <reponame>"

            }

    error:  null

grant_users_group_permission

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

Grant permission for users 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.

INPUT::

    api_key : "<api_key>"

    method :  "grant_users_group_permission"

    args:     {

                "repo_name" : "<reponame>",

                "group_name" : "<usersgroupname>",

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

              }

OUTPUT::

    result: {

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

            }

    error:  null

revoke_users_group_permission

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

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

executed only using api_key belonging to user with admin rights.

INPUT::

    api_key : "<api_key>"

    method  : "revoke_users_group_permission"

    args:     {

                "repo_name" :  "<reponame>",

                "users_group" :   "<usersgroupname>",

              }

OUTPUT::

    result: {

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

            }

        result = []

        for repository in Repository.getAll():

            result.append(

                dict(

                    id=repository.repo_id,

                    repo_name=repository.repo_name,

                    type=repository.repo_type,

                    description=repository.description

                )

            )

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

        """

        Create a repository

        :param apiuser:

        :param repo_name:

        :param description:

        :param type:

        :param private:

        :param owner_name:

        """

        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('/')

            real_name = groups[-1]

            groups = groups[:-1]

            parent_id = None

            for g in groups:

                group = RepoGroup.get_by_group_name(g)

                if not group:

                    group = ReposGroupModel().create(g, '', parent_id)

                parent_id = group.group_id

            repo = RepoModel().create(

                dict(

                    repo_name=real_name,

                    repo_name_full=repo_name,

                    description=description,

                    private=private,

                    repo_type=repo_type,

                    repo_group=parent_id,

                    clone_uri=None

                ),

                owner

            )

            Session.commit()

            return dict(

                id=repo.repo_id,

                msg="Created new repository %s" % repo.repo_name

            )

        except Exception:

            log.error(traceback.format_exc())

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

    @HasPermissionAnyDecorator('hg.admin')

    def grant_user_permission(self, 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()

            return dict(

                msg='Granted perm: %s for user: %s in repo: %s' % (

                    perm, username, repo_name

                )

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'failed to edit permission %(repo)s for %(user)s' % dict(

                    user=username, repo=repo_name

                )

            )

    @HasPermissionAnyDecorator('hg.admin')

    def revoke_user_permission(self, repo_name, username):

        """

        Revoke permission for user on given repository

        :param repo_name:

        :param username:

        """

        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().revoke_user_permission(repo=repo_name, user=username)

            Session.commit()

            return dict(

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

                    username, repo_name

                )

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'failed to edit permission %(repo)s for %(user)s' % dict(

                    user=username, repo=repo_name

                )

            )

    @HasPermissionAnyDecorator('hg.admin')

    def grant_users_group_permission(self, repo_name, group_name, perm):

        """

        Grant permission for users group on given repository, or update

        existing one if found

        :param repo_name:

        :param group_name:

        :param perm:

        """

        try:

            repo = Repository.get_by_repo_name(repo_name)

            if repo is None:

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

            user_group = UsersGroup.get_by_group_name(group_name)

            if user_group is None:

                raise JSONRPCError('unknown users group %s' % user_group)

            RepoModel().grant_users_group_permission(repo=repo_name,

                                                     group_name=group_name,

                                                     perm=perm)

            Session.commit()

            return dict(

                msg='Granted perm: %s for group: %s in repo: %s' % (

        try:

            if fork:

                fork_parent_id = form_data['fork_parent_id']

            # repo name is just a name of repository

            # while repo_name_full is a full qualified name that is combined

            # with name and path of group

            repo_name = form_data['repo_name']

            repo_name_full = form_data['repo_name_full']

            new_repo = Repository()

            new_repo.enable_statistics = False

            for k, v in form_data.items():

                if k == 'repo_name':

                    v = repo_name_full

                if k == 'repo_group':

                    k = 'group_id'

                if k == 'description':

                    v = v or repo_name

                setattr(new_repo, k, v)

            if fork:

                parent_repo = Repository.get(fork_parent_id)

                new_repo.fork = parent_repo

            new_repo.user_id = cur_user.user_id

            self.sa.add(new_repo)

            def _create_default_perms():

                # create default permission

                repo_to_perm = UserRepoToPerm()

                default = 'repository.read'

                for p in User.get_by_username('default').user_perms:

                    if p.permission.permission_name.startswith('repository.'):

                        default = p.permission.permission_name

                        break

                default_perm = 'repository.none' if form_data['private'] else default

                repo_to_perm.permission_id = self.sa.query(Permission)\

                        .filter(Permission.permission_name == default_perm)\

                        .one().permission_id

                repo_to_perm.repository = new_repo

                repo_to_perm.user_id = User.get_by_username('default').user_id

                self.sa.add(repo_to_perm)

            if fork:

                if form_data.get('copy_permissions'):

                    repo = Repository.get(fork_parent_id)

                    user_perms = UserRepoToPerm.query()\

                        .filter(UserRepoToPerm.repository == repo).all()

                    group_perms = UsersGroupRepoToPerm.query()\

                        .filter(UsersGroupRepoToPerm.repository == repo).all()

                    for perm in user_perms:

                        UserRepoToPerm.create(perm.user, new_repo,

                                              perm.permission)

                    for perm in group_perms:

                        UsersGroupRepoToPerm.create(perm.users_group, new_repo,

                                                    perm.permission)

                else:

                    _create_default_perms()

            else:

                _create_default_perms()

            if not just_db:

                self.__create_repo(repo_name, form_data['repo_type'],

                                   form_data['repo_group'],

                                   form_data['clone_uri'])

            # now automatically start following this repository as owner

            ScmModel(self.sa).toggle_following_repo(new_repo.repo_id,

                                                    cur_user.user_id)

            log_create_repository(new_repo.get_dict(),

                                  created_by=cur_user.username)

            return new_repo

        except:

            log.error(traceback.format_exc())

            raise

    def create_fork(self, form_data, cur_user):

        """

        Simple wrapper into executing celery task for fork creation

        :param form_data:

        :param cur_user:

        """

        from rhodecode.lib.celerylib import tasks, run_task

        run_task(tasks.create_repo_fork, form_data, cur_user)

    def delete(self, repo):

        try:

            self.sa.delete(repo)

            self.__delete_repo(repo)

        except:

            log.error(traceback.format_exc())

            raise

    def grant_user_permission(self, repo, user, perm):

        """

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

        if found

        :param repo: Instance of Repository, repository_id, or repository name

        :param user: Instance of User, user_id or username

        :param perm: Instance of Permission, or permission_name

        """

        user = self.__get_user(user)

        repo = self.__get_repo(repo)

        permission = self.__get_perm(perm)

        # check if we have that permission already

        obj = self.sa.query(UserRepoToPerm)\

            .filter(UserRepoToPerm.user == user)\

            .filter(UserRepoToPerm.repository == repo)\

            .scalar()

        if obj is None:

            # create new !

            obj = UserRepoToPerm()

        obj.repository = repo

        obj.user = user

        obj.permission = permission

        self.sa.add(obj)

    def revoke_user_permission(self, repo, user):

        """

        Revoke permission for user on given repository

        :param repo: Instance of Repository, repository_id, or repository name

        :param user: Instance of User, user_id or username

        """

        user = self.__get_user(user)

        repo = self.__get_repo(repo)

        obj = self.sa.query(UserRepoToPerm)\

            .filter(UserRepoToPerm.repository == repo)\

            .filter(UserRepoToPerm.user == user)\

            .one()

        self.sa.delete(obj)

    def grant_users_group_permission(self, repo, group_name, perm):

        """

        Grant permission for users group on given repository, or update

        existing one if found

        :param repo: Instance of Repository, repository_id, or repository name

        :param group_name: Instance of UserGroup, users_group_id,

            or users group name

        :param perm: Instance of Permission, or permission_name

        """

        repo = self.__get_repo(repo)

        group_name = self.__get_users_group(group_name)

        permission = self.__get_perm(perm)

        # check if we have that permission already

        obj = self.sa.query(UsersGroupRepoToPerm)\

            .filter(UsersGroupRepoToPerm.users_group == group_name)\

            .filter(UsersGroupRepoToPerm.repository == repo)\

            .scalar()

        if obj is None:

            # create new

            obj = UsersGroupRepoToPerm()

        obj.repository = repo

        obj.users_group = group_name

        obj.permission = permission

        self.sa.add(obj)

    def revoke_users_group_permission(self, repo, group_name):

        """

        Revoke permission for users group on given repository

        :param repo: Instance of Repository, repository_id, or repository name

        :param group_name: Instance of UserGroup, users_group_id,

            or users group name

        """

        repo = self.__get_repo(repo)

        group_name = self.__get_users_group(group_name)

        obj = self.sa.query(UsersGroupRepoToPerm)\

            .filter(UsersGroupRepoToPerm.repository == repo)\

            .filter(UsersGroupRepoToPerm.users_group == group_name)\

            .one()

        self.sa.delete(obj)

    def delete_stats(self, repo_name):