notifications: adjusting how instance name is passed and fixing tests

rhodecode/model/notification.py

@@ -1,366 +1,367 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2011-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 """
 Model for notifications
 """
 
 
 import logging
 import traceback
 
 from pylons import tmpl_context as c
 from pylons.i18n.translation import _, ungettext
 from sqlalchemy.sql.expression import false, true
 from mako import exceptions
 
 import rhodecode
 from rhodecode.lib import helpers as h
 from rhodecode.lib.utils import PartialRenderer
 from rhodecode.model import BaseModel
 from rhodecode.model.db import Notification, User, UserNotification
 from rhodecode.model.meta import Session
 from rhodecode.model.settings import SettingsModel
 
 log = logging.getLogger(__name__)
 
 
 class NotificationModel(BaseModel):
 
     cls = Notification
 
     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, notification_subject, notification_body,
             notification_type=Notification.TYPE_MESSAGE, recipients=None,
             mention_recipients=None, with_email=True, email_kwargs=None):
         """
 
         Creates notification of given type
 
         :param created_by: int, str or User instance. User who created this
             notification
         :param notification_subject: subject of notification itself
         :param notification_body: body of notification text
         :param notification_type: type of notification, based on that we
             pick templates
 
         :param recipients: list of int, str or User objects, when None
             is given send to all admins
         :param mention_recipients: list of int, str or User objects,
             that were mentioned
         :param with_email: send email with this notification
         :param email_kwargs: dict with arguments to generate email
         """
 
         from rhodecode.lib.celerylib import tasks, run_task
 
         if recipients and not getattr(recipients, '__iter__', False):
             raise Exception('recipients must be an iterable object')
 
         created_by_obj = self._get_user(created_by)
         # default MAIN body if not given
         email_kwargs = email_kwargs or {'body': notification_body}
         mention_recipients = mention_recipients or set()
 
         if not created_by_obj:
             raise Exception('unknown user %s' % created_by)
 
         if recipients is None:
             # recipients is None means to all admins
             recipients_objs = User.query().filter(User.admin == true()).all()
             log.debug('sending notifications %s to admins: %s',
                       notification_type, recipients_objs)
         else:
             recipients_objs = []
             for u in recipients:
                 obj = self._get_user(u)
                 if obj:
                     recipients_objs.append(obj)
                 else:  # we didn't find this user, log the error and carry on
                     log.error('cannot notify unknown user %r', u)
 
             recipients_objs = set(recipients_objs)
             if not recipients_objs:
                 raise Exception('no valid recipients specified')
 
             log.debug('sending notifications %s to %s',
                       notification_type, recipients_objs)
 
         # add mentioned users into recipients
         final_recipients = set(recipients_objs).union(mention_recipients)
         notification = Notification.create(
             created_by=created_by_obj, subject=notification_subject,
             body=notification_body, recipients=final_recipients,
             type_=notification_type
         )
 
         if not with_email:  # skip sending email, and just create notification
             return notification
 
         # don't send email to person who created this comment
         rec_objs = set(recipients_objs).difference(set([created_by_obj]))
 
         # now notify all recipients in question
 
         for recipient in rec_objs.union(mention_recipients):
             # inject current recipient
             email_kwargs['recipient'] = recipient
             email_kwargs['mention'] = recipient in mention_recipients
             (subject, headers, email_body,
              email_body_plaintext) = EmailNotificationModel().render_email(
                 notification_type, **email_kwargs)
 
             log.debug(
                 'Creating notification email task for user:`%s`', recipient)
             task = run_task(
                 tasks.send_email, recipient.email, subject,
                 email_body_plaintext, email_body)
             log.debug('Created email task: %s', task)
 
         return notification
 
     def delete(self, user, notification):
         # we don't want to remove actual notification just the assignment
         try:
             notification = self.__get_notification(notification)
             user = self._get_user(user)
             if notification and user:
                 obj = UserNotification.query()\
                     .filter(UserNotification.user == user)\
                     .filter(UserNotification.notification == notification)\
                     .one()
                 Session().delete(obj)
                 return True
         except Exception:
             log.error(traceback.format_exc())
             raise
 
     def get_for_user(self, user, filter_=None):
         """
         Get mentions for given user, filter them if filter dict is given
 
         :param user:
         :param filter:
         """
         user = self._get_user(user)
 
         q = UserNotification.query()\
             .filter(UserNotification.user == user)\
             .join((
                 Notification, UserNotification.notification_id ==
                 Notification.notification_id))
 
         if filter_:
             q = q.filter(Notification.type_.in_(filter_))
 
         return q.all()
 
     def mark_read(self, user, notification):
         try:
             notification = self.__get_notification(notification)
             user = self._get_user(user)
             if notification and user:
                 obj = UserNotification.query()\
                     .filter(UserNotification.user == user)\
                     .filter(UserNotification.notification == notification)\
                     .one()
                 obj.read = True
                 Session().add(obj)
                 return True
         except Exception:
             log.error(traceback.format_exc())
             raise
 
     def mark_all_read_for_user(self, user, filter_=None):
         user = self._get_user(user)
         q = UserNotification.query()\
             .filter(UserNotification.user == user)\
             .filter(UserNotification.read == false())\
             .join((
                 Notification, UserNotification.notification_id ==
                 Notification.notification_id))
         if filter_:
             q = q.filter(Notification.type_.in_(filter_))
 
         # this is a little inefficient but sqlalchemy doesn't support
         # update on joined tables :(
         for obj in q.all():
             obj.read = True
             Session().add(obj)
 
     def get_unread_cnt_for_user(self, user):
         user = self._get_user(user)
         return UserNotification.query()\
             .filter(UserNotification.read == false())\
             .filter(UserNotification.user == user).count()
 
     def get_unread_for_user(self, user):
         user = self._get_user(user)
         return [x.notification for x in UserNotification.query()
                 .filter(UserNotification.read == false())
                 .filter(UserNotification.user == user).all()]
 
     def get_user_notification(self, user, notification):
         user = self._get_user(user)
         notification = self.__get_notification(notification)
 
         return UserNotification.query()\
             .filter(UserNotification.notification == notification)\
             .filter(UserNotification.user == user).scalar()
 
     def make_description(self, notification, show_age=True):
         """
         Creates a human readable description based on properties
         of notification object
         """
 
         _map = {
             notification.TYPE_CHANGESET_COMMENT: [
                 _('%(user)s commented on commit %(date_or_age)s'),
                 _('%(user)s commented on commit at %(date_or_age)s'),
                 ],
             notification.TYPE_MESSAGE: [
                 _('%(user)s sent message %(date_or_age)s'),
                 _('%(user)s sent message at %(date_or_age)s'),
                 ],
             notification.TYPE_MENTION: [
                 _('%(user)s mentioned you %(date_or_age)s'),
                 _('%(user)s mentioned you at %(date_or_age)s'),
                 ],
             notification.TYPE_REGISTRATION: [
                 _('%(user)s registered in RhodeCode %(date_or_age)s'),
                 _('%(user)s registered in RhodeCode at %(date_or_age)s'),
                 ],
             notification.TYPE_PULL_REQUEST: [
                 _('%(user)s opened new pull request %(date_or_age)s'),
                 _('%(user)s opened new pull request at %(date_or_age)s'),
                 ],
             notification.TYPE_PULL_REQUEST_COMMENT: [
                 _('%(user)s commented on pull request %(date_or_age)s'),
                 _('%(user)s commented on pull request at %(date_or_age)s'),
                 ],
         }
 
         templates = _map[notification.type_]
 
         if show_age:
             template = templates[0]
             date_or_age = h.age(notification.created_on)
         else:
             template = templates[1]
             date_or_age = h.format_date(notification.created_on)
 
         return template % {
             'user': notification.created_by_user.username,
             'date_or_age': date_or_age,
         }
 
 
 class EmailNotificationModel(BaseModel):
     TYPE_COMMIT_COMMENT = Notification.TYPE_CHANGESET_COMMENT
     TYPE_REGISTRATION = Notification.TYPE_REGISTRATION
     TYPE_PULL_REQUEST = Notification.TYPE_PULL_REQUEST
     TYPE_PULL_REQUEST_COMMENT = Notification.TYPE_PULL_REQUEST_COMMENT
     TYPE_MAIN = Notification.TYPE_MESSAGE
 
     TYPE_PASSWORD_RESET = 'password_reset'
     TYPE_PASSWORD_RESET_CONFIRMATION = 'password_reset_confirmation'
     TYPE_EMAIL_TEST = 'email_test'
     TYPE_TEST = 'test'
 
     email_types = {
         TYPE_MAIN: 'email_templates/main.mako',
         TYPE_TEST: 'email_templates/test.mako',
         TYPE_EMAIL_TEST: 'email_templates/email_test.mako',
         TYPE_REGISTRATION: 'email_templates/user_registration.mako',
         TYPE_PASSWORD_RESET: 'email_templates/password_reset.mako',
         TYPE_PASSWORD_RESET_CONFIRMATION: 'email_templates/password_reset_confirmation.mako',
         TYPE_COMMIT_COMMENT: 'email_templates/commit_comment.mako',
         TYPE_PULL_REQUEST: 'email_templates/pull_request_review.mako',
         TYPE_PULL_REQUEST_COMMENT: 'email_templates/pull_request_comment.mako',
     }
 
     def __init__(self):
         """
         Example usage::
 
             (subject, headers, email_body,
              email_body_plaintext) = EmailNotificationModel().render_email(
                 EmailNotificationModel.TYPE_TEST, **email_kwargs)
 
         """
         super(EmailNotificationModel, self).__init__()
 
     def _update_kwargs_for_render(self, kwargs):
         """
         Inject params required for Mako rendering
 
         :param kwargs:
         :return:
         """
         _kwargs = {
-            'instance_url': h.url('home', qualified=True)
+            'instance_url': h.url('home', qualified=True),
+            'rhodecode_instance_name': getattr(c, 'rhodecode_name', '')
         }
         _kwargs.update(kwargs)
         return _kwargs
 
     def get_renderer(self, type_):
         template_name = self.email_types[type_]
         return PartialRenderer(template_name)
 
     def render_email(self, type_, **kwargs):
         """
         renders template for email, and returns a tuple of
         (subject, email_headers, email_html_body, email_plaintext_body)
         """
         # translator and helpers inject
         _kwargs = self._update_kwargs_for_render(kwargs)
 
         email_template = self.get_renderer(type_)
 
         subject = email_template.render('subject', **_kwargs)
 
         try:
             headers = email_template.render('headers', **_kwargs)
         except AttributeError:
             # it's not defined in template, ok we can skip it
             headers = ''
 
         try:
             body_plaintext = email_template.render('body_plaintext', **_kwargs)
         except AttributeError:
             # it's not defined in template, ok we can skip it
             body_plaintext = ''
 
         # render WHOLE template
         body = email_template.render(None, **_kwargs)
 
         return subject, headers, body, body_plaintext

