rmap.connect('logout_home', '%s/logout' % ADMIN_PREFIX, controller='login',

                 action='logout')

    rmap.connect('register', '%s/register' % ADMIN_PREFIX, controller='login',

                 action='register')

    rmap.connect('reset_password', '%s/password_reset' % ADMIN_PREFIX,

                 controller='login', action='password_reset')

    rmap.connect('reset_password_confirmation',

                 '%s/password_reset_confirmation' % ADMIN_PREFIX,

                 controller='login', action='password_reset_confirmation')

    # FEEDS

    rmap.connect('rss_feed_home', '/{repo_name:.*?}/feed/rss',

                controller='feed', action='rss',

                conditions=dict(function=check_repo))

    rmap.connect('atom_feed_home', '/{repo_name:.*?}/feed/atom',

                controller='feed', action='atom',

                conditions=dict(function=check_repo))

    #==========================================================================

    # REPOSITORY ROUTES

    #==========================================================================

    rmap.connect('repo_creating_home', '/{repo_name:.*?}/repo_creating',

                controller='admin/repos', action='repo_creating')

    rmap.connect('repo_check_home', '/{repo_name:.*?}/repo_check_creating',

                controller='admin/repos', action='repo_check')

    rmap.connect('summary_home', '/{repo_name:.*?}',

                controller='summary',

                conditions=dict(function=check_repo))

    # must be here for proper group/repo catching

    rmap.connect('repos_group_home', '/{group_name:.*}',

                controller='admin/repo_groups', action="show_by_name",

                conditions=dict(function=check_group))

    rmap.connect('repo_stats_home', '/{repo_name:.*?}/statistics',

                controller='summary', action='statistics',

                conditions=dict(function=check_repo))

    rmap.connect('repo_size', '/{repo_name:.*?}/repo_size',

                controller='summary', action='repo_size',

                conditions=dict(function=check_repo))

    rmap.connect('repo_refs_data', '/{repo_name:.*?}/refs-data',

                 controller='home', action='repo_refs_data')

    rmap.connect('changeset_home', '/{repo_name:.*?}/changeset/{revision:.*}',

                controller='changeset', revision='tip',

                conditions=dict(function=check_repo))

    rmap.connect('changeset_children', '/{repo_name:.*?}/changeset_children/{revision}',

                controller='changeset', revision='tip', action="changeset_children",

                conditions=dict(function=check_repo))

    rmap.connect('changeset_parents', '/{repo_name:.*?}/changeset_parents/{revision}',

                controller='changeset', revision='tip', action="changeset_parents",

                conditions=dict(function=check_repo))

    # repo edit options

    rmap.connect("edit_repo", "/{repo_name:.*?}/settings",

                 controller='admin/repos', action="edit",

                 conditions=dict(method=["GET"], function=check_repo))

    rmap.connect("edit_repo_perms", "/{repo_name:.*?}/settings/permissions",

                 controller='admin/repos', action="edit_permissions",

                 conditions=dict(method=["GET"], function=check_repo))

    rmap.connect("edit_repo_perms_update", "/{repo_name:.*?}/settings/permissions",

                 controller='admin/repos', action="edit_permissions_update",

                 conditions=dict(method=["POST"], function=check_repo))

    rmap.connect("edit_repo_perms_revoke", "/{repo_name:.*?}/settings/permissions/delete",

                 controller='admin/repos', action="edit_permissions_revoke",

                 conditions=dict(method=["POST"], function=check_repo))

    rmap.connect("edit_repo_fields", "/{repo_name:.*?}/settings/fields",

                 controller='admin/repos', action="edit_fields",

                 conditions=dict(method=["GET"], function=check_repo))

    rmap.connect('create_repo_fields', "/{repo_name:.*?}/settings/fields/new",

                 controller='admin/repos', action="create_repo_field",

                 conditions=dict(method=["POST"], function=check_repo))

    rmap.connect('delete_repo_fields', "/{repo_name:.*?}/settings/fields/{field_id}/delete",

                 controller='admin/repos', action="delete_repo_field",

                 conditions=dict(method=["POST"], function=check_repo))

    rmap.connect("edit_repo_advanced", "/{repo_name:.*?}/settings/advanced",

                 controller='admin/repos', action="edit_advanced",

                 conditions=dict(method=["GET"], function=check_repo))

    rmap.connect("edit_repo_advanced_journal", "/{repo_name:.*?}/settings/advanced/journal",

                 controller='admin/repos', action="edit_advanced_journal",

                 conditions=dict(method=["POST"], function=check_repo))

    rmap.connect("edit_repo_advanced_fork", "/{repo_name:.*?}/settings/advanced/fork",

                 controller='admin/repos', action="edit_advanced_fork",

                 conditions=dict(method=["POST"], function=check_repo))

    rmap.connect("edit_repo_remote", "/{repo_name:.*?}/settings/remote",

                 controller='admin/repos', action="edit_remote",

                 conditions=dict(method=["GET"], function=check_repo))

    rmap.connect("edit_repo_remote_update", "/{repo_name:.*?}/settings/remote",

                 controller='admin/repos', action="edit_remote",

                 conditions=dict(method=["POST"], function=check_repo))

    rmap.connect("edit_repo_statistics", "/{repo_name:.*?}/settings/statistics",

                 controller='admin/repos', action="edit_statistics",

                 conditions=dict(method=["GET"], function=check_repo))

    rmap.connect("edit_repo_statistics_update", "/{repo_name:.*?}/settings/statistics",

                 controller='admin/repos', action="edit_statistics",

                 conditions=dict(method=["POST"], function=check_repo))

    # still working url for backward compat.

    rmap.connect('raw_changeset_home_depraced',

                 '/{repo_name:.*?}/raw-changeset/{revision}',

                 controller='changeset', action='changeset_raw',

                 revision='tip', conditions=dict(function=check_repo))

    ## new URLs

    rmap.connect('changeset_raw_home',

                 '/{repo_name:.*?}/changeset-diff/{revision}',

                 controller='changeset', action='changeset_raw',

                 revision='tip', conditions=dict(function=check_repo))

    rmap.connect('changeset_patch_home',

                 '/{repo_name:.*?}/changeset-patch/{revision}',

                 controller='changeset', action='changeset_patch',

                 revision='tip', conditions=dict(function=check_repo))

    rmap.connect('changeset_download_home',

                 '/{repo_name:.*?}/changeset-download/{revision}',

                 controller='changeset', action='changeset_download',

                 revision='tip', conditions=dict(function=check_repo))

    rmap.connect('changeset_comment',

                 '/{repo_name:.*?}/changeset-comment/{revision}',

                controller='changeset', revision='tip', action='comment',

                conditions=dict(function=check_repo))

    rmap.connect('changeset_comment_delete',

                 '/{repo_name:.*?}/changeset-comment/{comment_id}/delete',

                controller='changeset', action='delete_comment',

                conditions=dict(function=check_repo, method=["POST"]))

    rmap.connect('changeset_info', '/changeset_info/{repo_name:.*?}/{revision}',

                 controller='changeset', action='changeset_info')

    rmap.connect('compare_home',

                 '/{repo_name:.*?}/compare',

                 controller='compare',

                 conditions=dict(function=check_repo))

    rmap.connect('compare_url',

                 '/{repo_name:.*?}/compare/{org_ref_type}@{org_ref_name:.*?}...{other_ref_type}@{other_ref_name:.*?}',

                 controller='compare', action='compare',

                 conditions=dict(function=check_repo),

                 requirements=dict(

                            org_ref_type='(branch|book|tag|rev|__other_ref_type__)',

                            other_ref_type='(branch|book|tag|rev|__org_ref_type__)')

                 )

    rmap.connect('pullrequest_home',

                 '/{repo_name:.*?}/pull-request/new', controller='pullrequests',

                 conditions=dict(function=check_repo,

                                                 method=["GET"]))

    rmap.connect('pullrequest_repo_info',

                 '/{repo_name:.*?}/pull-request-repo-info',

                 controller='pullrequests', action='repo_info',

                 conditions=dict(function=check_repo, method=["GET"]))

    rmap.connect('pullrequest',

                 '/{repo_name:.*?}/pull-request/new', controller='pullrequests',

                 action='create', conditions=dict(function=check_repo,

                                                  method=["POST"]))

    rmap.connect('pullrequest_show',

                 '/{repo_name:.*?}/pull-request/{pull_request_id:\\d+}{extra:(/.*)?}', extra='',

                 controller='pullrequests',

                 action='show', conditions=dict(function=check_repo,

                                                method=["GET"]))

    rmap.connect('pullrequest_post',

                 '/{repo_name:.*?}/pull-request/{pull_request_id}',

                 controller='pullrequests',

                 action='post', conditions=dict(function=check_repo,

                                                method=["POST"]))

    rmap.connect('pullrequest_delete',

                 '/{repo_name:.*?}/pull-request/{pull_request_id}/delete',

                 controller='pullrequests',

                 action='delete', conditions=dict(function=check_repo,

                                                  method=["POST"]))

    rmap.connect('pullrequest_show_all',

                 '/{repo_name:.*?}/pull-request',

        except formencode.Invalid as e:

            h.flash(_('Field validation error: %s') % e.msg, category='error')

        except Exception as e:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during creation of field: %r') % e, category='error')

        raise HTTPFound(location=url('edit_repo_fields', repo_name=repo_name))

    @HasRepoPermissionLevelDecorator('admin')

    def delete_repo_field(self, repo_name, field_id):

        field = RepositoryField.get_or_404(field_id)

        try:

            Session().delete(field)

            Session().commit()

        except Exception as e:

            log.error(traceback.format_exc())

            msg = _('An error occurred during removal of field')

            h.flash(msg, category='error')

        raise HTTPFound(location=url('edit_repo_fields', repo_name=repo_name))

    @HasRepoPermissionLevelDecorator('admin')

    def edit_advanced(self, repo_name):

        c.repo_info = self._load_repo()

        c.default_user_id = User.get_default_user().user_id

        c.in_public_journal = UserFollowing.query() \

            .filter(UserFollowing.user_id == c.default_user_id) \

            .filter(UserFollowing.follows_repository == c.repo_info).scalar()

        _repos = Repository.query(sorted=True).all()

        read_access_repos = RepoList(_repos, perm_level='read')

        c.repos_list = [(None, _('-- Not a fork --'))]

        c.repos_list += [(x.repo_id, x.repo_name)

                         for x in read_access_repos

                         if x.repo_id != c.repo_info.repo_id

                         and x.repo_type == c.repo_info.repo_type]

        defaults = {

            'id_fork_of': c.repo_info.fork_id if c.repo_info.fork_id else ''

        }

        c.active = 'advanced'

        if request.POST:

            raise HTTPFound(location=url('repo_edit_advanced'))

        return htmlfill.render(

            render('admin/repos/repo_edit.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    @HasRepoPermissionLevelDecorator('admin')

    def edit_advanced_journal(self, repo_name):

        """

        Sets this repository to be visible in public journal,

        in other words asking default user to follow this repo

        :param repo_name:

        """

        try:

            repo_id = Repository.get_by_repo_name(repo_name).repo_id

            user_id = User.get_default_user().user_id

            self.scm_model.toggle_following_repo(repo_id, user_id)

            h.flash(_('Updated repository visibility in public journal'),

                    category='success')

            Session().commit()

        except Exception:

            h.flash(_('An error occurred during setting this'

                      ' repository in public journal'),

                    category='error')

        raise HTTPFound(location=url('edit_repo_advanced', repo_name=repo_name))

    @HasRepoPermissionLevelDecorator('admin')

    def edit_advanced_fork(self, repo_name):

        """

        Mark given repository as a fork of another

        :param repo_name:

        """

        try:

            fork_id = request.POST.get('id_fork_of')

            repo = ScmModel().mark_as_fork(repo_name, fork_id,

                                           request.authuser.username)

            fork = repo.fork.repo_name if repo.fork else _('Nothing')

            Session().commit()

            h.flash(_('Marked repository %s as fork of %s') % (repo_name, fork),

                    category='success')

        except RepositoryError as e:

            log.error(traceback.format_exc())

            h.flash(e, category='error')

        except Exception as e:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during this operation'),

                    category='error')

        raise HTTPFound(location=url('edit_repo_advanced', repo_name=repo_name))

    @HasRepoPermissionLevelDecorator('admin')

    def edit_remote(self, repo_name):

        c.repo_info = self._load_repo()

        c.active = 'remote'

        if request.POST:

            try:

                ScmModel().pull_changes(repo_name, request.authuser.username, request.ip_addr)

                h.flash(_('Pulled from remote location'), category='success')

            except Exception as e:

                log.error(traceback.format_exc())

                h.flash(_('An error occurred during pull from remote location'),

                        category='error')

            raise HTTPFound(location=url('edit_repo_remote', repo_name=c.repo_name))

        return render('admin/repos/repo_edit.html')

    @HasRepoPermissionLevelDecorator('admin')

    def edit_statistics(self, repo_name):

        c.repo_info = self._load_repo()

        repo = c.repo_info.scm_instance

        if c.repo_info.stats:

            # this is on what revision we ended up so we add +1 for count

            last_rev = c.repo_info.stats.stat_on_revision + 1

        else:

            last_rev = 0

        c.stats_revision = last_rev

        c.repo_last_rev = repo.count() if repo.revisions else 0

        if last_rev == 0 or c.repo_last_rev == 0:

            c.stats_percentage = 0

        else:

            c.stats_percentage = '%.2f' % ((float((last_rev)) / c.repo_last_rev) * 100)

        c.active = 'statistics'

        if request.POST:

            try:

                RepoModel().delete_stats(repo_name)

                Session().commit()

            except Exception as e:

                log.error(traceback.format_exc())

                h.flash(_('An error occurred during deletion of repository stats'),

                        category='error')

            raise HTTPFound(location=url('edit_repo_statistics', repo_name=c.repo_name))

        return render('admin/repos/repo_edit.html')

# -*- coding: utf-8 -*-

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""

kallithea.model.db

~~~~~~~~~~~~~~~~~~

Database Models for Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Apr 08, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import base64

import collections

import datetime

import functools

import hashlib

import logging

import os

import time

import traceback

import ipaddr

import sqlalchemy

from sqlalchemy import Boolean, Column, DateTime, Float, ForeignKey, Index, Integer, LargeBinary, String, Unicode, UnicodeText, UniqueConstraint

from sqlalchemy.ext.hybrid import hybrid_property

from sqlalchemy.orm import class_mapper, joinedload, relationship, validates

from tg.i18n import lazy_ugettext as _

from webob.exc import HTTPNotFound

import kallithea

from kallithea.lib import ext_json

from kallithea.lib.exceptions import DefaultUserException

from kallithea.lib.utils2 import (Optional, ascii_bytes, aslist, get_changeset_safe, get_clone_url, remove_prefix, safe_bytes, safe_int, safe_str, str2bool,

                                  urlreadable)

from kallithea.lib.vcs import get_backend

from kallithea.lib.vcs.backends.base import EmptyChangeset

from kallithea.lib.vcs.utils.helpers import get_scm

from kallithea.model.meta import Base, Session

URL_SEP = '/'

log = logging.getLogger(__name__)

#==============================================================================

# BASE CLASSES

#==============================================================================

def _hash_key(k):

    return hashlib.md5(safe_bytes(k)).hexdigest()

class BaseDbModel(object):

    """

    Base Model for all classes

    """

    @classmethod

    def _get_keys(cls):

        """return column names for this model """

        # Note: not a normal dict - iterator gives "users.firstname", but keys gives "firstname"

        return class_mapper(cls).c.keys()

    def get_dict(self):

        """

        return dict with keys and values corresponding

        to this model data """

        d = {}

        for k in self._get_keys():

            d[k] = getattr(self, k)

        # also use __json__() if present to get additional fields

        _json_attr = getattr(self, '__json__', None)

        if _json_attr:

            # update with attributes from __json__

            if callable(_json_attr):

                _json_attr = _json_attr()

            for k, val in _json_attr.items():

                d[k] = val

        return d

    def get_appstruct(self):

        """return list with keys and values tuples corresponding

        to this model data """

        return [

            (k, getattr(self, k))

            for k in self._get_keys()

        ]

    def populate_obj(self, populate_dict):

        """populate model with data from given populate_dict"""

        for k in self._get_keys():

            if k in populate_dict:

                setattr(self, k, populate_dict[k])

    @classmethod

    def query(cls):

        return Session().query(cls)

    @classmethod

    def get(cls, id_):

        if id_:

            return cls.query().get(id_)

    @classmethod

    def guess_instance(cls, value, callback=None):

        """Haphazardly attempt to convert `value` to a `cls` instance.

        If `value` is None or already a `cls` instance, return it. If `value`

        is a number (or looks like one if you squint just right), assume it's

        a database primary key and let SQLAlchemy sort things out. Otherwise,

        fall back to resolving it using `callback` (if specified); this could

        e.g. be a function that looks up instances by name (though that won't

        work if the name begins with a digit). Otherwise, raise Exception.

        """

        if value is None:

    @classmethod

    def query(cls, sorted=False):

        """Add Repository-specific helpers for common query constructs.

        sorted: if True, apply the default ordering (name, case insensitive).

        """

        q = super(Repository, cls).query()

        if sorted:

            q = q.order_by(sqlalchemy.func.lower(Repository.repo_name))

        return q

    @classmethod

    def normalize_repo_name(cls, repo_name):

        """

        Normalizes os specific repo_name to the format internally stored inside

        database using URL_SEP

        :param cls:

        :param repo_name:

        """

        return URL_SEP.join(repo_name.split(os.sep))

    @classmethod

    def guess_instance(cls, value):

        return super(Repository, cls).guess_instance(value, Repository.get_by_repo_name)

    @classmethod

    def get_by_repo_name(cls, repo_name, case_insensitive=False):

        """Get the repo, defaulting to database case sensitivity.

        case_insensitive will be slower and should only be specified if necessary."""

        if case_insensitive:

            q = Session().query(cls).filter(sqlalchemy.func.lower(cls.repo_name) == sqlalchemy.func.lower(repo_name))

        else:

            q = Session().query(cls).filter(cls.repo_name == repo_name)

        q = q.options(joinedload(Repository.fork)) \

                .options(joinedload(Repository.owner)) \

                .options(joinedload(Repository.group))

        return q.scalar()

    @classmethod

    def get_by_full_path(cls, repo_full_path):

        base_full_path = os.path.realpath(kallithea.CONFIG['base_path'])

        repo_full_path = os.path.realpath(repo_full_path)

        assert repo_full_path.startswith(base_full_path + os.path.sep)

        repo_name = repo_full_path[len(base_full_path) + 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)

    @property

    def forks(self):

        """

        Return forks of this repo

        """

        return Repository.get_repo_forks(self.repo_id)

    @property

    def parent(self):

        """

        Returns fork parent

        """

        return self.fork

    @property

    def just_name(self):

        return self.repo_name.split(URL_SEP)[-1]

    @property

    def groups_with_parents(self):

        groups = []

        group = self.group

        while group is not None:

            groups.append(group)

            group = group.parent_group

            assert group not in groups, group # avoid recursion on bad db content

        groups.reverse()

        return groups

    @property

    def repo_full_path(self):

        """

        Returns base full path for the repository - where it actually

        exists on a filesystem.

        """

        p = [kallithea.CONFIG['base_path']]

        # we need to split the name by / since this is how we store the

        # names in the database, but that eventually needs to be converted

        # into a valid system path

        p += self.repo_name.split(URL_SEP)

        return os.path.join(*p)

    def get_new_name(self, repo_name):

        """

        returns new full repository name based on assigned group and new new

        :param group_name:

        """

        path_prefix = self.group.full_path_splitted if self.group else []

        return URL_SEP.join(path_prefix + [repo_name])

    @property

    def _ui(self):

        """

        Creates an db based ui object for this repository

        """

        from kallithea.lib.utils import make_ui

        return make_ui()

    @classmethod

    def is_valid(cls, repo_name):

        """

        returns True if given repo name is a valid filesystem repository

        :param cls:

        :param repo_name:

        """

        from kallithea.lib.utils import is_valid_repo

        return is_valid_repo(repo_name, kallithea.CONFIG['base_path'])

    def get_api_data(self, with_revision_names=False,

                           with_pullrequests=False):

        """

        Common function for generating repo api data.

        Optionally, also return tags, branches, bookmarks and PRs.

        """

        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.owner.username,

            fork_of=repo.fork.repo_name if repo.fork else None,

            enable_statistics=repo.enable_statistics,

            enable_downloads=repo.enable_downloads,

            last_changeset=repo.changeset_cache,

        )

        if with_revision_names:

            scm_repo = repo.scm_instance_no_cache()

            data.update(dict(

                tags=scm_repo.tags,

                branches=scm_repo.branches,

                bookmarks=scm_repo.bookmarks,

            ))

        if with_pullrequests:

            data['pull_requests'] = repo.pull_requests_other

        rc_config = Setting.get_app_settings()

        repository_fields = str2bool(rc_config.get('repository_fields'))

        if repository_fields:

            for f in self.extra_fields:

                data[f.field_key_prefixed] = f.field_value

        return data

    @property

    def last_db_change(self):

        return self.updated_on

    @property

    def clone_uri_hidden(self):

        clone_uri = self.clone_uri

        if clone_uri:

            import urlobject

            url_obj = urlobject.URLObject(self.clone_uri)

            if url_obj.password:

                clone_uri = url_obj.with_password('*****')

        return clone_uri

    def clone_url(self, clone_uri_tmpl, with_id=False, username=None):

        if '{repo}' not in clone_uri_tmpl and '_{repoid}' not in clone_uri_tmpl:

            log.error("Configured clone_uri_tmpl %r has no '{repo}' or '_{repoid}' and cannot toggle to use repo id URLs", clone_uri_tmpl)

        elif with_id:

            clone_uri_tmpl = clone_uri_tmpl.replace('{repo}', '_{repoid}')

        else:

            clone_uri_tmpl = clone_uri_tmpl.replace('_{repoid}', '{repo}')

        import kallithea.lib.helpers as h

        prefix_url = h.canonical_url('home')

        return get_clone_url(clone_uri_tmpl=clone_uri_tmpl,

                             prefix_url=prefix_url,

                             repo_name=self.repo_name,

            message

            date

            author

        :param cs_cache:

        """

        from kallithea.lib.vcs.backends.base import BaseChangeset

        if cs_cache is None:

            cs_cache = EmptyChangeset()

            # use no-cache version here

            scm_repo = self.scm_instance_no_cache()

            if scm_repo:

                cs_cache = scm_repo.get_changeset()

        if isinstance(cs_cache, BaseChangeset):

            cs_cache = cs_cache.__json__()

        if (not self.changeset_cache or cs_cache['raw_id'] != self.changeset_cache['raw_id']):

            _default = datetime.datetime.fromtimestamp(0)

            last_change = cs_cache.get('date') or _default

            log.debug('updated repo %s with new cs cache %s',

                      self.repo_name, cs_cache)

            self.updated_on = last_change

            self.changeset_cache = cs_cache

            Session().commit()

        else:

            log.debug('changeset_cache for %s already up to date with %s',

                      self.repo_name, cs_cache['raw_id'])

    @property

    def tip(self):

        return self.get_changeset('tip')

    @property

    def author(self):

        return self.tip.author

    @property

    def last_change(self):

        return self.scm_instance.last_change

    def get_comments(self, revisions=None):

        """

        Returns comments for this repository grouped by revisions

        :param revisions: filter query by revisions only

        """

        cmts = ChangesetComment.query() \

            .filter(ChangesetComment.repo == self)

        if revisions is not None:

            if not revisions:

                return {} # don't use sql 'in' on empty set

            cmts = cmts.filter(ChangesetComment.revision.in_(revisions))

        grouped = collections.defaultdict(list)

        for cmt in cmts.all():

            grouped[cmt.revision].append(cmt)

        return grouped

    def statuses(self, revisions):

        """

        Returns statuses for this repository.

        PRs without any votes do _not_ show up as unreviewed.

        :param revisions: list of revisions to get statuses for

        """

        if not revisions:

            return {}

        statuses = ChangesetStatus.query() \

            .filter(ChangesetStatus.repo == self) \

            .filter(ChangesetStatus.version == 0) \

            .filter(ChangesetStatus.revision.in_(revisions))

        grouped = {}

        for stat in statuses.all():

            pr_id = pr_nice_id = pr_repo = None

            if stat.pull_request:

                pr_id = stat.pull_request.pull_request_id

                pr_nice_id = PullRequest.make_nice_id(pr_id)

                pr_repo = stat.pull_request.other_repo.repo_name

            grouped[stat.revision] = [str(stat.status), stat.status_lbl,

                                      pr_id, pr_repo, pr_nice_id,

                                      stat.author]

        return grouped

    def _repo_size(self):

        from kallithea.lib import helpers as h

        log.debug('calculating repository size...')

        return h.format_byte_size(self.scm_instance.size)

    #==========================================================================

    # SCM CACHE INSTANCE

    #==========================================================================

    def set_invalidate(self):

        """

        """

    @property

    def scm_instance(self):

        if self._scm_instance is None:

        return self._scm_instance

    def scm_instance_no_cache(self):

        repo_full_path = self.repo_full_path

        alias = get_scm(repo_full_path)[0]

        log.debug('Creating instance of %s repository from %s',

                  alias, self.repo_full_path)

        backend = get_backend(alias)

        if alias == 'hg':

        else:

    def __json__(self):

        return dict(

            repo_id=self.repo_id,

            repo_name=self.repo_name,

            landing_rev=self.landing_rev,

        )

class RepoGroup(Base, BaseDbModel):

    __tablename__ = 'groups'

    __table_args__ = (

        _table_args_default_dict,

    )

    SEP = ' » '

    group_id = Column(Integer(), primary_key=True)