from kallithea.lib.page import Page

from kallithea.lib.utils2 import safe_int

from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError, ChangesetError, EmptyRepositoryError, NodeDoesNotExistError, RepositoryError

log = logging.getLogger(__name__)

class ChangelogController(BaseRepoController):

    def _before(self, *args, **kwargs):

        super(ChangelogController, self)._before(*args, **kwargs)

        c.affected_files_cut_off = 60

    @staticmethod

    def __get_cs(rev, repo):

        """

        Safe way to get changeset. If error occur fail with error message.

        :param rev: revision to fetch

        :param repo: repo instance

        """

        try:

            return c.db_repo_scm_instance.get_changeset(rev)

        except EmptyRepositoryError as e:

            h.flash(_('There are no changesets yet'), category='error')

        except RepositoryError as e:

            log.error(traceback.format_exc())

            h.flash(e, category='error')

        raise HTTPBadRequest()

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

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

        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)

        p = safe_int(request.GET.get('page'), 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)

                        collection = cs.get_file_history(f_path)

                    except RepositoryError as e:

                        h.flash(e, category='warning')

                        raise HTTPFound(location=h.url('changelog_home', repo_name=repo_name))

            else:

                collection = c.db_repo_scm_instance.get_changesets(start=0, end=revision,

                                                        branch_name=branch_name, reverse=True)

            c.total_cs = len(collection)

            c.cs_pagination = Page(collection, page=p, item_count=c.total_cs, items_per_page=c.size,

                                   branch=branch_name)

            page_revisions = [x.raw_id for x in c.cs_pagination]

            c.cs_comments = c.db_repo.get_comments(page_revisions)

            c.cs_statuses = c.db_repo.statuses(page_revisions)

        except EmptyRepositoryError as e:

            h.flash(e, category='warning')

            raise HTTPFound(location=url('summary_home', repo_name=c.repo_name))

        except (RepositoryError, ChangesetDoesNotExistError, Exception) as e:

            log.error(traceback.format_exc())

            h.flash(e, category='error')

            raise HTTPFound(location=url('changelog_home', repo_name=c.repo_name))

        c.branch_name = branch_name

        c.branch_filters = [('', _('None'))] + \

        if c.db_repo_scm_instance.closed_branches:

            prefix = _('(closed)') + ' '

            c.branch_filters += [('-', '-')] + \

        revs = []

        if not f_path:

            revs = [x.revision for x in c.cs_pagination]

        c.jsdata = graph_data(c.db_repo_scm_instance, revs)

        c.revision = revision # requested revision ref

        c.first_revision = c.cs_pagination[0] # pagination is never empty here!

        return render('changelog/changelog.html')

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def changelog_details(self, cs):

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

            c.cs = c.db_repo_scm_instance.get_changeset(cs)

            return render('changelog/changelog_details.html')

        raise HTTPNotFound()

            indexed += 1

            log.debug('    >> %s %s/%s', cs, indexed, total)

            writer.add_document(

                raw_id=unicode(cs.raw_id),

                owner=unicode(repo.contact),

                date=cs._timestamp,

                repository_rawname=safe_unicode(repo_name),

                repository=safe_unicode(repo_name),

                author=cs.author,

                message=cs.message,

                last=cs.last,

                added=u' '.join([safe_unicode(node.path) for node in cs.added]).lower(),

                removed=u' '.join([safe_unicode(node.path) for node in cs.removed]).lower(),

                changed=u' '.join([safe_unicode(node.path) for node in cs.changed]).lower(),

                parents=u' '.join([cs.raw_id for cs in cs.parents]),

            )

        return indexed

    def index_files(self, file_idx_writer, repo_name, repo):

        """

        Index files for given repo_name

        :param file_idx_writer: the whoosh index writer to add to

        :param repo_name: name of the repository we're indexing

        :param repo: instance of vcs repo

        """

        i_cnt = iwc_cnt = 0

        log.debug('Building file index for %s @revision:%s', repo_name,

                                                self._get_index_revision(repo))

        index_rev = self._get_index_revision(repo)

        for idx_path in self.get_paths(repo):

            i, iwc = self.add_doc(file_idx_writer, idx_path, repo, repo_name, index_rev)

            i_cnt += i

            iwc_cnt += iwc

        log.debug('added %s files %s with content for repo %s',

                  i_cnt + iwc_cnt, iwc_cnt, repo.path)

        return i_cnt, iwc_cnt

    def update_changeset_index(self):

        idx = open_dir(self.index_location, indexname=CHGSET_IDX_NAME)

        with idx.searcher() as searcher:

            writer = idx.writer()

            writer_is_dirty = False

            try:

                indexed_total = 0

                repo_name = None

                for repo_name, repo in sorted(self.repo_paths.items()):

                    log.debug('Updating changeset index for repo %s', repo_name)

                    # skip indexing if there aren't any revs in the repo

                    num_of_revs = len(repo)

                    if num_of_revs < 1:

                        continue

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

                    q = qp.parse(u"last:t AND %s" % repo_name)

                    results = searcher.search(q)

                    # default to scanning the entire repo

                    last_rev = 0

                    start_id = None

                    if len(results) > 0:

                        # assuming that there is only one result, if not this

                        # may require a full re-index.

                        start_id = results[0]['raw_id']

                        last_rev = repo.get_changeset(revision=start_id).revision

                    # there are new changesets to index or a new repo to index

                    if last_rev == 0 or num_of_revs > last_rev + 1:

                        # delete the docs in the index for the previous

                        # last changeset(s)

                        for hit in results:

                            q = qp.parse(u"last:t AND %s AND raw_id:%s" %

                                            (repo_name, hit['raw_id']))

                            writer.delete_by_query(q)

                        # index from the previous last changeset + all new ones

                        indexed_total += self.index_changesets(writer,

                                                repo_name, repo, start_id)

                        writer_is_dirty = True

                log.debug('indexed %s changesets for repo %s',

                          indexed_total, repo_name

                )

            finally:

                if writer_is_dirty:

                    log.debug('>> COMMITING CHANGES TO CHANGESET INDEX<<')

                    writer.commit(merge=True)

                    log.debug('>>> FINISHED REBUILDING CHANGESET INDEX <<<')

                else:

                    log.debug('>> NOTHING TO COMMIT TO CHANGESET INDEX<<')

    def update_file_index(self):

        idx = open_dir(self.index_location, indexname=self.indexname)

        # The set of all paths in the index

        indexed_paths = set()

        # The set of all paths we need to re-index

        to_index = set()

        writer = idx.writer()

        writer_is_dirty = False

        try:

            with idx.reader() as reader:

                # Loop over the stored fields in the index

                for fields in reader.all_stored_fields():

                    indexed_path = fields['path']

                    indexed_repo_path = fields['repository']

                    indexed_paths.add(indexed_path)

                    if indexed_repo_path not in self.filtered_repo_update_paths:

                        continue

                    repo = self.repo_paths[indexed_repo_path]

                    try:

                        node = self.get_node(repo, indexed_path)

                        # Check if this file was changed since it was indexed

                        indexed_time = fields['modtime']

                        mtime = self.get_node_mtime(node)

                        if mtime > indexed_time:

                            # The file has changed, delete it and add it to

                            # the list of files to reindex

                            log.debug(

                                'adding to reindex list %s mtime: %s vs %s',

                                    indexed_path, mtime, indexed_time

                            )

                            writer.delete_by_term('fileid', indexed_path)

                            writer_is_dirty = True

                            to_index.add(indexed_path)

                    except (ChangesetError, NodeDoesNotExistError):

                        # This file was deleted since it was indexed

                        log.debug('removing from index %s', indexed_path)

                        writer.delete_by_term('path', indexed_path)

                        writer_is_dirty = True

            # Loop over the files in the filesystem

            # Assume we have a function that gathers the filenames of the

            # documents to be indexed

            ri_cnt_total = 0  # indexed

            riwc_cnt_total = 0  # indexed with content

            for repo_name, repo in sorted(self.repo_paths.items()):

                log.debug('Updating file index for repo %s', repo_name)

                # skip indexing if there aren't any revisions

                if len(repo) < 1:

                    continue

                ri_cnt = 0   # indexed

                riwc_cnt = 0  # indexed with content

                for path in self.get_paths(repo):

                    path = safe_unicode(path)

                    if path in to_index or path not in indexed_paths:

                        # This is either a file that's changed, or a new file

                        # that wasn't indexed before. So index it!

                        i, iwc = self.add_doc(writer, path, repo, repo_name)

                        writer_is_dirty = True

                        ri_cnt += i

                        ri_cnt_total += 1

                        riwc_cnt += iwc

                        riwc_cnt_total += iwc

                log.debug('added %s files %s with content for repo %s',

                             ri_cnt + riwc_cnt, riwc_cnt, repo.path

                )

            log.debug('indexed %s files in total and %s with content',

                        ri_cnt_total, riwc_cnt_total

            )

        finally:

            if writer_is_dirty:

                log.debug('>> COMMITING CHANGES TO FILE INDEX <<')

                writer.commit(merge=True)

                log.debug('>>> FINISHED REBUILDING FILE INDEX <<<')

            else:

                log.debug('>> NOTHING TO COMMIT TO FILE INDEX <<')

                writer.cancel()

    def build_indexes(self):

        if os.path.exists(self.index_location):

            log.debug('removing previous index')

            rmtree(self.index_location)

        if not os.path.exists(self.index_location):

            os.mkdir(self.index_location)

        chgset_idx = create_in(self.index_location, CHGSETS_SCHEMA,

                               indexname=CHGSET_IDX_NAME)

        chgset_idx_writer = chgset_idx.writer()

        file_idx = create_in(self.index_location, SCHEMA, indexname=IDX_NAME)

        file_idx_writer = file_idx.writer()

        log.debug('BUILDING INDEX FOR EXTENSIONS %s '

        for repo_name, repo in sorted(self.repo_paths.items()):

            log.debug('Updating indices for repo %s', repo_name)

            # skip indexing if there aren't any revisions

            if len(repo) < 1:

                continue

            self.index_files(file_idx_writer, repo_name, repo)

            self.index_changesets(chgset_idx_writer, repo_name, repo)

        log.debug('>> COMMITING CHANGES <<')

        file_idx_writer.commit(merge=True)

        chgset_idx_writer.commit(merge=True)

        log.debug('>>> FINISHED BUILDING INDEX <<<')

    def update_indexes(self):

        self.update_file_index()

        self.update_changeset_index()

    def run(self, full_index=False):

        """Run daemon"""

        if full_index or self.initial:

            self.build_indexes()

        else:

            self.update_indexes()

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

"""

    vcs.backends

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

    Main package for scm backends

    :created_on: Apr 8, 2010

    :copyright: (c) 2010-2011 by Marcin Kuzminski, Lukasz Balcerzak.

"""

import os

from kallithea.lib.vcs.conf import settings

from kallithea.lib.vcs.exceptions import VCSError

from kallithea.lib.vcs.utils.helpers import get_scm

from kallithea.lib.vcs.utils.imports import import_class

from kallithea.lib.vcs.utils.paths import abspath

def get_repo(path=None, alias=None, create=False):

    """

    Returns ``Repository`` object of type linked with given ``alias`` at

    the specified ``path``. If ``alias`` is not given it will try to guess it

    using get_scm method

    """

    if create:

        if not (path or alias):

            raise TypeError("If create is specified, we need path and scm type")

        return get_backend(alias)(path, create=True)

    if path is None:

        path = abspath(os.path.curdir)

    try:

        scm, path = get_scm(path, search_up=True)

        path = abspath(path)

        alias = scm

    except VCSError:

        raise VCSError("No scm found at %s" % path)

    if alias is None:

        alias = get_scm(path)[0]

    backend = get_backend(alias)

    repo = backend(path, create=create)

    return repo

def get_backend(alias):

    """

    Returns ``Repository`` class identified by the given alias or raises

    VCSError if alias is not recognized or backend class cannot be imported.

    """

    if alias not in settings.BACKENDS:

        raise VCSError("Given alias '%s' is not recognized! Allowed aliases:\n"

    backend_path = settings.BACKENDS[alias]

    klass = import_class(backend_path)

    return klass

def get_supported_backends():

    """

    Returns list of aliases of supported backends.

    """

    return settings.BACKENDS.keys()

        'NOTICE':       { 'fg': 'red' },

        'SQL_FIELD':    { 'fg': 'green', 'opts': ('bold',) },

        'SQL_COLTYPE':  { 'fg': 'green' },

        'SQL_KEYWORD':  { 'fg': 'yellow' },

        'SQL_TABLE':    { 'opts': ('bold',) },

        'HTTP_INFO':         { 'opts': ('bold',) },

        'HTTP_SUCCESS':      { },

        'HTTP_REDIRECT':     { 'fg': 'green' },

        'HTTP_NOT_MODIFIED': { 'fg': 'cyan' },

        'HTTP_BAD_REQUEST':  { 'fg': 'red', 'opts': ('bold',) },

        'HTTP_NOT_FOUND':    { 'fg': 'yellow' },

        'HTTP_SERVER_ERROR': { 'fg': 'magenta', 'opts': ('bold',) },

    },

    LIGHT_PALETTE: {

        'ERROR':        { 'fg': 'red', 'opts': ('bold',) },

        'NOTICE':       { 'fg': 'red' },

        'SQL_FIELD':    { 'fg': 'green', 'opts': ('bold',) },

        'SQL_COLTYPE':  { 'fg': 'green' },

        'SQL_KEYWORD':  { 'fg': 'blue' },

        'SQL_TABLE':    { 'opts': ('bold',) },

        'HTTP_INFO':         { 'opts': ('bold',) },

        'HTTP_SUCCESS':      { },

        'HTTP_REDIRECT':     { 'fg': 'green', 'opts': ('bold',) },

        'HTTP_NOT_MODIFIED': { 'fg': 'green' },

        'HTTP_BAD_REQUEST':  { 'fg': 'red', 'opts': ('bold',) },

        'HTTP_NOT_FOUND':    { 'fg': 'red' },

        'HTTP_SERVER_ERROR': { 'fg': 'magenta', 'opts': ('bold',) },

    }

}