rhodecode/templates/email_templates/base.mako

@@ -1,106 +1,106 b''
 ## -*- coding: utf-8 -*-
 
 ## headers we additionally can set for email
 <%def name="headers()" filter="n,trim"></%def>
 
 <%def name="plaintext_footer()">
 ${_('This is a notification from RhodeCode. %(instance_url)s') % {'instance_url': instance_url}}
 </%def>
 
 <%def name="body_plaintext()" filter="n,trim">
 ## this example is not called itself but overridden in each template
 ## the plaintext_footer should be at the bottom of both html and text emails
 ${self.plaintext_footer()}
 </%def>
 
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> 
 <html xmlns="http://www.w3.org/1999/xhtml">
 <head>
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
     <title>${self.subject()}</title>
     <style type="text/css">
         /* Based on The MailChimp Reset INLINE: Yes. */  
         #outlook a {padding:0;} /* Force Outlook to provide a "view in browser" menu link. */
         body{width:100% !important; -webkit-text-size-adjust:100%; -ms-text-size-adjust:100%; margin:0; padding:0;} 
         /* Prevent Webkit and Windows Mobile platforms from changing default font sizes.*/ 
         .ExternalClass {width:100%;} /* Force Hotmail to display emails at full width */  
         .ExternalClass, .ExternalClass p, .ExternalClass span, .ExternalClass font, .ExternalClass td, .ExternalClass div {line-height: 100%;}
         /* Forces Hotmail to display normal line spacing.  More on that: http://www.emailonacid.com/forum/viewthread/43/ */ 
         #backgroundTable {margin:0; padding:0; line-height: 100% !important;}
         /* End reset */
 
         /* defaults for images*/
         img {outline:none; text-decoration:none; -ms-interpolation-mode: bicubic;} 
         a img {border:none;} 
         .image_fix {display:block;}
 
         body {line-height:1.2em;}
         p {margin: 0 0 20px;}
         h1, h2, h3, h4, h5, h6 {color:#323232!important;}
         a {color:#427cc9;text-decoration:none;outline:none;cursor:pointer;}
         a:focus {outline:none;}
         a:hover {color: #305b91;}
         h1 a, h2 a, h3 a, h4 a, h5 a, h6 a {color:#427cc9!important;text-decoration:none!important;}
         h1 a:active, h2 a:active,  h3 a:active, h4 a:active, h5 a:active, h6 a:active {color: #305b91!important;}
         h1 a:visited, h2 a:visited,  h3 a:visited, h4 a:visited, h5 a:visited, h6 a:visited {color: #305b91!important;}
         table {font-size:13px;border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;}
         table td {padding:.65em 1em .65em 0;border-collapse:collapse;vertical-align:top;text-align:left;}
         input {display:inline;border-radius:2px;border-style:solid;border: 1px solid #dbd9da;padding:.5em;}
         input:focus {outline: 1px solid #979797}
         @media only screen and (-webkit-min-device-pixel-ratio: 2) {
         /* Put your iPhone 4g styles in here */ 
         }
 
         /* Android targeting */
         @media only screen and (-webkit-device-pixel-ratio:.75){
         /* Put CSS for low density (ldpi) Android layouts in here */
         }
         @media only screen and (-webkit-device-pixel-ratio:1){
         /* Put CSS for medium density (mdpi) Android layouts in here */
         }
         @media only screen and (-webkit-device-pixel-ratio:1.5){
         /* Put CSS for high density (hdpi) Android layouts in here */
         }
         /* end Android targeting */
 
     </style>
 
     <!-- Targeting Windows Mobile -->
     <!--[if IEMobile 7]>
     <style type="text/css">
     
     </style>
     <![endif]-->
 
     <!--[if gte mso 9]>
         <style>
         /* Target Outlook 2007 and 2010 */
         </style>
     <![endif]-->
 </head>
 <body>
 <!-- Wrapper/Container Table: Use a wrapper table to control the width and the background color consistently of your email. Use this approach instead of setting attributes on the body tag. -->
 <table cellpadding="0" cellspacing="0" border="0" id="backgroundTable" align="left" style="margin:1%;width:97%;padding:0;font-family:sans-serif;font-weight:100;border:1px solid #dbd9da">
     <tr>
         <td valign="top" style="padding:0;"> 
             <table cellpadding="0" cellspacing="0" border="0" align="left" width="100%">
                 <tr><td style="width:100%;padding:7px;background-color:#202020" valign="top">
                     <a style="width:100%;height:100%;display:block;color:#eeeeee;text-decoration:none;" href="${instance_url}">
                         ${_('RhodeCode')}
-                        % if c.rhodecode_name:
-                            - ${c.rhodecode_name}
+                        % if rhodecode_instance_name:
+                            - ${rhodecode_instance_name}
                         % endif
                     </a>
                 </td></tr>
                 <tr><td style="padding:15px;" valign="top">${self.body()}</td></tr>
             </table>
         </td>
     </tr>
 </table>  
 <!-- End of wrapper table -->
 <p><a style="margin-top:15px;margin-left:1%;font-family:sans-serif;font-weight:100;font-size:11px;display:block;color:#666666;text-decoration:none;" href="${instance_url}">
     ${self.plaintext_footer()}
 </a></p>
 </body>
 </html>

rhodecode/tests/lib/test_mako_emails.py

@@ -1,68 +1,68 b''
 import collections
 
 import pytest
 
 from rhodecode.lib.utils import PartialRenderer
 from rhodecode.model.notification import EmailNotificationModel
 
 
 def test_get_template_obj(pylonsapp):
     template = EmailNotificationModel().get_renderer(
         EmailNotificationModel.TYPE_TEST)
     assert isinstance(template, PartialRenderer)
 
 
 def test_render_email(pylonsapp):
     kwargs = {}
     subject, headers, body, body_plaintext = EmailNotificationModel().render_email(
         EmailNotificationModel.TYPE_TEST, **kwargs)
 
     # subject
     assert subject == 'Test "Subject" hello "world"'
 
     # headers
     assert headers == 'X=Y'
 
     # body plaintext
     assert body_plaintext == 'Email Plaintext Body'
 
     # body
-    assert '<b>This is a notification ' \
-           'from RhodeCode. http://test.example.com:80/</b>' in body
-    assert '<b>Email Body' in body
+    assert 'This is a notification ' \
+           'from RhodeCode. http://test.example.com:80/' in body
+    assert 'Email Body' in body
 
 
 def test_render_pr_email(pylonsapp, user_admin):
 
     ref = collections.namedtuple('Ref',
         'name, type')(
         'fxies123', 'book'
         )
 
     pr = collections.namedtuple('PullRequest',
         'pull_request_id, title, description, source_ref_parts, source_ref_name, target_ref_parts, target_ref_name')(
         200, 'Example Pull Request', 'Desc of PR', ref, 'bookmark', ref, 'Branch')
 
     source_repo = target_repo = collections.namedtuple('Repo',
         'type, repo_name')(
         'hg', 'pull_request_1')
 
     kwargs = {
         'user': '<[e-mail]> Marcin Kuzminski',
         'pull_request': pr,
         'pull_request_commits': [],
 
         'pull_request_target_repo': target_repo,
         'pull_request_target_repo_url': 'x',
 
         'pull_request_source_repo': source_repo,
         'pull_request_source_repo_url': 'x',
 
         'pull_request_url': 'http://localhost/pr1',
     }
 
     subject, headers, body, body_plaintext = EmailNotificationModel().render_email(
         EmailNotificationModel.TYPE_PULL_REQUEST, **kwargs)
 
     # subject
     assert subject == 'Marcin Kuzminski wants you to review pull request #200: "Example Pull Request"'