_url = h.url('changeset_home',

                repo_name=repo.repo_name,

                revision=revision,

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

                qualified=True,

            )

            subj = safe_unicode(

                h.link_to('Re changeset: %(desc)s %(line)s' % \

                          {'desc': desc, 'line': line},

                          _url)

            )

            # get the current participants of this changeset

            recipients = ChangesetComment.get_users(revision=revision)

            # add changeset author if it's in kallithea system

            cs_author = User.get_from_cs_author(cs.author)

            if not cs_author:

                #use repo owner if we cannot extract the author correctly

                cs_author = repo.user

            recipients += [cs_author]

            email_kwargs = {

                'status_change': status_change,

                'cs_comment_user': h.person(user),

                'cs_target_repo': h.url('summary_home', repo_name=repo.repo_name,

                                        qualified=True),

                'cs_comment_url': _url,

                'raw_id': revision,

            }

        #pull request

        elif pull_request:

            notification_type = Notification.TYPE_PULL_REQUEST_COMMENT

            desc = comment.pull_request.title

            _url = h.url('pullrequest_show',

                repo_name=pull_request.other_repo.repo_name,

                pull_request_id=pull_request.pull_request_id,

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

                qualified=True,

            )

            subj = safe_unicode(

                h.link_to('Re pull request #%(pr_id)s: %(desc)s %(line)s' % \

                          {'desc': desc,

                           'pr_id': comment.pull_request.pull_request_id,

                           'line': line},

                          _url)

            )

            # get the current participants of this pull request

            recipients = ChangesetComment.get_users(pull_request_id=

                                                pull_request.pull_request_id)

            # add pull request author

            recipients += [pull_request.author]

            # add the reviewers to notification

            recipients += [x.user for x in pull_request.reviewers]

            #set some variables for email notification

            email_kwargs = {

                'pr_title': pull_request.title,

                'pr_id': pull_request.pull_request_id,

                'status_change': status_change,

                'closing_pr': closing_pr,

                'pr_comment_url': _url,

                'pr_comment_user': h.person(user),

                'pr_target_repo': h.url('summary_home',

                                   repo_name=pull_request.other_repo.repo_name,

            }

    def create(self, text, repo, user, revision=None, pull_request=None,

               f_path=None, line_no=None, status_change=None, closing_pr=False,

               send_email=True):

        """

        Creates new comment for changeset or pull request.

        If status_change is not None this comment is associated with a

        status change of changeset or changesets associated with pull request

        :param text:

        :param repo:

        :param user:

            comment.revision = revision

        elif pull_request:

            pull_request = self.__get_pull_request(pull_request)

            comment.pull_request = pull_request

        else:

            raise Exception('Please specify revision or pull_request_id')

        Session().add(comment)

        Session().flush()

        if send_email:

            (subj, body, recipients, notification_type,

                                repo, comment, user,

                                comment_text=text,

                                line_no=line_no,

                                revision=revision,

                                pull_request=pull_request,

                                status_change=status_change,

                                closing_pr=closing_pr)

            # create notification objects, and emails

            NotificationModel().create(

                created_by=user, subject=subj, body=body,

                recipients=recipients, type_=notification_type,

            )

            mention_recipients = set(self._extract_mentions(body))\

                                    .difference(recipients)

            if mention_recipients:

                email_kwargs.update({'pr_mention': True})

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

                NotificationModel().create(

                    created_by=user, subject=subj, body=body,

                    recipients=mention_recipients,

                    type_=notification_type,

                    email_kwargs=email_kwargs

    def __get_notification(self, notification):

        if isinstance(notification, Notification):

            return notification

        elif isinstance(notification, (int, long)):

            return Notification.get(notification)

        else:

            if notification:

                raise Exception('notification must be int, long or Instance'

                                ' of Notification got %s' % type(notification))

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

               type_=Notification.TYPE_MESSAGE, with_email=True,

        """

        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

        :param with_email: send email with this notification

        :param email_kwargs: additional dict to pass as args to email template

        """

        from kallithea.lib.celerylib import tasks, run_task

        if recipients and not getattr(recipients, '__iter__', False):

            raise Exception('recipients must be a list or iterable')

        created_by_obj = self._get_user(created_by)

        recipients_objs = []

        if recipients:

            for u in recipients:

                obj = self._get_user(u)

            created_by=created_by_obj, subject=subject,

            body=body, recipients=recipients_objs, type_=type_

        )

        if not with_email:

            return notif

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

            email_body = None  # we set body to none, we just send HTML emails

            ## this is passed into template

            kwargs.update(email_kwargs)

            email_body_html = EmailNotificationModel()\

                                .get_email_tmpl(type_, **kwargs)

            run_task(tasks.send_email, [rec.email], email_subject, email_body,

                     email_body_html)

        return notif

    def delete(self, user, notification):

        # we don't want to remove actual notification just the assignment

        try:

            notification = self.__get_notification(notification)

        else:

            when = h.fmt_date(notification.created_on)

        return tmpl % dict(

            user=notification.created_by_user.username,

            when=when,

            )

class EmailNotificationModel(BaseModel):

    TYPE_CHANGESET_COMMENT = Notification.TYPE_CHANGESET_COMMENT

    TYPE_PASSWORD_RESET = 'password_link'

    TYPE_REGISTRATION = Notification.TYPE_REGISTRATION

    TYPE_PULL_REQUEST = Notification.TYPE_PULL_REQUEST

    TYPE_PULL_REQUEST_COMMENT = Notification.TYPE_PULL_REQUEST_COMMENT

    TYPE_DEFAULT = 'default'

    def __init__(self):

        super(EmailNotificationModel, self).__init__()

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

        self._tmpl_lookup = kallithea.CONFIG['pylons.app_globals'].mako_lookup

        self.email_types = {

            self.TYPE_CHANGESET_COMMENT: 'email_templates/changeset_comment.html',

            self.TYPE_PASSWORD_RESET: 'email_templates/password_reset.html',

            self.TYPE_REGISTRATION: 'email_templates/registration.html',

            self.TYPE_DEFAULT: 'email_templates/default.html',

            self.TYPE_PULL_REQUEST: 'email_templates/pull_request.html',

            self.TYPE_PULL_REQUEST_COMMENT: 'email_templates/pull_request_comment.html',

        }

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

        """

        return generated template for email based on given type

        """

        base = self.email_types.get(type_, self.email_types[self.TYPE_DEFAULT])

        email_template = self._tmpl_lookup.get_template(base)

        # translator and helpers inject

        _kwargs = {'_': _,

                   'h': h,

                   'c': c}

        _kwargs.update(kwargs)

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

        return email_template.render(**_kwargs)

        pr_url = h.url('pullrequest_show', repo_name=pr.other_repo.repo_name,

                       pull_request_id=pr.pull_request_id,

                       qualified=True)

        subject = safe_unicode(

            h.link_to(

              _('%(user)s wants you to review pull request #%(pr_id)s: %(pr_title)s') % \

                {'user': pr.author.username,

                 'pr_title': pr.title,

                 'pr_id': pr.pull_request_id},

                pr_url)

            )

        body = pr.description

            'pr_title': pr.title,

            'pr_user_created': h.person(pr.author),

            'pr_repo_url': h.url('summary_home', repo_name=pr.other_repo.repo_name,

                                 qualified=True,),

            'pr_url': pr_url,

        NotificationModel().create(created_by=pr.author, subject=subject, body=body,

                                   recipients=reviewers,

    def update_reviewers(self, pull_request, reviewers_ids):

        reviewers_ids = set(reviewers_ids)

        pull_request = self.__get_pull_request(pull_request)

        current_reviewers = PullRequestReviewers.query()\

                            .filter(PullRequestReviewers.pull_request==

                                   pull_request)\

                            .all()

        current_reviewers_ids = set([x.user.user_id for x in current_reviewers])

        to_add = reviewers_ids.difference(current_reviewers_ids)

        to_remove = current_reviewers_ids.difference(reviewers_ids)

            self.sa.add(new_user)

            self.sa.flush()

            # notification to admins

            subject = _('New user registration')

            body = ('New user registration\n'

                    '---------------------\n'

                    '- Username: %s\n'

                    '- Full Name: %s\n'

                    '- Email: %s\n')

            body = body % (new_user.username, new_user.full_name, new_user.email)

            edit_url = url('edit_user', id=new_user.user_id, qualified=True)

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

                                       body=body, recipients=None,

                                       type_=Notification.TYPE_REGISTRATION,

        except Exception:

            log.error(traceback.format_exc())

            raise

    def update(self, user_id, form_data, skip_attrs=[]):

        from kallithea.lib.auth import get_crypt_password

        try:

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

            if user.username == User.DEFAULT_USER:

                raise DefaultUserException(

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

                                  "crucial for entire application"))

    def reset_password_link(self, data):

        from kallithea.lib.celerylib import tasks, run_task

        from kallithea.model.notification import EmailNotificationModel

        user_email = data['email']

        try:

            user = User.get_by_email(user_email)

            if user:

                log.debug('password reset user found %s' % user)

                link = url('reset_password_confirmation', key=user.api_key,

                           qualified=True)

                reg_type = EmailNotificationModel.TYPE_PASSWORD_RESET

                body = EmailNotificationModel().get_email_tmpl(reg_type,

                log.debug('sending email')

                run_task(tasks.send_email, [user_email],

                         _("Password reset link"), body, body)

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

            else:

                log.debug("password reset email %s not found" % user_email)

        except Exception:

            log.error(traceback.format_exc())

            return False

        return True