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 from openerp import tools
  25
  26 from openerp.osv import osv
  27 from openerp.osv import fields
  28 from openerp.tools.safe_eval import safe_eval as eval
  29 from openerp.tools.translate import _
  30
  31 # main mako-like expression pattern
  32 EXPRESSION_PATTERN = re.compile('(\$\{.+?\})')
  33
  34
  35 class mail_compose_message(osv.TransientModel):
  36     """ Generic message composition wizard. You may inherit from this wizard
  37         at model and view levels to provide specific features.
  38
  39         The behavior of the wizard depends on the composition_mode field:
  40         - 'reply': reply to a previous message. The wizard is pre-populated
  41             via ``get_message_data``.
  42         - 'comment': new post on a record. The wizard is pre-populated via
  43             ``get_record_data``
  44         - 'mass_mail': wizard in mass mailing mode where the mail details can
  45             contain template placeholders that will be merged with actual data
  46             before being sent to each recipient.
  47     """
  48     _name = 'mail.compose.message'
  49     _inherit = 'mail.message'
  50     _description = 'Email composition wizard'
  51     _log_access = True
  52
  53     def default_get(self, cr, uid, fields, context=None):
  54         """ Handle composition mode. Some details about context keys:
  55             - comment: default mode, model and ID of a record the user comments
  56                 - default_model or active_model
  57                 - default_res_id or active_id
  58             - reply: active_id of a message the user replies to
  59                 - default_parent_id or message_id or active_id: ID of the
  60                     mail.message we reply to
  61                 - message.res_model or default_model
  62                 - message.res_id or default_res_id
  63             - mass_mail: model and IDs of records the user mass-mails
  64                 - active_ids: record IDs
  65                 - default_model or active_model
  66         """
  67         if context is None:
  68             context = {}
  69         result = super(mail_compose_message, self).default_get(cr, uid, fields, context=context)
  70
  71         # get some important values from context
  72         composition_mode = context.get('default_composition_mode', context.get('mail.compose.message.mode'))
  73         model = context.get('default_model', context.get('active_model'))
  74         res_id = context.get('default_res_id', context.get('active_id'))
  75         message_id = context.get('default_parent_id', context.get('message_id', context.get('active_id')))
  76         active_ids = context.get('active_ids')
  77
  78         # get default values according to the composition mode
  79         if composition_mode == 'reply':
  80             vals = self.get_message_data(cr, uid, message_id, context=context)
  81         elif composition_mode == 'comment' and model and res_id:
  82             vals = self.get_record_data(cr, uid, model, res_id, context=context)
  83         elif composition_mode == 'mass_mail' and model and active_ids:
  84             vals = {'model': model, 'res_id': res_id}
  85         else:
  86             vals = {'model': model, 'res_id': res_id}
  87         if composition_mode:
  88             vals['composition_mode'] = composition_mode
  89
  90         for field in vals:
  91             if field in fields:
  92                 result[field] = vals[field]
  93
  94         # TDE HACK: as mailboxes used default_model='res.users' and default_res_id=uid
  95         # (because of lack of an accessible pid), creating a message on its own
  96         # profile may crash (res_users does not allow writing on it)
  97         # Posting on its own profile works (res_users redirect to res_partner)
  98         # but when creating the mail.message to create the mail.compose.message
  99         # access rights issues may rise
 100         # We therefore directly change the model and res_id
 101         if result.get('model') == 'res.users' and result.get('res_id') == uid:
 102             result['model'] = 'res.partner'
 103             result['res_id'] = self.pool.get('res.users').browse(cr, uid, uid).partner_id.id
 104         return result
 105
 106     def _get_composition_mode_selection(self, cr, uid, context=None):
 107         return [('comment', 'Comment a document'), ('reply', 'Reply to a message'), ('mass_mail', 'Mass mailing')]
 108
 109     _columns = {
 110         'composition_mode': fields.selection(
 111             lambda s, *a, **k: s._get_composition_mode_selection(*a, **k),
 112             string='Composition mode'),
 113         'partner_ids': fields.many2many('res.partner',
 114             'mail_compose_message_res_partner_rel',
 115             'wizard_id', 'partner_id', 'Additional contacts'),
 116         'post': fields.boolean('Post a copy in the document',
 117             help='Post a copy of the message on the document communication history.'),
 118         'notify': fields.boolean('Notify followers',
 119             help='Notify followers of the document'),
 120         'same_thread': fields.boolean('Replies in the document',
 121             help='Replies to the messages will go into the selected document.'),
 122         'attachment_ids': fields.many2many('ir.attachment',
 123             'mail_compose_message_ir_attachments_rel',
 124             'wizard_id', 'attachment_id', 'Attachments'),
 125         'filter_id': fields.many2one('ir.filters', 'Filters'),
 126     }
 127
 128     _defaults = {
 129         'composition_mode': 'comment',
 130         'email_from': lambda self, cr, uid, ctx={}: self.pool.get('mail.mail')._get_default_from(cr, uid, context=ctx),
 131         'body': lambda self, cr, uid, ctx={}: '',
 132         'subject': lambda self, cr, uid, ctx={}: False,
 133         'partner_ids': lambda self, cr, uid, ctx={}: [],
 134         'notify': lambda self, cr, uid, ctx={}: False,
 135         'post': lambda self, cr, uid, ctx={}: True,
 136         'same_thread': lambda self, cr, uid, ctx={}: True,
 137     }
 138
 139     def _notify(self, cr, uid, newid, context=None):
 140         """ Override specific notify method of mail.message, because we do
 141             not want that feature in the wizard. """
 142         return
 143
 144     def get_record_data(self, cr, uid, model, res_id, context=None):
 145         """ Returns a defaults-like dict with initial values for the composition
 146             wizard when sending an email related to the document record
 147             identified by ``model`` and ``res_id``.
 148
 149             :param str model: model name of the document record this mail is
 150                 related to.
 151             :param int res_id: id of the document record this mail is related to
 152         """
 153         doc_name_get = self.pool.get(model).name_get(cr, uid, [res_id], context=context)
 154         if doc_name_get:
 155             record_name = doc_name_get[0][1]
 156         else:
 157             record_name = False
 158         return {'model': model, 'res_id': res_id, 'record_name': record_name}
 159
 160     def get_message_data(self, cr, uid, message_id, context=None):
 161         """ Returns a defaults-like dict with initial values for the composition
 162             wizard when replying to the given message (e.g. including the quote
 163             of the initial message, and the correct recipients).
 164
 165             :param int message_id: id of the mail.message to which the user
 166                 is replying.
 167         """
 168         if not message_id:
 169             return {}
 170         if context is None:
 171             context = {}
 172         message_data = self.pool.get('mail.message').browse(cr, uid, message_id, context=context)
 173
 174         # create subject
 175         re_prefix = _('Re:')
 176         reply_subject = tools.ustr(message_data.subject or '')
 177         if not (reply_subject.startswith('Re:') or reply_subject.startswith(re_prefix)) and message_data.subject:
 178             reply_subject = "%s %s" % (re_prefix, reply_subject)
 179         # get partner_ids from original message
 180         partner_ids = [partner.id for partner in message_data.partner_ids] if message_data.partner_ids else []
 181         partner_ids += context.get('default_partner_ids', [])
 182
 183         # update the result
 184         result = {
 185             'record_name': message_data.record_name,
 186             'model': message_data.model,
 187             'res_id': message_data.res_id,
 188             'parent_id': message_data.id,
 189             'subject': reply_subject,
 190             'partner_ids': partner_ids,
 191         }
 192         return result
 193
 194     #------------------------------------------------------
 195     # Wizard validation and send
 196     #------------------------------------------------------
 197
 198     def send_mail(self, cr, uid, ids, context=None):
 199         """ Process the wizard content and proceed with sending the related
 200             email(s), rendering any template patterns on the fly if needed. """
 201         if context is None:
 202             context = {}
 203         active_ids = context.get('active_ids')
 204         is_log = context.get('mail_compose_log', False)
 205
 206         for wizard in self.browse(cr, uid, ids, context=context):
 207             mass_mail_mode = wizard.composition_mode == 'mass_mail'
 208             if mass_mail_mode:  # mass mail: avoid any auto subscription because this could lead to people being follower of plenty of documents
 209                 context['mail_create_nosubscribe'] = True
 210             active_model_pool = self.pool.get(wizard.model if wizard.model else 'mail.thread')
 211
 212             # wizard works in batch mode: [res_id] or active_ids
 213             res_ids = active_ids if mass_mail_mode and wizard.model and active_ids else [wizard.res_id]
 214             for res_id in res_ids:
 215                 # default values, according to the wizard options
 216                 post_values = {
 217                     'subject': wizard.subject,
 218                     'body': wizard.body,
 219                     'parent_id': wizard.parent_id and wizard.parent_id.id,
 220                     'partner_ids': [partner.id for partner in wizard.partner_ids],
 221                     'attachments': [(attach.datas_fname or attach.name, base64.b64decode(attach.datas)) for attach in wizard.attachment_ids],
 222                 }
 223                 # mass mailing: render and override default values
 224                 if mass_mail_mode and wizard.model:
 225                     email_dict = self.render_message(cr, uid, wizard, res_id, context=context)
 226                     new_partner_ids = email_dict.pop('partner_ids', [])
 227                     post_values['partner_ids'] += new_partner_ids
 228                     new_attachments = email_dict.pop('attachments', [])
 229                     post_values['attachments'] += new_attachments
 230                     post_values.update(email_dict)
 231                     # email_from: mass mailing only can specify another email_from
 232                     if email_dict.get('email_from'):
 233                         post_values['email_from'] = email_dict.pop('email_from')
 234                     # replies redirection: mass mailing only
 235                     if not wizard.same_thread:
 236                         post_values['reply_to'] = email_dict.pop('reply_to')
 237                 # clean the context (hint: mass mailing sets some default values that
 238                 # could be wrongly interpreted by mail_mail)
 239                 context.pop('default_email_to', None)
 240                 context.pop('default_partner_ids', None)
 241                 # post the message
 242                 if mass_mail_mode and not wizard.post:
 243                     post_values['recipient_ids'] = [(4, id) for id in post_values.pop('partner_ids', [])]
 244                     self.pool.get('mail.mail').create(cr, uid, post_values, context=context)
 245                 else:
 246                     subtype = 'mail.mt_comment'
 247                     if is_log or (mass_mail_mode and not wizard.notify):
 248                         subtype = False
 249                     msg_id = active_model_pool.message_post(cr, uid, [res_id], type='comment', subtype=subtype, context=context, **post_values)
 250                     # mass_mailing, post without notify: notify specific partners
 251                     if mass_mail_mode and not wizard.notify and post_values['partner_ids']:
 252                         self.pool.get('mail.notification')._notify(cr, uid, msg_id, post_values['partner_ids'], context=context)
 253
 254         return {'type': 'ir.actions.act_window_close'}
 255
 256     def render_message(self, cr, uid, wizard, res_id, context=None):
 257         """ Generate an email from the template for given (wizard.model, res_id)
 258             pair. This method is meant to be inherited by email_template that
 259             will produce a more complete dictionary. """
 260         return {
 261             'subject': self.render_template(cr, uid, wizard.subject, wizard.model, res_id, context),
 262             'body': self.render_template(cr, uid, wizard.body, wizard.model, res_id, context),
 263             'email_from': self.render_template(cr, uid, wizard.email_from, wizard.model, res_id, context),
 264             'reply_to': self.render_template(cr, uid, wizard.reply_to, wizard.model, res_id, context),
 265         }
 266
 267     def render_template(self, cr, uid, template, model, res_id, context=None):
 268         """ Render the given template text, replace mako-like expressions ``${expr}``
 269             with the result of evaluating these expressions with an evaluation context
 270             containing:
 271
 272                 * ``user``: browse_record of the current user
 273                 * ``object``: browse_record of the document record this mail is
 274                               related to
 275                 * ``context``: the context passed to the mail composition wizard
 276
 277             :param str template: the template text to render
 278             :param str model: model name of the document record this mail is related to.
 279             :param int res_id: id of the document record this mail is related to.
 280         """
 281         if context is None:
 282             context = {}
 283
 284         def merge(match):
 285             exp = str(match.group()[2:-1]).strip()
 286             result = eval(exp, {
 287                 'user': self.pool.get('res.users').browse(cr, uid, uid, context=context),
 288                 'object': self.pool.get(model).browse(cr, uid, res_id, context=context),
 289                 'context': dict(context),  # copy context to prevent side-effects of eval
 290                 })
 291             return result and tools.ustr(result) or ''
 292         return template and EXPRESSION_PATTERN.sub(merge, template)