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', 'comment'))
  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         if not hasattr(self.pool[result['model']], 'message_post'):
  77             result['no_auto_thread'] = True
  78
  79         # default values according to composition mode - NOTE: reply is deprecated, fall back on comment
  80         if result['composition_mode'] == 'reply':
  81             result['composition_mode'] = 'comment'
  82         vals = {}
  83         if 'active_domain' in context:  # not context.get() because we want to keep global [] domains
  84             vals['use_active_domain'] = True
  85             vals['active_domain'] = '%s' % context.get('active_domain')
  86         if result['composition_mode'] == 'comment':
  87             vals.update(self.get_record_data(cr, uid, result, context=context))
  88
  89         for field in vals:
  90             if field in fields:
  91                 result[field] = vals[field]
  92
  93         # TDE HACK: as mailboxes used default_model='res.users' and default_res_id=uid
  94         # (because of lack of an accessible pid), creating a message on its own
  95         # profile may crash (res_users does not allow writing on it)
  96         # Posting on its own profile works (res_users redirect to res_partner)
  97         # but when creating the mail.message to create the mail.compose.message
  98         # access rights issues may rise
  99         # We therefore directly change the model and res_id
 100         if result['model'] == 'res.users' and result['res_id'] == uid:
 101             result['model'] = 'res.partner'
 102             result['res_id'] = self.pool.get('res.users').browse(cr, uid, uid).partner_id.id
 103
 104         if fields is not None:
 105             [result.pop(field, None) for field in result.keys() if field not in fields]
 106         return result
 107
 108     def _get_composition_mode_selection(self, cr, uid, context=None):
 109         return [('comment', 'Post on a document'),
 110                 ('mass_mail', 'Email Mass Mailing'),
 111                 ('mass_post', 'Post on Multiple Documents')]
 112
 113     _columns = {
 114         'composition_mode': fields.selection(
 115             lambda s, *a, **k: s._get_composition_mode_selection(*a, **k),
 116             string='Composition mode'),
 117         'partner_ids': fields.many2many('res.partner',
 118             'mail_compose_message_res_partner_rel',
 119             'wizard_id', 'partner_id', 'Additional Contacts'),
 120         'use_active_domain': fields.boolean('Use active domain'),
 121         'active_domain': fields.char('Active domain', readonly=True),
 122         'attachment_ids': fields.many2many('ir.attachment',
 123             'mail_compose_message_ir_attachments_rel',
 124             'wizard_id', 'attachment_id', 'Attachments'),
 125         'is_log': fields.boolean('Log an Internal Note',
 126                                  help='Whether the message is an internal note (comment mode only)'),
 127         # mass mode options
 128         'notify': fields.boolean('Notify followers',
 129             help='Notify followers of the document (mass post only)'),
 130     }
 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     }
 137
 138     def check_access_rule(self, cr, uid, ids, operation, context=None):
 139         """ Access rules of mail.compose.message:
 140             - create: if
 141                 - model, no res_id, I create a message in mass mail mode
 142             - then: fall back on mail.message acces rules
 143         """
 144         if isinstance(ids, (int, long)):
 145             ids = [ids]
 146
 147         # Author condition (CREATE (mass_mail))
 148         if operation == 'create' and uid != SUPERUSER_ID:
 149             # read mail_compose_message.ids to have their values
 150             message_values = {}
 151             cr.execute('SELECT DISTINCT id, model, res_id FROM "%s" WHERE id = ANY (%%s) AND res_id = 0' % self._table, (ids,))
 152             for id, rmod, rid in cr.fetchall():
 153                 message_values[id] = {'model': rmod, 'res_id': rid}
 154             # remove from the set to check the ids that mail_compose_message accepts
 155             author_ids = [mid for mid, message in message_values.iteritems()
 156                 if message.get('model') and not message.get('res_id')]
 157             ids = list(set(ids) - set(author_ids))
 158
 159         return super(mail_compose_message, self).check_access_rule(cr, uid, ids, operation, context=context)
 160
 161     def _notify(self, cr, uid, newid, context=None, force_send=False, user_signature=True):
 162         """ Override specific notify method of mail.message, because we do
 163             not want that feature in the wizard. """
 164         return
 165
 166     def get_record_data(self, cr, uid, values, context=None):
 167         """ Returns a defaults-like dict with initial values for the composition
 168         wizard when sending an email related a previous email (parent_id) or
 169         a document (model, res_id). This is based on previously computed default
 170         values. """
 171         if context is None:
 172             context = {}
 173         result, subject = {}, False
 174         if values.get('parent_id'):
 175             parent = self.pool.get('mail.message').browse(cr, uid, values.get('parent_id'), context=context)
 176             result['record_name'] = parent.record_name,
 177             subject = tools.ustr(parent.subject or parent.record_name or '')
 178             if not values.get('model'):
 179                 result['model'] = parent.model
 180             if not values.get('res_id'):
 181                 result['res_id'] = parent.res_id
 182             partner_ids = values.get('partner_ids', list()) + [partner.id for partner in parent.partner_ids]
 183             if context.get('is_private') and parent.author_id:  # check message is private then add author also in partner list.
 184                 partner_ids += [parent.author_id.id]
 185             result['partner_ids'] = partner_ids
 186         elif values.get('model') and values.get('res_id'):
 187             doc_name_get = self.pool[values.get('model')].name_get(cr, uid, [values.get('res_id')], context=context)
 188             result['record_name'] = doc_name_get and doc_name_get[0][1] or ''
 189             subject = tools.ustr(result['record_name'])
 190
 191         re_prefix = _('Re:')
 192         if subject and not (subject.startswith('Re:') or subject.startswith(re_prefix)):
 193             subject = "%s %s" % (re_prefix, subject)
 194         result['subject'] = subject
 195
 196         return result
 197
 198     #------------------------------------------------------
 199     # Wizard validation and send
 200     #------------------------------------------------------
 201
 202     def send_mail(self, cr, uid, ids, context=None):
 203         """ Process the wizard content and proceed with sending the related
 204             email(s), rendering any template patterns on the fly if needed. """
 205         context = dict(context or {})
 206
 207         # clean the context (hint: mass mailing sets some default values that
 208         # could be wrongly interpreted by mail_mail)
 209         context.pop('default_email_to', None)
 210         context.pop('default_partner_ids', None)
 211
 212         for wizard in self.browse(cr, uid, ids, context=context):
 213             mass_mode = wizard.composition_mode in ('mass_mail', 'mass_post')
 214             active_model_pool = self.pool[wizard.model if wizard.model else 'mail.thread']
 215             if not hasattr(active_model_pool, 'message_post'):
 216                 context['thread_model'] = wizard.model
 217                 active_model_pool = self.pool['mail.thread']
 218
 219             # wizard works in batch mode: [res_id] or active_ids or active_domain
 220             if mass_mode and wizard.use_active_domain and wizard.model:
 221                 res_ids = self.pool[wizard.model].search(cr, uid, eval(wizard.active_domain), context=context)
 222             elif mass_mode and wizard.model and context.get('active_ids'):
 223                 res_ids = context['active_ids']
 224             else:
 225                 res_ids = [wizard.res_id]
 226
 227             batch_size = int(self.pool['ir.config_parameter'].get_param(cr, SUPERUSER_ID, 'mail.batch_size')) or self._batch_size
 228
 229             sliced_res_ids = [res_ids[i:i + batch_size] for i in range(0, len(res_ids), batch_size)]
 230             for res_ids in sliced_res_ids:
 231                 all_mail_values = self.get_mail_values(cr, uid, wizard, res_ids, context=context)
 232                 for res_id, mail_values in all_mail_values.iteritems():
 233                     if wizard.composition_mode == 'mass_mail':
 234                         self.pool['mail.mail'].create(cr, uid, mail_values, context=context)
 235                     else:
 236                         subtype = 'mail.mt_comment'
 237                         if context.get('mail_compose_log') or (wizard.composition_mode == 'mass_post' and not wizard.notify):  # log a note: subtype is False
 238                             subtype = False
 239                         if wizard.composition_mode == 'mass_post':
 240                             context = dict(context,
 241                                            mail_notify_force_send=False,  # do not send emails directly but use the queue instead
 242                                            mail_create_nosubscribe=True)  # add context key to avoid subscribing the author
 243                         active_model_pool.message_post(cr, uid, [res_id], type='comment', subtype=subtype, context=context, **mail_values)
 244
 245         return {'type': 'ir.actions.act_window_close'}
 246
 247     def get_mail_values(self, cr, uid, wizard, res_ids, context=None):
 248         """Generate the values that will be used by send_mail to create mail_messages
 249         or mail_mails. """
 250         results = dict.fromkeys(res_ids, False)
 251         rendered_values, default_recipients = {}, {}
 252         mass_mail_mode = wizard.composition_mode == 'mass_mail'
 253
 254         # render all template-based value at once
 255         if mass_mail_mode and wizard.model:
 256             rendered_values = self.render_message_batch(cr, uid, wizard, res_ids, context=context)
 257         # compute alias-based reply-to in batch
 258         reply_to_value = dict.fromkeys(res_ids, None)
 259         if mass_mail_mode and not wizard.no_auto_thread:
 260             reply_to_value = self.pool['mail.thread'].message_get_reply_to(cr, uid, res_ids, default=wizard.email_from, context=dict(context, thread_model=wizard.model))
 261
 262         for res_id in res_ids:
 263             # static wizard (mail.message) values
 264             mail_values = {
 265                 'subject': wizard.subject,
 266                 'body': wizard.body,
 267                 'parent_id': wizard.parent_id and wizard.parent_id.id,
 268                 'partner_ids': [partner.id for partner in wizard.partner_ids],
 269                 'attachment_ids': [attach.id for attach in wizard.attachment_ids],
 270                 'author_id': wizard.author_id.id,
 271                 'email_from': wizard.email_from,
 272                 'record_name': wizard.record_name,
 273                 'no_auto_thread': wizard.no_auto_thread,
 274             }
 275             # mass mailing: rendering override wizard static values
 276             if mass_mail_mode and wizard.model:
 277                 # always keep a copy, reset record name (avoid browsing records)
 278                 mail_values.update(notification=True, model=wizard.model, res_id=res_id, record_name=False)
 279                 # auto deletion of mail_mail
 280                 if 'mail_auto_delete' in context:
 281                     mail_values['auto_delete'] = context.get('mail_auto_delete')
 282                 # rendered values using template
 283                 email_dict = rendered_values[res_id]
 284                 mail_values['partner_ids'] += email_dict.pop('partner_ids', [])
 285                 mail_values.update(email_dict)
 286                 if not wizard.no_auto_thread:
 287                     mail_values.pop('reply_to')
 288                     if reply_to_value.get(res_id):
 289                         mail_values['reply_to'] = reply_to_value[res_id]
 290                 if wizard.no_auto_thread and not mail_values.get('reply_to'):
 291                     mail_values['reply_to'] = mail_values['email_from']
 292                 # mail_mail values: body -> body_html, partner_ids -> recipient_ids
 293                 mail_values['body_html'] = mail_values.get('body', '')
 294                 mail_values['recipient_ids'] = [(4, id) for id in mail_values.pop('partner_ids', [])]
 295
 296                 # process attachments: should not be encoded before being processed by message_post / mail_mail create
 297                 mail_values['attachments'] = [(name, base64.b64decode(enc_cont)) for name, enc_cont in email_dict.pop('attachments', list())]
 298                 attachment_ids = []
 299                 for attach_id in mail_values.pop('attachment_ids'):
 300                     new_attach_id = self.pool.get('ir.attachment').copy(cr, uid, attach_id, {'res_model': self._name, 'res_id': wizard.id}, context=context)
 301                     attachment_ids.append(new_attach_id)
 302                 mail_values['attachment_ids'] = self.pool['mail.thread']._message_preprocess_attachments(
 303                     cr, uid, mail_values.pop('attachments', []),
 304                     attachment_ids, 'mail.message', 0, context=context)
 305
 306             results[res_id] = mail_values
 307         return results
 308
 309     #------------------------------------------------------
 310     # Template rendering
 311     #------------------------------------------------------
 312
 313     def render_message_batch(self, cr, uid, wizard, res_ids, context=None):
 314         """Generate template-based values of wizard, for the document records given
 315         by res_ids. This method is meant to be inherited by email_template that
 316         will produce a more complete dictionary, using Jinja2 templates.
 317
 318         Each template is generated for all res_ids, allowing to parse the template
 319         once, and render it multiple times. This is useful for mass mailing where
 320         template rendering represent a significant part of the process.
 321
 322         Default recipients are also computed, based on mail_thread method
 323         message_get_default_recipients. This allows to ensure a mass mailing has
 324         always some recipients specified.
 325
 326         :param browse wizard: current mail.compose.message browse record
 327         :param list res_ids: list of record ids
 328
 329         :return dict results: for each res_id, the generated template values for
 330                               subject, body, email_from and reply_to
 331         """
 332         subjects = self.render_template_batch(cr, uid, wizard.subject, wizard.model, res_ids, context=context)
 333         bodies = self.render_template_batch(cr, uid, wizard.body, wizard.model, res_ids, context=context, post_process=True)
 334         emails_from = self.render_template_batch(cr, uid, wizard.email_from, wizard.model, res_ids, context=context)
 335         replies_to = self.render_template_batch(cr, uid, wizard.reply_to, wizard.model, res_ids, context=context)
 336
 337         ctx = dict(context, thread_model=wizard.model)
 338         default_recipients = self.pool['mail.thread'].message_get_default_recipients(cr, uid, res_ids, context=ctx)
 339
 340         results = dict.fromkeys(res_ids, False)
 341         for res_id in res_ids:
 342             results[res_id] = {
 343                 'subject': subjects[res_id],
 344                 'body': bodies[res_id],
 345                 'email_from': emails_from[res_id],
 346                 'reply_to': replies_to[res_id],
 347             }
 348             results[res_id].update(default_recipients.get(res_id, dict()))
 349         return results
 350
 351     def render_template_batch(self, cr, uid, template, model, res_ids, context=None, post_process=False):
 352         """ Render the given template text, replace mako-like expressions ``${expr}``
 353         with the result of evaluating these expressions with an evaluation context
 354         containing:
 355
 356             * ``user``: browse_record of the current user
 357             * ``object``: browse_record of the document record this mail is
 358                           related to
 359             * ``context``: the context passed to the mail composition wizard
 360
 361         :param str template: the template text to render
 362         :param str model: model name of the document record this mail is related to
 363         :param list res_ids: list of record ids
 364         """
 365         if context is None:
 366             context = {}
 367         results = dict.fromkeys(res_ids, False)
 368
 369         for res_id in res_ids:
 370             def merge(match):
 371                 exp = str(match.group()[2:-1]).strip()
 372                 result = eval(exp, {
 373                     'user': self.pool.get('res.users').browse(cr, uid, uid, context=context),
 374                     'object': self.pool[model].browse(cr, uid, res_id, context=context),
 375                     'context': dict(context),  # copy context to prevent side-effects of eval
 376                 })
 377                 return result and tools.ustr(result) or ''
 378             results[res_id] = template and EXPRESSION_PATTERN.sub(merge, template)
 379         return results
 380
 381     # Compatibility methods
 382     def render_template(self, cr, uid, template, model, res_id, context=None):
 383         return self.render_template_batch(cr, uid, template, model, [res_id], context)[res_id]
 384
 385     def render_message(self, cr, uid, wizard, res_id, context=None):
 386         return self.render_message_batch(cr, uid, wizard, [res_id], context)[res_id]