# -*- 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.controllers.journal

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

Journal controller

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: Nov 21, 2010

:author: marcink

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

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

"""

import logging

import traceback

from itertools import groupby

from sqlalchemy import or_

from sqlalchemy.orm import joinedload

from sqlalchemy.sql.expression import func

from webhelpers.feedgenerator import Atom1Feed, Rss201rev2Feed

from webob.exc import HTTPBadRequest

from pylons import request, tmpl_context as c, response

from pylons.i18n.translation import _

from kallithea.config.routing import url

from kallithea.controllers.admin.admin import _journal_filter

from kallithea.model.db import UserLog, UserFollowing, Repository, User

from kallithea.model.meta import Session

from kallithea.model.repo import RepoModel

import kallithea.lib.helpers as h

from kallithea.lib.auth import LoginRequired, NotAnonymous

from kallithea.lib.base import BaseController, render

from kallithea.lib.compat import json

from kallithea.lib.page import Page

from kallithea.lib.utils2 import safe_int, AttributeDict

log = logging.getLogger(__name__)

class JournalController(BaseController):

    def __before__(self):

        super(JournalController, self).__before__()

        self.language = 'en-us'

        self.ttl = "5"

        self.feed_nr = 20

        c.search_term = request.GET.get('filter')

    def _get_daily_aggregate(self, journal):

        groups = []

        for k, g in groupby(journal, lambda x: x.action_as_day):

            user_group = []

            #groupby username if it's a present value, else fallback to journal username

            for _unused, g2 in groupby(list(g), lambda x: x.user.username if x.user else x.username):

                l = list(g2)

                user_group.append((l[0].user, l))

            groups.append((k, user_group,))

        return groups

    def _get_journal_data(self, following_repos):

        user_ids = [x.follows_user_id for x in following_repos

                    if x.follows_user_id is not None]

        filtering_criterion = None

        if repo_ids and user_ids:

            filtering_criterion = or_(UserLog.repository_id.in_(repo_ids),

                        UserLog.user_id.in_(user_ids))

        if repo_ids and not user_ids:

            filtering_criterion = UserLog.repository_id.in_(repo_ids)

        if not repo_ids and user_ids:

            filtering_criterion = UserLog.user_id.in_(user_ids)

        if filtering_criterion is not None:

            journal = self.sa.query(UserLog) \

                .options(joinedload(UserLog.user)) \

                .options(joinedload(UserLog.repository))

            #filter

            journal = _journal_filter(journal, c.search_term)

            journal = journal.filter(filtering_criterion) \

                        .order_by(UserLog.action_date.desc())

        else:

            journal = []

        return journal

    def _atom_feed(self, repos, public=True):

        journal = self._get_journal_data(repos)

        if public:

            _link = h.canonical_url('public_journal_atom')

            _desc = '%s %s %s' % (c.site_name, _('Public Journal'),

                                  'atom feed')

        else:

            _link = h.canonical_url('journal_atom')

            _desc = '%s %s %s' % (c.site_name, _('Journal'), 'atom feed')

        feed = Atom1Feed(title=_desc,

                         link=_link,

                         description=_desc,

                         language=self.language,

                         ttl=self.ttl)

        for entry in journal[:self.feed_nr]:

            user = entry.user

            if user is None:

                #fix deleted users

                user = AttributeDict({'short_contact': entry.username,

                                      'email': '',

                                      'full_contact': ''})

            action, action_extra, ico = h.action_parser(entry, feed=True)

            title = "%s - %s %s" % (user.short_contact, action(),

                                    entry.repository.repo_name)

            desc = action_extra()

            _url = None

            if entry.repository is not None:

                _url = h.canonical_url('changelog_home',

                           repo_name=entry.repository.repo_name)

            feed.add_item(title=title,

                          pubdate=entry.action_date,

                          link=_url or h.canonical_url(''),

                          author_email=user.email,

                          author_name=user.full_contact,

                          description=desc)

        response.content_type = feed.mime_type

        return feed.writeString('utf-8')

    def _rss_feed(self, repos, public=True):

        journal = self._get_journal_data(repos)

        if public:

            _link = h.canonical_url('public_journal_atom')

            _desc = '%s %s %s' % (c.site_name, _('Public Journal'),

                                  'rss feed')

        else:

            _link = h.canonical_url('journal_atom')

            _desc = '%s %s %s' % (c.site_name, _('Journal'), 'rss feed')

        feed = Rss201rev2Feed(title=_desc,

                         link=_link,

                         description=_desc,

                         language=self.language,

                         ttl=self.ttl)

        for entry in journal[:self.feed_nr]:

            user = entry.user

            if user is None:

                #fix deleted users

                user = AttributeDict({'short_contact': entry.username,

                                      'email': '',

                                      'full_contact': ''})

            action, action_extra, ico = h.action_parser(entry, feed=True)

            title = "%s - %s %s" % (user.short_contact, action(),

                                    entry.repository.repo_name)

            desc = action_extra()

            _url = None

            if entry.repository is not None:

                                                   admin=True)

        #json used to render the grid

        c.data = json.dumps(repos_data)

        watched_repos_data = []

        ## watched repos

        _render = RepoModel._render_datatable

        def quick_menu(repo_name):

            return _render('quick_menu', repo_name)

        def repo_lnk(name, rtype, rstate, private, fork_of):

            return _render('repo_name', name, rtype, rstate, private, fork_of,

                           short_name=False, admin=False)

        def last_rev(repo_name, cs_cache):

            return _render('revision', repo_name, cs_cache.get('revision'),

                           cs_cache.get('raw_id'), cs_cache.get('author'),

                           cs_cache.get('message'))

        def desc(desc):

            from pylons import tmpl_context as c

            return h.urlify_text(desc, truncate=60, stylize=c.visual.stylify_metatags)

        def repo_actions(repo_name):

            return _render('repo_actions', repo_name)

        def owner_actions(user_id, username):

            return _render('user_name', user_id, username)

        def toogle_follow(repo_id):

            return  _render('toggle_follow', repo_id)

        for entry in c.following:

            repo = entry.follows_repository

            cs_cache = repo.changeset_cache

            row = {

                "menu": quick_menu(repo.repo_name),

                "raw_name": repo.repo_name,

                "name": repo_lnk(repo.repo_name, repo.repo_type,

                                 repo.repo_state, repo.private, repo.fork),

                "last_changeset": last_rev(repo.repo_name, cs_cache),

                "last_rev_raw": cs_cache.get('revision'),

                "action": toogle_follow(repo.repo_id)

            }

            watched_repos_data.append(row)

        c.watched_data = json.dumps({

            "totalRecords": len(c.following),

            "startIndex": 0,

            "sort": "name",

            "dir": "asc",

            "records": watched_repos_data

        })

        return render('journal/journal.html')

    @LoginRequired(api_access=True)

    @NotAnonymous()

    def journal_atom(self):

        """

        Produce an atom-1.0 feed via feedgenerator module

        """

        following = self.sa.query(UserFollowing) \

            .filter(UserFollowing.user_id == self.authuser.user_id) \

            .options(joinedload(UserFollowing.follows_repository)) \

            .all()

        return self._atom_feed(following, public=False)

    @LoginRequired(api_access=True)

    @NotAnonymous()

    def journal_rss(self):

        """

        Produce an rss feed via feedgenerator module

        """

        following = self.sa.query(UserFollowing) \

            .filter(UserFollowing.user_id == self.authuser.user_id) \

            .options(joinedload(UserFollowing.follows_repository)) \

            .all()

        return self._rss_feed(following, public=False)

    @LoginRequired()

    @NotAnonymous()

    def toggle_following(self):

        user_id = request.POST.get('follows_user_id')

        if user_id:

            try:

                self.scm_model.toggle_following_user(user_id,

                                            self.authuser.user_id)

                Session.commit()

                return 'ok'

            except Exception:

                log.error(traceback.format_exc())

                raise HTTPBadRequest()

        if repo_id:

            try:

                self.scm_model.toggle_following_repo(repo_id,

                                            self.authuser.user_id)

                Session.commit()

                return 'ok'

            except Exception:

                log.error(traceback.format_exc())

                raise HTTPBadRequest()

        raise HTTPBadRequest()

    @LoginRequired()

    def public_journal(self):

        # Return a rendered template

        p = safe_int(request.GET.get('page'), 1)

        c.following = self.sa.query(UserFollowing) \

            .filter(UserFollowing.user_id == self.authuser.user_id) \

            .options(joinedload(UserFollowing.follows_repository)) \

            .all()

        journal = self._get_journal_data(c.following)

        c.journal_pager = Page(journal, page=p, items_per_page=20)

        c.journal_day_aggregate = self._get_daily_aggregate(c.journal_pager)

        if request.environ.get('HTTP_X_PARTIAL_XHR'):

            return render('journal/journal_data.html')

        return render('journal/public_journal.html')

    @LoginRequired(api_access=True)

    def public_journal_atom(self):

        """

        Produce an atom-1.0 feed via feedgenerator module

        """

        c.following = self.sa.query(UserFollowing) \

            .filter(UserFollowing.user_id == self.authuser.user_id) \

            .options(joinedload(UserFollowing.follows_repository)) \

            .all()

        return self._atom_feed(c.following)

    @LoginRequired(api_access=True)

    def public_journal_rss(self):

        """

        Produce an rss2 feed via feedgenerator module

        """

        c.following = self.sa.query(UserFollowing) \

            .filter(UserFollowing.user_id == self.authuser.user_id) \

            .options(joinedload(UserFollowing.follows_repository)) \

            .all()

        return self._rss_feed(c.following)

        _table_args_default_dict,

    )

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

    users_group_id = Column(Integer(), ForeignKey('users_groups.users_group_id'), nullable=False)

    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False)

    user = relationship('User')

    users_group = relationship('UserGroup')

    def __init__(self, gr_id='', u_id=''):

        self.users_group_id = gr_id

        self.user_id = u_id

class RepositoryField(Base, BaseDbModel):

    __tablename__ = 'repositories_fields'

    __table_args__ = (

        UniqueConstraint('repository_id', 'field_key'),  # no-multi field

        _table_args_default_dict,

    )

    PREFIX = 'ex_'  # prefix used in form to not conflict with already existing fields

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

    repository_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=False)

    field_key = Column(String(250), nullable=False)

    field_label = Column(String(1024), nullable=False)

    field_value = Column(String(10000), nullable=False)

    field_desc = Column(String(1024), nullable=False)

    field_type = Column(String(255), nullable=False)

    created_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    repository = relationship('Repository')

    @property

    def field_key_prefixed(self):

        return 'ex_%s' % self.field_key

    @classmethod

    def un_prefix_key(cls, key):

        if key.startswith(cls.PREFIX):

            return key[len(cls.PREFIX):]

        return key

    @classmethod

    def get_by_key_name(cls, key, repo):

        row = cls.query() \

                .filter(cls.repository == repo) \

                .filter(cls.field_key == key).scalar()

        return row

class Repository(Base, BaseDbModel):

    __tablename__ = 'repositories'

    __table_args__ = (

        Index('r_repo_name_idx', 'repo_name'),

        _table_args_default_dict,

    )

    DEFAULT_CLONE_URI = '{scheme}://{user}@{netloc}/{repo}'

    DEFAULT_CLONE_URI_ID = '{scheme}://{user}@{netloc}/_{repoid}'

    STATE_CREATED = u'repo_state_created'

    STATE_PENDING = u'repo_state_pending'

    STATE_ERROR = u'repo_state_error'

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

    repo_name = Column(Unicode(255), nullable=False, unique=True)

    repo_state = Column(String(255), nullable=False)

    clone_uri = Column(String(255), nullable=True) # FIXME: not nullable?

    repo_type = Column(String(255), nullable=False)

    owner_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)

    private = Column(Boolean(), nullable=False)

    enable_statistics = Column("statistics", Boolean(), nullable=False, default=True)

    enable_downloads = Column("downloads", Boolean(), nullable=False, default=True)

    description = Column(Unicode(10000), nullable=False)

    created_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    updated_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    _landing_revision = Column("landing_revision", String(255), nullable=False)

    enable_locking = Column(Boolean(), nullable=False, default=False)

    _locked = Column("locked", String(255), nullable=True) # FIXME: not nullable?

    _changeset_cache = Column("changeset_cache", LargeBinary(), nullable=True) # JSON data # FIXME: not nullable?

    fork_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=True)

    group_id = Column(Integer(), ForeignKey('groups.group_id'), nullable=True)

    owner = relationship('User')

    fork = relationship('Repository', remote_side=repo_id)

    group = relationship('RepoGroup')

    repo_to_perm = relationship('UserRepoToPerm', cascade='all', order_by='UserRepoToPerm.repo_to_perm_id')

    users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all')

    stats = relationship('Statistics', cascade='all', uselist=False)

    followers = relationship('UserFollowing',

                             cascade='all')

    extra_fields = relationship('RepositoryField',

                                cascade="all, delete-orphan")

    logs = relationship('UserLog')

    comments = relationship('ChangesetComment', cascade="all, delete-orphan")

    pull_requests_org = relationship('PullRequest',

                    primaryjoin='PullRequest.org_repo_id==Repository.repo_id',

                    cascade="all, delete-orphan")

    pull_requests_other = relationship('PullRequest',

                    primaryjoin='PullRequest.other_repo_id==Repository.repo_id',

                    cascade="all, delete-orphan")

    def __unicode__(self):

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

                                   safe_unicode(self.repo_name))

    @hybrid_property

    def landing_rev(self):

        # always should return [rev_type, rev]

        if self._landing_revision:

            _rev_info = self._landing_revision.split(':')

            if len(_rev_info) < 2:

                _rev_info.insert(0, 'rev')

            return [_rev_info[0], _rev_info[1]]

        return [None, None]

    @landing_rev.setter

    def landing_rev(self, val):

        if ':' not in val:

            raise ValueError('value must be delimited with `:` and consist '

                             'of <rev_type>:<rev>, got %s instead' % val)

        self._landing_revision = val

    @hybrid_property

    def locked(self):

        # always should return [user_id, timelocked]

        if self._locked:

            _lock_info = self._locked.split(':')

            return int(_lock_info[0]), _lock_info[1]

        return [None, None]

    @locked.setter

    def locked(self, val):

        if val and isinstance(val, (list, tuple)):

            self._locked = ':'.join(map(str, val))

        else:

            self._locked = None

    @hybrid_property

    def changeset_cache(self):

        try:

            cs_cache = json.loads(self._changeset_cache) # might raise on bad data

            cs_cache['raw_id'] # verify data, raise exception on error

            return cs_cache

        except (TypeError, KeyError, ValueError):

            return EmptyChangeset().__json__()

    @changeset_cache.setter

    def changeset_cache(self, val):

        try:

            self._changeset_cache = json.dumps(val)

        except Exception:

            log.error(traceback.format_exc())

    @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(func.lower(Repository.repo_name))

        return q

    @classmethod

    def url_sep(cls):

        return URL_SEP

    @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 cls.url_sep().join(repo_name.split(os.sep))

    @classmethod

        return u'<UserGroupUserGroup:%s => %s >' % (self.target_user_group, self.user_group)

class UserGroupToPerm(Base, BaseDbModel):

    __tablename__ = 'users_group_to_perm'

    __table_args__ = (

        UniqueConstraint('users_group_id', 'permission_id',),

        _table_args_default_dict,

    )

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

    users_group_id = Column(Integer(), ForeignKey('users_groups.users_group_id'), nullable=False)

    permission_id = Column(Integer(), ForeignKey('permissions.permission_id'), nullable=False)

    users_group = relationship('UserGroup')

    permission = relationship('Permission')

class UserRepoGroupToPerm(Base, BaseDbModel):

    __tablename__ = 'user_repo_group_to_perm'

    __table_args__ = (

        UniqueConstraint('user_id', 'group_id', 'permission_id'),

        _table_args_default_dict,

    )

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

    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False)

    group_id = Column(Integer(), ForeignKey('groups.group_id'), nullable=False)

    permission_id = Column(Integer(), ForeignKey('permissions.permission_id'), nullable=False)

    user = relationship('User')

    group = relationship('RepoGroup')

    permission = relationship('Permission')

    @classmethod

    def create(cls, user, repository_group, permission):

        n = cls()

        n.user = user

        n.group = repository_group

        n.permission = permission

        Session().add(n)

        return n

class UserGroupRepoGroupToPerm(Base, BaseDbModel):

    __tablename__ = 'users_group_repo_group_to_perm'

    __table_args__ = (

        UniqueConstraint('users_group_id', 'group_id'),

        _table_args_default_dict,

    )

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

    users_group_id = Column(Integer(), ForeignKey('users_groups.users_group_id'), nullable=False)

    group_id = Column(Integer(), ForeignKey('groups.group_id'), nullable=False)

    permission_id = Column(Integer(), ForeignKey('permissions.permission_id'), nullable=False)

    users_group = relationship('UserGroup')

    permission = relationship('Permission')

    group = relationship('RepoGroup')

    @classmethod

    def create(cls, user_group, repository_group, permission):

        n = cls()

        n.users_group = user_group

        n.group = repository_group

        n.permission = permission

        Session().add(n)

        return n

class Statistics(Base, BaseDbModel):

    __tablename__ = 'statistics'

    __table_args__ = (

         _table_args_default_dict,

    )

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

    repository_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True)

    stat_on_revision = Column(Integer(), nullable=False)

    commit_activity = Column(LargeBinary(1000000), nullable=False)#JSON data

    commit_activity_combined = Column(LargeBinary(), nullable=False)#JSON data

    languages = Column(LargeBinary(1000000), nullable=False)#JSON data

    repository = relationship('Repository', single_parent=True)

class UserFollowing(Base, BaseDbModel):

    __tablename__ = 'user_followings'

    __table_args__ = (

        UniqueConstraint('user_id', 'follows_repository_id', name='uq_user_followings_user_repo'),

        UniqueConstraint('user_id', 'follows_user_id', name='uq_user_followings_user_user'),

        _table_args_default_dict,

    )

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

    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False)

    follows_user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=True)

    follows_from = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id')

    follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')

    follows_repository = relationship('Repository', order_by=lambda: func.lower(Repository.repo_name))

    @classmethod

    def get_repo_followers(cls, repo_id):

class CacheInvalidation(Base, BaseDbModel):

    __tablename__ = 'cache_invalidation'

    __table_args__ = (

        Index('key_idx', 'cache_key'),

        _table_args_default_dict,

    )

    # cache_id, not used

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

    # cache_key as created by _get_cache_key

    cache_key = Column(Unicode(255), nullable=False, unique=True)

    # cache_args is a repo_name

    cache_args = Column(Unicode(255), nullable=False)

    # instance sets cache_active True when it is caching, other instances set

    # cache_active to False to indicate that this cache is invalid

    cache_active = Column(Boolean(), nullable=False, default=False)

    def __init__(self, cache_key, repo_name=''):

        self.cache_key = cache_key

        self.cache_args = repo_name

        self.cache_active = False

    def __unicode__(self):

        return u"<%s('%s:%s[%s]')>" % (

            self.__class__.__name__,

            self.cache_id, self.cache_key, self.cache_active)

    def _cache_key_partition(self):

        prefix, repo_name, suffix = self.cache_key.partition(self.cache_args)

        return prefix, repo_name, suffix

    def get_prefix(self):

        """

        get prefix that might have been used in _get_cache_key to

        generate self.cache_key. Only used for informational purposes

        in repo_edit.html.

        """

        # prefix, repo_name, suffix

        return self._cache_key_partition()[0]

    def get_suffix(self):

        """

        get suffix that might have been used in _get_cache_key to

        generate self.cache_key. Only used for informational purposes

        in repo_edit.html.

        """

        # prefix, repo_name, suffix

        return self._cache_key_partition()[2]

    @classmethod

    def clear_cache(cls):

        """

        Delete all cache keys from database.

        Should only be run when all instances are down and all entries thus stale.

        """

        cls.query().delete()

        Session().commit()

    @classmethod

    def _get_cache_key(cls, key):

        """

        Wrapper for generating a unique cache key for this instance and "key".

        key must / will start with a repo_name which will be stored in .cache_args .

        """

        import kallithea

        prefix = kallithea.CONFIG.get('instance_id', '')

        return "%s%s" % (prefix, key)

    @classmethod

    def set_invalidate(cls, repo_name):

        """

        Mark all caches of a repo as invalid in the database.

        """

        inv_objs = Session().query(cls).filter(cls.cache_args == repo_name).all()

        log.debug('for repo %s got %s invalidation objects',

                  safe_str(repo_name), inv_objs)

        for inv_obj in inv_objs:

            log.debug('marking %s key for invalidation based on repo_name=%s',

                      inv_obj, safe_str(repo_name))

            Session().delete(inv_obj)

        Session().commit()

    @classmethod

    def test_and_set_valid(cls, repo_name, kind, valid_cache_keys=None):

        """

        Mark this cache key as active and currently cached.

        Return True if the existing cache registration still was valid.

        Return False to indicate that it had been invalidated and caches should be refreshed.

        """

        key = (repo_name + '_' + kind) if kind else repo_name

        cache_key = cls._get_cache_key(key)

                    extra_kwargs=extra_kwargs)

class ScmModel(BaseModel):

    """

    Generic Scm Model

    """

    def __get_repo(self, instance):

        cls = Repository

        if isinstance(instance, cls):

            return instance

        elif isinstance(instance, int) or safe_str(instance).isdigit():

            return cls.get(instance)

        elif isinstance(instance, basestring):

            return cls.get_by_repo_name(instance)

        elif instance is not None:

            raise Exception('given object must be int, basestr or Instance'

                            ' of %s got %s' % (type(cls), type(instance)))

    @LazyProperty

    def repos_path(self):

        """

        Gets the repositories root path from database

        """

        q = self.sa.query(Ui).filter(Ui.ui_key == '/').one()

        return q.ui_value

    def repo_scan(self, repos_path=None):

        """

        Listing of repositories in given path. This path should not be a

        repository itself. Return a dictionary of repository objects

        :param repos_path: path to directory containing repositories

        """

        if repos_path is None:

            repos_path = self.repos_path

        log.info('scanning for repositories in %s', repos_path)

        baseui = make_ui('db')

        repos = {}

        for name, path in get_filesystem_repos(repos_path):

            # name need to be decomposed and put back together using the /

            # since this is internal storage separator for kallithea

            name = Repository.normalize_repo_name(name)

            try:

                if name in repos:

                    raise RepositoryError('Duplicate repository name %s '

                                          'found in %s' % (name, path))

                else:

                    klass = get_backend(path[0])

                    if path[0] == 'hg' and path[0] in BACKENDS.keys():

                        repos[name] = klass(safe_str(path[1]), baseui=baseui)

                    if path[0] == 'git' and path[0] in BACKENDS.keys():

                        repos[name] = klass(path[1])

            except OSError:

                continue

        log.debug('found %s paths with repositories', len(repos))

        return repos

    def get_repos(self, repos):

        """Return the repos the user has access to"""

        return RepoList(repos)

    def get_repo_groups(self, groups=None):

        """Return the repo groups the user has access to

        If no groups are specified, use top level groups.

        """

        if groups is None:

            groups = RepoGroup.query() \

                .filter(RepoGroup.parent_group_id == None).all()

        return RepoGroupList(groups)

    def mark_for_invalidation(self, repo_name):

        """

        Mark caches of this repo invalid in the database.

        :param repo_name: the repo for which caches should be marked invalid

        """

        CacheInvalidation.set_invalidate(repo_name)

        repo = Repository.get_by_repo_name(repo_name)

        if repo is not None:

            repo.update_changeset_cache()

    def toggle_following_repo(self, follow_repo_id, user_id):

        f = self.sa.query(UserFollowing) \

            .filter(UserFollowing.user_id == user_id).scalar()

        if f is not None:

            try:

                self.sa.delete(f)

                action_logger(UserTemp(user_id),

                              'stopped_following_repo',

                              RepoTemp(follow_repo_id))

                return

            except Exception:

                log.error(traceback.format_exc())

                raise

        try:

            f = UserFollowing()

            f.user_id = user_id

            self.sa.add(f)

            action_logger(UserTemp(user_id),

                          'started_following_repo',

                          RepoTemp(follow_repo_id))

        except Exception:

            log.error(traceback.format_exc())

            raise

    def toggle_following_user(self, follow_user_id, user_id):

        f = self.sa.query(UserFollowing) \

            .filter(UserFollowing.follows_user_id == follow_user_id) \

            .filter(UserFollowing.user_id == user_id).scalar()