group_name = self.__get_users_group(group_name)

        obj = self.sa.query(UsersGroupRepoToPerm)\

            .filter(UsersGroupRepoToPerm.repository == repo)\

            .filter(UsersGroupRepoToPerm.users_group == group_name)\

            .one()

        self.sa.delete(obj)

    def delete_stats(self, repo_name):

        """

        removes stats for given repo

        :param repo_name:

        """

        try:

            obj = self.sa.query(Statistics)\

                    .filter(Statistics.repository ==

                            self.get_by_repo_name(repo_name))\

                    .one()

            self.sa.delete(obj)

        except:

            log.error(traceback.format_exc())

            raise

    def __create_repo(self, repo_name, alias, new_parent_id, clone_uri=False):

        """

        makes repository on filesystem. It's group aware means it'll create

        a repository within a group, and alter the paths accordingly of

        group location

        :param repo_name:

        :param alias:

        :param parent_id:

        :param clone_uri:

        """

        from rhodecode.lib.utils import is_valid_repo, is_valid_repos_group

        if new_parent_id:

            paths = RepoGroup.get(new_parent_id)\

                .full_path.split(RepoGroup.url_sep())

            new_parent_path = os.sep.join(paths)

        else:

            new_parent_path = ''

        # we need to make it str for mercurial

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

                                [self.repos_path, new_parent_path, repo_name]))

        # 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_repos_group(repo_path, self.repos_path):

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

        log.info('creating repo %s in %s @ %s' % (

                     repo_name, safe_unicode(repo_path), clone_uri

                )

        )

        backend = get_backend(alias)

        if alias == 'hg':

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

        elif alias == 'git':

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

        else:

            raise Exception('Undefined alias %s' % alias)

    def __rename_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 = os.path.join(self.repos_path, old)

        new_path = 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_repo(self, repo):

        """

        removes repo from filesystem, the removal is acctually made by

        added rm__ prefix into dir, and rename internat .hg/.git dirs so this

        repository is no longer valid for rhodecode, can be undeleted later on

        by reverting the renames on this repository

        :param repo: repo object

        """

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

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

        alias = repo.repo_type

        shutil.move(os.path.join(rm_path, '.%s' % alias),

                    os.path.join(rm_path, 'rm__.%s' % alias))

        # disable repo

        _d = 'rm__%s__%s' % (datetime.now().strftime('%Y%m%d_%H%M%S_%f'),

                             repo.repo_name)

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