# need to use first here since there can be multiple statuses

        # returned from pull_request

        status = q.first()

        if as_str:

            return str(status.status) if status else ChangesetStatus.DEFAULT

        return status

    def set_status(self, repo, status, user, comment, revision=None,

                   pull_request=None, dont_allow_on_closed_pull_request=False):

        """

        Creates new status for changeset or updates the old ones bumping their

        :param repo:

        :param status:

        :param user:

        :param comment:

        :param revision:

        :param pull_request:

        :param dont_allow_on_closed_pull_request: don't allow a status change

            if last status was for pull request and it's closed. We shouldn't

            mess around this manually

        """

        repo = self._get_repo(repo)

    def get_by_full_path(cls, repo_full_path):

        repo_name = repo_full_path.split(cls.base_path(), 1)[-1]

        repo_name = cls.normalize_repo_name(repo_name)

        return cls.get_by_repo_name(repo_name.strip(URL_SEP))

    @classmethod

    def get_repo_forks(cls, repo_id):

        return cls.query().filter(Repository.fork_id == repo_id)

    @classmethod

    def base_path(cls):

        """

        :param cls:

        """

        q = Session().query(Ui)\

            .filter(Ui.ui_key == cls.url_sep())

        q = q.options(FromCache("sql_cache_short", "repository_repo_path"))

        return q.one().ui_value

    @property

    def forks(self):

        """

        Return forks of this repo

    def gist_url(self):

        import kallithea

        alias_url = kallithea.CONFIG.get('gist_alias_url')

        if alias_url:

            return alias_url.replace('{gistid}', self.gist_access_id)

        import kallithea.lib.helpers as h

        return h.canonical_url('gist', gist_id=self.gist_access_id)

    @classmethod

    def base_path(cls):

        """

        :param cls:

        """

        from kallithea.model.gist import GIST_STORE_LOC

        q = Session().query(Ui)\

            .filter(Ui.ui_key == URL_SEP)

        q = q.options(FromCache("sql_cache_short", "repository_repo_path"))

        return os.path.join(q.one().ui_value, GIST_STORE_LOC)

    def get_api_data(self):

        """

        Common function for generating gist related data for API

        """

        Create permissions for whole system

        """

        for p in Permission.PERMS:

            if not Permission.get_by_key(p[0]):

                new_perm = Permission()

                new_perm.permission_name = p[0]

                new_perm.permission_longname = p[0]  #translation err with p[1]

                self.sa.add(new_perm)

    def create_default_permissions(self, user, force=False):

        """

        :param user:

        """

        user = self._get_user(user)

        def _make_perm(perm):

            new_perm = UserToPerm()

            new_perm.user = user

            new_perm.permission = Permission.get_by_key(perm)

            return new_perm

        def _get_group(perm_name):

        perms = UserToPerm.query().filter(UserToPerm.user == user).all()

        defined_perms_groups = map(_get_group,

                                (x.permission.permission_name for x in perms))

        log.debug('GOT ALREADY DEFINED:%s' % perms)

        DEFAULT_PERMS = Permission.DEFAULT_USER_PERMISSIONS

        if force:

            for perm in perms:

                self.sa.delete(perm)

            self.sa.commit()

            defined_perms_groups = []

        for perm_name in DEFAULT_PERMS:

            gr = _get_group(perm_name)

            if gr not in defined_perms_groups:

                log.debug('GR:%s not found, creating permission %s'

                          % (gr, perm_name))

                new_perm = _make_perm(perm_name)

                self.sa.add(new_perm)

    def update(self, form_result):

        perm_user = User.get_by_username(username=form_result['perm_user_name'])

        try:

            return cur_repo

        except Exception:

            log.error(traceback.format_exc())

            raise

    def _create_repo(self, repo_name, repo_type, description, owner,

                     private=False, clone_uri=None, repo_group=None,

                     landing_rev='rev:tip', fork_of=None,

                     copy_fork_permissions=False, enable_statistics=False,

                     enable_locking=False, enable_downloads=False,

                     copy_group_permissions=False, state=Repository.STATE_PENDING):

        """

        """

        from kallithea.model.scm import ScmModel

        owner = self._get_user(owner)

        fork_of = self._get_repo(fork_of)

        repo_group = self._get_repo_group(repo_group)

        try:

            repo_name = safe_unicode(repo_name)

            description = safe_unicode(description)

            # repo name is just a name of repository

            # while repo_name_full is a full qualified name that is combined

        try:

            obj = self.sa.query(Statistics) \

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

            if obj:

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

        """

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

class RepoTemp(object):

    def __init__(self, repo_id):

        self.repo_id = repo_id

    def __repr__(self):

        return "<%s('id:%s')>" % (self.__class__.__name__, self.repo_id)

class CachedRepoList(object):

    """

    """

    def __init__(self, db_repo_list, repos_path, order_by=None, perm_set=None):

        self.db_repo_list = db_repo_list

        self.repos_path = repos_path

        self.order_by = order_by

        self.reversed = (order_by or '').startswith('-')

        if not perm_set:

            perm_set = ['repository.read', 'repository.write',

                        'repository.admin']

        self.perm_set = perm_set

                          revisions=[tip.raw_id])

        return tip

    def _sanitize_path(self, f_path):

        if f_path.startswith('/') or f_path.startswith('.') or '../' in f_path:

            raise NonRelativePathError('%s is not an relative path' % f_path)

        if f_path:

            f_path = os.path.normpath(f_path)

        return f_path

    def get_nodes(self, repo_name, revision, root_path='/', flat=True):

        """

        :param repo_name: name of repository

        :param revision: revision for which to list nodes

        :param root_path: root path to list

        :param flat: return as a list, if False returns a dict with description

        """

        _files = list()

        _dirs = list()

        try:

            _repo = self.__get_repo(repo_name)

            changeset = _repo.scm_instance.get_changeset(revision)

                for d in dirs:

                    _dirs.append(d.path if flat else {"name": d.path,

                                                      "type": "dir"})

        except RepositoryError:

            log.debug(traceback.format_exc())

            raise

        return _dirs, _files

    def create_nodes(self, user, repo, message, nodes, parent_cs=None,

                     author=None, trigger_push_hook=True):

        """

        :param user: Kallithea User object or user_id, the commiter

        :param repo: Kallithea Repository object

        :param message: commit message

        :param nodes: mapping {filename:{'content':content},...}

        :param parent_cs: parent changeset, can be empty than it's initial commit

        :param author: author of commit, cna be different that commiter only for git

        :param trigger_push_hook: trigger push hooks

        :returns: new commited changeset

        """

        self.mark_for_invalidation(repo.repo_name)

        if trigger_push_hook:

            self._handle_push(scm_instance,

                              username=user.username,

                              action='push_local',

                              repo_name=repo.repo_name,

                              revisions=[tip.raw_id])

    def delete_nodes(self, user, repo, message, nodes, parent_cs=None,

                     author=None, trigger_push_hook=True):

        """

        :param user: Kallithea User object or user_id, the commiter

        :param repo: Kallithea Repository object

        :param message: commit message

        :param nodes: mapping {filename:{'content':content},...}

        :param parent_cs: parent changeset, can be empty than it's initial commit

        :param author: author of commit, cna be different that commiter only for git

        :param trigger_push_hook: trigger push hooks

        :returns: new commited changeset after deletion

        """