import kallithea.lib.helpers as h

from kallithea.lib.helpers import Page

from kallithea.lib.auth import LoginRequired, NotAnonymous

from kallithea.lib.base import BaseController, render

from kallithea.lib.utils2 import safe_int, AttributeDict

from kallithea.lib.compat import json

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

                l = list(g2)

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

            groups.append((k, user_group,))

        return groups

    def _get_journal_data(self, following_repos):

        repo_ids = [x.follows_repository.repo_id for x in following_repos

                    if x.follows_repository is not None]

        user_ids = [x.follows_user.user_id for x in following_repos

                    if x.follows_user 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)\

import traceback

import logging

from os.path import join as jn

from time import mktime

from operator import itemgetter

from string import lower

from pylons import config

from kallithea import CELERY_ON

from kallithea.lib.celerylib import run_task, locked_task, dbsession, \

    str2bool, __get_lockkey, LockHeld, DaemonLock, get_session

from kallithea.lib.helpers import person

from kallithea.lib.rcmail.smtp_mailer import SmtpMailer

from kallithea.lib.utils import add_cache, action_logger

from kallithea.lib.compat import json, OrderedDict

from kallithea.lib.hooks import log_create_repository

from kallithea.model.db import Statistics, Repository, User

add_cache(config)  # pragma: no cover

def get_logger(cls):

    if CELERY_ON:

        try:

            log = cls.get_logger()

        except Exception:

            log = logging.getLogger(__name__)

    else:

        log = logging.getLogger(__name__)

    return log

@task(ignore_result=True)

@locked_task

@dbsession

def whoosh_index(repo_location, full_index):

    from kallithea.lib.indexers.daemon import WhooshIndexingDaemon

    DBS = get_session()

    index_location = config['index_dir']

    WhooshIndexingDaemon(index_location=index_location,

                         repo_location=repo_location, sa=DBS)\

    def keys(self):

        """

        In a series of upgrades x -> y, keys are version x. Sorted.

        """

        ret = super(Changeset, self).keys()

        # Reverse order if downgrading

        ret.sort(reverse=(self.step < 1))

        return ret

    def values(self):

        return [self[k] for k in self.keys()]

    def items(self):

        return zip(self.keys(), self.values())

    def add(self, change):

        """Add new change to changeset"""

        key = self.end

        self.end += self.step

        self[key] = change

    def run(self, *p, **k):

        """Run the changeset scripts"""

            script.run(*p, **k)

