addons/mail/wizard/mail_compose_message.py

   1 # -*- coding: utf-8 -*-
   2 ##############################################################################
   3 #
   4 #    OpenERP, Open Source Management Solution
   5 #    Copyright (C) 2010-Today OpenERP SA (<http://www.openerp.com>)
   6 #
   7 #    This program is free software: you can redistribute it and/or modify
   8 #    it under the terms of the GNU General Public License as published by
   9 #    the Free Software Foundation, either version 3 of the License, or
  10 #    (at your option) any later version.
  11 #
  12 #    This program is distributed in the hope that it will be useful,
  13 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 #    GNU General Public License for more details.
  16 #
  17 #    You should have received a copy of the GNU General Public License
  18 #    along with this program.  If not, see <http://www.gnu.org/licenses/>
  19 #
  20 ##############################################################################
  21
  22 import base64
  23 import re
  24
  25 from openerp import tools
  26 from openerp import SUPERUSER_ID
  27 from openerp.osv import osv
  28 from openerp.osv import fields
  29 from openerp.tools.safe_eval import safe_eval as eval
  30 from openerp.tools.translate import _
  31
  32 # main mako-like expression pattern
  33 EXPRESSION_PATTERN = re.compile('(\$\{.+?\})')
  34
  35
  36 class mail_compose_message(osv.TransientModel):
  37     """ Generic message composition wizard. You may inherit from this wizard
  38         at model and view levels to provide specific features.
  39
  40         The behavior of the wizard depends on the composition_mode field:
  41         - 'comment': post on a record. The wizard is pre-populated via ``get_record_data``
  42         - 'mass_mail': wizard in mass mailing mode where the mail details can
  43             contain template placeholders that will be merged with actual data
  44             before being sent to each recipient.
  45     """
  46     _name = 'mail.compose.message'
  47     _inherit = 'mail.message'
  48     _description = 'Email composition wizard'
  49     _log_access = True
  50     _batch_size = 500
  51
  52     def default_get(self, cr, uid, fields, context=None):
  53         """ Handle composition mode. Some details about context keys:
  54             - comment: default mode, model and ID of a record the user comments
  55                 - default_model or active_model
  56                 - default_res_id or active_id
  57             - reply: active_id of a message the user replies to
  58                 - default_parent_id or message_id or active_id: ID of the
  59                     mail.message we reply to
  60                 - message.res_model or default_model
  61                 - message.res_id or default_res_id
  62             - mass_mail: model and IDs of records the user mass-mails
  63                 - active_ids: record IDs
  64                 - default_model or active_model
  65         """
  66         if context is None:
  67             context = {}
  68         result = super(mail_compose_message, self).default_get(cr, uid, fields, context=context)
  69
  70         # v6.1 compatibility mode
  71         result['composition_mode'] = result.get('composition_mode', context.get('mail.compose.message.mode'))
  72         result['model'] = result.get('model', context.get('active_model'))
  73         result['res_id'] = result.get('res_id', context.get('active_id'))
  74         result['parent_id'] = result.get('parent_id', context.get('message_id'))
  75
  76         # default values according to composition mode - NOTE: reply is deprecated, fall back on comment
  77         if result['composition_mode'] == 'reply':
  78             result['composition_mode'] = 'comment'
  79         vals = {}
  80         if 'active_domain' in context:  # not context.get() because we want to keep global [] domains
  81             vals['use_active_domain'] = True
  82             vals['active_domain'] = '%s' % context.get('active_domain')
  83         if result['composition_mode'] == 'comment':
  84             vals.update(self.get_record_data(cr, uid, result, context=context))
  85         result['recipients_data'] = self.get_recipients_data(cr, uid, result, context=context)
  86
  87         for field in vals:
  88             if field in fields:
  89                 result[field] = vals[field]
  90
  91         # TDE HACK: as mailboxes used default_model='res.users' and default_res_id=uid
  92         # (because of lack of an accessible pid), creating a message on its own
  93         # profile may crash (res_users does not allow writing on it)
  94         # Posting on its own profile works (res_users redirect to res_partner)
  95         # but when creating the mail.message to create the mail.compose.message
  96         # access rights issues may rise
  97         # We therefore directly change the model and res_id
  98         if result['model'] == 'res.users' and result['res_id'] == uid:
  99             result['model'] = 'res.partner'
 100             result['res_id'] = self.pool.get('res.users').browse(cr, uid, uid).partner_id.id
 101         return result
 102
 103     def _get_composition_mode_selection(self, cr, uid, context=None):
 104         return [('comment', 'Post on a document'),
 105                 ('mass_mail', 'Email Mass Mailing'),
 106                 ('mass_post', 'Post on Multiple Documents')]
 107
 108     _columns = {
 109         'composition_mode': fields.selection(
 110             lambda s, *a, **k: s._get_composition_mode_selection(*a, **k),
 111             string='Composition mode'),
 112         'partner_ids': fields.many2many('res.partner',
 113             'mail_compose_message_res_partner_rel',
 114             'wizard_id', 'partner_id', 'Additional Contacts'),
 115         'recipients_data': fields.text(string='Recipients Data',
 116             help='Helper field used in mass mailing to display a sample of recipients'),
 117         'use_active_domain': fields.boolean('Use active domain'),
 118         'active_domain': fields.char('Active domain', readonly=True),
 119         'attachment_ids': fields.many2many('ir.attachment',
 120             'mail_compose_message_ir_attachments_rel',
 121             'wizard_id', 'attachment_id', 'Attachments'),
 122         'is_log': fields.boolean('Log an Internal Note',
 123                                  help='Whether the message is an internal note (comment mode only)'),
 124         # mass mode options
 125         'notify': fields.boolean('Notify followers',
 126             help='Notify followers of the document (mass post only)'),
 127         'same_thread': fields.boolean('Replies in the document',
 128             help='Replies to the messages will go into the selected document (mass mail only)'),
 129     }
 130     #TODO change same_thread to False in trunk (Require view update)
 131     _defaults = {
 132         'composition_mode': 'comment',
 133         'body': lambda self, cr, uid, ctx={}: '',
 134         'subject': lambda self, cr, uid, ctx={}: False,
 135         'partner_ids': lambda self, cr, uid, ctx={}: [],
 136         'same_thread': True,
 137     }
 138
 139     def check_access_rule(self, cr, uid, ids, operation, context=None):
 140         """ Access rules of mail.compose.message:
 141             - create: if
 142                 - model, no res_id, I create a message in mass mail mode
 143             - then: fall back on mail.message acces rules
 144         """
 145         if isinstance(ids, (int, long)):
 146             ids = [ids]
 147
 148         # Author condition (CREATE (mass_mail))
 149         if operation == 'create' and uid != SUPERUSER_ID:
 150             # read mail_compose_message.ids to have their values
 151             message_values = {}
 152             cr.execute('SELECT DISTINCT id, model, res_id FROM "%s" WHERE id = ANY (%%s) AND res_id = 0' % self._table, (ids,))
 153             for id, rmod, rid in cr.fetchall():
 154                 message_values[id] = {'model': rmod, 'res_id': rid}
 155             # remove from the set to check the ids that mail_compose_message accepts
 156             author_ids = [mid for mid, message in message_values.iteritems()
 157                 if message.get('model') and not message.get('res_id')]
 158             ids = list(set(ids) - set(author_ids))
 159
 160         return super(mail_compose_message, self).check_access_rule(cr, uid, ids, operation, context=context)
 161
 162     def _notify(self, cr, uid, newid, context=None, force_send=False, user_signature=True):
 163         """ Override specific notify method of mail.message, because we do
 164             not want that feature in the wizard. """
 165         return
 166
 167     def get_recipients_data(self, cr, uid, values, context=None):
 168         """ Returns a string explaining the targetted recipients, to ease the use
 169         of the wizard. """
 170         composition_mode, model, res_id = values['composition_mode'], values['model'], values['res_id']
 171         if composition_mode == 'comment' and model and res_id:
 172             doc_name = self.pool[model].name_get(cr, uid, [res_id], context=context)
 173             return doc_name and 'Followers of %s' % doc_name[0][1] or False
 174         elif composition_mode == 'mass_post' and model:
 175             if 'active_domain' in context:
 176                 active_ids = self.pool[model].search(cr, uid, eval(context['active_domain']), limit=100, context=context)
 177             else:
 178                 active_ids = context.get('active_ids', list())
 179             if active_ids:
 180                 name_gets = [rec_name[1] for rec_name in self.pool[model].name_get(cr, uid, active_ids[:3], context=context)]
 181                 return 'Followers of selected documents (' + ', '.join(name_gets) + len(active_ids) > 3 and ', ...' or '' + ')'
 182         return False
 183
 184     def get_record_data(self, cr, uid, values, context=None):
 185         """ Returns a defaults-like dict with initial values for the composition
 186         wizard when sending an email related a previous email (parent_id) or
 187         a document (model, res_id). This is based on previously computed default
 188         values. """
 189         if context is None:
 190             context = {}
 191         result, subject = {}, False
 192         if values.get('parent_id'):
 193             parent = self.pool.get('mail.message').browse(cr, uid, values.get('parent_id'), context=context)
 194             result['record_name'] = parent.record_name,
 195             subject = tools.ustr(parent.subject or parent.record_name or '')
 196             if not values.get('model'):
 197                 result['model'] = parent.model
 198             if not values.get('res_id'):
 199                 result['res_id'] = parent.res_id
 200             partner_ids = values.get('partner_ids', list()) + [partner.id for partner in parent.partner_ids]
 201             if context.get('is_private') and parent.author_id:  # check message is private then add author also in partner list.
 202                 partner_ids += [parent.author_id.id]
 203             result['partner_ids'] = partner_ids
 204         elif values.get('model') and values.get('res_id'):
 205             doc_name_get = self.pool[values.get('model')].name_get(cr, uid, [values.get('res_id')], context=context)
 206             result['record_name'] = doc_name_get and doc_name_get[0][1] or ''
 207             subject = tools.ustr(result['record_name'])
 208
 209         re_prefix = _('Re:')
 210         if subject and not (subject.startswith('Re:') or subject.startswith(re_prefix)):
 211             subject = "%s %s" % (re_prefix, subject)
 212         result['subject'] = subject
 213
 214         return result
 215
 216     #------------------------------------------------------
 217     # Wizard validation and send
 218     #------------------------------------------------------
 219
 220     def send_mail(self, cr, uid, ids, context=None):
 221         """ Process the wizard content and proceed with sending the related
 222             email(s), rendering any template patterns on the fly if needed. """
 223         if context is None:
 224             context = {}
 225         # import datetime
 226         # print '--> beginning sending email', datetime.datetime.now()
 227
 228         # clean the context (hint: mass mailing sets some default values that
 229         # could be wrongly interpreted by mail_mail)
 230         context.pop('default_email_to', None)
 231         context.pop('default_partner_ids', None)
 232
 233         for wizard in self.browse(cr, uid, ids, context=context):
 234             mass_mode = wizard.composition_mode in ('mass_mail', 'mass_post')
 235             active_model_pool = self.pool[wizard.model if wizard.model else 'mail.thread']
 236             if not hasattr(active_model_pool, 'message_post'):
 237                 context['thread_model'] = wizard.model
 238                 active_model_pool = self.pool['mail.thread']
 239
 240             # wizard works in batch mode: [res_id] or active_ids or active_domain
 241             if mass_mode and wizard.use_active_domain and wizard.model:
 242                 res_ids = self.pool[wizard.model].search(cr, uid, eval(wizard.active_domain), context=context)
 243             elif mass_mode and wizard.model and context.get('active_ids'):
 244                 res_ids = context['active_ids']
 245             else:
 246                 res_ids = [wizard.res_id]
 247
 248             # print '----> before computing values', datetime.datetime.now()
 249             # print '----> after computing values', datetime.datetime.now()
 250
 251             sliced_res_ids = [res_ids[i:i + self._batch_size] for i in range(0, len(res_ids), self._batch_size)]
 252             for res_ids in sliced_res_ids:
 253                 all_mail_values = self.get_mail_values(cr, uid, wizard, res_ids, context=context)
 254                 for res_id, mail_values in all_mail_values.iteritems():
 255                     if wizard.composition_mode == 'mass_mail':
 256                         self.pool['mail.mail'].create(cr, uid, mail_values, context=context)
 257                     else:
 258                         subtype = 'mail.mt_comment'
 259                         if context.get('mail_compose_log') or (wizard.composition_mode == 'mass_post' and not wizard.notify):  # log a note: subtype is False
 260                             subtype = False
 261                         if wizard.composition_mode == 'mass_post':
 262                             context = dict(context,
 263                                            mail_notify_force_send=False,  # do not send emails directly but use the queue instead
 264                                            mail_create_nosubscribe=True)  # add context key to avoid subscribing the author
 265                         active_model_pool.message_post(cr, uid, [res_id], type='comment', subtype=subtype, context=context, **mail_values)
 266
 267         # print '--> finished sending email', datetime.datetime.now()
 268         return {'type': 'ir.actions.act_window_close'}
 269
 270     def get_mail_values(self, cr, uid, wizard, res_ids, context=None):
 271         """Generate the values that will be used by send_mail to create mail_messages
 272         or mail_mails. """
 273         results = dict.fromkeys(res_ids, False)
 274         rendered_values, default_recipients = {}, {}
 275         mass_mail_mode = wizard.composition_mode == 'mass_mail'
 276
 277         # render all template-based value at once
 278         if mass_mail_mode and wizard.model:
 279             rendered_values = self.render_message_batch(cr, uid, wizard, res_ids, context=context)
 280
 281         for res_id in res_ids:
 282             # static wizard (mail.message) values
 283             mail_values = {
 284                 'subject': wizard.subject,
 285                 'body': wizard.body,
 286                 'parent_id': wizard.parent_id and wizard.parent_id.id,
 287                 'partner_ids': [partner.id for partner in wizard.partner_ids],
 288                 'attachment_ids': [attach.id for attach in wizard.attachment_ids],
 289                 'author_id': wizard.author_id.id,
 290                 'email_from': wizard.email_from,
 291                 'record_name': wizard.record_name,
 292             }
 293             # mass mailing: rendering override wizard static values
 294             if mass_mail_mode and wizard.model:
 295                 # always keep a copy, reset record name (avoid browsing records)
 296                 mail_values.update(notification=True, model=wizard.model, res_id=res_id, record_name=False)
 297                 # auto deletion of mail_mail
 298                 if 'mail_auto_delete' in context:
 299                     mail_values['auto_delete'] = context.get('mail_auto_delete')
 300                 # rendered values using template
 301                 email_dict = rendered_values[res_id]
 302                 mail_values['partner_ids'] += email_dict.pop('partner_ids', [])
 303                 mail_values.update(email_dict)
 304                 if wizard.same_thread:
 305                     mail_values.pop('reply_to')
 306                 elif not mail_values.get('reply_to'):
 307                     mail_values['reply_to'] = mail_values['email_from']
 308                 # mail_mail values: body -> body_html, partner_ids -> recipient_ids
 309                 mail_values['body_html'] = mail_values.get('body', '')
 310                 mail_values['recipient_ids'] = [(4, id) for id in mail_values.pop('partner_ids', [])]
 311
 312                 # process attachments: should not be encoded before being processed by message_post / mail_mail create
 313                 mail_values['attachments'] = [(name, base64.b64decode(enc_cont)) for name, enc_cont in email_dict.pop('attachments', list())]
 314                 attachment_ids = []
 315                 for attach_id in mail_values.pop('attachment_ids'):
 316                     new_attach_id = self.pool.get('ir.attachment').copy(cr, uid, attach_id, {'res_model': self._name, 'res_id': wizard.id}, context=context)
 317                     attachment_ids.append(new_attach_id)
 318                 mail_values['attachment_ids'] = self.pool['mail.thread']._message_preprocess_attachments(
 319                     cr, uid, mail_values.pop('attachments', []),
 320                     attachment_ids, 'mail.message', 0, context=context)
 321
 322             results[res_id] = mail_values
 323         return results
 324
 325     #------------------------------------------------------
 326     # Template rendering
 327     #------------------------------------------------------
 328
 329     def render_message_batch(self, cr, uid, wizard, res_ids, context=None):
 330         """Generate template-based values of wizard, for the document records given
 331         by res_ids. This method is meant to be inherited by email_template that
 332         will produce a more complete dictionary, using Jinja2 templates.
 333
 334         Each template is generated for all res_ids, allowing to parse the template
 335         once, and render it multiple times. This is useful for mass mailing where
 336         template rendering represent a significant part of the process.
 337
 338         Default recipients are also computed, based on mail_thread method
 339         message_get_default_recipients. This allows to ensure a mass mailing has
 340         always some recipients specified.
 341
 342         :param browse wizard: current mail.compose.message browse record
 343         :param list res_ids: list of record ids
 344
 345         :return dict results: for each res_id, the generated template values for
 346                               subject, body, email_from and reply_to
 347         """
 348         subjects = self.render_template_batch(cr, uid, wizard.subject, wizard.model, res_ids, context=context)
 349         bodies = self.render_template_batch(cr, uid, wizard.body, wizard.model, res_ids, context=context, post_process=True)
 350         emails_from = self.render_template_batch(cr, uid, wizard.email_from, wizard.model, res_ids, context=context)
 351         replies_to = self.render_template_batch(cr, uid, wizard.reply_to, wizard.model, res_ids, context=context)
 352
 353         if wizard.model and hasattr(self.pool[wizard.model], 'message_get_default_recipients'):
 354             default_recipients = self.pool[wizard.model].message_get_default_recipients(cr, uid, res_ids, context=context)
 355         elif wizard.model:
 356             ctx = dict(context, thread_model=wizard.model)
 357             default_recipients = self.pool['mail.thread'].message_get_default_recipients(cr, uid, res_ids, context=ctx)
 358         else:
 359             default_recipients = {}
 360
 361         results = dict.fromkeys(res_ids, False)
 362         for res_id in res_ids:
 363             results[res_id] = {
 364                 'subject': subjects[res_id],
 365                 'body': bodies[res_id],
 366                 'email_from': emails_from[res_id],
 367                 'reply_to': replies_to[res_id],
 368             }
 369             results[res_id].update(default_recipients.get(res_id, dict()))
 370         return results
 371
 372     def render_template_batch(self, cr, uid, template, model, res_ids, context=None, post_process=False):
 373         """ Render the given template text, replace mako-like expressions ``${expr}``
 374         with the result of evaluating these expressions with an evaluation context
 375         containing:
 376
 377             * ``user``: browse_record of the current user
 378             * ``object``: browse_record of the document record this mail is
 379                           related to
 380             * ``context``: the context passed to the mail composition wizard
 381
 382         :param str template: the template text to render
 383         :param str model: model name of the document record this mail is related to
 384         :param list res_ids: list of record ids
 385         """
 386         if context is None:
 387             context = {}
 388         results = dict.fromkeys(res_ids, False)
 389
 390         for res_id in res_ids:
 391             def merge(match):
 392                 exp = str(match.group()[2:-1]).strip()
 393                 result = eval(exp, {
 394                     'user': self.pool.get('res.users').browse(cr, uid, uid, context=context),
 395                     'object': self.pool[model].browse(cr, uid, res_id, context=context),
 396                     'context': dict(context),  # copy context to prevent side-effects of eval
 397                 })
 398                 return result and tools.ustr(result) or ''
 399             results[res_id] = template and EXPRESSION_PATTERN.sub(merge, template)
 400         return results
 401
 402     # Compatibility methods
 403     def render_template(self, cr, uid, template, model, res_id, context=None):
 404         return self.render_template_batch(cr, uid, template, model, [res_id], context)[res_id]
 405
 406     def render_message(self, cr, uid, wizard, res_id, context=None):
 407         return self.render_message_batch(cr, uid, wizard, [res_id], context)[res_id]