if RepoModel().get_by_repo_name(repo_name):

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

        defs = db.Setting.get_default_repo_settings(strip_prefix=True)

        if private is None:

            private = defs.get('repo_private') or False

        if repo_type is None:

            repo_type = defs.get('repo_type')

        if enable_statistics is None:

            enable_statistics = defs.get('repo_enable_statistics')

        if enable_downloads is None:

            enable_downloads = defs.get('repo_enable_downloads')

        try:

            data = dict(

                repo_name=repo_name_parts[-1],

                repo_name_full=repo_name,

                repo_type=repo_type,

                repo_description=description,

                repo_private=private,

                clone_uri=clone_uri,

                repo_group=group_name,

                repo_landing_rev=landing_rev,

                repo_copy_permissions=copy_permissions,

            )

            RepoModel().create(form_data=data, cur_user=owner.username)

            # no commit, it's done in RepoModel, or async via celery

            return dict(

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

                success=True,  # cannot return the repo data here since fork

                               # can be done async

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'failed to create repository `%s`' % (repo_name,))

    # permission check inside

    def update_repo(self, repoid, name=None,

                    owner=None,

                    group=None,

                    description=None, private=None,

                    clone_uri=None, landing_rev=None,

                    enable_statistics=None,

                    enable_downloads=None):

        """

            args = repo.group.full_path_splitted + [_d]

            _d = os.path.join(*args)

        if os.path.exists(rm_path):

            shutil.move(rm_path, os.path.join(self.repos_path, _d))

        else:

            log.error("Can't find repo to delete in %r", rm_path)

@celerylib.task

def create_repo(form_data, cur_user):

    cur_user = db.User.guess_instance(cur_user)

    owner = cur_user

    repo_name = form_data['repo_name']

    repo_name_full = 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')

    repo_group = form_data['repo_group']

    landing_rev = form_data['repo_landing_rev']

    copy_fork_permissions = form_data.get('copy_permissions')

    copy_group_permissions = form_data.get('repo_copy_permissions')

    fork_of = form_data.get('fork_parent_id')

    state = form_data.get('repo_state', db.Repository.STATE_PENDING)

    try:

        db_repo = RepoModel()._create_repo(

            repo_name=repo_name_full,

            repo_type=repo_type,

            description=description,

            owner=owner,

            private=private,

            clone_uri=clone_uri,

            repo_group=repo_group,

            landing_rev=landing_rev,

            fork_of=fork_of,

            copy_fork_permissions=copy_fork_permissions,

            copy_group_permissions=copy_group_permissions,

            enable_statistics=enable_statistics,

            enable_downloads=enable_downloads,

            state=state

        )

        userlog.action_logger(cur_user, 'user_created_repo',

                      form_data['repo_name_full'], '')

        meta.Session().commit()

        # now create this repo on Filesystem

        RepoModel()._create_filesystem_repo(

            </div>

        </div>

        <div id="copy_perms" class="form-group">

            <label class="control-label" for="repo_copy_permissions">${_('Copy parent group permissions')}:</label>

            <div>

                ${h.checkbox('repo_copy_permissions',value="True")}

                <span class="help-block">${_('Copy permission set from parent repository group.')}</span>

            </div>

        </div>

        <div class="form-group">

            <label class="control-label" for="repo_landing_rev">${_('Landing revision')}:</label>

            <div>

                ${h.select('repo_landing_rev',None,c.landing_revs,class_='form-control')}

                <span class="help-block">${_('Default revision for files page, downloads, full text search index and readme generation')}</span>

            </div>

        </div>

        <div class="form-group">

            <label class="control-label" for="repo_private">${_('Private repository')}:</label>

            <div>

                ${h.checkbox('repo_private',value="True")}

                <span class="help-block">${_('Private repositories are only visible to people explicitly added as collaborators.')}</span>

            </div>

        </div>

        <div class="form-group">

            <div class="buttons">

                ${h.submit('add',_('Add'),class_="btn btn-default")}

            </div>

        </div>

    </div>

${h.end_form()}

<script>

    'use strict';

    $(document).ready(function(){

        $('#repo_type').select2({

            'minimumResultsForSearch': -1

        });

        $('#repo_group').select2({

            'dropdownAutoWidth': true

        });

        function setCopyPermsOption(group_val){

            if(group_val != "-1"){

                $('#copy_perms').show();

            }

            else{

                $('#copy_perms').hide();

            }

        rev = 'tip'

        path = '/'

        id_, params = _build_data(self.apikey_regular, 'get_repo_nodes',

                                  repoid=self.REPO, revision=rev,

                                  root_path=path,

                                  ret_type=ret_type)

        response = api_call(self, params)

        # we don't the actual return types here since it's tested somewhere

        # else

        expected = response.json['result']

        try:

            self._compare_ok(id_, expected, given=response.body)

        finally:

            RepoModel().revoke_user_permission(self.REPO, self.TEST_USER_LOGIN)

    @base.parametrize('changing_attr,updates', [

        ('owner', {'owner': base.TEST_USER_REGULAR_LOGIN}),

        ('description', {'description': 'new description'}),

        ('clone_uri', {'clone_uri': 'http://example.com/repo'}), # will fail - pulling from non-existing repo should fail

        ('clone_uri', {'clone_uri': '/repo'}), # will fail - pulling from local repo was a misfeature - it would bypass access control

        ('clone_uri', {'clone_uri': None}),

        ('landing_rev', {'landing_rev': 'branch:master'}),

        ('private', {'private': True}),

        ('repo_group', {'group': 'test_group_for_update'}),

    ])

    def test_api_create_repo(self, changing_attr, updates):

        repo_name = repo_name_full = 'new_repo'

        if changing_attr == 'repo_group':

            group_name = updates['group']

            fixture.create_repo_group(group_name)

            repo_name_full = '/'.join([group_name, repo_name])

            updates = {}

        id_, params = _build_data(self.apikey, 'create_repo',

                                  repo_type=self.REPO_TYPE, repo_name=repo_name_full, **updates)

        response = api_call(self, params)

        try:

            expected = {

                'msg': 'Created new repository `%s`' % repo_name_full,

                'success': True}

            if changing_attr == 'clone_uri' and updates['clone_uri']:

                expected = 'failed to create repository `%s`' % repo_name

                self._compare_error(id_, expected, given=response.body)

                return

            else:

        class context(object):

            def __enter__(self):

                anon = db.User.get_default_user()

                self._before = anon.active

                anon.active = status

                meta.Session().commit()

                invalidate_all_caches()

            def __exit__(self, exc_type, exc_val, exc_tb):

                anon = db.User.get_default_user()

                anon.active = self._before

                meta.Session().commit()

        return context()

    def _get_repo_create_params(self, **custom):

        """Return form values to be validated through RepoForm"""

        defs = dict(

            repo_name=None,

            repo_type='hg',

            clone_uri='',

            repo_group='-1',

            repo_description='DESC',

            repo_private=False,

            repo_landing_rev='rev:tip',

            repo_copy_permissions=False,

            repo_state=db.Repository.STATE_CREATED,

        )

        defs.update(custom)

        if 'repo_name_full' not in custom:

            defs.update({'repo_name_full': defs['repo_name']})

        # fix the repo name if passed as repo_name_full

        if defs['repo_name']:

            defs['repo_name'] = defs['repo_name'].split('/')[-1]

        return defs

    def _get_repo_group_create_params(self, **custom):

        """Return form values to be validated through RepoGroupForm"""

        defs = dict(

            group_name=None,

            group_description='DESC',

            parent_group_id='-1',

            perms_updates=[],

            perms_new=[],

            recursive=False

        )