DEFAULT_PALETTE = DARK_PALETTE

def parse_color_setting(config_string):

    """Parse a DJANGO_COLORS environment variable to produce the system palette

    The general form of a palette definition is:

        "palette;role=fg;role=fg/bg;role=fg,option,option;role=fg/bg,option,option"

    where:

        palette is a named palette; one of 'light', 'dark', or 'nocolor'.

        role is a named style used by Django

        fg is a background color.

        bg is a background color.

        option is a display options.

    Specifying a named palette is the same as manually specifying the individual

    definitions for each role. Any individual definitions following the palette

    definition will augment the base palette definition.

    Valid roles:

        'error', 'notice', 'sql_field', 'sql_coltype', 'sql_keyword', 'sql_table',

        'http_info', 'http_success', 'http_redirect', 'http_bad_request',

        'http_not_found', 'http_server_error'

    Valid colors:

        'black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white'

    Valid options:

        'bold', 'underscore', 'blink', 'reverse', 'conceal'

    """

    if not config_string:

        return PALETTES[DEFAULT_PALETTE]

    # Split the color configuration into parts

    parts = config_string.lower().split(';')

    palette = PALETTES[NOCOLOR_PALETTE].copy()

    for part in parts:

        if part in PALETTES:

            # A default palette has been specified

            palette.update(PALETTES[part])

        elif '=' in part:

            # Process a palette defining string

            definition = {}

            # Break the definition into the role,

            # plus the list of specific instructions.

            # The role must be in upper case

            role, instructions = part.split('=')

            role = role.upper()

            styles = instructions.split(',')

            styles.reverse()

            # The first instruction can contain a slash

            # to break apart fg/bg.

            colors = styles.pop().split('/')

            colors.reverse()

            fg = colors.pop()

            if fg in color_names:

                definition['fg'] = fg

            if colors and colors[-1] in color_names:

                definition['bg'] = colors[-1]

            # All remaining instructions are options

            if opts:

                definition['opts'] = opts

            # The nocolor palette has all available roles.

            # Use that palette as the basis for determining

            # if the role is valid.

            if role in PALETTES[NOCOLOR_PALETTE] and definition:

                palette[role] = definition

    # If there are no colors specified, return the empty palette.

    if palette == PALETTES[NOCOLOR_PALETTE]:

        return None

    return palette

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

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

