:author: marcink

    :copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# 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/>.

import logging

from pylons import request, tmpl_context as c, url

from sqlalchemy.orm import joinedload

from webhelpers.paginate import Page

from whoosh.qparser.default import QueryParser

from whoosh import query

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.model.db import UserLog, User

from rhodecode.lib.utils2 import safe_int, remove_prefix, remove_suffix

from rhodecode.lib.indexers import JOURNAL_SCHEMA

from whoosh.qparser.dateparse import DateParserPlugin

log = logging.getLogger(__name__)

def _journal_filter(user_log, search_term):

    """

    Filters sqlalchemy user_log based on search_term with whoosh Query language

    http://packages.python.org/Whoosh/querylang.html

    :param user_log:

    :param search_term:

    """

    log.debug('Initial search term: %r' % search_term)

    qry = None

    if search_term:

        qp = QueryParser('repository', schema=JOURNAL_SCHEMA)

        qp.add_plugin(DateParserPlugin())

        qry = qp.parse(unicode(search_term))

        log.debug('Filtering using parsed query %r' % qry)

    def wildcard_handler(col, wc_term):

        if wc_term.startswith('*') and not wc_term.endswith('*'):

            #postfix == endswith

            wc_term = remove_prefix(wc_term, prefix='*')

        elif wc_term.startswith('*') and wc_term.endswith('*'):

            #wildcard == ilike

            wc_term = remove_prefix(wc_term, prefix='*')

            wc_term = remove_suffix(wc_term, suffix='*')

    def get_filterion(field, val, term):

        if field == 'repository':

            field = getattr(UserLog, 'repository_name')

        elif field == 'ip':

            field = getattr(UserLog, 'user_ip')

        elif field == 'date':

            field = getattr(UserLog, 'action_date')

        elif field == 'username':

            field = getattr(UserLog, 'username')

        else:

            field = getattr(UserLog, field)

        log.debug('filter field: %s val=>%s' % (field, val))

        #sql filtering

        if isinstance(term, query.Wildcard):

            return wildcard_handler(field, val)

        elif isinstance(term, query.Prefix):

        elif isinstance(term, query.DateRange):

            return and_(field >= val[0], field <= val[1])

    if isinstance(qry, (query.And, query.Term, query.Prefix, query.Wildcard,

                        query.DateRange)):

        if not isinstance(qry, query.And):

            qry = [qry]

        for term in qry:

            field = term.fieldname

            val = (term.text if not isinstance(term, query.DateRange)

                   else [term.startdate, term.enddate])

            user_log = user_log.filter(get_filterion(field, val, term))

    elif isinstance(qry, query.Or):

        filters = []

        for term in qry:

            field = term.fieldname

            val = (term.text if not isinstance(term, query.DateRange)

                   else [term.startdate, term.enddate])

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

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

    return user_log

class AdminController(BaseController):

import csv

import datetime

from rhodecode.tests import *

from rhodecode.model.db import UserLog

from rhodecode.model.meta import Session

from rhodecode.lib.utils2 import safe_unicode

dn = os.path.dirname

FIXTURES = os.path.join(dn(dn(os.path.abspath(__file__))), 'fixtures')

class TestAdminController(TestController):

    @classmethod

    def setup_class(cls):

        UserLog.query().delete()

        Session().commit()

        with open(os.path.join(FIXTURES, 'journal_dump.csv')) as f:

            for row in csv.DictReader(f):

                ul = UserLog()

                for k, v in row.iteritems():

                    v = safe_unicode(v)

                    if k == 'action_date':

                        v = datetime.datetime.strptime(v, '%Y-%m-%d %H:%M:%S.%f')

                    setattr(ul, k, v)

                Session().add(ul)

            Session().commit()

    @classmethod

    def teardown_class(cls):

        UserLog.query().delete()

        Session().commit()

    def test_index(self):

        self.log_user()

        response = self.app.get(url(controller='admin/admin', action='index'))

        response.mustcontain('Admin journal')

    def test_filter_all_entries(self):

        self.log_user()

        response = self.app.get(url(controller='admin/admin', action='index',))

        response.mustcontain('2034 entries')

    def test_filter_journal_filter_exact_match_on_repository(self):

        self.log_user()

        response = self.app.get(url(controller='admin/admin', action='index',

                                    filter='repository:rhodecode'))

        response.mustcontain('3 entries')

    def test_filter_journal_filter_wildcard_on_repository(self):

        self.log_user()

        response = self.app.get(url(controller='admin/admin', action='index',

                                    filter='repository:*test*'))

        response.mustcontain('862 entries')

    def test_filter_journal_filter_prefix_on_repository(self):

        self.log_user()

        response = self.app.get(url(controller='admin/admin', action='index',

                                    filter='repository:test*'))

        response.mustcontain('257 entries')

    def test_filter_journal_filter_prefix_on_repository_and_user(self):

        self.log_user()

        response = self.app.get(url(controller='admin/admin', action='index',

                                    filter='repository:test* AND username:demo'))

        response.mustcontain('130 entries')

    def test_filter_journal_filter_prefix_on_repository_or_other_repo(self):

        self.log_user()

        response = self.app.get(url(controller='admin/admin', action='index',

                                    filter='repository:test* OR repository:rhodecode'))

        response.mustcontain('260 entries')  # 257 + 3

    def test_filter_journal_filter_exact_match_on_username(self):

        self.log_user()

        response = self.app.get(url(controller='admin/admin', action='index',

                                    filter='username:demo'))

        response.mustcontain('1087 entries')

    def test_filter_journal_filter_wildcard_on_username(self):

        self.log_user()

        response = self.app.get(url(controller='admin/admin', action='index',

                                    filter='username:*test*'))

        response.mustcontain('100 entries')

    def test_filter_journal_filter_prefix_on_username(self):

        self.log_user()

        response = self.app.get(url(controller='admin/admin', action='index',

                                    filter='username:demo*'))

        response.mustcontain('1101 entries')

    def test_filter_journal_filter_prefix_on_user_or_other_user(self):

        self.log_user()

        response = self.app.get(url(controller='admin/admin', action='index',

                                    filter='username:demo OR username:volcan'))

        response.mustcontain('1095 entries')  # 1087 + 8

    def test_filter_journal_filter_wildcard_on_action(self):

        self.log_user()

        response = self.app.get(url(controller='admin/admin', action='index',

                                    filter='action:*pull_request*'))

        response.mustcontain('187 entries')