# -*- coding: utf-8 -*-
# Part of Odoo. See LICENSE file for full copyright and licensing details.
import ast
import base64
import datetime
import logging
from odoo import _, api, fields, models, tools, Command
from odoo.exceptions import UserError, ValidationError
from odoo.osv import expression
from odoo.tools import is_html_empty
from odoo.addons.mail.tools.parser import parse_res_ids
def _reopen(self, res_id, model, context=None):
# save original model in context, because selecting the list of available
# templates requires a model in context
context = dict(context or {}, default_model=model)
return {'name': _('Compose Email'),
'type': 'ir.actions.act_window',
'view_mode': 'form',
'res_id': res_id,
'res_model': self._name,
'target': 'new',
'context': context,
}
class MailComposer(models.TransientModel):
""" Generic message composition wizard. You may inherit from this wizard
at model and view levels to provide specific features.
The behavior of the wizard depends on the composition_mode field:
- 'comment': post on a record.
- 'mass_mail': wizard in mass mailing mode where the mail details can
contain template placeholders that will be merged with actual data
before being sent to each recipient.
"""
_name = 'mail.compose.message'
_inherit = 'mail.composer.mixin'
_description = 'Email composition wizard'
_log_access = True
_batch_size = 50
@api.model
def default_get(self, fields_list):
""" Handle composition mode and contextual computation, until moving
to computed fields. Support active_model / active_id(s) as valid default
values, as this comes from standard web client usage.
Note that supporting active_ids through composer is still done, as we
may have to give a huge list of IDs that won't fit into res_ids field.
"""
# support subtype xmlid, like ``message_post``, when easier than using ``ref``
if self.env.context.get('default_subtype_xmlid'):
self = self.with_context(
default_subtype_id=self.env['ir.model.data']._xmlid_to_res_id(
self.env.context['default_subtype_xmlid']
)
)
# deprecated record context management
if 'default_res_id' in self.env.context:
raise ValueError(_("Deprecated usage of 'default_res_id', should use 'default_res_ids'."))
result = super().default_get(fields_list)
# when being in new mode, create_uid is not granted -> ACLs issue may arise
if 'create_uid' in fields_list and 'create_uid' not in result:
result['create_uid'] = self.env.uid
return {
fname: result[fname]
for fname in result if fname in fields_list
}
# content
subject = fields.Char(
'Subject',
compute='_compute_subject', readonly=False, store=True)
body = fields.Html(
'Contents',
render_engine='qweb', render_options={'post_process': True},
sanitize_style=True,
compute='_compute_body', readonly=False, store=True)
parent_id = fields.Many2one(
'mail.message', 'Parent Message', ondelete='set null')
template_id = fields.Many2one(
'mail.template', 'Use template',
domain="[('model', '=', model), '|', ('user_id','=', False), ('user_id', '=', uid)]"
)
attachment_ids = fields.Many2many(
'ir.attachment', 'mail_compose_message_ir_attachments_rel',
'wizard_id', 'attachment_id', string='Attachments',
compute='_compute_attachment_ids', readonly=False, store=True)
email_layout_xmlid = fields.Char(
'Email Notification Layout',
compute='_compute_email_layout_xmlid', readonly=False, store=True,
copy=False, compute_sudo=False)
email_add_signature = fields.Boolean(
'Add signature',
compute='_compute_email_add_signature', readonly=False, store=True)
# origin
email_from = fields.Char(
'From', compute='_compute_authorship', readonly=False, store=True, compute_sudo=False,
help="Email address of the sender. This field is set when no matching partner is found and replaces the author_id field in the chatter.")
author_id = fields.Many2one(
'res.partner', string='Author',
compute='_compute_authorship', readonly=False, store=True, compute_sudo=False,
help="Author of the message. If not set, email_from may hold an email address that did not match any partner.")
# composition
composition_mode = fields.Selection(
selection=[('comment', 'Post on a document'),
('mass_mail', 'Email Mass Mailing')],
string='Composition mode', default='comment')
composition_batch = fields.Boolean(
'Batch composition', compute='_compute_composition_batch') # more than 1 record (raw source)
model = fields.Char('Related Document Model', compute='_compute_model', readonly=False, store=True)
model_is_thread = fields.Boolean('Thread-Enabled', compute='_compute_model_is_thread')
res_ids = fields.Text('Related Document IDs', compute='_compute_res_ids', readonly=False, store=True)
res_domain = fields.Text('Active domain')
res_domain_user_id = fields.Many2one(
'res.users', string='Responsible',
help='Used as context used to evaluate composer domain')
record_alias_domain_id = fields.Many2one(
'mail.alias.domain', 'Alias Domain',
compute='_compute_record_environment', readonly=False, store=True) # useful only in monorecord comment mode
record_company_id = fields.Many2one(
'res.company', 'Company',
compute='_compute_record_environment', readonly=False, store=True) # useful only in monorecord comment mode
record_name = fields.Char(
'Record Name',
compute='_compute_record_name', readonly=False, store=True) # useful only in monorecord comment mode
# characteristics
message_type = fields.Selection([
('auto_comment', 'Automated Targeted Notification'),
('comment', 'Comment'),
('notification', 'System notification')],
'Type', required=True, default='comment',
help="Message type: email for email message, notification for system "
"message, comment for other messages such as user replies")
subtype_id = fields.Many2one(
'mail.message.subtype', 'Subtype', ondelete='set null',
compute="_compute_subtype_id", readonly=False, store=True)
subtype_is_log = fields.Boolean('Is a log', compute='_compute_subtype_is_log')
mail_activity_type_id = fields.Many2one('mail.activity.type', 'Mail Activity Type', ondelete='set null')
# destination
reply_to = fields.Char(
'Reply To', compute='_compute_reply_to', readonly=False, store=True, compute_sudo=False,
help='Reply email address. Setting the reply_to bypasses the automatic thread creation.')
reply_to_force_new = fields.Boolean(
string='Considers answers as new thread',
compute='_compute_reply_to_force_new', readonly=False, store=True,
help='Manage answers as new incoming emails instead of replies going to the same thread.')
reply_to_mode = fields.Selection([
('update', 'Store email and replies in the chatter of each record'),
('new', 'Collect replies on a specific email address')],
string='Replies', compute='_compute_reply_to_mode', inverse='_inverse_reply_to_mode',
help="Original Discussion: Answers go in the original document discussion thread. \n Another Email Address: Answers go to the email address mentioned in the tracking message-id instead of original document discussion thread. \n This has an impact on the generated message-id.")
# recipients
partner_ids = fields.Many2many(
'res.partner', 'mail_compose_message_res_partner_rel',
'wizard_id', 'partner_id', 'Additional Contacts',
compute='_compute_partner_ids', readonly=False, store=True)
# sending
auto_delete = fields.Boolean(
'Delete Emails',
compute="_compute_auto_delete", readonly=False, store=True, compute_sudo=False,
help='This option permanently removes any track of email after it\'s been sent, including from the Technical menu in the Settings, in order to preserve storage space of your Odoo database.')
auto_delete_keep_log = fields.Boolean(
'Keep Message Copy',
compute="_compute_auto_delete_keep_log", readonly=False, store=True,
help='Keep a copy of the email content if emails are removed (mass mailing only)')
force_send = fields.Boolean(
'Send mailing or notifications directly',
compute='_compute_force_send', readonly=False, store=True)
mail_server_id = fields.Many2one(
'ir.mail_server', string='Outgoing mail server',
compute='_compute_mail_server_id', readonly=False, store=True, compute_sudo=False)
scheduled_date = fields.Char(
'Scheduled Date',
compute='_compute_scheduled_date', readonly=False, store=True, compute_sudo=False,
help="In comment mode: if set, postpone notifications sending. "
"In mass mail mode: if sent, send emails after that date. "
"This date is considered as being in UTC timezone.")
use_exclusion_list = fields.Boolean('Check Exclusion List', default=True)
@api.constrains('res_ids')
def _check_res_ids(self):
""" Check res_ids is a valid list of integers (or Falsy). """
for composer in self:
composer._evaluate_res_ids()
@api.constrains('res_domain')
def _check_res_domain(self):
""" Check domain is a valid domain if set (otherwise it is considered
as a Falsy leaf. """
for composer in self:
composer._evaluate_res_domain()
@api.depends('composition_mode', 'model', 'parent_id', 'record_name',
'res_domain', 'res_ids', 'template_id')
def _compute_subject(self):
""" Computation is coming either form template, either from context.
When having a template with a value set, copy it (in batch mode) or
render it (in monorecord comment mode) on the composer. Otherwise
it comes from the parent (if set), or computed based on the generic
'_message_compute_subject' method in monorecord comment mode, or
set to False. When removing the template, reset it. """
for composer in self:
if composer.template_id:
composer._set_value_from_template('subject')
if not composer.template_id or not composer.subject:
subject = composer.parent_id.subject
if (not subject and composer.model and
composer.composition_mode == 'comment' and
not composer.composition_batch):
if composer.model_is_thread:
res_ids = composer._evaluate_res_ids()
subject = self.env[composer.model].browse(res_ids)._message_compute_subject()
else:
subject = composer.record_name
composer.subject = subject
@api.depends('composition_mode', 'model', 'res_domain', 'res_ids',
'template_id')
def _compute_body(self):
""" Computation is coming either from template, either reset. When
having a template with a value set, copy it (in batch mode) or render
it (in monorecord comment mode) on the composer. When removing the
template, reset it. """
for composer in self:
if composer.template_id:
composer._set_value_from_template('body_html', 'body')
if not composer.template_id:
composer.body = False
@api.depends('composition_mode', 'model', 'res_domain', 'res_ids', 'template_id')
def _compute_attachment_ids(self):
""" Computation is based on template and composition mode. In monorecord
comment mode, template is used to generate attachments based on both
attachment_ids of template, and reports coming from report_template_ids.
Those are generated based on the current record to display. As template
generation returns a list of tuples, new attachments are created on
the fly during the compute.
In batch or email mode, only attachment_ids from template are used on
the composer. Reports will be generated at sending time.
When template is removed, attachments are reset. """
for composer in self:
res_ids = composer._evaluate_res_ids() or [0]
if (composer.template_id.attachment_ids and
(composer.composition_mode == 'mass_mail' or composer.composition_batch)):
composer.attachment_ids = composer.template_id.attachment_ids
elif composer.template_id and composer.composition_mode == 'comment' and len(res_ids) == 1:
rendered_values = composer._generate_template_for_composer(
res_ids,
('attachment_ids', 'attachments'),
)[res_ids[0]]
attachment_ids = rendered_values.get('attachment_ids') or []
# transform attachments into attachment_ids; not attached to the
# document because this will be done further in the posting
# process, allowing to clean database if email not send
if rendered_values.get('attachments'):
attachment_ids += self.env['ir.attachment'].create([
{'name': attach_fname,
'datas': attach_datas,
'res_model': 'mail.compose.message',
'res_id': 0,
'type': 'binary', # override default_type from context, possibly meant for another model!
} for attach_fname, attach_datas in rendered_values.pop('attachments')
]).ids
if attachment_ids:
composer.attachment_ids = attachment_ids
elif not composer.template_id:
composer.attachment_ids = False
@api.depends('template_id')
def _compute_email_add_signature(self):
""" When having a template, consider it defines completely body and
do not add signature. Without template, add signature by default
in comment due to post processing for notification emails. Mailing
mode does not handle signature. """
for composer in self:
if composer.composition_mode == 'mass_mail':
composer.email_add_signature = False # not supported
else:
composer.email_add_signature = not bool(composer.template_id)
@api.depends('template_id')
def _compute_email_layout_xmlid(self):
""" Computation is coming either from template, either reset. When
having a template with a value set, set it on composer.When removing
the template, reset it. """
for composer in self:
if composer.template_id.email_layout_xmlid:
composer.email_layout_xmlid = composer.template_id.email_layout_xmlid
if not composer.template_id:
composer.email_layout_xmlid = False
@api.depends('composition_mode', 'email_from', 'model',
'res_domain', 'res_ids', 'template_id')
def _compute_authorship(self):
""" Computation is coming either from template, either from context.
When having a template with a value set, copy it (in batch mode) or
render it (in monorecord comment mode) on the composer. Otherwise
try to take current user's email. When removing the template, fallback
on default thread behavior (which is current user's email).
Author is not controllable from the template currently. We therefore
try to synchronize it with the given email_from (in rendered mode to
avoid trying to find partner based on qweb expressions), or fallback
on current user. """
Thread = self.env['mail.thread'].with_context(active_test=False)
for composer in self:
rendering_mode = composer.composition_mode == 'comment' and not composer.composition_batch
updated_author_id = None
# update email_from first as it is the main used field currently
if composer.template_id.email_from:
composer._set_value_from_template('email_from')
# switch to a template without email_from -> fallback on current user as default
elif composer.template_id:
composer.email_from = self.env.user.email_formatted
# removing template or void from -> fallback on current user as default
elif not composer.template_id or not composer.email_from:
if self.env.context.get('default_email_from'):
composer.email_from = self.env.context['default_email_from']
else:
composer.email_from = self.env.user.email_formatted
updated_author_id = self.env.user.partner_id.id
# Update author. When being in rendered mode: link with rendered
# email_from or fallback on current user if email does not match.
# When changing template in raw mode or resetting also fallback.
if composer.email_from and rendering_mode and not updated_author_id:
updated_author_id, _ = Thread._message_compute_author(
None, composer.email_from, raise_on_email=False,
)
if not updated_author_id:
updated_author_id = self.env.user.partner_id.id
if not rendering_mode or not composer.template_id:
updated_author_id = self.env.user.partner_id.id
if updated_author_id:
composer.author_id = updated_author_id
@api.depends('res_domain', 'res_ids')
def _compute_composition_batch(self):
""" Determine if batch mode is activated:
* using res_domain: always batch (even if result is singleton at a
given time, it is user and time dependent, hence batch);
* res_ids: if more than one item in the list (void and singleton are
not batch);
"""
for composer in self:
if composer.res_domain:
composer.composition_batch = True
continue
res_ids = composer._evaluate_res_ids()
composer.composition_batch = len(res_ids) > 1 if res_ids else False
@api.depends('composition_mode', 'parent_id')
def _compute_model(self):
""" Model can be set from parent or using 'active_model' context key
frequently used as the composer is most invoked from list or form
views. """
for composer in self:
if composer.parent_id and composer.composition_mode == 'comment':
composer.model = composer.parent_id.model
elif not composer.model:
composer.model = self.env.context.get('active_model')
@api.depends('model')
def _compute_model_is_thread(self):
""" Determine if model is thread enabled. """
for composer in self:
model = self.env['ir.model']._get(composer.model)
composer.model_is_thread = model.is_mail_thread
@api.depends('composition_mode', 'parent_id')
def _compute_res_ids(self):
""" Computation may come from parent in comment mode, if set. It takes
the parent message's res_id. Otherwise the composer uses the 'active_ids'
context key, unless it is too big to be stored in database. Indeed
when invoked for big mailings, 'active_ids' may be a very big list.
Support of 'active_ids' when sending is granted in order to not always
rely on 'res_ids' field. When 'active_ids' is not present, fallback
on 'active_id'. """
for composer in self.filtered(lambda composer: not composer.res_ids):
if composer.parent_id and composer.composition_mode == 'comment':
composer.res_ids = f"{[composer.parent_id.res_id]}"
else:
active_res_ids = parse_res_ids(self.env.context.get('active_ids'))
# beware, field is limited in storage, usage of active_ids in context still required
if active_res_ids and len(active_res_ids) <= 500:
composer.res_ids = f"{self.env.context['active_ids']}"
elif not active_res_ids and self.env.context.get('active_id'):
composer.res_ids = f"{[self.env.context['active_id']]}"
@api.depends('composition_mode', 'model', 'res_domain', 'res_ids')
def _compute_record_environment(self):
""" In monorecord mode, fetch record company and the linked alias domain,
easing future processing notably at post and notification sending time.
In batch mode it makes no sense to compute a single company, it will be
dynamically generated. """
toreset = self.filtered(
lambda comp: (comp.record_company_id or comp.record_alias_domain_id) and comp.composition_batch
)
if toreset:
toreset.record_alias_domain_id = False
toreset.record_company_id = False
toupdate = self.filtered(
lambda comp: not comp.composition_batch
)
for composer in toupdate:
res_ids = composer._evaluate_res_ids()
if composer.model in self.env and len(res_ids) == 1:
record = self.env[composer.model].browse(res_ids)
composer.record_company_id = record._mail_get_companies(
default=self.env.company
)[record.id]
composer.record_alias_domain_id = record._mail_get_alias_domains(
default_company=self.env.company
)[record.id]
@api.depends('composition_mode', 'model', 'parent_id', 'res_domain', 'res_ids')
def _compute_record_name(self):
""" Computation is coming either from parent message, either from the
record's display name in monorecord comment mode.
In batch mode it makes no sense to compute a single record name. In
email mode it is not used anyway. """
toreset = self.filtered(
lambda comp: comp.record_name
and (comp.composition_mode != 'comment' or comp.composition_batch)
)
if toreset:
toreset.record_name = False
toupdate = self.filtered(
lambda comp: not comp.record_name
and comp.composition_mode == 'comment'
and not comp.composition_batch
)
for composer in toupdate:
if composer.parent_id.record_name:
composer.record_name = composer.parent_id.record_name
continue
res_ids = composer._evaluate_res_ids()
if composer.model and len(res_ids) == 1:
composer.record_name = self.env[composer.model].browse(res_ids).display_name
@api.depends('composition_mode')
def _compute_subtype_id(self):
""" Computation defaults from composition mode. Subtype is not used in
mass mail mode, and is comment for comment mode. """
comment_composers = self.filtered(lambda comp: comp.composition_mode == 'comment')
if comment_composers:
comment_composers.subtype_id = self.env['ir.model.data']._xmlid_to_res_id('mail.mt_comment')
(self - comment_composers).subtype_id = False
@api.depends('subtype_id')
def _compute_subtype_is_log(self):
""" In comment mode, tells whether the subtype is a note. Subtype has
no use in email mode, and this field will be False. """
note_id = self.env['ir.model.data']._xmlid_to_res_id('mail.mt_note')
self.subtype_is_log = False
for composer in self.filtered('subtype_id'):
composer.subtype_is_log = composer.subtype_id.id == note_id
@api.depends('composition_mode', 'model', 'res_domain', 'res_ids',
'template_id')
def _compute_reply_to(self):
""" Computation is coming either from template, either reset. When
having a template with a value set, copy it (in batch mode) or render
it (in monorecord comment mode) on the composer. When removing the
template, reset it. """
for composer in self:
if composer.template_id:
composer._set_value_from_template('reply_to')
else:
composer.reply_to = False
@api.depends('model')
def _compute_reply_to_force_new(self):
""" If model does not inherit from MailThread, avoid replies to be
considered as thread updates, they will instead follow the routing
rules (alias, ...). """
self.filtered(
lambda composer: not composer.model or not composer.model_is_thread
).reply_to_force_new = True
@api.depends('reply_to_force_new')
def _compute_reply_to_mode(self):
for composer in self:
composer.reply_to_mode = 'new' if composer.reply_to_force_new else 'update'
def _inverse_reply_to_mode(self):
for composer in self:
composer.reply_to_force_new = composer.reply_to_mode == 'new'
@api.depends('composition_mode', 'model', 'parent_id', 'res_domain',
'res_ids', 'template_id')
def _compute_partner_ids(self):
""" Computation is coming either from template, either from context.
When having a template it uses its 3 fields 'email_cc', 'email_to' and
'partner_to', in monorecord comment mode. Emails are converted into
partners, creating new ones when the email does not match any existing
partner. Composer does not deal with emails but only with partners.
When having a template in other modes, no recipients are computed
as it is done at sending time. When removing the template, reset it.
When not having a template, recipients may come from the parent in
comment mode, to be sure to notify the same people. """
for composer in self:
if (composer.template_id and composer.composition_mode == 'comment'
and not composer.composition_batch):
res_ids = composer._evaluate_res_ids() or [0]
rendered_values = composer._generate_template_for_composer(
res_ids,
{'email_cc', 'email_to', 'partner_ids'},
find_or_create_partners=True,
)[res_ids[0]]
if rendered_values.get('partner_ids'):
composer.partner_ids = rendered_values['partner_ids']
elif composer.parent_id and composer.composition_mode == 'comment':
composer.partner_ids = composer.parent_id.partner_ids
elif not composer.template_id:
composer.partner_ids = False
@api.depends('composition_mode', 'template_id')
def _compute_auto_delete(self):
""" Computation is coming either from template, either from composition
mode. When having a template, its value is copied. Without template it
is True in comment mode to remove notification emails by default. In
email mode we keep emails (backward compatibility mode). """
for composer in self:
if composer.template_id:
composer.auto_delete = composer.template_id.auto_delete
else:
composer.auto_delete = composer.composition_mode == 'comment'
@api.depends('composition_mode', 'auto_delete')
def _compute_auto_delete_keep_log(self):
""" Keep logs is used only in email mode. It is used to keep the core
message when unlinking sent emails. It allows to keep the message as
a trace in the record's chatter. In other modes it has no use and
can be set to False. When auto_delete is turned off it has no usage. """
toreset = self.filtered(
lambda comp: comp.composition_mode != 'mass_mail' or
not comp.auto_delete
)
toreset.auto_delete_keep_log = False
(self - toreset).auto_delete_keep_log = True
@api.depends('composition_mode', 'model', 'res_domain', 'res_ids')
def _compute_force_send(self):
""" When being in single record mode, we force_send (post on a record
or send a single email right away). In batch mode: comment always uses
the email queue (lot of potentially different emails to craft). Mass
mailing mode depends on number of recipients and is configurable using
'mail.mail.force.send.limit' configuration parameter (default=100).
Using a domain forces the email queue usage as it depends on actual
evaluation and is generally used for big batches anyway. """
for composer in self:
if not composer.composition_batch:
composer.force_send = True
elif composer.composition_mode == 'comment' or composer.res_domain:
composer.force_send = False
else:
force_send_limit = int(self.env['ir.config_parameter'].sudo().get_param('mail.mail.force.send.limit', 100))
res_ids = composer._evaluate_res_ids()
composer.force_send = len(res_ids) <= force_send_limit
@api.depends('template_id')
def _compute_mail_server_id(self):
""" Copy value from template when updating it, if set on template. When
removing the template, reset it. """
for composer in self:
if composer.template_id.mail_server_id:
composer.mail_server_id = composer.template_id.mail_server_id
if not composer.template_id:
composer.mail_server_id = False
@api.depends('composition_mode', 'model', 'res_ids', 'template_id')
def _compute_scheduled_date(self):
""" Computation is coming either from template, either reset. When
having a template with a value set, copy it (in batch mode) or render
it (in monorecord comment mode) on the composer. When removing the
template, reset it. """
for composer in self:
if composer.template_id:
composer._set_value_from_template('scheduled_date')
if not composer.template_id:
composer.scheduled_date = False
# Overrides of mail.compose.mixin
@api.depends('template_id')
def _compute_lang(self):
""" Computation is coming either from template, either reset. When
having a template with a value set, copy it (in batch mode) or render
it (in monorecord comment mode) on the composer. When removing the
template, reset it. """
for composer in self:
if composer.template_id:
composer._set_value_from_template('lang')
if not composer.template_id:
composer.lang = False
# Overrides of mail.render.mixin
@api.depends('model')
def _compute_render_model(self):
for composer in self:
composer.render_model = composer.model
def _compute_can_edit_body(self):
"""Can edit the body if we are not in "mass_mail" mode because the template is
rendered before it's modified.
"""
non_mass_mail = self.filtered(lambda m: m.composition_mode != 'mass_mail')
non_mass_mail.can_edit_body = True
super(MailComposer, self - non_mass_mail)._compute_can_edit_body()
def _compute_field_value(self, field):
if field.compute_sudo:
return super(MailComposer, self.with_context(prefetch_fields=False))._compute_field_value(field)
return super()._compute_field_value(field)
# ------------------------------------------------------------
# CRUD / ORM
# ------------------------------------------------------------
@api.autovacuum
def _gc_lost_attachments(self):
""" Garbage collect lost mail attachments. Those are attachments
- linked to res_model 'mail.compose.message', the composer wizard
- with res_id 0, because they were created outside of an existing
wizard (typically user input through Chatter or reports
created on-the-fly by the templates)
- unused since at least one day (create_date and write_date)
"""
limit_date = fields.Datetime.subtract(fields.Datetime.now(), days=1)
self.env['ir.attachment'].search([
('res_model', '=', self._name),
('res_id', '=', 0),
('create_date', '<', limit_date),
('write_date', '<', limit_date)]
).unlink()
# ------------------------------------------------------------
# ACTIONS
# ------------------------------------------------------------
def action_send_mail(self):
""" Used for action button that do not accept arguments. """
self._action_send_mail(auto_commit=False)
return {'type': 'ir.actions.act_window_close'}
def _action_send_mail(self, auto_commit=False):
""" Process the wizard content and proceed with sending the related
email(s), rendering any template patterns on the fly if needed.
:return tuple: (
result_mails_su: in mass mode, sent emails (as sudo),
result_messages: in comment mode, posted messages
)
"""
result_mails_su, result_messages = self.env['mail.mail'].sudo(), self.env['mail.message']
for wizard in self:
if wizard.res_domain:
search_domain = wizard._evaluate_res_domain()
res_ids = self.env[wizard.model].search(search_domain).ids
else:
res_ids = wizard._evaluate_res_ids()
# in comment mode: raise here as anyway message_post will raise.
if not res_ids and wizard.composition_mode == 'comment':
raise ValueError(
_('Mail composer in comment mode should run on at least one record. No records found (model %(model_name)s).',
model_name=wizard.model)
)
if wizard.composition_mode == 'mass_mail':
result_mails_su += wizard._action_send_mail_mass_mail(res_ids, auto_commit=auto_commit)
else:
result_messages += wizard._action_send_mail_comment(res_ids)
return result_mails_su, result_messages
def _action_send_mail_comment(self, res_ids):
""" Send in comment mode. It calls message_post on model, or the generic
implementation of it if not available (as message_notify). """
self.ensure_one()
post_values_all = self._prepare_mail_values(res_ids)
ActiveModel = self.env[self.model] if self.model and hasattr(self.env[self.model], 'message_post') else self.env['mail.thread']
if self.composition_batch:
# add context key to avoid subscribing the author
ActiveModel = ActiveModel.with_context(
mail_create_nosubscribe=True,
)
messages = self.env['mail.message']
for res_id, post_values in post_values_all.items():
if ActiveModel._name == 'mail.thread':
post_values.pop('message_type') # forced to user_notification
post_values.pop('parent_id', False) # not supported in notify
if self.model:
post_values['model'] = self.model
post_values['res_id'] = res_id
message = ActiveModel.message_notify(**post_values)
if not message:
# if message_notify returns an empty record set, no recipients where found.
raise UserError(_("No recipient found."))
messages += message
else:
messages += ActiveModel.browse(res_id).message_post(**post_values)
return messages
def _action_send_mail_mass_mail(self, res_ids, auto_commit=False):
""" Send in mass mail mode. Mails are sudo-ed, as when going through
_prepare_mail_values standard access rights on related records will be
checked when browsing them to compute mail values. If people have
access to the records they have rights to create lots of emails in
sudo as it is considered as a technical model. """
mails_sudo = self.env['mail.mail'].sudo()
batch_size = int(
self.env['ir.config_parameter'].sudo().get_param('mail.batch_size')
) or self._batch_size or 50 # be sure to not have 0, as otherwise no iteration is done
for res_ids_iter in tools.split_every(batch_size, res_ids):
res_ids_values = list(self._prepare_mail_values(res_ids_iter).values())
iter_mails_sudo = self.env['mail.mail'].sudo().create(res_ids_values)
mails_sudo += iter_mails_sudo
records = self.env[self.model].browse(res_ids_iter) if self.model and hasattr(self.env[self.model], 'message_post') else False
if records:
records._message_mail_after_hook(iter_mails_sudo)
if self.force_send:
# as 'send' does not filter out scheduled mails (only 'process_email_queue'
# does) we need to do it manually
iter_mails_sudo_tosend = iter_mails_sudo.filtered(
lambda mail: (
not mail.scheduled_date or
mail.scheduled_date <= datetime.datetime.utcnow()
)
)
if iter_mails_sudo_tosend:
iter_mails_sudo_tosend.send(auto_commit=auto_commit)
continue
# sending emails will commit and invalidate cache; in case we do not force
# send better void the cache and commit what is already generated to avoid
# running several times on same records in case of issue
if auto_commit is True:
self._cr.commit()
self.env.invalidate_all()
return mails_sudo
def open_template_creation_wizard(self):
""" hit save as template button: opens a wizard that prompts for the template's subject.
`create_mail_template` is called when saving the new wizard. """
self.ensure_one()
saved_subject = self.subject
self.subject = False
return {
'type': 'ir.actions.act_window',
'view_mode': 'form',
'view_id': self.env.ref('mail.mail_compose_message_view_form_template_save').id,
'name': _('Create a new Mail Template'),
'res_model': 'mail.compose.message',
'context': {'dialog_size': 'medium', 'mail_composer_saved_subject': saved_subject},
'target': 'new',
'res_id': self.id,
}
def create_mail_template(self):
""" creates a mail template with the current mail composer's fields """
self.ensure_one()
if not self.model or not self.model in self.env:
raise UserError(_('Template creation from composer requires a valid model.'))
model_id = self.env['ir.model']._get_id(self.model)
values = {
'name': self.subject,
'subject': self.subject,
'body_html': self.body,
'model_id': model_id,
'use_default_to': True,
'user_id': self.env.uid,
}
template = self.env['mail.template'].create(values)
if self.attachment_ids:
attachments = self.env['ir.attachment'].sudo().browse(self.attachment_ids.ids).filtered(
lambda a: a.res_model == 'mail.compose.message' and a.create_uid.id == self._uid)
if attachments:
attachments.write({'res_model': template._name, 'res_id': template.id})
template.attachment_ids = self.attachment_ids
# generate the saved template
self.write({'template_id': template.id})
return _reopen(self, self.id, self.model, context={**self.env.context, 'dialog_size': 'large'})
def cancel_save_template(self):
""" Restore old subject when canceling the 'save as template' action
as it was erased to let user give a more custom input. """
self.ensure_one()
self.subject = self.env.context.get('mail_composer_saved_subject')
return _reopen(self, self.id, self.model, context={**self.env.context, 'dialog_size': 'large'})
# ------------------------------------------------------------
# RENDERING / VALUES GENERATION
# ------------------------------------------------------------
def _prepare_mail_values(self, res_ids):
"""Generate the values that will be used by send_mail to create either
mail_messages or mail_mails depending on composition mode.
Some summarized information on generation: mail versus message fields
(or both), and static (never rendered) versus dynamic (raw or rendered).
MAIL
STA - 'auto_delete',
DYN - 'body_html',
STA - 'force_send', (notify parameter)
STA - 'model',
DYN - 'recipient_ids', (from partner_ids)
DYN - 'res_id',
STA - 'is_notification',
MESSAGE
DYN - 'body',
STA - 'email_add_signature',
STA - 'email_layout_xmlid',
DYN - 'force_email_lang', # notify parameter
STA - 'record_alias_domain_id', # monorecord only
STA - 'record_company_id', # monorecord only
BOTH
DYN - 'attachment_ids',
STA - 'author_id', (to improve with template)
DYN - 'email_from',
STA - 'mail_activity_type_id',
STA - 'mail_server_id',
STA - 'message_type',
STA - 'parent_id',
DYN - 'partner_ids',
STA - 'record_name',
DYN - 'reply_to',
STA - 'reply_to_force_new',
DYN - 'scheduled_date',
DYN - 'subject',
STA - 'subtype_id',
:param list res_ids: list of record IDs on which composer runs;
:return dict: for each res_id, values to create the mail.mail or to
give to message_post, depending on composition mode;
"""
self.ensure_one()
email_mode = self.composition_mode == 'mass_mail'
rendering_mode = email_mode or self.composition_batch
# values that do not depend on rendering mode
base_values = self._prepare_mail_values_static()
additional_values_all = {}
# rendered based on raw content (wizard or template)
if rendering_mode and self.model:
additional_values_all = self._prepare_mail_values_dynamic(res_ids)
# wizard content already rendered
elif not rendering_mode:
additional_values_all = self._prepare_mail_values_rendered(res_ids)
mail_values_all = {
res_id: dict(
base_values,
**additional_values_all.get(res_id, {})
)
for res_id in res_ids
}
if email_mode:
mail_values_all = self._process_mail_values_state(mail_values_all)
# based on previous values, compute message ID / references
for res_id, mail_values in mail_values_all.items():
# generate message_id directly; instead of letting mail_message create
# method doing it. Then use it to craft references, allowing to keep
# a trace of message_id even when email providers override it.
# Note that if 'auto_delete' is set and if 'auto_delete_keep_log' is False,
# mail.message is removed and parent finding based on messageID
# may be broken, tough life
message_id = self.env['mail.message']._get_message_id(mail_values)
mail_values['message_id'] = message_id
mail_values['references'] = message_id
return mail_values_all
def _prepare_mail_values_static(self):
"""Prepare values always valid, not rendered or dynamic whatever the
composition mode and related records.
:return dict: a dict of (field name, value) to be used to populate
values for each res_id in '_prepare_mail_values';
"""
self.ensure_one()
email_mode = self.composition_mode == 'mass_mail'
if email_mode:
subtype_id = False
elif self.subtype_id:
subtype_id = self.subtype_id.id
else:
subtype_id = self.env['ir.model.data']._xmlid_to_res_id('mail.mt_comment')
values = {
'author_id': self.author_id.id,
'mail_activity_type_id': self.mail_activity_type_id.id,
'mail_server_id': self.mail_server_id.id,
'message_type': 'email_outgoing' if email_mode else self.message_type,
'parent_id': self.parent_id.id,
'record_name': False if email_mode else self.record_name,
'reply_to_force_new': self.reply_to_force_new,
'subtype_id': subtype_id,
}
# specific to mass mailing mode
if email_mode:
values.update(
auto_delete=self.auto_delete,
is_notification=self.auto_delete_keep_log,
model=self.model,
)
# specific to post mode
else:
# Several custom layouts make use of the model description at rendering, e.g. in the
# 'View <document>' button. Some models are used for different business concepts, such as
# 'purchase.order' which is used for a RFQ and and PO. To avoid confusion, we must use a
# different wording depending on the state of the object.
# Therefore, we can set the description in the context from the beginning to avoid falling
# back on the regular display_name retrieved in ``_notify_by_email_prepare_rendering_context()``.
model_description = self.env.context.get('model_description')
values.update(
email_add_signature=self.email_add_signature,
email_layout_xmlid=self.email_layout_xmlid,
force_send=self.force_send,
mail_auto_delete=self.auto_delete,
model_description=model_description,
record_alias_domain_id=self.record_alias_domain_id.id,
record_company_id=self.record_company_id.id,
)
return values
def _prepare_mail_values_dynamic(self, res_ids):
"""Generate values based on composer content as well as its template
based on records given by res_ids.
Part of the advanced rendering is delegated to template, notably
recipients or attachments dynamic generation. See sub methods for
more details.
:param list res_ids: list of record IDs on which composer runs;
:return dict results: for each res_id, the generated values used to
populate in '_prepare_mail_values';
"""
self.ensure_one()
RecordsModel = self.env[self.model].with_prefetch(res_ids)
email_mode = self.composition_mode == 'mass_mail'
# records values
companies = RecordsModel.browse(res_ids)._mail_get_companies(default=self.env.company)
alias_domains = RecordsModel.browse(res_ids)._mail_get_alias_domains(default_company=self.env.company)
# langs, used currently only to propagate in comment mode for notification
# layout translation
langs = self._render_field('lang', res_ids)
subjects = self._render_field('subject', res_ids, compute_lang=True)
bodies = self._render_field(
'body', res_ids, compute_lang=True,
# We want to preserve comments in emails so as to keep mso conditionals
options={'preserve_comments': email_mode},
)
emails_from = self._render_field('email_from', res_ids)
mail_values_all = {
res_id: {
'body': bodies[res_id], # should be void
'email_from': emails_from[res_id],
'scheduled_date': False,
'subject': subjects[res_id],
# record-specific environment values (company, alias_domain)
'record_alias_domain_id': alias_domains[res_id].id,
'record_company_id': companies[res_id].id,
# some fields are specific to mail
**(
{
'body_html': bodies[res_id],
'res_id': res_id,
} if email_mode else {}
),
# some fields are specific to message
**(
{
# notify parameter to force layout lang
'force_email_lang': langs[res_id],
} if not email_mode else {}
),
}
for res_id in res_ids
}
# generate template-based values
if self.template_id:
template_values = self._generate_template_for_composer(
res_ids,
('attachment_ids',
'email_to',
'email_cc',
'partner_ids',
'report_template_ids',
'scheduled_date',
)
)
for res_id in res_ids:
# remove attachments from template values as they should not be rendered
template_values[res_id].pop('attachment_ids', None)
mail_values_all[res_id].update(template_values[res_id])
# Handle recipients. Without template, if no partner_ids is given, update
# recipients using default recipients to be sure to notify someone
if not self.template_id and not self.partner_ids and email_mode:
default_recipients = RecordsModel.browse(res_ids)._message_get_default_recipients()
for res_id in res_ids:
mail_values_all[res_id].update(
default_recipients.get(res_id, {})
)
# TDE FIXME: seems to be missing an "else" here to add partner_ids in rendering mode
# Handle reply-to. In update mode (force_new False), reply-to value is
# computed from the records (to have their alias). In new mode, reply-to
# is coming from reply_to field to render.
if not self.reply_to_force_new:
# compute alias-based reply-to in batch
reply_to_values = RecordsModel.browse(res_ids)._notify_get_reply_to(default=False)
if self.reply_to_force_new:
reply_to_values = self._render_field('reply_to', res_ids)
# Handle per-record update
for res_id, mail_values in mail_values_all.items():
record = RecordsModel.browse(res_id)
# attachments. Copy attachment_ids (each has its own copies), and decode
# attachments as required by _process_attachments_for_post
attachment_ids = [
attachment.copy({'res_model': self._name, 'res_id': self.id}).id
for attachment in self.attachment_ids
]
attachment_ids.reverse()
decoded_attachments = [
(name, base64.b64decode(enc_cont))
for name, enc_cont in mail_values.pop('attachments', [])
]
# email_mode: prepare processed attachments as commands for mail.mail
if email_mode:
process_record = record if hasattr(record, "_process_attachments_for_post") else record.env["mail.thread"]
mail_values['attachment_ids'] = process_record._process_attachments_for_post(
decoded_attachments,
attachment_ids,
{'model': 'mail.message', 'res_id': 0}
)['attachment_ids']
# comment mode: prepare attachments as a list of IDs, to be processed by MailThread
else:
mail_values['attachments'] = decoded_attachments
mail_values['attachment_ids'] = attachment_ids
# headers
if email_mode:
mail_values['headers'] = repr(record._notify_by_email_get_headers())
# recipients: transform partner_ids (field used in mail_message) into
# recipient_ids, used by mail_mail
if email_mode:
recipient_ids_all = set(mail_values.pop('partner_ids', [])) | set(self.partner_ids.ids)
mail_values['recipient_ids'] = [(4, pid) for pid in recipient_ids_all]
# when having no specific reply_to -> fetch rendered email_from
if email_mode:
reply_to = reply_to_values.get(res_id)
if not reply_to:
reply_to = mail_values.get('email_from', False)
mail_values['reply_to'] = reply_to
# body: render layout in email mode (comment mode is managed by the
# notification process, see @_notify_thread_by_email)
if email_mode and self.email_layout_xmlid and mail_values['recipient_ids']:
lang = langs[res_id]
recipient_ids = [command[1] for command in mail_values['recipient_ids']]
msg_vals = {
'email_layout_xmlid': self.email_layout_xmlid,
'model': self.model,
'res_id': res_id,
}
message_inmem = self.env['mail.message'].new({
'body': mail_values['body'],
})
for _lang, render_values, recipients_group_data in record._notify_get_classified_recipients_iterator(
message_inmem,
[{
'active': True,
'id': pid,
'lang': lang,
'notif': 'email',
'share': True,
'type': 'customer',
'ushare': False,
} for pid in recipient_ids],
msg_vals=msg_vals,
model_description=False, # force dynamic computation
force_email_lang=lang,
):
mail_body = record._notify_by_email_render_layout(
message_inmem,
recipients_group_data,
msg_vals=msg_vals,
render_values=render_values,
)
mail_values['body_html'] = mail_body
return mail_values_all
def _prepare_mail_values_rendered(self, res_ids):
"""Generate values that are already rendered. This is used mainly in
monorecord mode, when the wizard contains value already generated
(e.g. "Send by email" on a sale order, in form view).
:param list res_ids: list of record IDs on which composer runs;
:return dict results: for each res_id, the generated values used to
populate in '_prepare_mail_values';
"""
self.ensure_one()
email_mode = self.composition_mode == 'mass_mail'
# Duplicate attachments linked to the email.template. Indeed, composer
# duplicates attachments in mass mode. But in 'rendered' mode attachments
# may come from an email template (same IDs). They also have to be
# duplicated to avoid changing their ownership.
if self.composition_mode == 'comment' and self.template_id and self.attachment_ids:
new_attachment_ids = []
for attachment in self.attachment_ids:
if attachment in self.template_id.attachment_ids:
new_attachment_ids.append(attachment.copy({
'res_model': 'mail.compose.message',
'res_id': self.id,
}).id)
else:
new_attachment_ids.append(attachment.id)
new_attachment_ids.reverse()
self.write({'attachment_ids': [Command.set(new_attachment_ids)]})
return {
res_id: {
'attachment_ids': [attach.id for attach in self.attachment_ids],
'body': self.body or '',
'email_from': self.email_from,
'partner_ids': self.partner_ids.ids,
'scheduled_date': self.scheduled_date,
'subject': self.subject or '',
**(
{
# notify parameter to force layout lang
'force_email_lang': self.lang,
} if not email_mode else {}
),
}
for res_id in res_ids
}
def _process_mail_values_state(self, mail_values_dict):
""" When being in mass mailing, avoid sending emails to void or invalid
emails. For that purpose a processing of generated values allows to
give a state and a failure type to mail.mail records that will be
created at sending time.
:param dict mail_values_dict: as generated by '_prepare_mail_values';
:return: updated mail_values_dict
"""
recipients_info = self._get_recipients_data(mail_values_dict)
blacklist_ids = self._get_blacklist_record_ids(mail_values_dict, recipients_info)
optout_emails = [tools.email_normalize(email) for email in self._get_optout_emails(mail_values_dict)]
done_emails = [tools.email_normalize(email) for email in self._get_done_emails(mail_values_dict)]
sent_emails_mapping = {} # distinct emails sent to each address as {email_address: [mail_values]}
for record_id, mail_values in mail_values_dict.items():
recipients = recipients_info[record_id]
# prevent sending to blocked addresses that were included by mistake
# blacklisted or optout or duplicate -> cancel
if record_id in blacklist_ids:
mail_values['state'] = 'cancel'
mail_values['failure_type'] = 'mail_bl'
# Do not post the mail into the recipient's chatter
mail_values['is_notification'] = False
# void or falsy values -> error
elif not any(recipients['mail_to']):
mail_values['state'] = 'cancel'
mail_values['failure_type'] = 'mail_email_missing'
elif not any(recipients['mail_to_normalized']):
mail_values['state'] = 'cancel'
mail_values['failure_type'] = 'mail_email_invalid'
elif optout_emails and all(
mail_to in optout_emails for mail_to in recipients['mail_to_normalized']
):
mail_values['state'] = 'cancel'
mail_values['failure_type'] = 'mail_optout'
elif done_emails and all(
mail_to in done_emails for mail_to in recipients['mail_to_normalized']
):
mail_values['state'] = 'cancel'
mail_values['failure_type'] = 'mail_dup'
elif (len(self.attachment_ids) == len(mail_values.get('attachment_ids', []))
and all(mail_to in sent_emails_mapping
for mail_to
in recipients['mail_to_normalized'])
and any(sent_mail.get('subject') == mail_values.get('subject')
and sent_mail.get('body') == mail_values.get('body')
for mail_to in recipients['mail_to_normalized']
for sent_mail in sent_emails_mapping[mail_to])):
mail_values['state'] = 'cancel'
mail_values['failure_type'] = 'mail_dup'
else:
for mail_to in recipients['mail_to_normalized']:
sent_emails_mapping.setdefault(mail_to, []).append(mail_values)
done_emails += sent_emails_mapping.keys()
return mail_values_dict
def _generate_template_for_composer(self, res_ids, render_fields,
find_or_create_partners=True):
""" Generate values based on template and relevant values for the
mail.compose.message wizard.
:param list res_ids: list of record IDs on which template is rendered;
:param list render_fields: list of fields to render on template;
:param boolean find_or_create_partners: transform emails into partners
(see ``Template._generate_template_recipients``);
:returns: a dict containing all asked fields for each record ID given by
res_ids. Note that
* 'body' comes from template 'body_html' generation;
* 'attachments' is an additional key coming with 'attachment_ids' due
to report generation (in the format [(report_name, data)] where data
is base64 encoded);
* 'partner_ids' is returned due to recipients generation that gives
partner ids coming from default computation as well as from email
to partner convert (see ``find_or_create_partners``);
"""
self.ensure_one()
# some fields behave / are named differently on template model
mapping = {
'attachments': 'report_template_ids',
'body': 'body_html',
'partner_ids': 'partner_to',
}
template_fields = {mapping.get(fname, fname) for fname in render_fields}
template_values = self.template_id._generate_template(
res_ids,
template_fields,
find_or_create_partners=find_or_create_partners,
)
exclusion_list = ('email_cc', 'email_to') if find_or_create_partners else ()
mapping = {'body_html': 'body'}
render_results = {}
for res_id in res_ids:
render_results[res_id] = {
mapping.get(fname, fname): value
for fname, value in template_values[res_id].items()
if fname not in exclusion_list and value
}
return render_results
# ----------------------------------------------------------------------
# EMAIL MANAGEMENT
# ---------------------------------------------------------------------
def _get_blacklist_record_ids(self, mail_values_dict, recipients_info=None):
blacklisted_rec_ids = set()
if not self.use_exclusion_list:
return blacklisted_rec_ids
if self.composition_mode == 'mass_mail':
self.env['mail.blacklist'].flush_model(['email', 'active'])
self._cr.execute("SELECT email FROM mail_blacklist WHERE active=true")
blacklist = {x[0] for x in self._cr.fetchall()}
if not blacklist:
return blacklisted_rec_ids
if isinstance(self.env[self.model], self.pool['mail.thread.blacklist']):
targets = self.env[self.model].browse(mail_values_dict.keys())
targets.fetch(['email_normalized'])
# First extract email from recipient before comparing with blacklist
blacklisted_rec_ids.update(target.id for target in targets
if target.email_normalized in blacklist)
elif recipients_info:
# Note that we exclude the record if at least one recipient is blacklisted (-> even if not all)
# But as commented above: Mass mailing should always have a single recipient per record.
blacklisted_rec_ids.update(res_id for res_id, recipient_info in recipients_info.items()
if blacklist & set(recipient_info['mail_to_normalized']))
return blacklisted_rec_ids
def _get_done_emails(self, mail_values_dict):
return []
def _get_optout_emails(self, mail_values_dict):
return []
def _get_recipients_data(self, mail_values_dict):
# Preprocess res.partners to batch-fetch from db if recipient_ids is present
# it means they are partners (the only object to fill get_default_recipient this way)
recipient_pids = [
recipient_command[1]
for mail_values in mail_values_dict.values()
# recipient_ids is a list of x2m command tuples at this point
for recipient_command in mail_values.get('recipient_ids') or []
if recipient_command[1]
]
recipient_emails = {
p.id: p.email
for p in self.env['res.partner'].browse(set(recipient_pids))
} if recipient_pids else {}
recipients_info = {}
for record_id, mail_values in mail_values_dict.items():
# add email from email_to; if unrecognized email in email_to keep
# it as used for further processing
mail_to = tools.email_split_and_format(mail_values.get('email_to'))
if not mail_to and mail_values.get('email_to'):
mail_to.append(mail_values['email_to'])
# add email from recipients (res.partner)
mail_to += [
recipient_emails[recipient_command[1]]
for recipient_command in mail_values.get('recipient_ids') or []
if recipient_command[1]
]
# uniquify, keep ordering
seen = set()
mail_to = [email for email in mail_to if email not in seen and not seen.add(email)]
recipients_info[record_id] = {
'mail_to': mail_to,
'mail_to_normalized': [
tools.email_normalize(mail, strict=False)
for mail in mail_to
if tools.email_normalize(mail, strict=False)
]
}
return recipients_info
# ----------------------------------------------------------------------
# MISC UTILS
# ----------------------------------------------------------------------
def _evaluate_res_domain(self):
""" Parse composer domain, which can be: an already valid list or
tuple (generally in code), a list or tuple as a string (coming from
actions). Void strings are considered as a falsy domain.
:return: an Odoo domain (list of leaves) """
self.ensure_one()
if isinstance(self.res_domain, (str, bool)) and not self.res_domain:
return expression.FALSE_DOMAIN
try:
domain = self.res_domain
if isinstance(self.res_domain, str):
domain = ast.literal_eval(domain)
expression.expression(
domain,
self.env[self.model],
)
except (ValueError, AssertionError) as e:
raise ValidationError(
_("Invalid domain %(domain)r (type %(domain_type)s)",
domain=self.res_domain,
domain_type=type(self.res_domain))
) from e
return domain
def _evaluate_res_ids(self):
""" Parse composer res_ids, which can be: an already valid list or
tuple (generally in code), a list or tuple as a string (coming from
actions). Void strings / missing values are evaluated as an empty list.
Note that 'active_ids' context key is supported at this point as mailing
on big ID list would create issues if stored in database.
Another context key 'composer_force_res_ids' is temporarily supported
to ease support of accounting wizard, while waiting to implement a
proper solution to language management.
:return: a list of IDs (empty list in case of falsy strings)"""
self.ensure_one()
return parse_res_ids(
self.env.context.get('composer_force_res_ids') or
self.res_ids or
self.env.context.get('active_ids')
) or []
def _set_value_from_template(self, template_fname, composer_fname=False):
""" Set composer value from its template counterpart. In monorecord
comment mode, we get directly the rendered value, giving the real
value to the user. Otherwise we get the raw (unrendered) value from
template, as it will be rendered at send time (for mass mail, whatever
the number of contextual records to mail) or before posting on records
(for comment in batch).
:param str template_fname: name of field on template model, used to
fetch the value (and maybe render it);
:param str composer_fname: name of field on composer model, when field
names do not match (e.g. body_html on template used to populate body
on composer);
"""
self.ensure_one()
composer_fname = composer_fname or template_fname
# fetch template value, check if void
template_value = self.template_id[template_fname] if self.template_id else False
if template_value and template_fname == 'body_html':
template_value = template_value if not is_html_empty(template_value) else False
if template_value:
if self.composition_mode == 'comment' and not self.composition_batch:
res_ids = self._evaluate_res_ids()
rendering_res_ids = res_ids or [0]
self[composer_fname] = self.template_id._generate_template(
rendering_res_ids,
{template_fname},
)[rendering_res_ids[0]][template_fname]
else:
self[composer_fname] = self.template_id[template_fname]
return self[composer_fname]