"""

kallithea.model.db

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

Database Models 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: Apr 08, 2010

:author: marcink

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

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

"""

import base64

import collections

import datetime

import functools

import hashlib

import logging

import os

import time

import traceback

import ipaddr

import sqlalchemy

from beaker.cache import cache_region, region_invalidate

from sqlalchemy import *

from sqlalchemy.ext.hybrid import hybrid_property

from sqlalchemy.orm import class_mapper, joinedload, relationship, validates

from tg.i18n import lazy_ugettext as _

from webob.exc import HTTPNotFound

import kallithea

from kallithea.lib.caching_query import FromCache

from kallithea.lib.compat import json

from kallithea.lib.exceptions import DefaultUserException

from kallithea.lib.utils2 import Optional, aslist, get_changeset_safe, get_clone_url, remove_prefix, safe_int, safe_str, safe_unicode, str2bool, urlreadable

from kallithea.lib.vcs import get_backend

from kallithea.lib.vcs.backends.base import EmptyChangeset

from kallithea.lib.vcs.utils.helpers import get_scm

from kallithea.lib.vcs.utils.lazy import LazyProperty

from kallithea.model.meta import Base, Session

URL_SEP = '/'

log = logging.getLogger(__name__)

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

# BASE CLASSES

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

_hash_key = lambda k: hashlib.md5(safe_str(k)).hexdigest()

