"repoid" : "<reponame or repo_id>"

              }

OUTPUT::

    id : <id_given_in_input>

    result: None if repository does not exist or

            {

                "repo_id" :     "<repo_id>",

                "repo_name" :   "<reponame>"

                "repo_type" :   "<repo_type>",

                "clone_uri" :   "<clone_uri>",

                "created_on" :  "<datetimecreated>",                

                "description" : "<description>",

                "landing_rev":  "<landing_rev>",

                "owner":        "<repo_owner>",

                "fork_of":  "<name_of_fork_parent>",

                "members" :     [

                                  { 

                                    "type": "user",

                                    "user_id" :  "<user_id>",

                                    "username" : "<username>",

                                    "firstname": "<firstname>",

                                    "lastname" : "<lastname>",

    result: [

              {

                "repo_id" :     "<repo_id>",

                "repo_name" :   "<reponame>"

                "repo_type" :   "<repo_type>",

                "clone_uri" :   "<clone_uri>",

                "private": :    "<bool>",

                "created_on" :  "<datetimecreated>",                

                "description" : "<description>",

                "landing_rev":  "<landing_rev>",

                "owner":        "<repo_owner>",

                "fork_of":  "<name_of_fork_parent>",

              },

              …

            ]

    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 

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

                "description" : "<description> = Optional('')",

                "private" :     "<bool> = Optional(False)",

                "clone_uri" :   "<clone_uri> = Optional(None)",

                "landing_rev" : "<landing_rev> = Optional('tip')",

              }

OUTPUT::

    id : <id_given_in_input>

    result: {

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

              "repo": {

                "repo_id" :     "<repo_id>",

                "repo_name" :   "<reponame>"

                "repo_type" :   "<repo_type>",

                "clone_uri" :   "<clone_uri>",

                "private": :    "<bool>",

                "created_on" :  "<datetimecreated>",                

                "description" : "<description>",

                "landing_rev":  "<landing_rev>",

                "owner":        "<repo_owner>",

                "fork_of":  "<name_of_fork_parent>",

              },

            }

    error:  null

delete_repo

-----------

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

belonging to user with admin rights.

import logging

from rhodecode.controllers.api import JSONRPCController, JSONRPCError

from rhodecode.lib.auth import HasPermissionAllDecorator, \

    HasPermissionAnyDecorator, PasswordGenerator, AuthUser

from rhodecode.lib.utils import map_groups, repo2db_mapper

from rhodecode.model.meta import Session

from rhodecode.model.scm import ScmModel

from rhodecode.model.repo import RepoModel

from rhodecode.model.user import UserModel

from rhodecode.model.users_group import UsersGroupModel

from rhodecode.model.permission import PermissionModel

log = logging.getLogger(__name__)

class Optional(object):

    """

    Defines an optional parameter::

        param = param.getval() if isinstance(param, Optional) else param

        param = param() if isinstance(param, Optional) else param

    is equivalent of::

                'dirs': _d,

            }

            return _map[ret_type]

        except KeyError:

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

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'failed to get repo: `%s` nodes' % repo.repo_name

            )

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

                    description=Optional(''), private=Optional(False),

        """

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

        if repo_name is withina  group name the groups will be created

        automatically if they aren't present

        :param apiuser:

        :param repo_name:

        :param onwer:

        :param repo_type:

        :param description:

        :param private:

        :param clone_uri:

        :param landing_rev:

        """

        owner = get_user_or_error(owner)

        if RepoModel().get_by_repo_name(repo_name):

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

        clone_uri = Optional.extract(clone_uri)

        description = Optional.extract(description)

        landing_rev = Optional.extract(landing_rev)

        try:

            # create structure of groups and return the last group

            group = map_groups(repo_name)

            repo = RepoModel().create_repo(

                repo_name=repo_name,

                repo_type=repo_type,

                description=description,

                owner=owner,

                private=private,

                clone_uri=clone_uri,

                repos_group=group,

                landing_rev=landing_rev,

            )

            Session().commit()

            return dict(

                msg="Created new repository `%s`" % (repo.repo_name),

                repo=repo.get_api_data()

            )

        except Exception:

            log.error(traceback.format_exc())

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

    sa = meta.Session()

    rm = RepoModel()

    user = sa.query(User).filter(User.admin == True).first()

    if user is None:

        raise Exception('Missing administrative account!')

    added = []

#    # clear cache keys

#    log.debug("Clearing cache keys now...")

#    CacheInvalidation.clear_cache()

#    sa.commit()

    for name, repo in initial_repo_list.items():

        group = map_groups(name)

        db_repo = rm.get_by_repo_name(name)

        # found repo that is on filesystem not in RhodeCode database

        if not db_repo:

            log.info('repository %s not found, creating now' % name)

            added.append(name)

            desc = (repo.description

                    if repo.description != 'unknown'

                    else '%s repository' % name)

            new_repo = rm.create_repo(

                repo_name=name,

                repo_type=repo.alias,

                description=desc,

                repos_group=getattr(group, 'group_id', None),

                owner=user,

            )

            # we added that repo just now, and make sure it has githook

            # installed

            if new_repo.repo_type == 'git':

                ScmModel().install_git_hook(new_repo.scm_instance)

        elif install_git_hook:

            if db_repo.repo_type == 'git':

                ScmModel().install_git_hook(db_repo.scm_instance)

        # during starting install all cache keys for all repositories in the

        # system, this will register all repos and multiple instances

        key, _prefix, _org_key = CacheInvalidation._get_key(name)

        CacheInvalidation.invalidate(name)

        """

        repo = self

        data = dict(

            repo_id=repo.repo_id,

            repo_name=repo.repo_name,

            repo_type=repo.repo_type,

            clone_uri=repo.clone_uri,

            private=repo.private,

            created_on=repo.created_on,

            description=repo.description,

            landing_rev=repo.landing_rev,

            owner=repo.user.username,

        )

        return data

    @classmethod

    def lock(cls, repo, user_id):

        repo.locked = [user_id, time.time()]

        Session().add(repo)

        Session().commit()

    @classmethod

    def unlock(cls, repo):

        """

        owner = cur_user

        repo_name = form_data['repo_name_full']

        repo_type = form_data['repo_type']

        description = form_data['repo_description']

        private = form_data['repo_private']

        clone_uri = form_data.get('clone_uri')

        repos_group = form_data['repo_group']

        landing_rev = form_data['repo_landing_rev']

        copy_fork_permissions = form_data.get('copy_permissions')

        fork_of = form_data.get('fork_parent_id')

        defs = RhodeCodeSetting.get_default_repo_settings(strip_prefix=True)

        enable_locking = defs.get('repo_enable_locking')

        enable_downloads = defs.get('repo_enable_downloads')

        return self.create_repo(

            repo_name, repo_type, description, owner, private, clone_uri,

            repos_group, landing_rev, just_db, fork_of, copy_fork_permissions,

            enable_statistics, enable_locking, enable_downloads

        )

    def create_fork(self, form_data, cur_user):

        """

        Simple wrapper into executing celery task for fork creation