# 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

log = logging.getLogger(__name__)

    """

    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)

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

            return getattr(col, 'endswith')(wc_term)

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

            #wildcard == ilike

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

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

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

            return field.startswith(val)

        return field == val

        if not isinstance(qry, query.And):

            qry = [qry]

        for term in qry:

            field = term.fieldname

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

    elif isinstance(qry, query.Or):

        filters = []

        for term in qry:

            field = term.fieldname

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

        try:

        except:

            # we want this to crash for now

            raise

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

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

        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)

from webob.exc import HTTPBadRequest

from pylons import request, tmpl_context as c, response, url

from pylons.i18n.translation import _

import rhodecode.lib.helpers as h

from rhodecode.lib.auth import LoginRequired, NotAnonymous

from rhodecode.lib.base import BaseController, render

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

from rhodecode.model.meta import Session

from sqlalchemy.sql.expression import func

from rhodecode.model.scm import ScmModel

from rhodecode.lib.utils2 import safe_int

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

    @LoginRequired()

    @NotAnonymous()

    def index(self):

        # Return a rendered template

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

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

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

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

            .options(joinedload(UserFollowing.follows_repository))\

            .all()

        journal = self._get_journal_data(c.following)

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

        c.journal_data = render('journal/journal_data.html')

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

            return c.journal_data

        return render('journal/journal.html')

    @LoginRequired()

    @NotAnonymous()

    def index_my_repos(self):

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

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

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

        else:

            journal = []

        return journal

    @LoginRequired()

    @NotAnonymous()

    def toggle_following(self):

        cur_token = request.POST.get('auth_token')

        token = h.get_token()

        if cur_token == token:

Consists of functions to typically be used within templates, but also

available to Controllers. This module is available to both as 'h'.

"""

import random

import hashlib

import StringIO

import urllib

import math

import logging

import re

import urlparse

from datetime import datetime

from pygments.formatters.html import HtmlFormatter

from pygments import highlight as code_highlight

from pylons import url, request, config

from pylons.i18n.translation import _, ungettext

from hashlib import md5

from webhelpers.html import literal, HTML, escape

from webhelpers.html.tools import *

from webhelpers.html.builder import make_tag

from webhelpers.html.tags import auto_discovery_link, checkbox, css_classes, \

def changeset_status(repo, revision):

    return ChangesetStatusModel().get_status(repo, revision)

def changeset_status_lbl(changeset_status):

    return dict(ChangesetStatus.STATUSES).get(changeset_status)

def get_permission_name(key):

    return dict(Permission.PERMS).get(key)

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

<%inherit file="/base/base.html"/>

<%def name="title()">

    ${_('Admin journal')} - ${c.rhodecode_name}

</%def>

<%def name="breadcrumbs_links()">

    <form id="filter_form">

    <input type='submit' value="${_('filter')}" class="ui-btn" style="padding:0px 2px 0px 2px;margin:0px"/>

    ${_('Admin journal')} - ${ungettext('%s entry', '%s entries', c.users_log.item_count) % (c.users_log.item_count)}

    </form>

    ${h.end_form()}

</%def>

<%def name="page_nav()">

	${self.menu('admin')}

</%def>

<%def name="main()">

<div class="box">

	<!-- box / title -->

	<div class="title">

	    ${self.breadcrumbs()}

	</div>

	<!-- end box / title -->

	<div class="table">

	    <div id="user_log">

	        ${c.log_data}

	    </div>

	</div>

</div>

<script>

	}

});

}

});

YUE.on('filter_form','submit',function(e){

	YUE.preventDefault(e)

	window.location = "${url.current(filter='__FILTER__')}".replace('__FILTER__',val);

});

</script>

</%def>

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

<%inherit file="/base/base.html"/>

<%def name="title()">

    ${_('Journal')} - ${c.rhodecode_name}

</%def>

<%def name="breadcrumbs()">

</%def>

<%def name="page_nav()">

	${self.menu('home')}

</%def>

<%def name="head_extra()">

<link href="${h.url('journal_atom', api_key=c.rhodecode_user.api_key)}" rel="alternate" title="${_('ATOM journal feed')}" type="application/atom+xml" />

<link href="${h.url('journal_rss', api_key=c.rhodecode_user.api_key)}" rel="alternate" title="${_('RSS journal feed')}" type="application/rss+xml" />

</%def>

<%def name="main()">

    <div class="box box-left">

	    <!-- box / title -->

	    <div class="title">

	    </div>

	    <div id="journal">${c.journal_data}</div>

    </div>

    <div class="box box-right">

        <!-- box / title -->

        <div class="title">

            <h5>

            <input class="q_filter_box" id="q_filter" size="15" type="text" name="filter" value="${_('quick filter...')}"/>

            <a id="show_watched" class="link-white" href="#watched">${_('Watched')}</a> / <a id="show_my" class="link-white" href="#my">${_('My repos')}</a>

            </h5>

             %if h.HasPermissionAny('hg.admin','hg.create.repository')():

             <ul class="links">

                %endfor

            </tbody>

            </table>

          %else:

              <div style="padding:5px 0px 10px 0px;">

              ${_('You are not following any users or repositories')}

              </div>

          %endif

        </div>

    </div>

    <script type="text/javascript">

    var show_my = function(e){

        YUD.setStyle('watched','display','none');

        YUD.setStyle('my','display','');

        var url = "${h.url('admin_settings_my_repos')}";

        ypjax(url, 'my', function(){

            tooltip_activate();

            quick_repo_menu();

            var nodes = YUQ('#my tr td a.repo_name');

            var func = function(node){

                return node.parentNode.parentNode.parentNode;

            }

    var tabs = {

        'watched': show_watched,

        'my': show_my,

    }

    var url = location.href.split('#');

    if (url[1]) {

        //We have a hash

        var tabHash = url[1];

        tabs[tabHash]();

    }

    YUE.on('refresh','click',function(e){

        	show_more_event();

        	tooltip_activate();

        	show_changeset_tooltip();

        	});

        YUE.preventDefault(e);

    });

    // main table sorting

    var myColumnDefs = [

        {key:"menu",label:"",sortable:false,className:"quick_repo_menu hidden"},

        {key:"name",label:"${_('Name')}",sortable:true,

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