mcm-odooandThibault Delavallée
de1743ab12
RATIONALE
Mail template model holds a field telling odoo mail engine to automatically
add the current user's signature to the body. Its use depends on the use
case
* using the template in the composer on a single record: it is displayed
in the rendered template in the composer, meaning people could change it.
This behavior is interesting as it allows to see the email content;
* using the template in the composer in mass mail mode: it is not displayed
as only the raw jinja is displayed. It is therefore not obvious that it
will be appended to the body of the mail. People could add it manually and
have 2 signatures as a result;
A mechanism automatically adding a signature to sent emails when posting a
message is already implemented and is based on template existence. If a
template has been used when posting, no signature is added in sent emails.
Otherwise it is automatically added. This behavior should not change.
Behavior will therefore be
* use a template -> specify signature usage in it manually through jinja;
* do not use a template -> signature added in sent emails;
SPECIFICATIONS
Remove user_signature.
Update template body accordingly. In customer oriented templates that are using
it and do not already contain it, manually add a call to user.signature within
the jinja code. When set to False, just remove its declaration.
Quickly clean some signature integration.
LINKS
Task ID 2089252
Community PR odoo/odoo#39482
Enterprise PR odoo/enterprise#6459
Upgrade PR odoo/upgrate#761
Related: odoo/enterprise#6459
Related: odoo/upgrade#761
Signed-off-by: Thibault Delavallee (tde) <tde@openerp.com>
Co-authored-by: Michaël Mattiello <mcm@odoo.com>
Co-authored-by: Thibault Delavallée <tde@odoo.com>
468 lines
22 KiB
Python
468 lines
22 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
import babel
|
|
import base64
|
|
import copy
|
|
import datetime
|
|
import dateutil.relativedelta as relativedelta
|
|
import functools
|
|
import logging
|
|
|
|
from werkzeug import urls
|
|
|
|
from odoo import _, api, fields, models, tools
|
|
from odoo.exceptions import UserError
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
|
|
def format_date(env, date, pattern=False, lang_code=False):
|
|
try:
|
|
return tools.format_date(env, date, date_format=pattern, lang_code=lang_code)
|
|
except babel.core.UnknownLocaleError:
|
|
return date
|
|
|
|
|
|
def format_datetime(env, dt, tz=False, dt_format='medium', lang_code=False):
|
|
try:
|
|
return tools.format_datetime(env, dt, tz=tz, dt_format=dt_format, lang_code=lang_code)
|
|
except babel.core.UnknownLocaleError:
|
|
return dt
|
|
|
|
try:
|
|
# We use a jinja2 sandboxed environment to render mako templates.
|
|
# Note that the rendering does not cover all the mako syntax, in particular
|
|
# arbitrary Python statements are not accepted, and not all expressions are
|
|
# allowed: only "public" attributes (not starting with '_') of objects may
|
|
# be accessed.
|
|
# This is done on purpose: it prevents incidental or malicious execution of
|
|
# Python code that may break the security of the server.
|
|
from jinja2.sandbox import SandboxedEnvironment
|
|
mako_template_env = SandboxedEnvironment(
|
|
block_start_string="<%",
|
|
block_end_string="%>",
|
|
variable_start_string="${",
|
|
variable_end_string="}",
|
|
comment_start_string="<%doc>",
|
|
comment_end_string="</%doc>",
|
|
line_statement_prefix="%",
|
|
line_comment_prefix="##",
|
|
trim_blocks=True, # do not output newline after blocks
|
|
autoescape=True, # XML/HTML automatic escaping
|
|
)
|
|
mako_template_env.globals.update({
|
|
'str': str,
|
|
'quote': urls.url_quote,
|
|
'urlencode': urls.url_encode,
|
|
'datetime': datetime,
|
|
'len': len,
|
|
'abs': abs,
|
|
'min': min,
|
|
'max': max,
|
|
'sum': sum,
|
|
'filter': filter,
|
|
'reduce': functools.reduce,
|
|
'map': map,
|
|
'round': round,
|
|
|
|
# dateutil.relativedelta is an old-style class and cannot be directly
|
|
# instanciated wihtin a jinja2 expression, so a lambda "proxy" is
|
|
# is needed, apparently.
|
|
'relativedelta': lambda *a, **kw : relativedelta.relativedelta(*a, **kw),
|
|
})
|
|
mako_safe_template_env = copy.copy(mako_template_env)
|
|
mako_safe_template_env.autoescape = False
|
|
except ImportError:
|
|
_logger.warning("jinja2 not available, templating features will not work!")
|
|
|
|
|
|
class MailTemplate(models.Model):
|
|
"Templates for sending email"
|
|
_name = "mail.template"
|
|
_inherit = ['mail.render.mixin']
|
|
_description = 'Email Templates'
|
|
_order = 'name'
|
|
|
|
@api.model
|
|
def default_get(self, fields):
|
|
res = super(MailTemplate, self).default_get(fields)
|
|
if res.get('model'):
|
|
res['model_id'] = self.env['ir.model']._get(res.pop('model')).id
|
|
return res
|
|
|
|
name = fields.Char('Name')
|
|
model_id = fields.Many2one('ir.model', 'Applies to', help="The type of document this template can be used with")
|
|
model = fields.Char('Related Document Model', related='model_id.model', index=True, store=True, readonly=True)
|
|
lang = fields.Char('Language',
|
|
help="Optional translation language (ISO code) to select when sending out an email. "
|
|
"If not set, the english version will be used. "
|
|
"This should usually be a placeholder expression "
|
|
"that provides the appropriate language, e.g. "
|
|
"${object.partner_id.lang}.",
|
|
placeholder="${object.partner_id.lang}")
|
|
subject = fields.Char('Subject', translate=True, help="Subject (placeholders may be used here)")
|
|
email_from = fields.Char('From',
|
|
help="Sender address (placeholders may be used here). If not set, the default "
|
|
"value will be the author's email alias if configured, or email address.")
|
|
use_default_to = fields.Boolean(
|
|
'Default recipients',
|
|
help="Default recipients of the record:\n"
|
|
"- partner (using id on a partner or the partner_id field) OR\n"
|
|
"- email (using email_from or email field)")
|
|
email_to = fields.Char('To (Emails)', help="Comma-separated recipient addresses (placeholders may be used here)")
|
|
partner_to = fields.Char('To (Partners)',
|
|
help="Comma-separated ids of recipient partners (placeholders may be used here)")
|
|
email_cc = fields.Char('Cc', help="Carbon copy recipients (placeholders may be used here)")
|
|
reply_to = fields.Char('Reply-To', help="Preferred response address (placeholders may be used here)")
|
|
mail_server_id = fields.Many2one('ir.mail_server', 'Outgoing Mail Server', readonly=False,
|
|
help="Optional preferred server for outgoing mails. If not set, the highest "
|
|
"priority one will be used.")
|
|
body_html = fields.Html('Body', translate=True, sanitize=False)
|
|
report_name = fields.Char('Report Filename', translate=True,
|
|
help="Name to use for the generated report file (may contain placeholders)\n"
|
|
"The extension can be omitted and will then come from the report type.")
|
|
report_template = fields.Many2one('ir.actions.report', 'Optional report to print and attach')
|
|
ref_ir_act_window = fields.Many2one('ir.actions.act_window', 'Sidebar action', readonly=True, copy=False,
|
|
help="Sidebar action to make this template available on records "
|
|
"of the related document model")
|
|
attachment_ids = fields.Many2many('ir.attachment', 'email_template_attachment_rel', 'email_template_id',
|
|
'attachment_id', 'Attachments',
|
|
help="You may attach files to this template, to be added to all "
|
|
"emails created from this template")
|
|
auto_delete = fields.Boolean('Auto Delete', default=True, help="Permanently delete this email after sending it, to save space")
|
|
|
|
scheduled_date = fields.Char('Scheduled Date', help="If set, the queue manager will send the email after the date. If not set, the email will be send as soon as possible. Jinja2 placeholders may be used.")
|
|
|
|
@api.onchange('model_id')
|
|
def onchange_model_id(self):
|
|
# TDE CLEANME: should'nt it be a stored related ?
|
|
if self.model_id:
|
|
self.model = self.model_id.model
|
|
else:
|
|
self.model = False
|
|
|
|
def unlink(self):
|
|
self.unlink_action()
|
|
return super(MailTemplate, self).unlink()
|
|
|
|
@api.returns('self', lambda value: value.id)
|
|
def copy(self, default=None):
|
|
default = dict(default or {},
|
|
name=_("%s (copy)") % self.name)
|
|
return super(MailTemplate, self).copy(default=default)
|
|
|
|
def unlink_action(self):
|
|
for template in self:
|
|
if template.ref_ir_act_window:
|
|
template.ref_ir_act_window.unlink()
|
|
return True
|
|
|
|
def create_action(self):
|
|
ActWindow = self.env['ir.actions.act_window']
|
|
view = self.env.ref('mail.email_compose_message_wizard_form')
|
|
|
|
for template in self:
|
|
button_name = _('Send Mail (%s)') % template.name
|
|
action = ActWindow.create({
|
|
'name': button_name,
|
|
'type': 'ir.actions.act_window',
|
|
'res_model': 'mail.compose.message',
|
|
'context': "{'default_composition_mode': 'mass_mail', 'default_template_id' : %d, 'default_use_template': True}" % (template.id),
|
|
'view_mode': 'form,tree',
|
|
'view_id': view.id,
|
|
'target': 'new',
|
|
'binding_model_id': template.model_id.id,
|
|
})
|
|
template.write({'ref_ir_act_window': action.id})
|
|
|
|
return True
|
|
|
|
# ----------------------------------------
|
|
# RENDERING
|
|
# ----------------------------------------
|
|
|
|
@api.model
|
|
def render_post_process(self, html):
|
|
html = self.env['mail.thread']._replace_local_links(html)
|
|
return html
|
|
|
|
@api.model
|
|
def _render_template(self, template_txt, model, res_ids, post_process=False):
|
|
""" Render the given template text, replace mako expressions ``${expr}``
|
|
with the result of evaluating these expressions with an evaluation
|
|
context containing:
|
|
|
|
- ``user``: Model of the current user
|
|
- ``object``: record of the document record this mail is related to
|
|
- ``context``: the context passed to the mail composition wizard
|
|
|
|
:param str template_txt: the template text to render
|
|
:param str model: model name of the document record this mail is related to.
|
|
:param int res_ids: list of ids of document records those mails are related to.
|
|
"""
|
|
multi_mode = True
|
|
if isinstance(res_ids, int):
|
|
multi_mode = False
|
|
res_ids = [res_ids]
|
|
|
|
results = dict.fromkeys(res_ids, u"")
|
|
|
|
# try to load the template
|
|
try:
|
|
mako_env = mako_safe_template_env if self.env.context.get('safe') else mako_template_env
|
|
template = mako_env.from_string(tools.ustr(template_txt))
|
|
except Exception:
|
|
_logger.info("Failed to load template %r", template_txt, exc_info=True)
|
|
return multi_mode and results or results[res_ids[0]]
|
|
|
|
# prepare template variables
|
|
records = self.env[model].browse(it for it in res_ids if it) # filter to avoid browsing [None]
|
|
res_to_rec = dict.fromkeys(res_ids, None)
|
|
for record in records:
|
|
res_to_rec[record.id] = record
|
|
variables = {
|
|
'format_date': lambda date, date_format=False, lang_code=False: format_date(self.env, date, date_format, lang_code),
|
|
'format_datetime': lambda dt, tz=False, dt_format=False, lang_code=False: format_datetime(self.env, dt, tz, dt_format, lang_code),
|
|
'format_amount': lambda amount, currency, lang_code=False: tools.format_amount(self.env, amount, currency, lang_code),
|
|
'format_duration': lambda value: tools.format_duration(value),
|
|
'user': self.env.user,
|
|
'ctx': self._context, # context kw would clash with mako internals
|
|
}
|
|
for res_id, record in res_to_rec.items():
|
|
variables['object'] = record
|
|
try:
|
|
render_result = template.render(variables)
|
|
except Exception as e:
|
|
_logger.info("Failed to render template : %s" % e, exc_info=True)
|
|
raise UserError(_("Failed to render template : %s") % e)
|
|
if render_result == u"False":
|
|
render_result = u""
|
|
results[res_id] = render_result
|
|
|
|
if post_process:
|
|
for res_id, result in results.items():
|
|
results[res_id] = self.render_post_process(result)
|
|
|
|
return multi_mode and results or results[res_ids[0]]
|
|
|
|
def get_email_template(self, res_ids):
|
|
multi_mode = True
|
|
if isinstance(res_ids, int):
|
|
res_ids = [res_ids]
|
|
multi_mode = False
|
|
|
|
if res_ids is None:
|
|
res_ids = [None]
|
|
results = dict.fromkeys(res_ids, False)
|
|
|
|
if not self.ids:
|
|
return results
|
|
self.ensure_one()
|
|
|
|
if self.env.context.get('template_preview_lang'):
|
|
lang = self.env.context.get('template_preview_lang')
|
|
for res_id in res_ids:
|
|
results[res_id] = self.with_context(lang=lang)
|
|
else:
|
|
langs = self._render_template(self.lang, self.model, res_ids)
|
|
for res_id, lang in langs.items():
|
|
if lang:
|
|
template = self.with_context(lang=lang)
|
|
else:
|
|
template = self
|
|
results[res_id] = template
|
|
|
|
return multi_mode and results or results[res_ids[0]]
|
|
|
|
def generate_recipients(self, results, res_ids):
|
|
"""Generates the recipients of the template. Default values can ben generated
|
|
instead of the template values if requested by template or context.
|
|
Emails (email_to, email_cc) can be transformed into partners if requested
|
|
in the context. """
|
|
self.ensure_one()
|
|
|
|
if self.use_default_to or self._context.get('tpl_force_default_to'):
|
|
records = self.env[self.model].browse(res_ids).sudo()
|
|
default_recipients = self.env['mail.thread']._message_get_default_recipients_on_records(records)
|
|
for res_id, recipients in default_recipients.items():
|
|
results[res_id].pop('partner_to', None)
|
|
results[res_id].update(recipients)
|
|
|
|
records_company = None
|
|
if self._context.get('tpl_partners_only') and self.model and results and 'company_id' in self.env[self.model]._fields:
|
|
records = self.env[self.model].browse(results.keys()).read(['company_id'])
|
|
records_company = {rec['id']: (rec['company_id'][0] if rec['company_id'] else None) for rec in records}
|
|
|
|
for res_id, values in results.items():
|
|
partner_ids = values.get('partner_ids', list())
|
|
if self._context.get('tpl_partners_only'):
|
|
mails = tools.email_split(values.pop('email_to', '')) + tools.email_split(values.pop('email_cc', ''))
|
|
Partner = self.env['res.partner']
|
|
if records_company:
|
|
Partner = Partner.with_context(default_company_id=records_company[res_id])
|
|
for mail in mails:
|
|
partner_id = Partner.find_or_create(mail)
|
|
partner_ids.append(partner_id)
|
|
partner_to = values.pop('partner_to', '')
|
|
if partner_to:
|
|
# placeholders could generate '', 3, 2 due to some empty field values
|
|
tpl_partner_ids = [int(pid) for pid in partner_to.split(',') if pid]
|
|
partner_ids += self.env['res.partner'].sudo().browse(tpl_partner_ids).exists().ids
|
|
results[res_id]['partner_ids'] = partner_ids
|
|
return results
|
|
|
|
def generate_email(self, res_ids, fields):
|
|
"""Generates an email from the template for given the given model based on
|
|
records given by res_ids.
|
|
|
|
:param res_id: id of the record to use for rendering the template (model
|
|
is taken from template definition)
|
|
:returns: a dict containing all relevant fields for creating a new
|
|
mail.mail entry, with one extra key ``attachments``, in the
|
|
format [(report_name, data)] where data is base64 encoded.
|
|
"""
|
|
self.ensure_one()
|
|
multi_mode = True
|
|
if isinstance(res_ids, int):
|
|
res_ids = [res_ids]
|
|
multi_mode = False
|
|
|
|
res_ids_to_templates = self.get_email_template(res_ids)
|
|
|
|
# templates: res_id -> template; template -> res_ids
|
|
templates_to_res_ids = {}
|
|
for res_id, template in res_ids_to_templates.items():
|
|
templates_to_res_ids.setdefault(template, []).append(res_id)
|
|
|
|
results = dict()
|
|
for template, template_res_ids in templates_to_res_ids.items():
|
|
Template = self.env['mail.template']
|
|
# generate fields value for all res_ids linked to the current template
|
|
if template.lang:
|
|
Template = Template.with_context(lang=template._context.get('lang'))
|
|
for field in fields:
|
|
Template = Template.with_context(safe=field in {'subject'})
|
|
generated_field_values = Template._render_template(
|
|
getattr(template, field), template.model, template_res_ids,
|
|
post_process=(field == 'body_html'))
|
|
for res_id, field_value in generated_field_values.items():
|
|
results.setdefault(res_id, dict())[field] = field_value
|
|
# compute recipients
|
|
if any(field in fields for field in ['email_to', 'partner_to', 'email_cc']):
|
|
results = template.generate_recipients(results, template_res_ids)
|
|
# update values for all res_ids
|
|
for res_id in template_res_ids:
|
|
values = results[res_id]
|
|
if values.get('body_html'):
|
|
values['body'] = tools.html_sanitize(values['body_html'])
|
|
# technical settings
|
|
values.update(
|
|
mail_server_id=template.mail_server_id.id or False,
|
|
auto_delete=template.auto_delete,
|
|
model=template.model,
|
|
res_id=res_id or False,
|
|
attachment_ids=[attach.id for attach in template.attachment_ids],
|
|
)
|
|
|
|
# Add report in attachments: generate once for all template_res_ids
|
|
if template.report_template:
|
|
for res_id in template_res_ids:
|
|
attachments = []
|
|
report_name = self._render_template(template.report_name, template.model, res_id)
|
|
report = template.report_template
|
|
report_service = report.report_name
|
|
|
|
if report.report_type in ['qweb-html', 'qweb-pdf']:
|
|
result, format = report.render_qweb_pdf([res_id])
|
|
else:
|
|
res = report.render([res_id])
|
|
if not res:
|
|
raise UserError(_('Unsupported report type %s found.') % report.report_type)
|
|
result, format = res
|
|
|
|
# TODO in trunk, change return format to binary to match message_post expected format
|
|
result = base64.b64encode(result)
|
|
if not report_name:
|
|
report_name = 'report.' + report_service
|
|
ext = "." + format
|
|
if not report_name.endswith(ext):
|
|
report_name += ext
|
|
attachments.append((report_name, result))
|
|
results[res_id]['attachments'] = attachments
|
|
|
|
return multi_mode and results or results[res_ids[0]]
|
|
|
|
# ----------------------------------------
|
|
# EMAIL
|
|
# ----------------------------------------
|
|
|
|
def _send_check_access(self, res_ids):
|
|
records = self.env[self.model].browse(res_ids)
|
|
records.check_access_rights('read')
|
|
records.check_access_rule('read')
|
|
|
|
def send_mail(self, res_id, force_send=False, raise_exception=False, email_values=None, notif_layout=False):
|
|
""" Generates a new mail.mail. Template is rendered on record given by
|
|
res_id and model coming from template.
|
|
|
|
:param int res_id: id of the record to render the template
|
|
:param bool force_send: send email immediately; otherwise use the mail
|
|
queue (recommended);
|
|
:param dict email_values: update generated mail with those values to further
|
|
customize the mail;
|
|
:param str notif_layout: optional notification layout to encapsulate the
|
|
generated email;
|
|
:returns: id of the mail.mail that was created """
|
|
|
|
# Grant access to send_mail only if access to related document
|
|
self.ensure_one()
|
|
self._send_check_access([res_id])
|
|
|
|
Attachment = self.env['ir.attachment'] # TDE FIXME: should remove default_type from context
|
|
|
|
# create a mail_mail based on values, without attachments
|
|
values = self.generate_email(res_id, ['subject', 'body_html', 'email_from', 'email_to', 'partner_to', 'email_cc', 'reply_to', 'scheduled_date'])
|
|
values['recipient_ids'] = [(4, pid) for pid in values.get('partner_ids', list())]
|
|
values['attachment_ids'] = [(4, aid) for aid in values.get('attachment_ids', list())]
|
|
values.update(email_values or {})
|
|
attachment_ids = values.pop('attachment_ids', [])
|
|
attachments = values.pop('attachments', [])
|
|
# add a protection against void email_from
|
|
if 'email_from' in values and not values.get('email_from'):
|
|
values.pop('email_from')
|
|
# encapsulate body
|
|
if notif_layout and values['body_html']:
|
|
try:
|
|
template = self.env.ref(notif_layout, raise_if_not_found=True)
|
|
except ValueError:
|
|
_logger.warning('QWeb template %s not found when sending template %s. Sending without layouting.' % (notif_layout, self.name))
|
|
else:
|
|
record = self.env[self.model].browse(res_id)
|
|
template_ctx = {
|
|
'message': self.env['mail.message'].sudo().new(dict(body=values['body_html'], record_name=record.display_name)),
|
|
'model_description': self.env['ir.model']._get(record._name).display_name,
|
|
'company': 'company_id' in record and record['company_id'] or self.env.company,
|
|
'record': record,
|
|
}
|
|
body = template.render(template_ctx, engine='ir.qweb', minimal_qcontext=True)
|
|
values['body_html'] = self.env['mail.thread']._replace_local_links(body)
|
|
mail = self.env['mail.mail'].sudo().create(values)
|
|
|
|
# manage attachments
|
|
for attachment in attachments:
|
|
attachment_data = {
|
|
'name': attachment[0],
|
|
'datas': attachment[1],
|
|
'type': 'binary',
|
|
'res_model': 'mail.message',
|
|
'res_id': mail.mail_message_id.id,
|
|
}
|
|
attachment_ids.append((4, Attachment.create(attachment_data).id))
|
|
if attachment_ids:
|
|
mail.write({'attachment_ids': attachment_ids})
|
|
|
|
if force_send:
|
|
mail.send(raise_exception=raise_exception)
|
|
return mail.id # TDE CLEANME: return mail + api.returns ?
|