if not repo_ids and user_ids:

            filtering_criterion = UserLog.user_id.in_(user_ids)

        if filtering_criterion is not None:

                .options(joinedload(UserLog.user)) \

                .options(joinedload(UserLog.repository))

            #filter

        # Return a rendered template

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

        c.user = User.get(request.authuser.user_id)

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

            .options(joinedload(UserFollowing.follows_repository)) \

            .all()

        """

        Produce an atom-1.0 feed via feedgenerator module

        """

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

            .options(joinedload(UserFollowing.follows_repository)) \

            .all()

        """

        Produce an rss feed via feedgenerator module

        """

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

            .options(joinedload(UserFollowing.follows_repository)) \

            .all()

        # Return a rendered template

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

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

            .options(joinedload(UserFollowing.follows_repository)) \

            .all()

        """

        Produce an atom-1.0 feed via feedgenerator module

        """

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

            .options(joinedload(UserFollowing.follows_repository)) \

            .all()

        """

        Produce an rss2 feed via feedgenerator module

        """

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

            .options(joinedload(UserFollowing.follows_repository)) \

            .all()

        else:

            c.show_stats = False

            .filter(Statistics.repository == c.db_repo) \

            .scalar()

        c.ts_min = ts_min_m

        c.ts_max = ts_max_y

            .filter(Statistics.repository == c.db_repo) \

            .scalar()

        c.stats_percentage = 0

        c.my_pr_count = PullRequest.query(reviewer_id=request.authuser.user_id, include_closed=False).count()

    @staticmethod

    def _determine_auth_user(api_key, bearer_token, session_authuser):

@celerylib.dbsession

