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'",

              }

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

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

    api_key : "<api_key>"

    method :  "grant_user_permission"

    args:     {

                "repo_name" :  "<reponame>",

        """"

        Get all repositories

        :param apiuser:

        """

        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='',

        """

        :param apiuser:

        :param repo_name:

        :param description:

        :param private:

        """

        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,

                ),

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

        if curr_version == __dbversion__:

            sys.exit('This database is already at the newest version')

        #======================================================================

        # UPGRADE STEPS

        #======================================================================

        class UpgradeSteps(object):

            """

            Those steps follow schema versions so for example schema

            for example schema with seq 002 == step_2 and so on.

            """

            def __init__(self, klass):

                self.klass = klass

            def step_0(self):

                # step 0 is the schema upgrade, and than follow proper upgrades

                print ('attempting to do database upgrade to version %s' \

                                % __dbversion__)

                api.upgrade(db_uri, repository_path, __dbversion__)

                print ('Schema upgrade completed')

            def step_1(self):

                pass

            def step_2(self):

                print ('Patching repo paths for newer version of RhodeCode')

                self.klass.fix_repo_paths()

                print ('Patching default user of RhodeCode')

                self.klass.fix_default_user()

                log.info('Changing ui settings')

                self.klass.create_ui_settings()

            def step_3(self):

                print ('Adding additional settings into RhodeCode db')

                self.klass.fix_settings()

                print ('Adding ldap defaults')

                self.klass.create_ldap_options(skip_existing=True)

            def step_4(self):

                print ('create permissions and fix groups')

                self.klass.create_permissions()

                self.klass.fixup_groups()

            def step_5(self):

                pass

        upgrade_steps = [0] + range(curr_version + 1, __dbversion__ + 1)

        # CALL THE PROPER ORDER OF STEPS TO PERFORM FULL UPGRADE

        for step in upgrade_steps:

            print ('performing upgrade step %s' % step)

            getattr(UpgradeSteps(self), 'step_%s' % step)()

            self.sa.commit()

    def fix_repo_paths(self):

        """

        Fixes a old rhodecode version path into new one without a '*'

        """

        paths = self.sa.query(RhodeCodeUi)\

                .filter(RhodeCodeUi.ui_key == '/')\

                .scalar()

        paths.ui_value = paths.ui_value.replace('*', '')

        try:

            self.sa.add(paths)

            self.sa.commit()

        except:

            self.sa.rollback()

            raise

    def fix_default_user(self):

        """

        Fixes a old default user with some 'nicer' default values,

        used mostly for anonymous access

        """

        def_user = self.sa.query(User)\

                .filter(User.username == 'default')\

                .one()

        def_user.name = 'Anonymous'

        def_user.lastname = 'User'

        def_user.email = 'anonymous@rhodecode.org'

        try:

            self.sa.add(def_user)

            self.sa.commit()

        except:

            self.sa.rollback()

            raise

    def fix_settings(self):

        """