class Repository(pathed.Pathed):

    """A project's change script repository"""

    _config = 'migrate.cfg'

    _versions = 'versions'

    def __init__(self, path):

        log.debug('Loading repository %s...' % path)

        self.verify(path)

        super(Repository, self).__init__(path)

        self.config = cfgparse.Config(os.path.join(self.path, self._config))

        self.versions = version.Collection(os.path.join(self.path,

                                                      self._versions))

        log.debug('Repository %s loaded successfully' % path)

        log.debug('Config: %r' % self.config.to_dict())

    @classmethod

    def verify(cls, path):

        """

        Ensure the target path is a valid repository.

            if s == 0.0:

                return v, v, v

            i = int(h * 6.0)  # XXX assume int() truncates!

            f = (h * 6.0) - i

            p = v * (1.0 - s)

            q = v * (1.0 - s * f)

            t = v * (1.0 - s * (1.0 - f))

            i = i % 6

            if i == 0:

                return v, t, p

            if i == 1:

                return q, v, p

            if i == 2:

                return p, v, t

            if i == 3:

                return p, q, v

            if i == 4:

                return t, p, v

            if i == 5:

                return v, p, q

        golden_ratio = 0.618033988749895

        h = 0.22717784590367374

            h += golden_ratio

            h %= 1

            HSV_tuple = [h, 0.95, 0.95]

            RGB_tuple = hsv_to_rgb(*HSV_tuple)

            yield map(lambda x: str(int(x * 256)), RGB_tuple)

    cgenerator = gen_color()

    def get_color_string(cs):

        if cs in color_dict:

            col = color_dict[cs]

        else:

            col = color_dict[cs] = cgenerator.next()

        return "color: rgb(%s)! important;" % (', '.join(col))

    def url_func(repo_name):

        def _url_func(changeset):

            author = changeset.author

            date = changeset.date

            message = tooltip(changeset.message)

            tooltip_html = ("<div style='font-size:0.8em'><b>Author:</b>"

                            " %s<br/><b>Date:</b> %s</b><br/><b>Message:"

            [lnk(rev, repo_name) for rev in revs[:revs_limit]]

        )]

        _op1, _name1 = _get_op(revs_ids[0])

        _op2, _name2 = _get_op(revs_ids[-1])

        _rev = '%s...%s' % (_name1, _name2)

        compare_view = (

            ' <div class="compare_view tooltip" title="%s">'

            '<a href="%s">%s</a> </div>' % (

                _('Show all combined changesets %s->%s') % (

                    revs_ids[0][:12], revs_ids[-1][:12]

                ),

                url('changeset_home', repo_name=repo_name,

                    revision=_rev

                ),

                _('compare view')

            )

        )

        # if we have exactly one more than normally displayed

        # just display it, takes less space than displaying

        # "and 1 more revisions"

        if len(revs_ids) == revs_limit + 1:

        # hidden-by-default ones

        if len(revs_ids) > revs_limit + 1:

            uniq_id = revs_ids[0]

            html_tmpl = (

                '<span> %s <a class="show_more" id="_%s" '

                'href="#more">%s</a> %s</span>'

            )

            if not feed:

                cs_links.append(html_tmpl % (

                      _('and'),

                      uniq_id, _('%s more') % (len(revs_ids) - revs_limit),

                      _('revisions')

                    )

                )

            if not feed:

                html_tmpl = '<span id="%s" style="display:none">, %s </span>'

            else:

                html_tmpl = '<span id="%s"> %s </span>'

            morelinks = ', '.join(

              [lnk(rev, repo_name) for rev in revs[revs_limit:]]

            )

            if x and 'issue_server_link%s' % x.group(1) in conf

            and 'issue_prefix%s' % x.group(1) in conf

        ]

        log.debug('found issue server suffixes `%s` during valuation of: %s'

                  % (','.join(valid_indices), newtext))

        for pattern_index in valid_indices:

            ISSUE_PATTERN = conf.get('issue_pat%s' % pattern_index)

            ISSUE_SERVER_LNK = conf.get('issue_server_link%s' % pattern_index)

            ISSUE_PREFIX = conf.get('issue_prefix%s' % pattern_index)

            log.debug('pattern suffix `%s` PAT:%s SERVER_LINK:%s PREFIX:%s'

                      % (pattern_index, ISSUE_PATTERN, ISSUE_SERVER_LNK,

                         ISSUE_PREFIX))

            URL_PAT = re.compile(r'%s' % ISSUE_PATTERN)

            def url_func(match_obj):

                pref = ''

                if match_obj.group().startswith(' '):

                    pref = ' '

                issue_id = ''.join(match_obj.groups())

                '%(pref)s<a class="%(cls)s" href="%(url)s">'

                '%(issue-prefix)s%(id-repr)s'

                '</a>'

                     'pref': pref,

                     'cls': 'issue-tracker-link',

                     'id-repr': issue_id,

                     'issue-prefix': ISSUE_PREFIX,

                     'serv': ISSUE_SERVER_LNK,

                }

            newtext = URL_PAT.sub(url_func, newtext)

            log.debug('processed prefix:`%s` => %s' % (pattern_index, newtext))

        # if we actually did something above

        if link_:

            # wrap not links into final link => link_

            newtext = linkify_others(newtext, link_)

    except Exception:

        log.error(traceback.format_exc())

        pass

    return literal(newtext)

def rst(source):

    return literal('<div class="rst-block">%s</div>' %

                   MarkupRenderer.rst(source))

def rst_w_mentions(source):

#

# 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.lib.paster_commands.make_index

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

make-index paster command for Kallithea

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: Aug 17, 2010

:author: marcink

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

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

"""

from __future__ import with_statement

import os

import sys

import logging

from string import strip

from kallithea.model.repo import RepoModel

from kallithea.lib.utils import BasePasterCommand, load_rcextensions

# Add location of top level folder to sys.path

from os.path import dirname as dn

rc_path = dn(dn(dn(os.path.realpath(__file__))))

sys.path.append(rc_path)

class Command(BasePasterCommand):

    max_args = 1

    min_args = 1

    usage = "CONFIG_FILE"

    group_name = "Kallithea"

    takes_config_file = -1

    parser = BasePasterCommand.standard_parser(verbose=True)

    summary = "Creates or updates full text search index"

    def command(self):

        logging.config.fileConfig(self.path_to_ini_file)

        #get SqlAlchemy session