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         # mass mode options
 123         'notify': fields.boolean('Notify followers',
 124             help='Notify followers of the document (mass post only)'),
 125         'same_thread': fields.boolean('Replies in the document',
 126             help='Replies to the messages will go into the selected document (mass mail only)'),
 127     }
 128     #TODO change same_thread to False in trunk (Require view update)
 129     _defaults = {
 130         'composition_mode': 'comment',
 131         'body': lambda self, cr, uid, ctx={}: '',
 132         'subject': lambda self, cr, uid, ctx={}: False,
 133         'partner_ids': lambda self, cr, uid, ctx={}: [],
 134         'same_thread': True,
 135     }
 136
 137     def check_access_rule(self, cr, uid, ids, operation, context=None):
 138         """ Access rules of mail.compose.message:
 139             - create: if
 140                 - model, no res_id, I create a message in mass mail mode
 141             - then: fall back on mail.message acces rules
 142         """
 143         if isinstance(ids, (int, long)):
 144             ids = [ids]
 145
 146         # Author condition (CREATE (mass_mail))
 147         if operation == 'create' and uid != SUPERUSER_ID:
 148             # read mail_compose_message.ids to have their values
 149             message_values = {}
 150             cr.execute('SELECT DISTINCT id, model, res_id FROM "%s" WHERE id = ANY (%%s) AND res_id = 0' % self._table, (ids,))
 151             for id, rmod, rid in cr.fetchall():
 152                 message_values[id] = {'model': rmod, 'res_id': rid}
 153             # remove from the set to check the ids that mail_compose_message accepts
 154             author_ids = [mid for mid, message in message_values.iteritems()
 155                 if message.get('model') and not message.get('res_id')]
 156             ids = list(set(ids) - set(author_ids))
 157
 158         return super(mail_compose_message, self).check_access_rule(cr, uid, ids, operation, context=context)
 159
 160     def _notify(self, cr, uid, newid, context=None, force_send=False, user_signature=True):
 161         """ Override specific notify method of mail.message, because we do
 162             not want that feature in the wizard. """
 163         return
 164
 165     def get_recipients_data(self, cr, uid, values, context=None):
 166         """ Returns a string explaining the targetted recipients, to ease the use
 167         of the wizard. """
 168         composition_mode, model, res_id = values['composition_mode'], values['model'], values['res_id']
 169         if composition_mode == 'comment' and model and res_id:
 170             doc_name = self.pool[model].name_get(cr, uid, [res_id], context=context)
 171             return doc_name and 'Followers of %s' % doc_name[0][1] or False
 172         elif composition_mode == 'mass_post' and model:
 173             if 'active_domain' in context:
 174                 active_ids = self.pool[model].search(cr, uid, eval(context['active_domain']), limit=100, context=context)
 175             else:
 176                 active_ids = context.get('active_ids', list())
 177             if active_ids:
 178                 name_gets = [rec_name[1] for rec_name in self.pool[model].name_get(cr, uid, active_ids[:3], context=context)]
 179                 return 'Followers of selected documents (' + ', '.join(name_gets) + len(active_ids) > 3 and ', ...' or '' + ')'
 180         return False
 181
 182     def get_record_data(self, cr, uid, values, context=None):
 183         """ Returns a defaults-like dict with initial values for the composition
 184             wizard when sending an email related to the document record
 185             identified by ``model`` and ``res_id``.
 186
 187             :param values: dictionary of default and already computed values for the mail_compose_message_res_partner_re
 188             :type values: dict"""
 189         if context is None:
 190             context = {}
 191         model, res_id, parent_id = values.get('model'), values.get('res_id'), values.get('parent_id')
 192         record_name, subject, partner_ids = values.get('record_name'), values.get('subject'), values.get('partner_ids', list())
 193         if parent_id:
 194             message_data = self.pool.get('mail.message').browse(cr, uid, parent_id, context=context)
 195             record_name = message_data.record_name,
 196             subject = tools.ustr(message_data.subject or message_data.record_name or '')
 197             if not model:
 198                 model = message_data.model
 199             if not res_id:
 200                 res_id = message_data.res_id
 201             # get partner_ids from original message
 202             partner_ids += [partner.id for partner in message_data.partner_ids]
 203             if context.get('is_private') and message_data.author_id:  # check message is private then add author also in partner list.
 204                 partner_ids += [message_data.author_id.id]
 205         elif model and res_id:
 206             doc_name_get = self.pool[model].name_get(cr, uid, [res_id], context=context)
 207             record_name = doc_name_get and doc_name_get[0][1] or ''
 208             subject = tools.ustr(record_name)
 209
 210         # create subject
 211         re_prefix = _('Re:')
 212         if not (subject.startswith('Re:') or subject.startswith(re_prefix)):
 213             subject = "%s %s" % (re_prefix, subject)
 214
 215         return {
 216             'record_name': record_name,
 217             'subject': subject,
 218             'partner_ids': list(set(partner_ids)),
 219             'model': model,
 220             'res_id': res_id,
 221         }
 222
 223     #------------------------------------------------------
 224     # Wizard validation and send
 225     #------------------------------------------------------
 226
 227     def send_mail(self, cr, uid, ids, context=None):
 228         """ Process the wizard content and proceed with sending the related
 229             email(s), rendering any template patterns on the fly if needed. """
 230         if context is None:
 231             context = {}
 232         # import datetime
 233         # print '--> beginning sending email', datetime.datetime.now()
 234         # clean the context (hint: mass mailing sets some default values that
 235         # could be wrongly interpreted by mail_mail)
 236         context.pop('default_email_to', None)
 237         context.pop('default_partner_ids', None)
 238
 239         for wizard in self.browse(cr, uid, ids, context=context):
 240             mass_mode = wizard.composition_mode in ('mass_mail', 'mass_post')
 241             active_model_pool = self.pool[wizard.model if wizard.model else 'mail.thread']
 242             if not hasattr(active_model_pool, 'message_post'):
 243                 context['thread_model'] = wizard.model
 244                 active_model_pool = self.pool['mail.thread']
 245
 246             # wizard works in batch mode: [res_id] or active_ids or active_domain
 247             if mass_mode and wizard.use_active_domain and wizard.model:
 248                 res_ids = self.pool[wizard.model].search(cr, uid, eval(wizard.active_domain), context=context)
 249             elif mass_mode and wizard.model and context.get('active_ids'):
 250                 res_ids = context['active_ids']
 251             else:
 252                 res_ids = [wizard.res_id]
 253
 254             # print '----> before computing values', datetime.datetime.now()
 255             # print '----> after computing values', datetime.datetime.now()
 256
 257             sliced_res_ids = [res_ids[i:i + self._batch_size] for i in range(0, len(res_ids), self._batch_size)]
 258             for res_ids in sliced_res_ids:
 259                 all_mail_values = self.get_mail_values(cr, uid, wizard, res_ids, context=context)
 260                 for res_id, mail_values in all_mail_values.iteritems():
 261                     if wizard.composition_mode == 'mass_mail':
 262                         self.pool['mail.mail'].create(cr, uid, mail_values, context=context)
 263                     else:
 264                         subtype = 'mail.mt_comment'
 265                         if context.get('mail_compose_log') or (wizard.composition_mode == 'mass_post' and not wizard.notify):  # log a note: subtype is False
 266                             subtype = False
 267                         if wizard.composition_mode == 'mass_post':
 268                             context = dict(context,
 269                                            mail_notify_force_send=False,  # do not send emails directly but use the queue instead
 270                                            mail_create_nosubscribe=True)  # add context key to avoid subscribing the author
 271                         active_model_pool.message_post(cr, uid, [res_id], type='comment', subtype=subtype, context=context, **mail_values)
 272
 273         # print '--> finished sending email', datetime.datetime.now()
 274         return {'type': 'ir.actions.act_window_close'}
 275
 276     def get_mail_values(self, cr, uid, wizard, res_ids, context=None):
 277         """Generate the values that will be used by send_mail to create mail_messages
 278         or mail_mails. """
 279         results = dict.fromkeys(res_ids, False)
 280         mass_mail_mode = wizard.composition_mode == 'mass_mail'
 281
 282         # render all template-based value at once
 283         if mass_mail_mode and wizard.model:
 284             rendered_values = self.render_message_batch(cr, uid, wizard, res_ids, context=context)
 285
 286         for res_id in res_ids:
 287             # static wizard (mail.message) values
 288             mail_values = {
 289                 'subject': wizard.subject,
 290                 'body': wizard.body,
 291                 'parent_id': wizard.parent_id and wizard.parent_id.id,
 292                 'partner_ids': [partner.id for partner in wizard.partner_ids],
 293                 'attachment_ids': [attach.id for attach in wizard.attachment_ids],
 294                 'author_id': wizard.author_id.id,
 295                 'email_from': wizard.email_from,
 296                 'record_name': wizard.record_name,
 297             }
 298             # mass mailing: rendering override wizard static values
 299             if mass_mail_mode and wizard.model:
 300                 # always keep a copy, reset record name (avoid browsing records)
 301                 mail_values.update(notification=True, model=wizard.model, res_id=res_id, record_name=False)
 302                 # auto deletion of mail_mail
 303                 if 'mail_auto_delete' in context:
 304                     mail_values['auto_delete'] = context.get('mail_auto_delete')
 305                 # rendered values using template
 306                 email_dict = rendered_values[res_id]
 307                 mail_values['partner_ids'] += email_dict.pop('partner_ids', [])
 308                 if wizard.same_thread:
 309                     email_dict.pop('reply_to', None)
 310                 else:
 311                     mail_values['reply_to'] = email_dict.pop('reply_to', None)
 312                 # if not mail_values.get('reply_to'):
 313                 #     mail_values['reply_to'] = mail_values['email_from']
 314                 mail_values.update(email_dict)
 315
 316                 # process attachments: should not be encoded before being processed by message_post / mail_mail create
 317                 mail_values['attachments'] = [(name, base64.b64decode(enc_cont)) for name, enc_cont in email_dict.pop('attachments', list())]
 318                 attachment_ids = []
 319                 for attach_id in mail_values.pop('attachment_ids'):
 320                     new_attach_id = self.pool.get('ir.attachment').copy(cr, uid, attach_id, {'res_model': self._name, 'res_id': wizard.id}, context=context)
 321                     attachment_ids.append(new_attach_id)
 322                 mail_values['attachment_ids'] = self.pool['mail.thread']._message_preprocess_attachments(
 323                     cr, uid, mail_values.pop('attachments', []),
 324                     attachment_ids, 'mail.message', 0, context=context)
 325                 # mail_mail values: body -> body_html, partner_ids -> recipient_ids
 326                 mail_values['body_html'] = mail_values.get('body', '')
 327                 mail_values['recipient_ids'] = [(4, id) for id in mail_values.pop('partner_ids', [])]
 328
 329             results[res_id] = mail_values
 330         return results
 331
 332     #------------------------------------------------------
 333     # Template rendering
 334     #------------------------------------------------------
 335
 336     def render_message_batch(self, cr, uid, wizard, res_ids, context=None):
 337         """Generate template-based values of wizard, for the document records given
 338         by res_ids. This method is meant to be inherited by email_template that
 339         will produce a more complete dictionary, using Jinja2 templates.
 340
 341         Each template is generated for all res_ids, allowing to parse the template
 342         once, and render it multiple times. This is useful for mass mailing where
 343         template rendering represent a significant part of the process.
 344
 345         :param browse wizard: current mail.compose.message browse record
 346         :param list res_ids: list of record ids
 347
 348         :return dict results: for each res_id, the generated template values for
 349                               subject, body, email_from and reply_to
 350         """
 351         subjects = self.render_template_batch(cr, uid, wizard.subject, wizard.model, res_ids, context=context)
 352         bodies = self.render_template_batch(cr, uid, wizard.body, wizard.model, res_ids, context=context, post_process=True)
 353         emails_from = self.render_template_batch(cr, uid, wizard.email_from, wizard.model, res_ids, context=context)
 354         replies_to = self.render_template_batch(cr, uid, wizard.reply_to, wizard.model, res_ids, context=context)
 355
 356         results = dict.fromkeys(res_ids, False)
 357         for res_id in res_ids:
 358             results[res_id] = {
 359                 'subject': subjects[res_id],
 360                 'body': bodies[res_id],
 361                 'email_from': emails_from[res_id],
 362                 'reply_to': replies_to[res_id],
 363             }
 364         return results
 365
 366     def render_template_batch(self, cr, uid, template, model, res_ids, context=None, post_process=False):
 367         """ Render the given template text, replace mako-like expressions ``${expr}``
 368         with the result of evaluating these expressions with an evaluation context
 369         containing:
 370
 371             * ``user``: browse_record of the current user
 372             * ``object``: browse_record of the document record this mail is
 373                           related to
 374             * ``context``: the context passed to the mail composition wizard
 375
 376         :param str template: the template text to render
 377         :param str model: model name of the document record this mail is related to
 378         :param list res_ids: list of record ids
 379         """
 380         if context is None:
 381             context = {}
 382         results = dict.fromkeys(res_ids, False)
 383
 384         for res_id in res_ids:
 385             def merge(match):
 386                 exp = str(match.group()[2:-1]).strip()
 387                 result = eval(exp, {
 388                     'user': self.pool.get('res.users').browse(cr, uid, uid, context=context),
 389                     'object': self.pool[model].browse(cr, uid, res_id, context=context),
 390                     'context': dict(context),  # copy context to prevent side-effects of eval
 391                 })
 392                 return result and tools.ustr(result) or ''
 393             results[res_id] = template and EXPRESSION_PATTERN.sub(merge, template)
 394         return results
 395
 396     # Compatibility methods
 397     def render_template(self, cr, uid, template, model, res_id, context=None):
 398         return self.render_template_batch(cr, uid, template, model, [res_id], context)[res_id]
 399
 400     def render_message(self, cr, uid, wizard, res_id, context=None):
 401         return self.render_message_batch(cr, uid, wizard, [res_id], context)[res_id]