def whoosh_index(repo_location, full_index):

    from kallithea.lib.indexers.daemon import WhooshIndexingDaemon

    index_location = config['index_dir']

    WhooshIndexingDaemon(index_location=index_location,

                         .run(full_index=full_index)

    enable_downloads = defs.get('repo_enable_downloads')

    try:

            repo_name=repo_name_full,

            repo_type=repo_type,

            description=description,

        DBS.commit()

        # now create this repo on Filesystem

            repo_name=repo_name,

            repo_type=repo_type,

            repo_group=RepoGroup.guess_instance(repo_group),

        if repo:

            Repository.delete(repo.repo_id)

            DBS.commit()

        raise

    return True

    try:

        fork_of = Repository.guess_instance(form_data.get('fork_parent_id'))

            repo_name=repo_name_full,

            repo_type=repo_type,

            description=form_data['description'],

        source_repo_path = os.path.join(base_path, fork_of.repo_name)

        # now create this repo on Filesystem

            repo_name=repo_name,

            repo_type=repo_type,

            repo_group=RepoGroup.guess_instance(repo_group),

        if repo:

            Repository.delete(repo.repo_id)

            DBS.commit()

        raise

    return True

        Fixes a old kallithea version path into new one without a '*'

        """

                .filter(Ui.ui_key == '/') \

                .scalar()

        Fixes a old default user with some 'nicer' default values,

        used mostly for anonymous access

        """

        def_user.name = 'Anonymous'

        def_user.lastname = 'User'

        #HOOKS

        hooks1_key = Ui.HOOK_UPDATE

            .filter(Ui.ui_key == hooks1_key).scalar()

        hooks1 = Ui() if hooks1_ is None else hooks1_

        self.sa.add(hooks1)

        hooks2_key = Ui.HOOK_REPO_SIZE

            .filter(Ui.ui_key == hooks2_key).scalar()

        hooks2 = Ui() if hooks2_ is None else hooks2_

        hooks2.ui_section = 'hooks'

        # module.(access|create|change|delete)_[name]

        # module.(none|read|write|admin)

        log.info('creating permissions')

    def populate_default_permissions(self):

        """

        permissions that are missing, and not alter already defined ones

        """

        log.info('creating default user permissions')

    """

    def __init__(self, indexname=IDX_NAME, index_location=None,

                 repo_update_list=None):

        self.indexname = indexname

        if not repo_location:

            raise Exception('You have to provide repositories location')

        #filter repo list

        if repo_list:

    # last element is repo in nested groups structure

    groups = groups[:-1]

    owner = User.get_first_admin()

    for lvl, group_name in enumerate(groups):

        group_name = u'/'.join(groups[:lvl] + [group_name])

                log.debug("Removing non-existing repository found in db `%s`",

                          repo.repo_name)

                try:

                    sa.commit()

                except Exception:

                    #don't hold further removals on error

import logging

from kallithea.lib.utils2 import generate_api_key

from kallithea.model.db import User, UserApiKeys

from kallithea.model.meta import Session

log = logging.getLogger(__name__)

    def create(self, user, description, lifetime=-1):

        """

    engine_str = obfuscate_url_pw(str(engine.url))

    log.info("initializing db for %s", engine_str)

    meta.Base.metadata.bind = engine

import logging

from sqlalchemy.orm import joinedload

from kallithea.lib.exceptions import StatusChangeOnClosedPullRequestError

log = logging.getLogger(__name__)

    def _get_status_query(self, repo, revision, pull_request,

                          with_revisions=False):

            new_status.revision = rev

            new_status.pull_request = pull_request

            new_statuses.append(new_status)

        return new_statuses

from kallithea.lib.utils2 import extract_mentioned_users, safe_unicode

from kallithea.lib import helpers as h

from kallithea.model.db import ChangesetComment, User, \

    Notification, PullRequest, Repository

from kallithea.model.notification import NotificationModel

        .all())

    def _get_notification_data(self, repo, comment, author, comment_text,

                               line_no=None, revision=None, pull_request=None,

from kallithea.lib.utils2 import safe_unicode, safe_int, \

    time_to_datetime, AttributeDict

from kallithea.lib.compat import json

from kallithea.model.repo import RepoModel

from kallithea.model.scm import ScmModel

    return u''.join(rnd.choice(alphabet) for _ in xrange(length))

    def __delete_gist(self, gist):

        """

        gist.owner_id = owner.user_id

        gist.gist_expires = gist_expires

        gist.gist_type = safe_unicode(gist_type)

        if gist_type == Gist.GIST_PUBLIC:

            # use DB ID for easy to use GIST ID

            gist_id = safe_unicode(gist.gist_id)

    def delete(self, gist, fs_remove=True):

        gist = Gist.guess_instance(gist)

        try:

            if fs_remove:

                self.__delete_gist(gist)

            else:

import kallithea

from kallithea.lib import helpers as h

from kallithea.lib.utils2 import safe_unicode

from kallithea.model.db import Notification, User, UserNotification

from kallithea.model.meta import Session

log = logging.getLogger(__name__)

    def create(self, created_by, subject, body, recipients=None,

               type_=Notification.TYPE_MESSAGE, with_email=True,

                )

    TYPE_CHANGESET_COMMENT = Notification.TYPE_CHANGESET_COMMENT

    TYPE_MESSAGE = Notification.TYPE_MESSAGE # only used for testing

from sqlalchemy.exc import DatabaseError

from kallithea.lib.utils2 import str2bool

log = logging.getLogger(__name__)

    """

    Permissions model for Kallithea

    """

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

                new_perm = Permission()

                new_perm.permission_name = p[0]

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

        """

        if force:

            for perm in perms:

            defined_perms_groups = []

        # For every default permission that needs to be created, we check if

        # its group is already defined. If it's not, we create default permission.

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

                          gr, perm_name)

                new_perm = _make_perm(perm_name)

    def update(self, form_result):

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

            # clear current entries, to make this function idempotent

            # it will fix even if we define more permissions or permissions

            # are somehow missing

                .filter(UserToPerm.user == perm_user) \

                .all()

            for p in u2p:

            #create fresh set of permissions

            for def_perm_key in ['default_repo_perm',

                                 'default_group_perm',

                                 'default_register',

                                 'default_extern_activate']:

                p = _make_new(perm_user, form_result[def_perm_key])

            #stage 3 update all default permissions for repos if checked

            if form_result['overwrite_default_repo']:

                _def_name = form_result['default_repo_perm'].split('repository.')[-1]

                _def = Permission.get_by_key('repository.' + _def_name)

                # repos

                               .filter(UserRepoToPerm.user == perm_user) \

                               .all():

                _def_name = form_result['default_group_perm'].split('group.')[-1]

                # groups

                _def = Permission.get_by_key('group.' + _def_name)

                               .filter(UserRepoGroupToPerm.user == perm_user) \

                               .all():

                    g2p.permission = _def

                _def_name = form_result['default_user_group_perm'].split('usergroup.')[-1]

                # groups

                _def = Permission.get_by_key('usergroup.' + _def_name)

                               .filter(UserUserGroupToPerm.user == perm_user) \

                               .all():

                    g2p.permission = _def

        except (DatabaseError,):

            log.error(traceback.format_exc())

            raise

from kallithea.model.meta import Session

from kallithea.lib import helpers as h

from kallithea.lib.exceptions import UserInvalidException

from kallithea.model.db import PullRequest, PullRequestReviewer, Notification, \

    ChangesetStatus, User

from kallithea.model.notification import NotificationModel

