…

            ]

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

        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:

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