# while repo_name_full is a full qualified name that is combined

            # with name and path of group

            repo_name_full = repo_name

            repo_name = repo_name.split(self.URL_SEPARATOR)[-1]

            new_repo = Repository()

            new_repo.repo_state = state

            new_repo.enable_statistics = False

            new_repo.repo_name = repo_name_full

            new_repo.repo_type = repo_type

            new_repo.user = owner

            new_repo.group = repo_group

            new_repo.description = description or repo_name

            new_repo.private = private

            new_repo.clone_uri = clone_uri

            new_repo.landing_rev = landing_rev

            new_repo.enable_statistics = enable_statistics

            new_repo.enable_locking = enable_locking

            new_repo.enable_downloads = enable_downloads

            if repo_group:

                new_repo.enable_locking = repo_group.enable_locking

            if fork_of:

                parent_repo = fork_of

                new_repo.fork = parent_repo

            self.sa.add(new_repo)

            if fork_of and copy_fork_permissions:

                repo = fork_of

                user_perms = UserRepoToPerm.query() \

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

                group_perms = UserGroupRepoToPerm.query() \

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

                for perm in user_perms:

                    UserRepoToPerm.create(perm.user, new_repo, perm.permission)

                for perm in group_perms:

                    UserGroupRepoToPerm.create(perm.users_group, new_repo,

                                               perm.permission)

            elif repo_group and copy_group_permissions:

                user_perms = UserRepoGroupToPerm.query() \

                    .filter(UserRepoGroupToPerm.group == repo_group).all()

                group_perms = UserGroupRepoGroupToPerm.query() \

                    .filter(UserGroupRepoGroupToPerm.group == repo_group).all()

                for perm in user_perms:

                    perm_name = perm.permission.permission_name.replace('group.', 'repository.')

                    perm_obj = Permission.get_by_key(perm_name)

                    UserRepoToPerm.create(perm.user, new_repo, perm_obj)

                for perm in group_perms:

                    perm_name = perm.permission.permission_name.replace('group.', 'repository.')

                    perm_obj = Permission.get_by_key(perm_name)

                    UserGroupRepoToPerm.create(perm.users_group, new_repo, perm_obj)

            else:

                perm_obj = self._create_default_perms(new_repo, private)

                self.sa.add(perm_obj)

            # now automatically start following this repository as owner

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

                                                    owner.user_id)

            # we need to flush here, in order to check if database won't

            # throw any exceptions, create filesystem dirs at the very end

            self.sa.flush()

            return new_repo

        except Exception:

            log.error(traceback.format_exc())

            raise

    def create(self, form_data, cur_user):

        """

        Create repository using celery tasks

        :param form_data:

        :param cur_user:

        """

        from kallithea.lib.celerylib import tasks, run_task

        return run_task(tasks.create_repo, form_data, cur_user)

    def _update_permissions(self, repo, perms_new=None, perms_updates=None,

                            check_perms=True):

        if not perms_new:

            perms_new = []

        if not perms_updates:

            perms_updates = []

        # update permissions

        for member, perm, member_type in perms_updates:

            if member_type == 'user':

                # this updates existing one

                self.grant_user_permission(

                    repo=repo, user=member, perm=perm

                )

            else:

                #check if we have permissions to alter this usergroup

                req_perms = (

                    'usergroup.read', 'usergroup.write', 'usergroup.admin')

                if not check_perms or HasUserGroupPermissionAny(*req_perms)(

                        member):

                    self.grant_user_group_permission(

                        repo=repo, group_name=member, perm=perm

                    )

            # set new permissions

        for member, perm, member_type in perms_new:

            if member_type == 'user':

                self.grant_user_permission(

                    repo=repo, user=member, perm=perm

                )

            else:

                #check if we have permissions to alter this usergroup

                req_perms = (

                    'usergroup.read', 'usergroup.write', 'usergroup.admin')

                if not check_perms or HasUserGroupPermissionAny(*req_perms)(

                        member):

                    self.grant_user_group_permission(

                        repo=repo, group_name=member, perm=perm

                    )

    def create_fork(self, form_data, cur_user):

        """

        Simple wrapper into executing celery task for fork creation

        :param form_data:

        :param cur_user:

        """

        from kallithea.lib.celerylib import tasks, run_task

        return run_task(tasks.create_repo_fork, form_data, cur_user)

    def delete(self, repo, forks=None, fs_remove=True, cur_user=None):

        """

        Delete given repository, forks parameter defines what do do with

        attached forks. Throws AttachedForksError if deleted repo has attached

        forks

        :param repo:

        :param forks: str 'delete' or 'detach'

        :param fs_remove: remove(archive) repo from filesystem

        """

        if not cur_user:

            cur_user = getattr(get_current_authuser(), 'username', None)

        repo = self._get_repo(repo)

        if repo is not None:

            if forks == 'detach':

                for r in repo.forks:

                    r.fork = None

                    self.sa.add(r)

            elif forks == 'delete':

                for r in repo.forks:

                    self.delete(r, forks='delete')

            elif [f for f in repo.forks]:

                raise AttachedForksError()

            old_repo_dict = repo.get_dict()

            try:

                self.sa.delete(repo)

                if fs_remove:

                    self._delete_filesystem_repo(repo)

                else:

                    log.debug('skipping removal from filesystem')

                log_delete_repository(old_repo_dict,

                                      deleted_by=cur_user)

            except Exception:

                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)

        log.debug('Granted perm %s to %s on %s', perm, user, repo)

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

            .scalar()

        if obj is not None:

            self.sa.delete(obj)

            log.debug('Revoked perm on %s on %s', repo, user)

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

        """

        Grant permission for user 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 user group name

        :param perm: Instance of Permission, or permission_name

        """

        repo = self._get_repo(repo)

        group_name = self._get_user_group(group_name)

        permission = self._get_perm(perm)

        # check if we have that permission already

        obj = self.sa.query(UserGroupRepoToPerm) \

            .filter(UserGroupRepoToPerm.users_group == group_name) \

            .filter(UserGroupRepoToPerm.repository == repo) \

            .scalar()

        if obj is None:

            # create new

            obj = UserGroupRepoToPerm()

        obj.repository = repo

        obj.users_group = group_name

        obj.permission = permission

        self.sa.add(obj)

        log.debug('Granted perm %s to %s on %s', perm, group_name, repo)

        return obj

    def revoke_user_group_permission(self, repo, group_name):

        """

        Revoke permission for user group on given repository

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

        :param group_name: Instance of UserGroup, users_group_id,

            or user group name

        """

        repo = self._get_repo(repo)

        group_name = self._get_user_group(group_name)

        obj = self.sa.query(UserGroupRepoToPerm) \

            .filter(UserGroupRepoToPerm.repository == repo) \

            .filter(UserGroupRepoToPerm.users_group == group_name) \

            .scalar()

        if obj is not None:

            self.sa.delete(obj)

            log.debug('Revoked perm to %s on %s', repo, group_name)

    def delete_stats(self, repo_name):

        """

        removes stats for given repo

        :param repo_name:

        """

        repo = self._get_repo(repo_name)

        try:

            obj = self.sa.query(Statistics) \

                .filter(Statistics.repository == repo).scalar()

            if obj is not None:

                self.sa.delete(obj)

        except Exception:

            log.error(traceback.format_exc())

            raise

    def _create_filesystem_repo(self, repo_name, repo_type, repo_group,

                                clone_uri=None, repo_store_location=None):

        """

        Makes repository on filesystem. Operation is group aware, meaning that it will create

        a repository within a group, and alter the paths accordingly to the group location.

        :param repo_name:

        :param alias:

        :param parent:

        :param clone_uri:

        :param repo_store_location:

        """

        from kallithea.lib.utils import is_valid_repo, is_valid_repo_group

        from kallithea.model.scm import ScmModel

        if '/' in repo_name:

            raise ValueError('repo_name must not contain groups got `%s`' % repo_name)

        if isinstance(repo_group, RepoGroup):

            new_parent_path = os.sep.join(repo_group.full_path_splitted)

        else:

            new_parent_path = repo_group or ''

        if repo_store_location:

            _paths = [repo_store_location]

        else:

            _paths = [self.repos_path, new_parent_path, repo_name]

            # we need to make it str for mercurial

        repo_path = os.path.join(*map(lambda x: safe_str(x), _paths))

        # check if this path is not a repository

        if is_valid_repo(repo_path, self.repos_path):

            raise Exception('This path %s is a valid repository' % repo_path)

        # check if this path is a group

        if is_valid_repo_group(repo_path, self.repos_path):

            raise Exception('This path %s is a valid group' % repo_path)

        log.info('creating repo %s in %s from url: `%s`',

            repo_name, safe_unicode(repo_path),

            obfuscate_url_pw(clone_uri))

        backend = get_backend(repo_type)

        if repo_type == 'hg':

            baseui = make_ui('db', clear_session=False)

            # patch and reset hooks section of UI config to not run any

            # hooks on creating remote repo

            for k, v in baseui.configitems('hooks'):

                baseui.setconfig('hooks', k, None)

            repo = backend(repo_path, create=True, src_url=clone_uri, baseui=baseui)

        elif repo_type == 'git':

            repo = backend(repo_path, create=True, src_url=clone_uri, bare=True)

            # add kallithea hook into this repo

            ScmModel().install_git_hooks(repo=repo)

        else:

            raise Exception('Not supported repo_type %s expected hg/git' % repo_type)

        log.debug('Created repo %s with %s backend',

                  safe_unicode(repo_name), safe_unicode(repo_type))

        return repo

    def _rename_filesystem_repo(self, old, new):

        """

        renames repository on filesystem

        :param old: old name

        :param new: new name

        """

        log.info('renaming repo from %s to %s', old, new)

        old_path = safe_str(os.path.join(self.repos_path, old))

        new_path = safe_str(os.path.join(self.repos_path, new))

        if os.path.isdir(new_path):

            raise Exception(

                'Was trying to rename to already existing dir %s' % new_path

            )

        shutil.move(old_path, new_path)

    def _delete_filesystem_repo(self, repo):

        """

        removes repo from filesystem, the removal is actually done by

        renaming dir to a 'rm__*' prefix which Kallithea will skip.

        It can be undeleted later by reverting the rename.

        :param repo: repo object

        """

        rm_path = safe_str(os.path.join(self.repos_path, repo.repo_name))

        log.info("Removing %s", rm_path)

        _now = datetime.now()

        _ms = str(_now.microsecond).rjust(6, '0')

        _d = 'rm__%s__%s' % (_now.strftime('%Y%m%d_%H%M%S_' + _ms),

                             repo.just_name)

        if repo.group:

            args = repo.group.full_path_splitted + [_d]

            _d = os.path.join(*args)

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