class BaseDbModel(object):

    """

    Base Model for all classes

    """

    @classmethod

    def _get_keys(cls):

        """return column names for this model """

        return class_mapper(cls).c.keys()

    def get_dict(self):

        """

        return dict with keys and values corresponding

        to this model data """

        d = {}

        for k in self._get_keys():

            d[k] = getattr(self, k)

        # also use __json__() if present to get additional fields

        _json_attr = getattr(self, '__json__', None)

        if _json_attr:

            # update with attributes from __json__

            if callable(_json_attr):

                _json_attr = _json_attr()

            for k, val in _json_attr.iteritems():

                d[k] = val

        return d

    def get_appstruct(self):

        """return list with keys and values tuples corresponding

        to this model data """

        return [

            (k, getattr(self, k))

            for k in self._get_keys()

        ]

    def populate_obj(self, populate_dict):

        """populate model with data from given populate_dict"""

        for k in self._get_keys():

            if k in populate_dict:

                setattr(self, k, populate_dict[k])

    @classmethod

    def query(cls):

        return Session().query(cls)

    @classmethod

    def get(cls, id_):

        if id_:

            return cls.query().get(id_)

    @classmethod

    def guess_instance(cls, value, callback=None):

        """Haphazardly attempt to convert `value` to a `cls` instance.

        If `value` is None or already a `cls` instance, return it. If `value`

        is a number (or looks like one if you squint just right), assume it's

        a database primary key and let SQLAlchemy sort things out. Otherwise,

        fall back to resolving it using `callback` (if specified); this could

        e.g. be a function that looks up instances by name (though that won't

        work if the name begins with a digit). Otherwise, raise Exception.

        """

        if value is None:

            return None

        if isinstance(value, cls):

            return value

        if isinstance(value, (int, long)):

            return cls.get(value)

        if isinstance(value, basestring) and value.isdigit():

            return cls.get(int(value))

        if callback is not None:

            return callback(value)

        raise Exception(

            'given object must be int, long or Instance of %s '

            'got %s, no callback provided' % (cls, type(value))

        )

    @classmethod

    def get_or_404(cls, id_):

        try:

            id_ = int(id_)

        except (TypeError, ValueError):

            raise HTTPNotFound

        res = cls.query().get(id_)

        if res is None:

            raise HTTPNotFound

        return res

    @classmethod

    def delete(cls, id_):

        obj = cls.query().get(id_)

        Session().delete(obj)

    def __repr__(self):

        if hasattr(self, '__unicode__'):

            # python repr needs to return str

            try:

                return safe_str(self.__unicode__())

                    # TODO: inform user that requested operation couldn't be completed

                    log.error('cannot email unknown user %r', u)

            log.debug('sending notifications %s to %s',

                type_, recipients_objs

            )

        elif recipients is None:

            # empty recipients means to all admins

            recipients_objs = User.query().filter(User.admin == True).all()

            log.debug('sending notifications %s to admins: %s',

                type_, recipients_objs

            )

        #else: silently skip notification mails?

        if not with_email:

            return

        headers = {}

        headers['X-Kallithea-Notification-Type'] = type_

        if 'threading' in email_kwargs:

            headers['References'] = ' '.join('<%s>' % x for x in email_kwargs['threading'])

        # this is passed into template

        created_on = h.fmt_date(datetime.datetime.now())

        html_kwargs = {

                  'subject': subject,

                  'body': h.render_w_mentions(body, repo_name),

                  'when': created_on,

                  'user': created_by_obj.username,

                  }

        txt_kwargs = {

                  'subject': subject,

                  'body': body,

                  'when': created_on,

                  'user': created_by_obj.username,

                  }

        html_kwargs.update(email_kwargs)

        txt_kwargs.update(email_kwargs)

        email_subject = EmailNotificationModel() \

                            .get_email_description(type_, **txt_kwargs)

        email_txt_body = EmailNotificationModel() \

                            .get_email_tmpl(type_, 'txt', **txt_kwargs)

        email_html_body = EmailNotificationModel() \

                            .get_email_tmpl(type_, 'html', **html_kwargs)

        # don't send email to person who created this comment

        rec_objs = set(recipients_objs).difference(set([created_by_obj]))

        # send email with notification to all other participants

        for rec in rec_objs:

            tasks.send_email([rec.email], email_subject, email_txt_body,

                     email_html_body, headers, author=created_by_obj)

