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