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

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

"""

import logging

from tg.i18n import ugettext as _

from collections import defaultdict

from kallithea.lib.utils2 import extract_mentioned_users, safe_unicode

from kallithea.lib import helpers as h

from kallithea.model.db import ChangesetComment, User, \

from kallithea.model.notification import NotificationModel

from kallithea.model.meta import Session

log = logging.getLogger(__name__)

def _list_changeset_commenters(revision):

    return (Session().query(User)

        .join(ChangesetComment.author)

        .filter(ChangesetComment.revision == revision)

        .all())

                               status_change=None, closing_pr=False):

        """

        :returns: tuple (subj,body,recipients,notification_type,email_kwargs)

        """

        # make notification

        body = comment_text  # text of the comment

        line = ''

        if line_no:

            line = _('on line %s') % line_no

        # changeset

        if revision:

            cs = repo.scm_instance.get_changeset(revision)

            desc = cs.short_id

            threading = ['%s-rev-%s@%s' % (repo.repo_name, revision, h.canonical_hostname())]

            if line_no: # TODO: url to file _and_ line number

                threading.append('%s-rev-%s-line-%s@%s' % (repo.repo_name, revision, line_no,

                                                           h.canonical_hostname()))

            comment_url = h.canonical_url('changeset_home',

                repo_name=repo.repo_name,

                revision=revision,

                anchor='comment-%s' % comment.comment_id)

            subj = safe_unicode(

                'raw_id': revision,

                'message': cs.message,

                'message_short': h.shorter(cs.message, 50, firstline=True),

                'cs_author': cs_author,

                'repo_name': repo.repo_name,

                'short_id': h.short_id(revision),

                'branch': cs.branch,

                'comment_username': author.username,

                'threading': threading,

            }

        # pull request

        elif pull_request:

            desc = comment.pull_request.title

            _org_ref_type, org_ref_name, _org_rev = comment.pull_request.org_ref.split(':')

            _other_ref_type, other_ref_name, _other_rev = comment.pull_request.other_ref.split(':')

            threading = ['%s-pr-%s@%s' % (pull_request.other_repo.repo_name,

                                          pull_request.pull_request_id,

                                          h.canonical_hostname())]

            if line_no: # TODO: url to file _and_ line number

                threading.append('%s-pr-%s-line-%s@%s' % (pull_request.other_repo.repo_name,

                                                          pull_request.pull_request_id, line_no,

                                                          h.canonical_hostname()))

            comment_url = pull_request.url(canonical=True,

                anchor='comment-%s' % comment.comment_id)

    user = relationship('User')

    pull_request = relationship('PullRequest')

    def __json__(self):

        return dict(

            username=self.user.username if self.user else None,

        )

class Notification(object):

    __tablename__ = 'notifications'

class UserNotification(object):

    __tablename__ = 'user_to_notification'

class Gist(Base, BaseDbModel):

    __tablename__ = 'gists'

    __table_args__ = (

        Index('g_gist_access_id_idx', 'gist_access_id'),

        Index('g_created_on_idx', 'created_on'),

        _table_args_default_dict,

    )

import datetime

import logging

import traceback

from tg import tmpl_context as c, app_globals

from tg.i18n import ugettext as _

from sqlalchemy.orm import joinedload, subqueryload

import kallithea

from kallithea.lib import helpers as h

from kallithea.lib.utils2 import safe_unicode

from kallithea.model.meta import Session

log = logging.getLogger(__name__)

class NotificationModel(object):

    def create(self, created_by, subject, body, recipients=None,

               email_kwargs=None, repo_name=None):

        """

        Creates notification of given type

        :param created_by: int, str or User instance. User who created this

            notification

        :param subject:

        :param body:

        :param recipients: list of int, str or User objects, when None

            is given send to all admins

        :param type_: type of notification

        # 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_PASSWORD_RESET = 'password_link'

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

import logging

import datetime

import re

from tg import request

from tg.i18n import ugettext as _

from sqlalchemy.orm import joinedload

from kallithea.model.meta import Session

from kallithea.lib import helpers as h

    ChangesetStatus, User

from kallithea.model.notification import NotificationModel

from kallithea.lib.utils2 import extract_mentioned_users, safe_str, safe_unicode

log = logging.getLogger(__name__)

