"""some hooks and views to handle notification on entity's changes
:organization: Logilab
:copyright: 2001-2009 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
:contact: http://www.logilab.fr/ -- mailto:contact@logilab.fr
"""
__docformat__ = "restructuredtext en"
from base64 import b64encode, b64decode
from itertools import repeat
from time import time
try:
from socket import gethostname
except ImportError:
def gethostname():
return 'XXX'
from logilab.common.textutils import normalize_text
from cubicweb import RegistryException
from cubicweb.common.view import EntityView, Component
from cubicweb.common.registerers import accepts_registerer
from cubicweb.common.selectors import implements
from cubicweb.common.mail import format_mail
from cubicweb.server.pool import PreCommitOperation
from cubicweb.server.hookhelper import SendMailOp
from cubicweb.server.hooksmanager import Hook
_ = unicode
class RecipientsFinder(Component):
"""this component is responsible to find recipients of a notification
by default user's with their email set are notified if any, else the default
email addresses specified in the configuration are used
"""
id = 'recipients_finder'
__registerer__ = accepts_registerer
__selectors__ = (implements('Any'),)
user_rql = ('Any X,E,A WHERE X is EUser, X in_state S, S name "activated",'
'X primary_email E, E address A')
def recipients(self):
mode = self.config['default-recipients-mode']
if mode == 'users':
# use unsafe execute else we may don't have the right to see users
# to notify...
execute = self.req.unsafe_execute
dests = [(u.get_email(), u.property_value('ui.language'))
for u in execute(self.user_rql, build_descr=True, propagate=True).entities()]
elif mode == 'default-dest-addrs':
lang = self.vreg.property_value('ui.language')
dests = zip(self.config['default-dest-addrs'], repeat(lang))
else: # mode == 'none'
dests = []
return dests
# hooks #######################################################################
class RenderAndSendNotificationView(PreCommitOperation):
"""delay rendering of notification view until precommit"""
def precommit_event(self):
if self.view.rset[0][0] in self.session.query_data('pendingeids', ()):
return # entity added and deleted in the same transaction
self.view.render_and_send(**getattr(self, 'viewargs', {}))
class StatusChangeHook(Hook):
"""notify when a workflowable entity has its state modified"""
events = ('after_add_entity',)
accepts = ('TrInfo',)
def call(self, session, entity):
if not entity.from_state: # not a transition
return
rset = entity.related('wf_info_for')
try:
view = session.vreg.select_view('notif_status_change',
session, rset, row=0)
except RegistryException:
return
comment = entity.printable_value('comment', format='text/plain')
if comment:
comment = normalize_text(comment, 80,
rest=entity.comment_format=='text/rest')
RenderAndSendNotificationView(session, view=view, viewargs={
'comment': comment, 'previous_state': entity.previous_state.name,
'current_state': entity.new_state.name})
class RelationChangeHook(Hook):
events = ('before_add_relation', 'after_add_relation',
'before_delete_relation', 'after_delete_relation')
accepts = ('Any',)
def call(self, session, fromeid, rtype, toeid):
"""if a notification view is defined for the event, send notification
email defined by the view
"""
rset = session.eid_rset(fromeid)
vid = 'notif_%s_%s' % (self.event, rtype)
try:
view = session.vreg.select_view(vid, session, rset, row=0)
except RegistryException:
return
RenderAndSendNotificationView(session, view=view)
class EntityChangeHook(Hook):
events = ('after_add_entity',
'after_update_entity')
accepts = ('Any',)
def call(self, session, entity):
"""if a notification view is defined for the event, send notification
email defined by the view
"""
rset = entity.as_rset()
vid = 'notif_%s' % self.event
try:
view = session.vreg.select_view(vid, session, rset, row=0)
except RegistryException:
return
RenderAndSendNotificationView(session, view=view)
# abstract or deactivated notification views and mixin ########################
class NotificationView(EntityView):
"""abstract view implementing the email API
all you have to do by default is :
* set id and accepts attributes to match desired events and entity types
* set a content attribute to define the content of the email (unless you
override call)
"""
accepts = ()
id = None
msgid_timestamp = True
def recipients(self):
finder = self.vreg.select_component('recipients_finder',
req=self.req, rset=self.rset)
return finder.recipients()
def subject(self):
entity = self.entity(0, 0)
subject = self.req._(self.message)
etype = entity.dc_type()
eid = entity.eid
login = self.user_login()
return self.req._('%(subject)s %(etype)s #%(eid)s (%(login)s)') % locals()
def user_login(self):
# req is actually a session (we are on the server side), and we have to
# prevent nested internal session
return self.req.actual_session().user.login
def context(self, **kwargs):
entity = self.entity(0, 0)
for key, val in kwargs.iteritems():
if val and val.strip():
kwargs[key] = self.req._(val)
kwargs.update({'user': self.user_login(),
'eid': entity.eid,
'etype': entity.dc_type(),
'url': entity.absolute_url(),
'title': entity.dc_long_title(),})
return kwargs
def cell_call(self, row, col=0, **kwargs):
self.w(self.req._(self.content) % self.context(**kwargs))
def construct_message_id(self, eid):
return construct_message_id(self.config.appid, eid, self.msgid_timestamp)
def render_and_send(self, **kwargs):
"""generate and send an email message for this view"""
self._kwargs = kwargs
recipients = self.recipients()
if not recipients:
self.info('skipping %s%s notification which has no recipients',
self.id, self.accepts)
return
if not isinstance(recipients[0], tuple):
from warnings import warn
warn('recipients should now return a list of 2-uple (email, language)',
DeprecationWarning, stacklevel=1)
lang = self.vreg.property_value('ui.language')
recipients = zip(recipients, repeat(lang))
entity = self.entity(0, 0)
# if the view is using timestamp in message ids, no way to reference
# previous email
if not self.msgid_timestamp:
refs = [self.construct_message_id(eid)
for eid in entity.notification_references(self)]
else:
refs = ()
msgid = self.construct_message_id(entity.eid)
userdata = self.req.user_data()
origlang = self.req.lang
for emailaddr, lang in recipients:
self.req.set_language(lang)
# since the same view (eg self) may be called multiple time and we
# need a fresh stream at each iteration, reset it explicitly
self.w = None
# call dispatch before subject to set .row/.col attributes on the view :/
content = self.dispatch(row=0, col=0, **kwargs)
subject = self.subject()
msg = format_mail(userdata, [emailaddr], content, subject,
config=self.config, msgid=msgid, references=refs)
self.send([emailaddr], msg)
# restore language
self.req.set_language(origlang)
def send(self, recipients, msg):
SendMailOp(self.req, recipients=recipients, msg=msg)
def construct_message_id(appid, eid, withtimestamp=True):
if withtimestamp:
addrpart = 'eid=%s×tamp=%.10f' % (eid, time())
else:
addrpart = 'eid=%s' % eid
# we don't want any equal sign nor trailing newlines
leftpart = b64encode(addrpart, '.-').rstrip().rstrip('=')
return '<%s@%s.%s>' % (leftpart, appid, gethostname())
def parse_message_id(msgid, appid):
if msgid[0] == '<':
msgid = msgid[1:]
if msgid[-1] == '>':
msgid = msgid[:-1]
try:
values, qualif = msgid.split('@')
padding = len(values) % 4
values = b64decode(str(values + '='*padding), '.-')
values = dict(v.split('=') for v in values.split('&'))
fromappid, host = qualif.split('.', 1)
except:
return None
if appid != fromappid or host != gethostname():
return None
return values
class StatusChangeMixIn(object):
id = 'notif_status_change'
msgid_timestamp = True
message = _('status changed')
content = _("""
%(user)s changed status from <%(previous_state)s> to <%(current_state)s> for entity
'%(title)s'
%(comment)s
url: %(url)s
""")
class ContentAddedMixIn(object):
"""define emailcontent view for entity types for which you want to be notified
"""
id = 'notif_after_add_entity'
msgid_timestamp = False
message = _('new')
content = """
%(title)s
%(content)s
url: %(url)s
"""
###############################################################################
# Actual notification views. #
# #
# disable them at the recipients_finder level if you don't want them #
###############################################################################
# XXX should be based on dc_title/dc_description, no?
class NormalizedTextView(ContentAddedMixIn, NotificationView):
def context(self, **kwargs):
entity = self.entity(0, 0)
content = entity.printable_value(self.content_attr, format='text/plain')
if content:
contentformat = getattr(entity, self.content_attr + '_format', 'text/rest')
content = normalize_text(content, 80, rest=contentformat=='text/rest')
return super(NormalizedTextView, self).context(content=content, **kwargs)
def subject(self):
entity = self.entity(0, 0)
return u'%s #%s (%s)' % (self.req.__('New %s' % entity.e_schema),
entity.eid, self.user_login())
class CardAddedView(NormalizedTextView):
"""get notified from new cards"""
__selectors__ = (implements('Card'),)
content_attr = 'synopsis'