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 import tools
  25
  26 from osv import osv
  27 from osv import fields
  28 from tools.safe_eval import safe_eval as eval
  29 from 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         return result
  94
  95     def _get_composition_mode_selection(self, cr, uid, context=None):
  96         return [('comment', 'Comment a document'), ('reply', 'Reply to a message'), ('mass_mail', 'Mass mailing')]
  97
  98     _columns = {
  99         'composition_mode': fields.selection(
 100             lambda s, *a, **k: s._get_composition_mode_selection(*a, **k),
 101             string='Composition mode'),
 102         'partner_ids': fields.many2many('res.partner',
 103             'mail_compose_message_res_partner_rel',
 104             'wizard_id', 'partner_id', 'Additional contacts'),
 105         'attachment_ids': fields.many2many('ir.attachment',
 106             'mail_compose_message_ir_attachments_rel',
 107             'wizard_id', 'attachment_id', 'Attachments'),
 108         'filter_id': fields.many2one('ir.filters', 'Filters'),
 109     }
 110
 111     _defaults = {
 112         'composition_mode': 'comment',
 113         'body': lambda self, cr, uid, ctx={}: '',
 114         'subject': lambda self, cr, uid, ctx={}: False,
 115         'partner_ids': lambda self, cr, uid, ctx={}: [],
 116     }
 117
 118     def _notify(self, cr, uid, newid, context=None):
 119         """ Override specific notify method of mail.message, because we do
 120             not want that feature in the wizard. """
 121         return
 122
 123     def get_record_data(self, cr, uid, model, res_id, context=None):
 124         """ Returns a defaults-like dict with initial values for the composition
 125             wizard when sending an email related to the document record
 126             identified by ``model`` and ``res_id``.
 127
 128             :param str model: model name of the document record this mail is
 129                 related to.
 130             :param int res_id: id of the document record this mail is related to
 131         """
 132         doc_name_get = self.pool.get(model).name_get(cr, uid, [res_id], context=context)
 133         if doc_name_get:
 134             record_name = doc_name_get[0][1]
 135         else:
 136             record_name = False
 137         return {'model': model, 'res_id': res_id, 'record_name': record_name}
 138
 139     def get_message_data(self, cr, uid, message_id, context=None):
 140         """ Returns a defaults-like dict with initial values for the composition
 141             wizard when replying to the given message (e.g. including the quote
 142             of the initial message, and the correct recipients).
 143
 144             :param int message_id: id of the mail.message to which the user
 145                 is replying.
 146         """
 147         if not message_id:
 148             return {}
 149         if context is None:
 150             context = {}
 151         message_data = self.pool.get('mail.message').browse(cr, uid, message_id, context=context)
 152
 153         # create subject
 154         re_prefix = _('Re:')
 155         reply_subject = tools.ustr(message_data.subject or '')
 156         if not (reply_subject.startswith('Re:') or reply_subject.startswith(re_prefix)) and message_data.subject:
 157             reply_subject = "%s %s" % (re_prefix, reply_subject)
 158         # get partner_ids from original message
 159         partner_ids = [partner.id for partner in message_data.partner_ids] if message_data.partner_ids else []
 160
 161         # update the result
 162         result = {
 163             'record_name': message_data.record_name,
 164             'model': message_data.model,
 165             'res_id': message_data.res_id,
 166             'parent_id': message_data.id,
 167             'subject': reply_subject,
 168             'partner_ids': partner_ids,
 169         }
 170         return result
 171
 172     #------------------------------------------------------
 173     # Wizard validation and send
 174     #------------------------------------------------------
 175
 176     def send_mail(self, cr, uid, ids, context=None):
 177         """ Process the wizard content and proceed with sending the related
 178             email(s), rendering any template patterns on the fly if needed. """
 179         if context is None:
 180             context = {}
 181         active_ids = context.get('active_ids')
 182
 183         for wizard in self.browse(cr, uid, ids, context=context):
 184             mass_mail_mode = wizard.composition_mode == 'mass_mail'
 185             active_model_pool = self.pool.get(wizard.model if wizard.model else 'mail.thread')
 186
 187             # wizard works in batch mode: [res_id] or active_ids
 188             res_ids = active_ids if mass_mail_mode and wizard.model and active_ids else [wizard.res_id]
 189             for res_id in res_ids:
 190                 # default values, according to the wizard options
 191                 post_values = {
 192                     'subject': wizard.subject,
 193                     'body': wizard.body,
 194                     'parent_id': wizard.parent_id and wizard.parent_id.id,
 195                     'partner_ids': [(4, partner.id) for partner in wizard.partner_ids],
 196                     'attachments': [(attach.datas_fname or attach.name, base64.b64decode(attach.datas)) for attach in wizard.attachment_ids],
 197                 }
 198                 # mass mailing: render and override default values
 199                 if mass_mail_mode and wizard.model:
 200                     email_dict = self.render_message(cr, uid, wizard, res_id, context=context)
 201                     new_partner_ids = email_dict.pop('partner_ids', [])
 202                     post_values['partner_ids'] += [(4, partner_id) for partner_id in new_partner_ids]
 203                     new_attachments = email_dict.pop('attachments', [])
 204                     post_values['attachments'] += new_attachments
 205                     post_values.update(email_dict)
 206                 # post the message
 207                 active_model_pool.message_post(cr, uid, [res_id], type='comment', subtype='mt_comment', context=context, **post_values)
 208
 209             # post process: update attachments, because id is not necessarily known when adding attachments in Chatter
 210             # self.pool.get('ir.attachment').write(cr, uid, [attach.id for attach in wizard.attachment_ids], {
 211             #     'res_id': wizard.id, 'res_model': wizard.model or False}, context=context)
 212
 213         return {'type': 'ir.actions.act_window_close'}
 214
 215     def render_message(self, cr, uid, wizard, res_id, context=None):
 216         """ Generate an email from the template for given (wizard.model, res_id)
 217             pair. This method is meant to be inherited by email_template that
 218             will produce a more complete dictionary. """
 219         return {
 220             'subject': self.render_template(cr, uid, wizard.subject, wizard.model, res_id, context),
 221             'body': self.render_template(cr, uid, wizard.body, wizard.model, res_id, context),
 222         }
 223
 224     def render_template(self, cr, uid, template, model, res_id, context=None):
 225         """ Render the given template text, replace mako-like expressions ``${expr}``
 226             with the result of evaluating these expressions with an evaluation context
 227             containing:
 228
 229                 * ``user``: browse_record of the current user
 230                 * ``object``: browse_record of the document record this mail is
 231                               related to
 232                 * ``context``: the context passed to the mail composition wizard
 233
 234             :param str template: the template text to render
 235             :param str model: model name of the document record this mail is related to.
 236             :param int res_id: id of the document record this mail is related to.
 237         """
 238         if context is None:
 239             context = {}
 240
 241         def merge(match):
 242             exp = str(match.group()[2:-1]).strip()
 243             result = eval(exp, {
 244                 'user': self.pool.get('res.users').browse(cr, uid, uid, context=context),
 245                 'object': self.pool.get(model).browse(cr, uid, res_id, context=context),
 246                 'context': dict(context), # copy context to prevent side-effects of eval
 247                 })
 248             return result and tools.ustr(result) or ''
 249         return template and EXPRESSION_PATTERN.sub(merge, template)