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