filters.append(get_filterion(field, val, term))

        user_log = user_log.filter(or_(*filters))

    return user_log

class AdminController(BaseController):

    @LoginRequired()

    def __before__(self):

        super(AdminController, self).__before__()

    @HasPermissionAllDecorator('hg.admin')

    def index(self):

        users_log = UserLog.query() \

                .options(joinedload(UserLog.user)) \

                .options(joinedload(UserLog.repository))

        #FILTERING

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

        users_log = _journal_filter(users_log, c.search_term)

        users_log = users_log.order_by(UserLog.action_date.desc())

        def url_generator(**kw):

            return url.current(filter=c.search_term, **kw)

        c.users_log = Page(users_log, page=p, items_per_page=10, url=url_generator)

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

            return render('admin/admin_log.html')

        return render('admin/admin.html')

        gists = Gist().query() \

            .filter(or_(Gist.gist_expires == -1, Gist.gist_expires >= time.time())) \

            .order_by(Gist.created_on.desc())

        # MY private

        if c.show_private and not c.show_public:

            gists = gists.filter(Gist.gist_type == Gist.GIST_PRIVATE) \

                             .filter(Gist.gist_owner == c.authuser.user_id)

        # MY public

        elif c.show_public and not c.show_private:

            gists = gists.filter(Gist.gist_type == Gist.GIST_PUBLIC) \

                             .filter(Gist.gist_owner == c.authuser.user_id)

        # MY public+private

        elif c.show_private and c.show_public:

            gists = gists.filter(or_(Gist.gist_type == Gist.GIST_PUBLIC,

                                     Gist.gist_type == Gist.GIST_PRIVATE)) \

                             .filter(Gist.gist_owner == c.authuser.user_id)

        # default show ALL public gists

        if not c.show_public and not c.show_private:

            gists = gists.filter(Gist.gist_type == Gist.GIST_PUBLIC)

        c.gists = gists

        c.gists_pager = Page(c.gists, page=p, items_per_page=10)

        return render('admin/gists/index.html')

    @LoginRequired()

    @NotAnonymous()

    def create(self):

        """POST /admin/gists: Create a new item"""

        # url('gists')

        self.__load_defaults()

        gist_form = GistForm([x[0] for x in c.lifetime_values])()

        try:

            form_result = gist_form.to_python(dict(request.POST))

            #TODO: multiple files support, from the form

            filename = form_result['filename'] or Gist.DEFAULT_FILENAME

            nodes = {

                filename: {

                    'content': form_result['content'],

                    'lexer': form_result['mimetype']  # None is autodetect

                }

            }

            _public = form_result['public']

            gist_type = Gist.GIST_PUBLIC if _public else Gist.GIST_PRIVATE

            gist = GistModel().create(

                description=form_result['description'],

log = logging.getLogger(__name__)

class NotificationsController(BaseController):

    """REST Controller styled on the Atom Publishing Protocol"""

    # To properly map this controller, ensure your config/routing.py

    # file has a resource setup:

    #     map.resource('notification', 'notifications', controller='_admin/notifications',

    #         path_prefix='/_admin', name_prefix='_admin_')

    @LoginRequired()

    @NotAnonymous()

    def __before__(self):

        super(NotificationsController, self).__before__()

    def index(self, format='html'):

        """GET /_admin/notifications: All items in the collection"""

        # url('notifications')

        c.user = self.authuser

        notif = NotificationModel().query_for_user(self.authuser.user_id,

                                            filter_=request.GET.getall('type'))

        c.notifications = Page(notif, page=p, items_per_page=10)

        c.pull_request_type = Notification.TYPE_PULL_REQUEST

        c.comment_type = [Notification.TYPE_CHANGESET_COMMENT,

                          Notification.TYPE_PULL_REQUEST_COMMENT]

        _current_filter = request.GET.getall('type')

        c.current_filter = 'all'

        if _current_filter == [c.pull_request_type]:

            c.current_filter = 'pull_request'

        elif _current_filter == c.comment_type:

            c.current_filter = 'comment'

        return render('admin/notifications/notifications.html')

    def mark_all_read(self):

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

            nm = NotificationModel()

            # mark all read

            nm.mark_all_read_for_user(self.authuser.user_id,

                                      filter_=request.GET.getall('type'))

            Session().commit()

            c.user = self.authuser

            notif = nm.query_for_user(self.authuser.user_id,

                                      filter_=request.GET.getall('type'))

        raise HTTPBadRequest()

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def index(self, repo_name, revision=None, f_path=None):

        # Fix URL after page size form submission via GET

        # TODO: Somehow just don't send this extra junk in the GET URL

        if request.GET.get('set'):

            request.GET.pop('set', None)

            if revision is None:

                raise HTTPFound(location=url('changelog_home', repo_name=repo_name, **request.GET))

            raise HTTPFound(location=url('changelog_file_home', repo_name=repo_name, revision=revision, f_path=f_path, **request.GET))

        limit = 2000

        default = 100

        if request.GET.get('size'):

            c.size = max(min(safe_int(request.GET.get('size')), limit), 1)

            session['changelog_size'] = c.size

            session.save()

        else:

            c.size = int(session.get('changelog_size', default))

        # min size must be 1

        c.size = max(c.size, 1)

        branch_name = request.GET.get('branch', None)

        if (branch_name and

            branch_name not in c.db_repo_scm_instance.branches and

            branch_name not in c.db_repo_scm_instance.closed_branches and

            not revision):

            raise HTTPFound(location=url('changelog_file_home', repo_name=c.repo_name,

                                    revision=branch_name, f_path=f_path or ''))

        if revision == 'tip':

            revision = None

        c.changelog_for_path = f_path

        try:

            if f_path:

                log.debug('generating changelog for path %s', f_path)

                # get the history for the file !

                tip_cs = c.db_repo_scm_instance.get_changeset()

                try:

                    collection = tip_cs.get_file_history(f_path)

                except (NodeDoesNotExistError, ChangesetError):

                    #this node is not present at tip !

                    try:

                        cs = self.__get_cs(revision, repo_name)

"""

import logging

from pylons import tmpl_context as c, request

from kallithea.lib.helpers import Page

from kallithea.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from kallithea.lib.base import BaseRepoController, render

from kallithea.model.db import UserFollowing

from kallithea.lib.utils2 import safe_int

log = logging.getLogger(__name__)

class FollowersController(BaseRepoController):

    def __before__(self):

        super(FollowersController, self).__before__()

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def followers(self, repo_name):

        repo_id = c.db_repo.repo_id

        d = UserFollowing.get_repo_followers(repo_id) \

            .order_by(UserFollowing.follows_from)

        c.followers_pager = Page(d, page=p, items_per_page=20)

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

            return render('/followers/followers_data.html')

        return render('/followers/followers.html')

        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)

        defaults = RepoModel()._get_defaults(repo_name)

        # alter the description to indicate a fork

        defaults['description'] = ('fork of repository: %s \n%s'

                                   % (defaults['repo_name'],

                                      defaults['description']))

        # add suffix to fork

        defaults['repo_name'] = '%s-fork' % defaults['repo_name']

        return defaults

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def forks(self, repo_name):

        repo_id = c.db_repo.repo_id

        d = []

        for r in Repository.get_repo_forks(repo_id):

            if not HasRepoPermissionAny(

                'repository.read', 'repository.write', 'repository.admin'

            )(r.repo_name, 'get forks check'):

                continue

            d.append(r)

        c.forks_pager = Page(d, page=p, items_per_page=20)

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

            return render('/forks/forks_data.html')

        return render('/forks/forks.html')

    @LoginRequired()

    @NotAnonymous()

    @HasPermissionAnyDecorator('hg.admin', 'hg.fork.repository')

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def fork(self, repo_name):

        c.repo_info = Repository.get_by_repo_name(repo_name)

        if not c.repo_info:

            h.not_mapped_error(repo_name)

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

    @LoginRequired()

    @NotAnonymous()

    def index(self):

        # Return a rendered template

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

        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)

        def url_generator(**kw):

            return url.current(filter=c.search_term, **kw)

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

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

        repos_list = Session().query(Repository) \

                     .filter(Repository.user_id ==

                             self.authuser.user_id) \

                     .order_by(func.lower(Repository.repo_name)).all()

        repos_data = RepoModel().get_repos_as_dict(repos_list=repos_list,

                                                   admin=True)

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

        repo_id = request.POST.get('follows_repo_id')

        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

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

                  (tags, _("Tags")),

                  ]

        return [g for g in groups if g[0]], selected

    def _get_is_allowed_change_status(self, pull_request):

        if pull_request.is_closed():

            return False

        owner = self.authuser.user_id == pull_request.user_id

        reviewer = PullRequestReviewers.query() \

            .filter(PullRequestReviewers.pull_request == pull_request) \

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

            .count() != 0

        return self.authuser.admin or owner or reviewer

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def show_all(self, repo_name):

        c.from_ = request.GET.get('from_') or ''

        c.closed = request.GET.get('closed') or ''

        c.pull_requests = PullRequestModel().get_all(repo_name, from_=c.from_, closed=c.closed)

        c.repo_name = repo_name

        c.pullrequests_pager = Page(c.pull_requests, page=p, items_per_page=100)

        return render('/pullrequests/pullrequest_show_all.html')

    @LoginRequired()

    @NotAnonymous()

    def show_my(self):

        c.closed = request.GET.get('closed') or ''

        def _filter(pr):

            s = sorted(pr, key=lambda o: o.created_on, reverse=True)

            if not c.closed:

                s = filter(lambda p: p.status != PullRequest.STATUS_CLOSED, s)

            return s

        c.my_pull_requests = _filter(PullRequest.query() \

                                .filter(PullRequest.user_id ==

                                        self.authuser.user_id) \

                                .all())

        c.participate_in_pull_requests = []

        c.participate_in_pull_requests_todo = []

        done_status = set([ChangesetStatus.STATUS_APPROVED, ChangesetStatus.STATUS_REJECTED])

                                      'path': 'path',

                                      'repository': 'repository'

                                      }.get(c.cur_type, 'content')

        index_name = {

            'content': IDX_NAME,

            'commit': CHGSET_IDX_NAME,

            'path': IDX_NAME

        }.get(c.cur_type, IDX_NAME)

        schema_defn = {

            'content': SCHEMA,

            'commit': CHGSETS_SCHEMA,

            'path': SCHEMA

        }.get(c.cur_type, SCHEMA)

        log.debug('IDX: %s', index_name)

        log.debug('SCHEMA: %s', schema_defn)

        if c.cur_query:

            cur_query = c.cur_query.lower()

            log.debug(cur_query)

        if c.cur_query:

            highlight_items = set()

            try:

                idx = open_dir(config['app_conf']['index_dir'],

                               indexname=index_name)

                searcher = idx.searcher()

                qp = QueryParser(search_type, schema=schema_defn)

                if c.repo_name:

                    cur_query = u'repository:%s %s' % (c.repo_name, cur_query)

                try:

                    query = qp.parse(unicode(cur_query))

                    # extract words for highlight

                    if isinstance(query, Phrase):

                        highlight_items.update(query.words)

                    elif isinstance(query, Prefix):

                        highlight_items.add(query.text)

                    else:

                        for i in query.all_terms():

                            if i[0] in ['content', 'message']:

                                highlight_items.add(i[1])

                    matcher = query.matcher(searcher)

                    log.debug('query: %s', query)