def _assert_valid_reviewers(seq):

    """Sanity check: elements are actual User objects, and not the default user."""

    assert not any(user.is_default_user for user in seq)

            'pr_source_repo': h.canonical_url('summary_home',

                               repo_name=pr.org_repo.repo_name),

            'pr_source_branch': org_ref_name,

            'pr_owner': pr.owner,

            'pr_owner_username': pr.owner.username,

            'pr_username': user.username,

            'threading': threading,

            'is_mention': False,

            }

        if reviewers:

            NotificationModel().create(created_by=user, subject=subject, body=body,

                                       recipients=reviewers,

                                       email_kwargs=email_kwargs)

        if mention_recipients:

            email_kwargs['is_mention'] = True

            subject = _('[Mention]') + ' ' + subject

            # FIXME: this subject is wrong and unused!

            NotificationModel().create(created_by=user, subject=subject, body=body,

                                       recipients=mention_recipients,

                                       email_kwargs=email_kwargs)

    def mention_from_description(self, user, pr, old_description=''):

        mention_recipients = (extract_mentioned_users(pr.description) -

                              extract_mentioned_users(old_description))

        log.debug("Mentioning %s", mention_recipients)

        self.add_reviewers(user, pr, set(), mention_recipients)

    def remove_reviewers(self, user, pull_request, reviewers):

        """Remove specified users from being reviewers of the PR."""

        if not reviewers:

import hmac

import logging

import time

import traceback

from tg import config

from tg.i18n import ugettext as _

from sqlalchemy.exc import DatabaseError

from kallithea.lib.utils2 import safe_str, generate_api_key, get_current_authuser

from kallithea.lib.caching_query import FromCache

    UserEmailMap, UserIpMap

from kallithea.lib.exceptions import DefaultUserException, \

    UserOwnsReposException

from kallithea.model.meta import Session

log = logging.getLogger(__name__)

class UserModel(object):

    password_reset_token_lifetime = 86400 # 24 hours

            '- Username: {user.username}\n'

            '- Full Name: {user.full_name}\n'

            '- Email: {user.email}\n'

            ).format(user=new_user)

        edit_url = h.canonical_url('edit_user', id=new_user.user_id)

        email_kwargs = {

            'registered_user_url': edit_url,

            'new_username': new_user.username,

            'new_email': new_user.email,

            'new_full_name': new_user.full_name}

        NotificationModel().create(created_by=new_user, subject=subject,

                                   body=body, recipients=None,

                                   email_kwargs=email_kwargs)

    def update(self, user_id, form_data, skip_attrs=None):

        from kallithea.lib.auth import get_crypt_password

        skip_attrs = skip_attrs or []

        user = self.get(user_id, cache=False)

        if user.is_default_user:

            raise DefaultUserException(

                            _("You can't edit this user since it's "

                              "crucial for entire application"))

        for k, v in form_data.items():

import os

import re

import mock

import routes.util

from kallithea.tests.base import *

from kallithea.lib import helpers as h

from kallithea.model.user import UserModel

from kallithea.model.meta import Session

from kallithea.model.notification import NotificationModel, EmailNotificationModel

import kallithea.lib.celerylib

import kallithea.lib.celerylib.tasks

from tg.util.webtest import test_context

class TestNotifications(TestController):

                    pr_title='The Title',

                    pr_title_short='The Title',

                    pr_url='http://pr.org/7',

                    pr_target_repo='http://mainline.com/repo',

                    pr_target_branch='trunk',

                    pr_source_repo='https://dev.org/repo',

                    pr_source_branch='devbranch',

                    pr_owner=User.get(self.u2),

                    pr_owner_username='u2'

                    )

                for type_, body, kwargs in [

                         u'This is the new \'comment\'.\n\n - and here it ends indented.',

                         dict(

                            short_id='cafe1234',

                            raw_id='cafe1234c0ffeecafe',

                            branch='brunch',

                            cs_comment_user='Opinionated User (jsmith)',

                            cs_comment_url='http://comment.org',

                            is_mention=[False, True],

                            message='This changeset did something clever which is hard to explain',

                            message_short='This changeset did something cl...',

                            status_change=[None, 'Approved'],

                            cs_target_repo='http://example.com/repo_target',

                            cs_url='http://changeset.com',

                            cs_author=User.get(self.u2))),

                         u'This is the \'body\' of the "test" message\n - nothing interesting here except indentation.',

                         dict()),

                         u'Registration body',

                         dict(

                            new_username='newbie',

                            registered_user_url='http://newbie.org',

                            new_email='new@email.com',

                            new_full_name='New Full Name')),

                         u'This PR is \'awesome\' because it does <stuff>\n - please approve indented!',

                         dict(

                            pr_user_created='Requesting User (root)', # pr_owner should perhaps be used for @mention in description ...

                            is_mention=[False, True],

                            pr_revisions=[('123abc'*7, "Introduce one and two\n\nand that's it"), ('567fed'*7, 'Make one plus two equal tree')],

                            org_repo_name='repo_org',

                            **pr_kwargs)),

                         u'Me too!\n\n - and indented on second line',

                         dict(

                            closing_pr=[False, True],

                            is_mention=[False, True],

                            pr_comment_user='Opinionated User (jsmith)',

                            pr_comment_url='http://pr.org/comment',

                            status_change=[None, 'Under Review'],

                            **pr_kwargs)),

                        ]:

                    kwargs['repo_name'] = u'repo/name'

                    params = [(type_, type_, body, kwargs)]

                    for param_name in ['is_mention', 'status_change', 'closing_pr']: # TODO: inline/general