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

"""

    rhodecode.lib.celerylib.tasks

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

    RhodeCode task modules, containing all task that suppose to be run

    by celery daemon

    :created_on: Oct 6, 2010

    :author: marcink

    :copyright: (C) 2009-2011 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; version 2

# of the License or (at your opinion) any later version of the license.

# 

# 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, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

# MA  02110-1301, USA.

from celery.decorators import task

import os

import traceback

import logging

from time import mktime

from operator import itemgetter

from pylons import config

from pylons.i18n.translation import _

from rhodecode.lib.celerylib import run_task, locked_task, str2bool

from rhodecode.lib.helpers import person

from rhodecode.lib.smtp_mailer import SmtpMailer

from rhodecode.lib.utils import OrderedDict, add_cache

from rhodecode.model import init_model

from rhodecode.model import meta

from rhodecode.model.db import RhodeCodeUi

from vcs.backends import get_repo

from sqlalchemy import engine_from_config

add_cache(config)

try:

    import json

except ImportError:

    #python 2.5 compatibility

    import simplejson as json

__all__ = ['whoosh_index', 'get_commits_stats',

           'reset_user_password', 'send_email']

CELERY_ON = str2bool(config['app_conf'].get('use_celery'))

def get_session():

    if CELERY_ON:

        engine = engine_from_config(config, 'sqlalchemy.db1.')

        init_model(engine)

    sa = meta.Session()

    return sa

def get_repos_path():

    sa = get_session()

    q = sa.query(RhodeCodeUi).filter(RhodeCodeUi.ui_key == '/').one()

    return q.ui_value

@task(ignore_result=True)

@locked_task

def whoosh_index(repo_location, full_index):

    #log = whoosh_index.get_logger()

    from rhodecode.lib.indexers.daemon import WhooshIndexingDaemon

    index_location = config['index_dir']

    WhooshIndexingDaemon(index_location=index_location,

                         repo_location=repo_location, sa=get_session())\

                         .run(full_index=full_index)

@task(ignore_result=True)

@locked_task

def get_commits_stats(repo_name, ts_min_y, ts_max_y):

    try:

        log = get_commits_stats.get_logger()

    except:

        log = logging.getLogger(__name__)

    from rhodecode.model.db import Statistics, Repository

    #for js data compatibilty

    author_key_cleaner = lambda k: person(k).replace('"', "")

    commits_by_day_author_aggregate = {}

    commits_by_day_aggregate = {}

    repos_path = get_repos_path()

    p = os.path.join(repos_path, repo_name)

    repo = get_repo(p)

    skip_date_limit = True

    parse_limit = int(config['app_conf'].get('commit_parse_limit'))

    last_rev = 0

    last_cs = None

    timegetter = itemgetter('time')

    sa = get_session()

    dbrepo = sa.query(Repository)\

        .filter(Repository.repo_name == repo_name).scalar()

    cur_stats = sa.query(Statistics)\

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

        last_rev = cur_stats.stat_on_revision

    if not repo.revisions:

        return True

        #pass silently without any work if we're not on first revision or 

        #current state of parsing revision(from db marker) is the last revision

        return True

    if cur_stats:

        commits_by_day_aggregate = OrderedDict(

                                       json.loads(

                                        cur_stats.commit_activity_combined))

        commits_by_day_author_aggregate = json.loads(cur_stats.commit_activity)

    log.debug('starting parsing %s', parse_limit)

    lmktime = mktime

    last_rev = last_rev + 1 if last_rev > 0 else last_rev

    for cs in repo[last_rev:last_rev + parse_limit]:

        last_cs = cs #remember last parsed changeset

        k = lmktime([cs.date.timetuple()[0], cs.date.timetuple()[1],

                      cs.date.timetuple()[2], 0, 0, 0, 0, 0, 0])

        if commits_by_day_author_aggregate.has_key(author_key_cleaner(cs.author)):

            try:

                l = [timegetter(x) for x in commits_by_day_author_aggregate\

                        [author_key_cleaner(cs.author)]['data']]

                time_pos = l.index(k)

            except ValueError:

                time_pos = False

            if time_pos >= 0 and time_pos is not False:

                datadict = commits_by_day_author_aggregate\

                    [author_key_cleaner(cs.author)]['data'][time_pos]

                datadict["commits"] += 1

                datadict["added"] += len(cs.added)

                datadict["changed"] += len(cs.changed)

                datadict["removed"] += len(cs.removed)

            else:

                if k >= ts_min_y and k <= ts_max_y or skip_date_limit:

                    datadict = {"time":k,

                                "commits":1,

                                "added":len(cs.added),

                                "changed":len(cs.changed),

                                "removed":len(cs.removed),

                               }

                    commits_by_day_author_aggregate\

                        [author_key_cleaner(cs.author)]['data'].append(datadict)

        else:

            if k >= ts_min_y and k <= ts_max_y or skip_date_limit:

                commits_by_day_author_aggregate[author_key_cleaner(cs.author)] = {

                                    "label":author_key_cleaner(cs.author),

                                    "data":[{"time":k,

                                             "commits":1,

                                             "added":len(cs.added),

                                             "changed":len(cs.changed),

                                             "removed":len(cs.removed),

                                             }],

                                    "schema":["commits"],

                                    }

        #gather all data by day

        if commits_by_day_aggregate.has_key(k):

            commits_by_day_aggregate[k] += 1

        else:

            commits_by_day_aggregate[k] = 1

    overview_data = sorted(commits_by_day_aggregate.items(), key=itemgetter(0))

    if not commits_by_day_author_aggregate:

        commits_by_day_author_aggregate[author_key_cleaner(repo.contact)] = {

            "label":author_key_cleaner(repo.contact),

            "data":[0, 1],

            "schema":["commits"],

        }

    stats = cur_stats if cur_stats else Statistics()

    stats.commit_activity = json.dumps(commits_by_day_author_aggregate)

    stats.commit_activity_combined = json.dumps(overview_data)

    log.debug('last revison %s', last_rev)

    leftovers = len(repo.revisions[last_rev:])

    log.debug('revisions to parse %s', leftovers)

    if last_rev == 0 or leftovers < parse_limit:

        log.debug('getting code trending stats')

        stats.languages = json.dumps(__get_codes_stats(repo_name))

    try:

        stats.repository = dbrepo

        stats.stat_on_revision = last_cs.revision if last_cs else 0

        sa.add(stats)

        sa.commit()

    except:

        log.error(traceback.format_exc())

        sa.rollback()

        return False

    if len(repo.revisions) > 1:

        run_task(get_commits_stats, repo_name, ts_min_y, ts_max_y)

    return True

@task(ignore_result=True)

def reset_user_password(user_email):

    try:

        log = reset_user_password.get_logger()

    except:

        log = logging.getLogger(__name__)

    from rhodecode.lib import auth

    from rhodecode.model.db import User

    try:

        try:

            sa = get_session()

            user = sa.query(User).filter(User.email == user_email).scalar()

            new_passwd = auth.PasswordGenerator().gen_password(8,

                             auth.PasswordGenerator.ALPHABETS_BIG_SMALL)

            if user:

                user.password = auth.get_crypt_password(new_passwd)

                sa.add(user)

                sa.commit()

                log.info('change password for %s', user_email)

            if new_passwd is None:

                raise Exception('unable to generate new password')

        except:

            log.error(traceback.format_exc())

            sa.rollback()

        run_task(send_email, user_email,

                 "Your new rhodecode password",

                 'Your new rhodecode password:%s' % (new_passwd))

        log.info('send new password mail to %s', user_email)

    except:

        log.error('Failed to update user password')

        log.error(traceback.format_exc())

    return True

@task(ignore_result=True)

def send_email(recipients, subject, body):

    """

    Sends an email with defined parameters from the .ini files.

    :param recipients: list of recipients, it this is empty the defined email

        address from field 'email_to' is used instead

    :param subject: subject of the mail

    :param body: body of the mail

    """

    try:

        log = send_email.get_logger()

    except:

        log = logging.getLogger(__name__)

    email_config = config

    if not recipients:

        recipients = [email_config.get('email_to')]

    mail_from = email_config.get('app_email_from')

    user = email_config.get('smtp_username')

    passwd = email_config.get('smtp_password')

    mail_server = email_config.get('smtp_server')

    mail_port = email_config.get('smtp_port')

    tls = str2bool(email_config.get('smtp_use_tls'))

    ssl = str2bool(email_config.get('smtp_use_ssl'))

    try:

        m = SmtpMailer(mail_from, user, passwd, mail_server,

                       mail_port, ssl, tls)

        m.send(recipients, subject, body)

    except:

        log.error('Mail sending failed')

        log.error(traceback.format_exc())

        return False

    return True

@task(ignore_result=True)

def create_repo_fork(form_data, cur_user):

    try:

        log = create_repo_fork.get_logger()

    except:

        log = logging.getLogger(__name__)

    from rhodecode.model.repo import RepoModel

    from vcs import get_backend

    repo_model = RepoModel(get_session())

    repo_model.create(form_data, cur_user, just_db=True, fork=True)

    repo_name = form_data['repo_name']

    repos_path = get_repos_path()

    repo_path = os.path.join(repos_path, repo_name)

    repo_fork_path = os.path.join(repos_path, form_data['fork_name'])

    alias = form_data['repo_type']

    log.info('creating repo fork %s as %s', repo_name, repo_path)

    backend = get_backend(alias)

    backend(str(repo_fork_path), create=True, src_url=str(repo_path))

def __get_codes_stats(repo_name):

    LANGUAGES_EXTENSIONS_MAP = {'scm': 'Scheme', 'asmx': 'VbNetAspx', 'Rout':

    'RConsole', 'rest': 'Rst', 'abap': 'ABAP', 'go': 'Go', 'phtml': 'HtmlPhp',

    'ns2': 'Newspeak', 'xml': 'EvoqueXml', 'sh-session': 'BashSession', 'ads':

    'Ada', 'clj': 'Clojure', 'll': 'Llvm', 'ebuild': 'Bash', 'adb': 'Ada',

    'ada': 'Ada', 'c++-objdump': 'CppObjdump', 'aspx':

    'VbNetAspx', 'ksh': 'Bash', 'coffee': 'CoffeeScript', 'vert': 'GLShader',

    'Makefile.*': 'Makefile', 'di': 'D', 'dpatch': 'DarcsPatch', 'rake':

    'Ruby', 'moo': 'MOOCode', 'erl-sh': 'ErlangShell', 'geo': 'GLShader',

    'pov': 'Povray', 'bas': 'VbNet', 'bat': 'Batch', 'd': 'D', 'lisp':

    'CommonLisp', 'h': 'C', 'rbx': 'Ruby', 'tcl': 'Tcl', 'c++': 'Cpp', 'md':

    'MiniD', '.vimrc': 'Vim', 'xsd': 'Xml', 'ml': 'Ocaml', 'el': 'CommonLisp',

    'befunge': 'Befunge', 'xsl': 'Xslt', 'pyx': 'Cython', 'cfm':

    'ColdfusionHtml', 'evoque': 'Evoque', 'cfg': 'Ini', 'htm': 'Html',

    'Makefile': 'Makefile', 'cfc': 'ColdfusionHtml', 'tex': 'Tex', 'cs':

    'CSharp', 'mxml': 'Mxml', 'patch': 'Diff', 'apache.conf': 'ApacheConf',

    'scala': 'Scala', 'applescript': 'AppleScript', 'GNUmakefile': 'Makefile',

    'c-objdump': 'CObjdump', 'lua': 'Lua', 'apache2.conf': 'ApacheConf', 'rb':

    'Ruby', 'gemspec': 'Ruby', 'rl': 'RagelObjectiveC', 'vala': 'Vala', 'tmpl':

    'Cheetah', 'bf': 'Brainfuck', 'plt': 'Gnuplot', 'G': 'AntlrRuby', 'xslt':

    'Xslt', 'flxh': 'Felix', 'asax': 'VbNetAspx', 'Rakefile': 'Ruby', 'S': 'S',

    'wsdl': 'Xml', 'js': 'Javascript', 'autodelegate': 'Myghty', 'properties':

    'Ini', 'bash': 'Bash', 'c': 'C', 'g': 'AntlrRuby', 'r3': 'Rebol', 's':

    'Gas', 'ashx': 'VbNetAspx', 'cxx': 'Cpp', 'boo': 'Boo', 'prolog': 'Prolog',

    'sqlite3-console': 'SqliteConsole', 'cl': 'CommonLisp', 'cc': 'Cpp', 'pot':

    'Gettext', 'vim': 'Vim', 'pxi': 'Cython', 'yaml': 'Yaml', 'SConstruct':

    'Python', 'diff': 'Diff', 'txt': 'Text', 'cw': 'Redcode', 'pxd': 'Cython',

    'plot': 'Gnuplot', 'java': 'Java', 'hrl': 'Erlang', 'py': 'Python',

    'makefile': 'Makefile', 'squid.conf': 'SquidConf', 'asm': 'Nasm', 'toc':

    'Tex', 'kid': 'Genshi', 'rhtml': 'Rhtml', 'po': 'Gettext', 'pl': 'Prolog',

    'pm': 'Perl', 'hx': 'Haxe', 'ascx': 'VbNetAspx', 'ooc': 'Ooc', 'asy':

    'Asymptote', 'hs': 'Haskell', 'SConscript': 'Python', 'pytb':

    'PythonTraceback', 'myt': 'Myghty', 'hh': 'Cpp', 'R': 'S', 'aux': 'Tex',

    'rst': 'Rst', 'cpp-objdump': 'CppObjdump', 'lgt': 'Logtalk', 'rss': 'Xml',

    'flx': 'Felix', 'b': 'Brainfuck', 'f': 'Fortran', 'rbw': 'Ruby',

    '.htaccess': 'ApacheConf', 'cxx-objdump': 'CppObjdump', 'j': 'ObjectiveJ',

    'mll': 'Ocaml', 'yml': 'Yaml', 'mu': 'MuPAD', 'r': 'Rebol', 'ASM': 'Nasm',

    'erl': 'Erlang', 'mly': 'Ocaml', 'mo': 'Modelica', 'def': 'Modula2', 'ini':

    'Ini', 'control': 'DebianControl', 'vb': 'VbNet', 'vapi': 'Vala', 'pro':

    'Prolog', 'spt': 'Cheetah', 'mli': 'Ocaml', 'as': 'ActionScript3', 'cmd':

    'Batch', 'cpp': 'Cpp', 'io': 'Io', 'tac': 'Python', 'haml': 'Haml', 'rkt':

    'Racket', 'st':'Smalltalk', 'inc': 'Povray', 'pas': 'Delphi', 'cmake':

    'CMake', 'csh':'Tcsh', 'hpp': 'Cpp', 'feature': 'Gherkin', 'html': 'Html',

    'php':'Php', 'php3':'Php', 'php4':'Php', 'php5':'Php', 'xhtml': 'Html',

    'hxx': 'Cpp', 'eclass': 'Bash', 'css': 'Css',

    'frag': 'GLShader', 'd-objdump': 'DObjdump', 'weechatlog': 'IrcLogs',

    'tcsh': 'Tcsh', 'objdump': 'Objdump', 'pyw': 'Python', 'h++': 'Cpp',

    'py3tb': 'Python3Traceback', 'jsp': 'Jsp', 'sql': 'Sql', 'mak': 'Makefile',

    'php': 'Php', 'mao': 'Mako', 'man': 'Groff', 'dylan': 'Dylan', 'sass':

    'Sass', 'cfml': 'ColdfusionHtml', 'darcspatch': 'DarcsPatch', 'tpl':

    'Smarty', 'm': 'ObjectiveC', 'f90': 'Fortran', 'mod': 'Modula2', 'sh':

    'Bash', 'lhs': 'LiterateHaskell', 'sources.list': 'SourcesList', 'axd':

    'VbNetAspx', 'sc': 'Python'}

    repos_path = get_repos_path()

    p = os.path.join(repos_path, repo_name)

    repo = get_repo(p)

    tip = repo.get_changeset()

    code_stats = {}

    def aggregate(cs):

        for f in cs[2]:

            ext = f.extension

            key = LANGUAGES_EXTENSIONS_MAP.get(ext, ext)

            key = key or ext

            if ext in LANGUAGES_EXTENSIONS_MAP.keys() and not f.is_binary:

                if code_stats.has_key(key):

                    code_stats[key] += 1

                else:

                    code_stats[key] = 1

    map(aggregate, tip.walk('/'))

    return code_stats or {}

        return literal('/'.join(url_l))

files_breadcrumbs = _FilesBreadCrumbs()

class CodeHtmlFormatter(HtmlFormatter):

    """My code Html Formatter for source codes

    """

    def wrap(self, source, outfile):

        return self._wrap_div(self._wrap_pre(self._wrap_code(source)))

    def _wrap_code(self, source):

        for cnt, it in enumerate(source):

            i, t = it

            t = '<div id="L%s">%s</div>' % (cnt + 1, t)

            yield i, t

    def _wrap_tablelinenos(self, inner):

        dummyoutfile = StringIO.StringIO()

        lncount = 0

        for t, line in inner:

            if t:

                lncount += 1

            dummyoutfile.write(line)

        fl = self.linenostart

        mw = len(str(lncount + fl - 1))

        sp = self.linenospecial

        st = self.linenostep

        la = self.lineanchors

        aln = self.anchorlinenos

        nocls = self.noclasses

        if sp:

            lines = []

            for i in range(fl, fl + lncount):

                if i % st == 0:

                    if i % sp == 0:

                        if aln:

                            lines.append('<a href="#%s%d" class="special">%*d</a>' %

                                         (la, i, mw, i))

                        else:

                            lines.append('<span class="special">%*d</span>' % (mw, i))

                    else:

                        if aln:

                            lines.append('<a href="#%s%d">%*d</a>' % (la, i, mw, i))

                        else:

                            lines.append('%*d' % (mw, i))

                else:

                    lines.append('')

            ls = '\n'.join(lines)

        else:

            lines = []

            for i in range(fl, fl + lncount):

                if i % st == 0:

                    if aln:

                        lines.append('<a href="#%s%d">%*d</a>' % (la, i, mw, i))

                    else:

                        lines.append('%*d' % (mw, i))

                else:

                    lines.append('')

            ls = '\n'.join(lines)

        # in case you wonder about the seemingly redundant <div> here: since the

        # content in the other cell also is wrapped in a div, some browsers in

        # some configurations seem to mess up the formatting...

        if nocls:

            yield 0, ('<table class="%stable">' % self.cssclass +

                      '<tr><td><div class="linenodiv" '

                      'style="background-color: #f0f0f0; padding-right: 10px">'

                      '<pre style="line-height: 125%">' +

                      ls + '</pre></div></td><td class="code">')

        else:

            yield 0, ('<table class="%stable">' % self.cssclass +

                      '<tr><td class="linenos"><div class="linenodiv"><pre>' +

                      ls + '</pre></div></td><td class="code">')

        yield 0, dummyoutfile.getvalue()

        yield 0, '</td></tr></table>'

def pygmentize(filenode, **kwargs):

    """pygmentize function using pygments

    :param filenode:

    """

    return literal(code_highlight(filenode.content,

                                  filenode.lexer, CodeHtmlFormatter(**kwargs)))

def pygmentize_annotation(filenode, **kwargs):

    """pygmentize function for annotation

    :param filenode:

    """

    color_dict = {}

    def gen_color(n=10000):

        """generator for getting n of evenly distributed colors using 

        hsv color and golden ratio. It always return same order of colors

        :returns: RGB tuple

        """

        import colorsys

        golden_ratio = 0.618033988749895

        h = 0.22717784590367374

        for c in xrange(n):

            h += golden_ratio

            h %= 1

            HSV_tuple = [h, 0.95, 0.95]

            RGB_tuple = colorsys.hsv_to_rgb(*HSV_tuple)

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

    cgenerator = gen_color()

    def get_color_string(cs):

        if color_dict.has_key(cs):

            col = color_dict[cs]

        else:

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

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

    def url_func(changeset):

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

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

        tooltip_html = tooltip_html % (changeset.author,

                                               changeset.date,

                                               tooltip(changeset.message))

        lnk_format = '%5s:%s' % ('r%s' % changeset.revision,

                                 short_id(changeset.raw_id))

        uri = link_to(

                lnk_format,

                url('changeset_home', repo_name=changeset.repository.name,

                    revision=changeset.raw_id),

                style=get_color_string(changeset.raw_id),

                class_='tooltip',

                title=tooltip_html

              )

        uri += '\n'

        return uri

    return literal(annotate_highlight(filenode, url_func, **kwargs))

def get_changeset_safe(repo, rev):

    from vcs.backends.base import BaseRepository

    from vcs.exceptions import RepositoryError

    if not isinstance(repo, BaseRepository):

        raise Exception('You must pass an Repository '

                        'object as first argument got %s', type(repo))

    try:

        cs = repo.get_changeset(rev)

    except RepositoryError:

        from rhodecode.lib.utils import EmptyChangeset

        cs = EmptyChangeset()

    return cs

def is_following_repo(repo_name, user_id):

    from rhodecode.model.scm import ScmModel

    return ScmModel().is_following_repo(repo_name, user_id)

flash = _Flash()

#==============================================================================

# MERCURIAL FILTERS available via h.

#==============================================================================

from mercurial import util

from mercurial.templatefilters import person as _person

def _age(curdate):

    """turns a datetime into an age string."""

    if not curdate:

        return ''

    from datetime import timedelta, datetime

    agescales = [("year", 3600 * 24 * 365),

                 ("month", 3600 * 24 * 30),

                 ("day", 3600 * 24),

                 ("hour", 3600),

                 ("minute", 60),

                 ("second", 1), ]

    age = datetime.now() - curdate

    age_seconds = (age.days * agescales[2][1]) + age.seconds

    pos = 1

    for scale in agescales:

        if scale[1] <= age_seconds:

            if pos == 6:pos = 5

            return time_ago_in_words(curdate, agescales[pos][0]) + ' ' + _('ago')

        pos += 1

    return _('just now')

age = lambda  x:_age(x)

capitalize = lambda x: x.capitalize()

email = util.email

email_or_none = lambda x: util.email(x) if util.email(x) != x else None

person = lambda x: _person(x)

short_id = lambda x: x[:12]

def bool2icon(value):

    """Returns True/False values represented as small html image of true/false

    icons

    :param value: bool value

    """

    if value is True:

        return HTML.tag('img', src=url("/images/icons/accept.png"),

                        alt=_('True'))

    if value is False:

        return HTML.tag('img', src=url("/images/icons/cancel.png"),

                        alt=_('False'))

    return value

def action_parser(user_log, feed=False):

    """This helper will action_map the specified string action into translated

    fancy names with icons and links

    :param user_log: user log instance

    :param feed: use output for feeds (no html and fancy icons)

    """

    action = user_log.action

    action_params = ' '

    x = action.split(':')

    if len(x) > 1:

        action, action_params = x

    def get_cs_links():

        revs_limit = 5 #display this amount always

        revs_top_limit = 50 #show upto this amount of changesets hidden

        revs = action_params.split(',')

        repo_name = user_log.repository.repo_name

        from rhodecode.model.scm import ScmModel

        repo, dbrepo = ScmModel().get(repo_name, retval='repo',

                                      invalidation_list=[])

        message = lambda rev: get_changeset_safe(repo, rev).message

        cs_links = " " + ', '.join ([link_to(rev,

                url('changeset_home',

                repo_name=repo_name,

                revision=rev), title=tooltip(message(rev)),

                class_='tooltip') for rev in revs[:revs_limit] ])

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

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

                        '</div>' % (_('Show all combined changesets %s->%s' \

                                      % (revs[0], revs[-1])),

                                    url('changeset_home', repo_name=repo_name,

                                        revision='%s...%s' % (revs[0], revs[-1])

                                    ),

                                    _('compare view'))

                        )

        if len(revs) > revs_limit:

            uniq_id = revs[0]

            html_tmpl = ('<span> %s '

            '<a class="show_more" id="_%s" href="#more">%s</a> '

            '%s</span>')

            if not feed:

                cs_links += html_tmpl % (_('and'), uniq_id, _('%s more') \

                                        % (len(revs) - revs_limit),

                                        _('revisions'))

            if not feed:

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

            else:

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

            cs_links += html_tmpl % (uniq_id, ', '.join([link_to(rev,

                url('changeset_home',

                repo_name=repo_name, revision=rev),

                title=message(rev), class_='tooltip')

                for rev in revs[revs_limit:revs_top_limit]]))

        if len(revs) > 1:

            cs_links += compare_view

        return cs_links

    def get_fork_name():

        repo_name = action_params

        return _('fork name ') + str(link_to(action_params, url('summary_home',

                                          repo_name=repo_name,)))

    action_map = {'user_deleted_repo':(_('[deleted] repository'), None),

           'user_created_repo':(_('[created] repository'), None),

           'user_forked_repo':(_('[forked] repository'), get_fork_name),

           'user_updated_repo':(_('[updated] repository'), None),

           'admin_deleted_repo':(_('[delete] repository'), None),

           'admin_created_repo':(_('[created] repository'), None),

           'admin_forked_repo':(_('[forked] repository'), None),

           'admin_updated_repo':(_('[updated] repository'), None),

           'push':(_('[pushed] into'), get_cs_links),

           'pull':(_('[pulled] from'), None),

           'started_following_repo':(_('[started following] repository'), None),

           'stopped_following_repo':(_('[stopped following] repository'), None),

            }

    action_str = action_map.get(action, action)

    if feed:

        action = action_str[0].replace('[', '').replace(']', '')

    else:

        action = action_str[0].replace('[', '<span class="journal_highlight">')\

                   .replace(']', '</span>')

    action_params_func = lambda :""

    if action_str[1] is not None:

        action_params_func = action_str[1]

    return [literal(action), action_params_func]

def action_parser_icon(user_log):

    action = user_log.action

    action_params = None

    x = action.split(':')

    if len(x) > 1:

        action, action_params = x

    tmpl = """<img src="%s/%s" alt="%s"/>"""

    map = {'user_deleted_repo':'database_delete.png',

           'user_created_repo':'database_add.png',

           'user_forked_repo':'arrow_divide.png',

           'user_updated_repo':'database_edit.png',

           'admin_deleted_repo':'database_delete.png',

           'admin_created_repo':'database_add.png',

           'admin_forked_repo':'arrow_divide.png',

           'admin_updated_repo':'database_edit.png',

           'push':'script_add.png',

           'pull':'down_16.png',

           'started_following_repo':'heart_add.png',

           'stopped_following_repo':'heart_delete.png',

            }

    return literal(tmpl % ((url('/images/icons/')),

                           map.get(action, action), action))

#==============================================================================

# PERMS

#==============================================================================

from rhodecode.lib.auth import HasPermissionAny, HasPermissionAll, \

HasRepoPermissionAny, HasRepoPermissionAll

#==============================================================================

# GRAVATAR URL

#==============================================================================

def gravatar_url(email_address, size=30):

    ssl_enabled = 'https' == request.environ.get('wsgi.url_scheme')

    default = 'identicon'

    baseurl_nossl = "http://www.gravatar.com/avatar/"

    baseurl_ssl = "https://secure.gravatar.com/avatar/"

    baseurl = baseurl_ssl if ssl_enabled else baseurl_nossl

    if isinstance(email_address, unicode):

        #hashlib crashes on unicode items

        email_address = email_address.encode('utf8', 'replace')

    # construct the url

    gravatar_url = baseurl + hashlib.md5(email_address.lower()).hexdigest() + "?"

    gravatar_url += urllib.urlencode({'d':default, 's':str(size)})

    return gravatar_url

#==============================================================================

# REPO PAGER

#==============================================================================

class RepoPage(Page):

    def __init__(self, collection, page=1, items_per_page=20,

        """Create a "RepoPage" instance. special pager for paging

        repository

        """

        self._url_generator = url

        # Safe the kwargs class-wide so they can be used in the pager() method

        self.kwargs = kwargs

        # Save a reference to the collection

        self.original_collection = collection

        self.collection = collection

        # The self.page is the number of the current page.

        # The first page has the number 1!

        try:

            self.page = int(page) # make it int() if we get it as a string

        except (ValueError, TypeError):

            self.page = 1

        self.items_per_page = items_per_page

        # Unless the user tells us how many items the collections has

        # we calculate that ourselves.

        if item_count is not None:

            self.item_count = item_count

        else:

            self.item_count = len(self.collection)

        # Compute the number of the first and last available page

        if self.item_count > 0:

            self.first_page = 1

            self.page_count = ((self.item_count - 1) / self.items_per_page) + 1

            self.last_page = self.first_page + self.page_count - 1

            # Make sure that the requested page number is the range of valid pages

            if self.page > self.last_page:

                self.page = self.last_page

            elif self.page < self.first_page:

                self.page = self.first_page

            # Note: the number of items on this page can be less than

            #       items_per_page if the last page is not full

            self.first_item = max(0, (self.item_count) - (self.page * items_per_page))

            iterator = self.collection.get_changesets(start=self.first_item,

                                                      end=self.last_item,

            self.items = list(iterator)

            # Links to previous and next page

            if self.page > self.first_page:

                self.previous_page = self.page - 1

            else:

                self.previous_page = None

            if self.page < self.last_page:

                self.next_page = self.page + 1

            else:

                self.next_page = None

        # No items available

        else:

            self.first_page = None

            self.page_count = 0

            self.last_page = None

            self.first_item = None

            self.last_item = None

            self.previous_page = None

            self.next_page = None