class EmailNotificationModel(object):

    TYPE_CHANGESET_COMMENT = NotificationModel.TYPE_CHANGESET_COMMENT

    TYPE_MESSAGE = NotificationModel.TYPE_MESSAGE # only used for testing

    # NotificationModel.TYPE_MENTION is not used

    TYPE_PASSWORD_RESET = 'password_link'

    TYPE_REGISTRATION = NotificationModel.TYPE_REGISTRATION

    TYPE_PULL_REQUEST = NotificationModel.TYPE_PULL_REQUEST

    TYPE_PULL_REQUEST_COMMENT = NotificationModel.TYPE_PULL_REQUEST_COMMENT

    TYPE_DEFAULT = 'default'

    def __init__(self):

        super(EmailNotificationModel, self).__init__()

        self._template_root = kallithea.CONFIG['paths']['templates'][0]

        self._tmpl_lookup = app_globals.mako_lookup

        self.email_types = {

            self.TYPE_CHANGESET_COMMENT: 'changeset_comment',

            self.TYPE_PASSWORD_RESET: 'password_reset',

            self.TYPE_REGISTRATION: 'registration',

            self.TYPE_DEFAULT: 'default',

            self.TYPE_PULL_REQUEST: 'pull_request',

            self.TYPE_PULL_REQUEST_COMMENT: 'pull_request_comment',

        }

        self._subj_map = {

            self.TYPE_CHANGESET_COMMENT: _('[Comment] %(repo_name)s changeset %(short_id)s "%(message_short)s" on %(branch)s'),

            self.TYPE_MESSAGE: 'Test Message',

            # self.TYPE_PASSWORD_RESET

            self.TYPE_REGISTRATION: _('New user %(new_username)s registered'),

            # self.TYPE_DEFAULT

            self.TYPE_PULL_REQUEST: _('[Review] %(repo_name)s PR %(pr_nice_id)s "%(pr_title_short)s" from %(pr_source_branch)s by %(pr_owner_username)s'),

            self.TYPE_PULL_REQUEST_COMMENT: _('[Comment] %(repo_name)s PR %(pr_nice_id)s "%(pr_title_short)s" from %(pr_source_branch)s by %(pr_owner_username)s'),

        }

    def get_email_description(self, type_, **kwargs):

        """

        return subject for email based on given type

        """

        tmpl = self._subj_map[type_]

        try:

            subj = tmpl % kwargs

        except KeyError as e:

            raise

        # gmail doesn't do proper threading but will ignore leading square

        # bracket content ... so that is where we put status info

        bracket_tags = []

        status_change = kwargs.get('status_change')

        if status_change:

            bracket_tags.append(unicode(status_change))  # apply unicode to evaluate LazyString before .join

        if kwargs.get('closing_pr'):

            bracket_tags.append(_('Closing'))

        if bracket_tags:

            if subj.startswith('['):

                subj = '[' + ', '.join(bracket_tags) + ': ' + subj[1:]

            else:

                subj = '[' + ', '.join(bracket_tags) + '] ' + subj

        return subj

    def get_email_tmpl(self, type_, content_type, **kwargs):

        """

        return generated template for email based on given type

        """

        base = 'email_templates/' + self.email_types.get(type_, self.email_types[self.TYPE_DEFAULT]) + '.' + content_type

        email_template = self._tmpl_lookup.get_template(base)

        # translator and helpers inject

        _kwargs = {'_': _,

                   'h': h,

                   'c': c}

        _kwargs.update(kwargs)

        if content_type == 'html':

            _kwargs.update({

                "color_text": "#202020",

                "color_emph": "#395fa0",

                "color_link": "#395fa0",

                "color_border": "#ddd",

                "color_background_grey": "#f9f9f9",

                "color_button": "#395fa0",

                "monospace_style": "font-family:Lucida Console,Consolas,Monaco,Inconsolata,Liberation Mono,monospace",

                "sans_style": "font-family:Helvetica,Arial,sans-serif",

                })

            _kwargs.update({

                "default_style": "%(sans_style)s;font-weight:200;font-size:14px;line-height:17px;color:%(color_text)s" % _kwargs,

                "comment_style": "%(monospace_style)s;white-space:pre-wrap" % _kwargs,

                "data_style": "border:%(color_border)s 1px solid;background:%(color_background_grey)s" % _kwargs,

                "emph_style": "font-weight:600;color:%(color_emph)s" % _kwargs,

                "link_style": "color:%(color_link)s;text-decoration:none" % _kwargs,

                "link_text_style": "color:%(color_text)s;text-decoration:none;border:%(color_border)s 1px solid;background:%(color_background_grey)s" % _kwargs,

                })

        log.debug('rendering tmpl %s with kwargs %s', base, _kwargs)

        return email_template.render_unicode(**_kwargs)

## snippet for displaying permissions overview for users

## usage:

##    <%namespace name="p" file="/base/perms_summary.html"/>

##    ${p.perms_summary(c.perm_user.permissions)}

<%def name="perms_summary(permissions, show_all=False, actions=True)">

<div id="perms">