app/soc/logic/helper/notifications.py

   1 #!/usr/bin/python2.5
   2 #
   3 # Copyright 2008 the Melange authors.
   4 #
   5 # Licensed under the Apache License, Version 2.0 (the "License");
   6 # you may not use this file except in compliance with the License.
   7 # You may obtain a copy of the License at
   8 #
   9 #   http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 # Unless required by applicable law or agreed to in writing, software
  12 # distributed under the License is distributed on an "AS IS" BASIS,
  13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16
  17 """Helper functions for sending out notifications.
  18 """
  19
  20 __authors__ = [
  21   '"Lennard de Rijk" <ljvderijk@gmail.com>',
  22   ]
  23
  24
  25 import os
  26 import time
  27
  28 from django.template import loader
  29 from django.utils.encoding import force_unicode
  30 from django.utils.translation import ugettext
  31
  32 # We cannot import soc.logic.models notification nor user here
  33 # due to cyclic imports
  34 from soc.logic import accounts
  35 from soc.logic import dicts
  36 from soc.logic import mail_dispatcher
  37 from soc.views.helper import redirects
  38
  39 import soc.views.models as model_view
  40 import soc.logic.models as model_logic
  41
  42
  43 DEF_NEW_NOTIFICATION_MSG = ugettext(
  44     "You have received a new Notification.")
  45
  46 DEF_INVITATION_MSG_FMT = ugettext(
  47     "Invitation to become a %(role_verbose)s for %(group)s.")
  48
  49 DEF_NEW_GROUP_MSG_FMT = ugettext(
  50     "Your %(application_type)s for %(group_name)s has been accepted.")
  51
  52 DEF_NEW_REVIEW_SUBJECT_FMT = ugettext(
  53     "New %s Review on %s")
  54
  55 DEF_WELCOME_MSG_FMT = ugettext("Welcome to %(site_name)s, %(name)s,")
  56
  57 DEF_GROUP_INVITE_NOTIFICATION_TEMPLATE = 'soc/notification/messages/' \
  58     'invitation.html'
  59
  60 DEF_NEW_REVIEW_NOTIFICATION_TEMPLATE = 'soc/notification/messages/' \
  61     'new_review.html'
  62
  63 DEF_NEW_GROUP_TEMPLATE = 'soc/group/messages/accepted.html'
  64
  65
  66 def sendInviteNotification(entity):
  67   """Sends out an invite notification to the user the request is for.
  68
  69   Args:
  70     entity : A request containing the information needed to create the message
  71   """
  72
  73   # get the user the request is for
  74   properties = {'link_id': entity.link_id }
  75   to_user = model_logic.user.logic.getForFields(properties, unique=True)
  76
  77   invitation_url = "http://%(host)s%(index)s" % {
  78       'host' : os.environ['HTTP_HOST'],
  79       'index': redirects.getInviteProcessRedirect(entity, None),
  80       }
  81
  82   message_properties = {
  83       'role_verbose' : entity.role_verbose,
  84       'group': entity.scope.name,
  85       'invitation_url': invitation_url,
  86       }
  87
  88   subject = DEF_INVITATION_MSG_FMT % {
  89       'role_verbose' : entity.role_verbose,
  90       'group' : entity.scope.name
  91       }
  92
  93   template = DEF_GROUP_INVITE_NOTIFICATION_TEMPLATE
  94
  95   from_user = model_logic.user.logic.getForCurrentAccount()
  96
  97   sendNotification(to_user, from_user, message_properties, subject, template)
  98
  99
 100 def sendNewGroupNotification(entity, params):
 101   """Sends out an invite notification to the applicant of the group.
 102
 103   Args:
 104     entity : An accepted group application
 105   """
 106
 107   url = "http://%(host)s%(redirect)s" % {
 108       'redirect': redirects.getApplicantRedirect(entity,
 109       {'url_name': params['group_url_name']}),
 110       'host': os.environ['HTTP_HOST'],
 111       }
 112
 113   message_properties = {
 114       'application_type': params['name'],
 115       'group_type': params['group_name'],
 116       'group_name': entity.name,
 117       'url': url,
 118       }
 119
 120   subject = DEF_NEW_GROUP_MSG_FMT % {
 121       'application_type': params['name'],
 122       'group_name': entity.name,
 123       }
 124
 125   template = DEF_NEW_GROUP_TEMPLATE
 126
 127   for to in [entity.applicant, entity.backup_admin]:
 128     if not to:
 129       continue
 130
 131     sendNotification(to, None, message_properties, subject, template)
 132
 133
 134 def sendNewReviewNotification(to_user, review, reviewed_name, redirect_url):
 135   """Sends out a notification to alert the user of a new Review.
 136
 137   Args:
 138     to_user: The user who should receive a notification
 139     review: The review which triggers this notification
 140     reviewed_name: Name of the entity reviewed
 141     redirect_url: URL to which the follower should be sent for more information
 142   """
 143
 144   message_properties = {'redirect_url': redirect_url,
 145       'reviewer_name': review.author_name(),
 146       'reviewed_name': reviewed_name,
 147       }
 148
 149   # determine the subject
 150   review_type = 'public' if review.is_public else 'private'
 151   subject =  DEF_NEW_REVIEW_SUBJECT_FMT % (review_type, reviewed_name)
 152
 153   template = DEF_NEW_REVIEW_NOTIFICATION_TEMPLATE
 154
 155   # send the notification from the system
 156   sendNotification(to_user, None, message_properties, subject, template)
 157
 158
 159 def sendNotification(to_user, from_user, message_properties, subject, template):
 160   """Sends out a notification to the specified user.
 161
 162   Args:
 163     to_user : user to which the notification will be send
 164     from_user: user from who sends the notifications (None iff sent by site)
 165     message_properties : message properties
 166     subject : subject of notification email
 167     template : template used for generating notification
 168   """
 169
 170   if from_user:
 171     sender_name = from_user.name
 172   else:
 173     site_entity = model_logic.site.logic.getSingleton()
 174     sender_name = 'The %s Team' % (site_entity.site_name)
 175
 176   new_message_properties = {
 177       'sender_name': sender_name,
 178       'to_name': to_user.name,
 179       }
 180
 181   message_properties = dicts.merge(message_properties, new_message_properties)
 182
 183   message = loader.render_to_string(template, dictionary=message_properties)
 184
 185   fields = {
 186       'from_user': from_user,
 187       'subject': subject,
 188       'message': message,
 189       'scope': to_user,
 190       'link_id': 't%i' % (int(time.time()*100)),
 191       'scope_path': to_user.link_id
 192   }
 193
 194   # pylint: disable-msg=W0612
 195   import soc.logic.models.notification
 196   key_name = model_logic.notification.logic.getKeyNameFromFields(fields)
 197
 198   # create and put a new notification in the datastore
 199   model_logic.notification.logic.updateOrCreateFromKeyName(fields, key_name)
 200
 201
 202 def sendNewNotificationMessage(notification_entity):
 203   """Sends an email to a user about a new notification.
 204
 205     Args:
 206       notification_entity: Notification about which the message should be sent
 207   """
 208   # pylint: disable-msg=W0612
 209   import soc.views.models.notification
 210
 211   # create the url to show this notification
 212   notification_url = "http://%(host)s%(index)s" % {
 213       'host' : os.environ['HTTP_HOST'],
 214       'index': redirects.getPublicRedirect(notification_entity,
 215           model_view.notification.view.getParams())}
 216
 217   sender = mail_dispatcher.getDefaultMailSender()
 218   site_entity = model_logic.site.logic.getSingleton()
 219   site_name = site_entity.site_name
 220
 221   # get the default mail sender
 222   default_sender = mail_dispatcher.getDefaultMailSender()
 223
 224   if not default_sender:
 225     # no valid sender found, abort
 226     return
 227   else:
 228     (sender_name, sender) = default_sender
 229
 230   to = accounts.denormalizeAccount(notification_entity.scope.account).email()
 231
 232   # create the message contents
 233   messageProperties = {
 234       'to_name': notification_entity.scope.name,
 235       'sender_name': sender_name,
 236       'to': to,
 237       'sender': sender,
 238       'site_name': site_name,
 239       'subject': force_unicode(DEF_NEW_NOTIFICATION_MSG),
 240       'notification' : notification_entity,
 241       'notification_url' : notification_url
 242       }
 243
 244   # send out the message using the default new notification template
 245   mail_dispatcher.sendMailFromTemplate('soc/mail/new_notification.html',
 246                                        messageProperties)
 247
 248
 249 def sendWelcomeMessage(user_entity):
 250   """Sends out a welcome message to a user.
 251
 252     Args:
 253       user_entity: User entity which the message should be send to
 254   """
 255
 256   # get site name
 257   site_entity = model_logic.site.logic.getSingleton()
 258   site_name = site_entity.site_name
 259
 260   # get the default mail sender
 261   default_sender = mail_dispatcher.getDefaultMailSender()
 262
 263   if not default_sender:
 264     # no valid sender found, should not happen but abort anyway
 265     return
 266   else:
 267     sender_name, sender = default_sender
 268
 269   to = accounts.denormalizeAccount(user_entity.account).email()
 270
 271   # create the message contents
 272   messageProperties = {
 273       'to_name': user_entity.name,
 274       'sender_name': sender_name,
 275       'site_name': site_name,
 276       'to': to,
 277       'sender': sender,
 278       'subject': DEF_WELCOME_MSG_FMT % {
 279           'site_name': site_name,
 280           'name': user_entity.name
 281           }
 282       }
 283
 284   # send out the message using the default welcome template
 285   mail_dispatcher.sendMailFromTemplate('soc/mail/welcome.html',
 286                                        messageProperties)