log = logging.getLogger(__name__)

    def _get_valid_reviewers(self, seq):

        """ Generate User objects from a sequence of user IDs, usernames or

from kallithea.lib.caching_query import FromCache

from kallithea.lib.hooks import log_delete_repository

from kallithea.model.db import Repository, UserRepoToPerm, UserGroupRepoToPerm, \

    Statistics, UserGroup, Ui, RepoGroup, RepositoryField

from kallithea.lib import helpers as h

log = logging.getLogger(__name__)

    URL_SEPARATOR = Repository.url_sep()

        repo_to_perm.repository = repository

        repo_to_perm.user_id = def_user.user_id

        return repo_to_perm

        Gets the repositories root path from database

        """

        return q.ui_value

    def get(self, repo_id, cache=False):

            .filter(Repository.repo_id == repo_id)

        if cache:

        return Repository.guess_instance(repository)

    def get_by_repo_name(self, repo_name, cache=False):

            .filter(Repository.repo_name == repo_name)

        if cache:

        return Repository.query().filter(Repository.repo_name.in_(repos))

    def get_users_js(self):

            .filter(User.active == True) \

            .order_by(User.name, User.lastname) \

            .all()

        )

    def get_user_groups_js(self):

            .filter(UserGroup.users_group_active == True) \

            .order_by(UserGroup.users_group_name) \

            .options(subqueryload(UserGroup.members)) \

                parent_repo = fork_of

                new_repo.fork = parent_repo

            if fork_of and copy_fork_permissions:

                repo = fork_of

                self._create_default_perms(new_repo, private)

            # now automatically start following this repository as owner

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

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

            return new_repo

        except Exception:

            log.error(traceback.format_exc())

            old_repo_dict = repo.get_dict()

            try:

                if fs_remove:

                    self._delete_filesystem_repo(repo)

                else:

        permission = Permission.guess_instance(perm)

        # check if we have that permission already

            .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

        user = User.guess_instance(user)

        repo = Repository.guess_instance(repo)

            .filter(UserRepoToPerm.repository == repo) \

            .filter(UserRepoToPerm.user == user) \

            .scalar()

        if obj is not None:

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

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

        permission = Permission.guess_instance(perm)

        # check if we have that permission already

            .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

        repo = Repository.guess_instance(repo)

        group_name = UserGroup.guess_instance(group_name)

            .filter(UserGroupRepoToPerm.repository == repo) \

            .filter(UserGroupRepoToPerm.users_group == group_name) \

            .scalar()

        if obj is not None:

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

    def delete_stats(self, repo_name):

        """

        repo = Repository.guess_instance(repo_name)

        try:

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

            if obj is not None:

        except Exception:

            log.error(traceback.format_exc())

            raise

from kallithea.lib.utils2 import LazyProperty

    User, Permission, UserGroupRepoGroupToPerm, UserGroup, Repository

log = logging.getLogger(__name__)

    @LazyProperty

    def repos_path(self):

        repo_group_to_perm.group = new_group

        repo_group_to_perm.user_id = def_user.user_id

        return repo_group_to_perm

    def _create_group(self, group_name):

            new_repo_group.parent_group = parent_group

            new_repo_group.group_name = new_repo_group.get_new_name(group_name)

            # create an ADMIN permission for owner except if we're super admin,

            # later owner should go into the owner field of groups

            if not just_db:

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

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

                self._create_group(new_repo_group.group_name)

            return new_repo_group

            repo_group.parent_group = RepoGroup.get(form_data['parent_group_id'])

            repo_group.group_name = repo_group.get_new_name(form_data['group_name'])

            new_path = repo_group.full_path

            # iterate over all members of this groups and do fixes

            # set locking if given

    def delete(self, repo_group, force_delete=False):

        repo_group = RepoGroup.guess_instance(repo_group)

        try:

            self._delete_group(repo_group, force_delete)

        except Exception:

            log.error('Error removing repo_group %s', repo_group)

        permission = Permission.guess_instance(perm)

        # check if we have that permission already

            .filter(UserRepoGroupToPerm.user == user) \

            .filter(UserRepoGroupToPerm.group == repo_group) \

            .scalar()

        if obj is None:

            # create new !

            obj = UserRepoGroupToPerm()

        obj.group = repo_group

        obj.user = user

        obj.permission = permission

        repo_group = RepoGroup.guess_instance(repo_group)

        user = User.guess_instance(user)

            .filter(UserRepoGroupToPerm.user == user) \

            .filter(UserRepoGroupToPerm.group == repo_group) \

            .scalar()

        if obj is not None:

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

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

        permission = Permission.guess_instance(perm)

        # check if we have that permission already

            .filter(UserGroupRepoGroupToPerm.group == repo_group) \

            .filter(UserGroupRepoGroupToPerm.users_group == group_name) \

            .scalar()

        if obj is None:

            # create new

            obj = UserGroupRepoGroupToPerm()

        obj.group = repo_group

        obj.users_group = group_name

        repo_group = RepoGroup.guess_instance(repo_group)

        group_name = UserGroup.guess_instance(group_name)

            .filter(UserGroupRepoGroupToPerm.group == repo_group) \

            .filter(UserGroupRepoGroupToPerm.users_group == group_name) \