# -*- coding: utf-8 -*- # Part of Odoo. See LICENSE file for full copyright and licensing details. import ast import datetime import json import logging import psycopg2 import pytz import re import smtplib from collections import defaultdict from datetime import timedelta from dateutil.parser import parse from odoo import _, api, fields, models, modules, SUPERUSER_ID, tools from odoo.addons.base.models.ir_mail_server import MailDeliveryException from odoo.exceptions import UserError, ValidationError from odoo.modules.registry import Registry _logger = logging.getLogger(__name__) _UNFOLLOW_REGEX = re.compile(r'', re.DOTALL) class MailMail(models.Model): """ Model holding RFC2822 email messages to send. This model also provides facilities to queue and send new email messages. """ _name = 'mail.mail' _description = 'Outgoing Mails' _inherits = {'mail.message': 'mail_message_id'} _order = 'id desc' _rec_name = 'subject' @api.model def default_get(self, fields): # protection for `default_type` values leaking from menu action context (e.g. for invoices) # To remove when automatic context propagation is removed in web client if self.env.context.get('default_type') not in self._fields['message_type'].base_field.selection: self = self.with_context(dict(self.env.context, default_type=None)) # noqa: PLW0642 if self.env.context.get('default_state') not in self._fields['state'].base_field.selection: self = self.with_context(dict(self.env.context, default_state='outgoing')) # noqa: PLW0642 return super().default_get(fields) # content mail_message_id = fields.Many2one('mail.message', 'Message', required=True, ondelete='cascade', index=True, bypass_search_access=True) mail_message_id_int = fields.Integer(compute='_compute_mail_message_id_int', compute_sudo=True) message_type = fields.Selection(related='mail_message_id.message_type', inherited=True, default='email_outgoing') body_html = fields.Text('Text Contents', help="Rich-text/HTML message") body_content = fields.Html('Rich-text Contents', sanitize=True, compute='_compute_body_content', search="_search_body_content") references = fields.Text('References', help='Message references, such as identifiers of previous messages', readonly=True) headers = fields.Text('Headers', copy=False) restricted_attachment_count = fields.Integer('Restricted attachments', compute='_compute_restricted_attachments') unrestricted_attachment_ids = fields.Many2many('ir.attachment', string='Unrestricted Attachments', compute='_compute_restricted_attachments', inverse='_inverse_unrestricted_attachment_ids') # Auto-detected based on create() - if 'mail_message_id' was passed then this mail is a notification # and during unlink() we will not cascade delete the parent and its attachments is_notification = fields.Boolean('Notification Email', help='Mail has been created to notify people of an existing mail.message') # recipients: include inactive partners (they may have been archived after # the message was sent, but they should remain visible in the relation) # note that email_{cc,to} are different from mail.message fields as mail.mail # are also used for outgoing emails sharing the same mail_message_id but with # different recipients email_to = fields.Text('To', help='Message recipients (emails)') email_cc = fields.Char('Cc', help='Carbon copy message recipients') recipient_ids = fields.Many2many('res.partner', string='To (Partners)', context={'active_test': False}) # process state = fields.Selection([ ('outgoing', 'Outgoing'), ('sent', 'Sent'), ('received', 'Received'), ('exception', 'Delivery Failed'), ('cancel', 'Cancelled'), ], 'Status', readonly=True, copy=False, default='outgoing') failure_type = fields.Selection(selection=[ # generic ("unknown", "Unknown error"), # mail ("mail_spam", "Detected As Spam"), ("mail_email_invalid", "Invalid email address"), ("mail_email_missing", "Missing email"), ("mail_from_invalid", "Invalid from address"), ("mail_from_missing", "Missing from address"), ("mail_smtp", "Connection failed (outgoing mail server problem)"), # mass mode ("mail_bl", "Blacklisted Address"), ("mail_optout", "Opted Out"), ("mail_dup", "Duplicated Email"), ], string='Failure type') failure_reason = fields.Text( 'Failure Reason', readonly=True, copy=False, help="Failure reason. This is usually the exception thrown by the email server, stored to ease the debugging of mailing issues.") auto_delete = fields.Boolean( 'Auto Delete', 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.") scheduled_date = fields.Datetime('Scheduled Send 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. Unless a timezone is specified, it is considered as being in UTC timezone.") fetchmail_server_id = fields.Many2one('fetchmail.server', "Inbound Mail Server", readonly=True, index='btree_not_null') @api.constrains('mail_message_id', 'mail_server_id') def _check_mail_server_id(self): for mail in self: if mail.mail_server_id and not mail._filter_mail_mail_servers(mail.mail_server_id): raise ValidationError(_("You may not create a message using another user's mail server.")) def _compute_body_content(self): for mail in self: mail.body_content = mail.body_html def _compute_mail_message_id_int(self): for mail in self: mail.mail_message_id_int = mail.mail_message_id.id @api.depends('attachment_ids') def _compute_restricted_attachments(self): """We might not have access to all the attachments of the emails. Compute the attachments we have access to, and the number of attachments we do not have access to. """ for mail_sudo, mail in zip(self.sudo(), self): mail.unrestricted_attachment_ids = mail_sudo.attachment_ids.sudo(False)._filtered_access('read') mail.restricted_attachment_count = len(mail_sudo.attachment_ids) - len(mail.unrestricted_attachment_ids) def _inverse_unrestricted_attachment_ids(self): """We can only remove the attachments we have access to.""" for mail_sudo, mail in zip(self.sudo(), self): restricted_attaments = mail_sudo.attachment_ids - mail_sudo.attachment_ids.sudo(False)._filtered_access('read') mail_sudo.attachment_ids = restricted_attaments | mail.unrestricted_attachment_ids def _search_body_content(self, operator, value): return [('body_html', operator, value)] @api.model_create_multi def create(self, vals_list): # notification field: if not set, set if mail comes from an existing mail.message for values in vals_list: if 'is_notification' not in values and values.get('mail_message_id'): values['is_notification'] = True if values.get('scheduled_date'): parsed_datetime = self._parse_scheduled_datetime(values['scheduled_date']) values['scheduled_date'] = parsed_datetime.replace(tzinfo=None) if parsed_datetime else False else: values['scheduled_date'] = False # void string crashes new_mails = super().create(vals_list) new_mails_w_attach = self.env['mail.mail'] for mail, values in zip(new_mails, vals_list): if values.get('attachment_ids'): new_mails_w_attach += mail if new_mails_w_attach: new_mails_w_attach.attachment_ids.check_access('read') return new_mails def write(self, vals): if vals.get('scheduled_date'): parsed_datetime = self._parse_scheduled_datetime(vals['scheduled_date']) vals['scheduled_date'] = parsed_datetime.replace(tzinfo=None) if parsed_datetime else False res = super(MailMail, self).write(vals) if vals.get('attachment_ids'): self.attachment_ids.check_access('read') return res def unlink(self): # cascade-delete the parent message for all mails that are not created for a notification mail_msg_cascade_ids = [mail.mail_message_id.id for mail in self if not mail.is_notification] res = super(MailMail, self).unlink() if mail_msg_cascade_ids: self.env['mail.message'].browse(mail_msg_cascade_ids).unlink() return res def action_retry(self): self.filtered(lambda mail: mail.state == 'exception').mark_outgoing() def action_open_document(self): """ Opens the related record based on the model and ID """ self.ensure_one() return { 'res_id': self.res_id, 'res_model': self.model, 'target': 'current', 'type': 'ir.actions.act_window', 'view_mode': 'form', } def mark_outgoing(self): return self.write({'state': 'outgoing'}) def cancel(self): return self.write({'state': 'cancel'}) @api.model def process_email_queue(self, email_ids=(), batch_size=1000): """Send immediately queued messages, committing after each message is sent - this is not transactional and should not be called during another transaction! A maximum of 1K MailMail (configurable using 'mail.mail.queue.batch.size' optional ICP) are fetched in order to keep time under control. :param list email_ids: optional list of emails ids to send. If given only scheduled and outgoing emails within this ids list are sent; """ domain = [ '&', ('state', '=', 'outgoing'), '|', ('scheduled_date', '=', False), ('scheduled_date', '<=', datetime.datetime.utcnow()), ] if 'filters' in self.env.context: domain.extend(self.env.context['filters']) batch_size = int(self.env['ir.config_parameter'].sudo().get_param('mail.mail.queue.batch.size', batch_size)) or batch_size send_ids = self.search(domain, limit=batch_size if not email_ids else batch_size * 10).ids if not email_ids: ids_done = set() total = len(send_ids) if len(send_ids) < batch_size else self.search_count(domain) def post_send_callback(ids): """ Track mail ids that have been sent, and notify cron progress accordingly. """ processed = set(ids) - ids_done ids_done.update(processed) if self.env.get('ir_cron'): # commit progress only when running from a cron job self.env['ir.cron']._commit_progress(len(processed), remaining=total - len(ids_done)) else: send_ids = list(set(send_ids) & set(email_ids)) post_send_callback = None send_ids.sort() res = None try: # auto-commit except in testing mode auto_commit = not modules.module.current_test res = self.browse(send_ids).send(auto_commit=auto_commit, post_send_callback=post_send_callback) except Exception: _logger.exception("Failed processing mail queue") return res def _postprocess_sent_message(self, success_pids, success_emails, failure_reason=False, failure_type=None): """Perform any post-processing necessary after sending ``mail`` successfully, including deleting it completely along with its attachment if the ``auto_delete`` flag of the mail was set. Overridden by subclasses for extra post-processing behaviors. :return: True """ notif_mails_ids = [mail.id for mail in self if mail.is_notification] if notif_mails_ids: notifications = self.env['mail.notification'].search([ ('notification_type', '=', 'email'), ('mail_mail_id', 'in', notif_mails_ids), ('notification_status', 'not in', ('sent', 'canceled')) ]) if notifications: # find all notification linked to a failure failed = self.env['mail.notification'] if failure_type: failed = notifications.filtered(lambda notif: notif.res_partner_id not in success_pids and notif.mail_email_address not in success_emails ) (notifications - failed).sudo().write({ 'notification_status': 'sent', 'failure_type': '', 'failure_reason': '', }) if failed: failed.sudo().write({ 'notification_status': 'exception', 'failure_type': failure_type, 'failure_reason': failure_reason, }) messages = notifications.mapped('mail_message_id').filtered(lambda m: m._is_thread_message()) # TDE TODO: could be great to notify message-based, not notifications-based, to lessen number of notifs messages._notify_message_notification_update() # notify user that we have a failure if not failure_type or failure_type in ['mail_email_invalid', 'mail_email_missing']: # if we have another error, we want to keep the mail. self.sudo().filtered(lambda mail: mail.auto_delete).unlink() return True def _parse_scheduled_datetime(self, scheduled_datetime): """ Taking an arbitrary datetime (either as a date, a datetime or a string) try to parse it and return a datetime timezoned to UTC. If no specific timezone information is given, we consider it as being given in UTC, as all datetime values given to the server. Trying to guess its timezone based on user or flow would be strange as this is not standard. When manually creating datetimes for mail.mail scheduled date, business code should ensure either a timezone info is set, either it is converted into UTC. Using yearfirst when parsing str datetimes eases parser's job when dealing with the hard-to-parse trio (01/04/09 -> ?). In most use cases year will be given first as this is the expected default formatting. :returns: parsed datetime (or False if parser failed) :rtype: datetime.datetime | bool """ if isinstance(scheduled_datetime, datetime.datetime): parsed_datetime = scheduled_datetime elif isinstance(scheduled_datetime, datetime.date): parsed_datetime = datetime.combine(scheduled_datetime, datetime.time.min) else: try: parsed_datetime = parse(scheduled_datetime, yearfirst=True) except (ValueError, TypeError): parsed_datetime = False if parsed_datetime: parsed_datetime = parsed_datetime.replace(microsecond=0) if not parsed_datetime.tzinfo: parsed_datetime = pytz.utc.localize(parsed_datetime) else: try: parsed_datetime = parsed_datetime.astimezone(pytz.utc) except Exception: pass return parsed_datetime # ------------------------------------------------------ # mail_mail formatting, tools and send mechanism # ------------------------------------------------------ @api.model def _estimate_email_size(self, headers, body, attachments_size): """ Estimate the email size, incorporating a small added security margin. :param dict headers: email headers :param str body: email body :param list attachments_size: list of attachment size in bytes """ return ( len(json.dumps(headers or {}, ensure_ascii=False).encode(errors='ignore')) + len((body or '').encode(errors='ignore')) + sum(attachments_size) * 8 / 6 + # 8 / 6 factor because base 64 are 6 bits coded in 8 bits 10 * 1024 # adding 10Ko as security ) def _filter_mail_mail_servers(self, mail_servers): if ( len(self.mail_message_id.create_uid) > 1 or # multiple create_uids -> subset that's allowed for all self.env['ir.config_parameter'].sudo().get_param('mail.disable_personal_mail_servers', False) ): return mail_servers.filtered(lambda server: not server.owner_user_id) return mail_servers.filtered(lambda server: server.owner_user_id in [self.env['res.users'], self.mail_message_id.create_uid]) def _prepare_outgoing_body(self): """Return a specific ir_email body. The main purpose of this method is to be inherited to add custom content depending on some module.""" self.ensure_one() if tools.is_html_empty(self.body_html): return '' return self.env['mail.render.mixin']._replace_local_links(self.body_html) def _personalize_outgoing_body(self, body, partner=False, doc_to_followers=None): """ Return a modified body based on the recipient (partner). It must be called when using standard notification layouts even for message without partners. :param str body: body to personalize for the recipient :param partner: recipient :param dict doc_to_followers: see ``Followers._get_mail_doc_to_followers()`` """ self.ensure_one() if (partner and self.model and self.id and # document based only (getattr(self.env[self.model], '_partner_unfollow_enabled', False) or not partner.partner_share) and # internal or model-allowance (doc_to_followers or {}).get((self.model, self.res_id))): unfollow_url = self.env['mail.thread']._notify_get_action_link( 'unfollow', model=self.model, res_id=self.res_id, pid=partner.id) body = body.replace('/mail/unfollow', unfollow_url) else: body = re.sub(_UNFOLLOW_REGEX, '', body) return body def _prepare_outgoing_list(self, mail_server=False, doc_to_followers=None): """ Return a list of emails to send based on current mail.mail. Each is a dictionary for specific email values, depending on a partner, or generic to the whole recipients given by mail.email_to. :param mail_server: mail server that will be used to send the mails, False if it is the default one :param dict doc_to_followers: see ``Followers._get_mail_doc_to_followers()`` :returns: list of dicts used in IrMailServer._build_email__() :rtype: list[dict] """ self.ensure_one() body = self._prepare_outgoing_body() # headers headers = {} if self.headers: try: headers = ast.literal_eval(self.headers) except (ValueError, TypeError) as e: _logger.warning( 'Evaluation error when evaluating mail headers (received %r): %s', self.headers, e, ) # global except as we don't want to crash the queue just due to a malformed # headers value except Exception as e: _logger.warning( 'Unknown error when evaluating mail headers (received %r): %s', self.headers, e, ) headers.setdefault('Return-Path', self.record_alias_domain_id.bounce_email or self.env.company.bounce_email) # prepare recipients: use email_to if defined then check recipient_ids # that receive a specific email, notably due to link shortening / redirect # that is recipients-dependent. Keep original email/partner as this is # used in post-processing to know failures, like missing recipients email_list = [] if self.email_to: email_to_normalized = tools.mail.email_normalize_all(self.email_to) email_to = tools.mail.email_split_and_format_normalize(self.email_to) email_list.append({ 'email_cc': [], 'email_to': email_to, # list of normalized emails to help extract_rfc2822 'email_to_normalized': email_to_normalized, # keep raw initial value for incoming pre processing of outgoing emails 'email_to_raw': self.email_to or '', 'partner_id': False, }) # add all cc once, either to the first "To", either as a single entry (do not mix # with partner-specific sending) if self.email_cc: if email_list: email_list[0]['email_cc'] = tools.mail.email_split_and_format_normalize(self.email_cc) email_list[0]['email_to_normalized'] += tools.mail.email_normalize_all(self.email_cc) else: email_list.append({ 'email_cc': tools.mail.email_split_and_format_normalize(self.email_cc), 'email_to': [], 'email_to_normalized': tools.mail.email_normalize_all(self.email_cc), 'email_to_raw': False, 'partner_id': False, }) # specific behavior to customize the send email for notified partners for partner in self.recipient_ids: # check partner email content email_to_normalized = tools.mail.email_normalize_all(partner.email) email_to = [ tools.formataddr((partner.name or "", email or "False")) for email in email_to_normalized or [partner.email] ] email_list.append({ 'email_cc': [], 'email_to': email_to, # list of normalized emails to help extract_rfc2822 'email_to_normalized': email_to_normalized, # keep raw initial value for incoming pre processing of outgoing emails 'email_to_raw': partner.email or '', 'partner_id': partner, }) attachments = self.attachment_ids # Prepare attachments: # Remove attachments if user send the link with the access_token. if body and attachments: link_ids = {int(link) for link in re.findall(r'/web/(?:content|image)/([0-9]+)', body)} if link_ids: attachments = attachments - self.env['ir.attachment'].browse(list(link_ids)) # Convert URL-only attachments (e.g. cloud or plain external links) into email links url_attachments = attachments.sudo().filtered( lambda a: a.url and not a.file_size and a.url.startswith(('http://', 'https://', 'ftp://'))) if url_attachments: url_attachments.sudo().generate_access_token() attachments_links = self.env['ir.qweb']._render('mail.mail_attachment_links', {'attachments': url_attachments}) body = tools.mail.append_content_to_html(body, attachments_links, plaintext=False) attachments -= url_attachments # Turn remaining attachments into links if they are too heavy and # their ownership are business models (i.e. something != mail.message, # otherwise they will be deleted along with the mail message leading to a 404) if record_owned_attachments := attachments.sudo().filtered( lambda a: a.res_model and a.res_id and a.res_model != 'mail.message'): estimated_email_size_bytes = self._estimate_email_size( headers, body, [a.file_size for a in attachments.sudo()]) max_email_size_bytes = (mail_server or self.env['ir.mail_server'] ).sudo()._get_max_email_size() * 1024 * 1024 if estimated_email_size_bytes > max_email_size_bytes: # Remove attachments and prepare downloadable links to be added in the body record_owned_attachments.sudo().generate_access_token() attachments_links = self.env['ir.qweb']._render('mail.mail_attachment_links', {'attachments': record_owned_attachments}) body = tools.mail.append_content_to_html(body, attachments_links, plaintext=False) attachments -= record_owned_attachments # Prepare the remaining attachment (those not embedded as link) # load attachment binary data with a separate read(), as prefetching all # `datas` (binary field) could bloat the browse cache, triggering # soft/hard mem limits with temporary data. # attachments sorted by increasing ID to match front-end and upload ordering email_attachments = [(a['name'], a['raw'], a['mimetype']) for a in attachments.sudo().sorted('id').read(['name', 'raw', 'mimetype']) if a['raw'] is not False] # Build final list of email values with personalized body for recipient results = [] for email_values in email_list: partner_id = email_values['partner_id'] body_personalized = self._personalize_outgoing_body(body, partner_id, doc_to_followers=doc_to_followers) results.append({ 'attachments': email_attachments, 'body': body_personalized, 'body_alternative': tools.html2plaintext(body_personalized), 'email_cc': email_values['email_cc'], 'email_from': self.email_from, 'email_to': email_values['email_to'], 'email_to_normalized': email_values['email_to_normalized'], 'email_to_raw': email_values['email_to_raw'], 'headers': headers, 'message_id': self.message_id, 'object_id': f'{self.res_id}-{self.model}' if self.res_id else '', 'partner_id': partner_id, 'references': self.references, 'reply_to': self.reply_to, 'subject': self.subject, }) return results def _split_by_mail_configuration(self): """Group the based on their "email_from", their "alias domain" and their "mail_server_id". The will have the "same sending configuration" if they have the same mail server, alias domain and mail from. For performance purpose, we can use an SMTP session in batch and therefore we need to group them by the parameter that will influence the mail server used. The same "sending configuration" may repeat in order to limit batch size according to the `mail.session.batch.size` system parameter. Return iterators over mail_server_id, email_from, Records.ids """ mail_values = self.with_context(prefetch_fields=False).read(['id', 'email_from', 'mail_server_id', 'record_alias_domain_id']) all_mail_servers = self.env['ir.mail_server'].sudo().search([], order='sequence, id') # First group the per mail_server_id, per alias_domain (if no server) and per email_from group_per_email_from = defaultdict(list) for mail, values in zip(self, mail_values): # protect against ill-formatted email_from when formataddr was used on an already formatted email emails_from = tools.mail.email_split_and_format_normalize(values['email_from']) email_from = emails_from[0] if emails_from else values['email_from'] mail_server_id = values['mail_server_id'][0] if values['mail_server_id'] else False alias_domain_id = values['record_alias_domain_id'][0] if values['record_alias_domain_id'] else False key = (mail_server_id, alias_domain_id, email_from, mail._filter_mail_mail_servers(all_mail_servers)) group_per_email_from[key].append(values['id']) group_per_smtp_from = defaultdict(list) for (mail_server_id, alias_domain_id, email_from, allowed_mail_servers), mail_ids in group_per_email_from.items(): if not mail_server_id: mail_server = self.env['ir.mail_server'] if alias_domain_id: alias_domain = self.env['mail.alias.domain'].sudo().browse(alias_domain_id) mail_server = mail_server.with_context( domain_notifications_email=alias_domain.default_from_email, domain_bounce_address=alias_domain.bounce_email, ) mail_server, smtp_from = mail_server._find_mail_server(email_from, allowed_mail_servers) mail_server_id = mail_server.id if mail_server else False else: smtp_from = email_from group_per_smtp_from[(mail_server_id, alias_domain_id, smtp_from)].extend(mail_ids) batch_size = int(self.env['ir.config_parameter'].sudo().get_param('mail.session.batch.size')) or 1000 for (mail_server_id, alias_domain_id, smtp_from), record_ids in group_per_smtp_from.items(): for batch_ids in tools.split_every(batch_size, record_ids): yield mail_server_id, alias_domain_id, smtp_from, batch_ids def _split_by_delayed_batch(self, mail_server): """To not flag personal email servers as spam, we throttle them at X emails / minutes.""" if not mail_server or not mail_server.owner_user_id: return self MAX_SEND = mail_server._get_personal_mail_servers_limit() current_minute = datetime.datetime.now().replace(second=0, microsecond=0) server_limit_minute = ( mail_server.owner_limit_time if mail_server.owner_limit_time else current_minute - timedelta(minutes=1) ) if server_limit_minute < current_minute: # Server limit is old, we can send up to the limit server_limit_minute = current_minute mail_server.owner_limit_time = current_minute mail_server.owner_limit_count = 0 elif server_limit_minute > current_minute: # Should not happen except if we manually write on the field mail_server.owner_limit_time = current_minute mail_server.owner_limit_count = 0 _logger.error( "Mail: invalid owner_limit_time %s > %s for %s", server_limit_minute, current_minute, mail_server.name, ) # Send the oldest mails in priority if the CRON is late to_send = self.browse() to_delay = self.browse() notifs = self.env['mail.notification'].sudo().search([ ('notification_type', '=', 'email'), ('mail_mail_id', 'in', self.ids), ('notification_status', 'not in', ('sent', 'canceled')) ]) for mail in self.sorted(lambda k: (k.create_date, k.id)): if mail_server.owner_limit_count >= MAX_SEND: to_delay |= mail elif mail_server.owner_limit_count + (len(mail.recipient_ids) or 1) > MAX_SEND: # Because we split for each recipient, if we want to # respect the limit we have to create new mails # (the first one keep the email_to and the email_cc # so it might send 2 emails instead of 1, # see `_prepare_outgoing_list`) to_keep = MAX_SEND - mail_server.owner_limit_count recipient_ids = mail.recipient_ids new_mail = mail.with_user(mail.create_uid).sudo().copy({ 'headers': mail.headers, 'mail_message_id': mail.mail_message_id.id, 'recipient_ids': recipient_ids[:to_keep].ids, }) mail.write({ 'recipient_ids': recipient_ids[to_keep:], 'email_cc': False, 'email_to': False, }) mail_server.owner_limit_count += to_keep or 1 notifs.filtered(lambda n: n.mail_mail_id == mail and n.res_partner_id in recipient_ids[:to_keep]).mail_mail_id = new_mail to_send |= new_mail to_delay |= mail else: to_send |= mail mail_server.owner_limit_count += len(mail.recipient_ids) or 1 # Delay if necessary if to_delay: owner_limit_count = mail_server.owner_limit_count for mail in to_delay: if owner_limit_count < MAX_SEND: owner_limit_count += len(mail.recipient_ids) or 1 else: owner_limit_count = len(mail.recipient_ids) or 1 server_limit_minute += timedelta(minutes=1) mail.scheduled_date = server_limit_minute self.env.ref('mail.ir_cron_mail_scheduler_action')._trigger( min(to_delay.mapped('scheduled_date')) + timedelta(seconds=59)) _logger.info( "Mail: personal server %s: %s emails about to be sent / %s emails delayed", mail_server.name, len(to_send), len(to_delay)) return to_send def send_after_commit(self): """Queues the email to be sent after the commit of the current cursor. Useful to send an email only if a transaction is successful. """ # send immediately on same cursor when testing as we don't want # to actually commit during tests if modules.module.current_test: self.send() return email_ids = self.ids dbname = self.env.cr.dbname _context = self.env.context @self.env.cr.postcommit.add def send_emails_with_new_cursor(): db_registry = Registry(dbname) with db_registry.cursor() as cr: env = api.Environment(cr, SUPERUSER_ID, _context) env['mail.mail'].browse(email_ids).send() def send(self, auto_commit=False, raise_exception=False, post_send_callback=None): """ Sends the selected emails immediately, ignoring their current state (mails that have already been sent should not be passed unless they should actually be re-sent). Emails successfully delivered are marked as 'sent', and those that fail to be deliver are marked as 'exception', and the corresponding error mail is output in the server logs. :param bool auto_commit: whether to force a commit of the mail status after sending each mail (meant only for scheduler processing); should never be True during normal transactions (default: False) :param bool raise_exception: whether to raise an exception if the email sending process has failed :param post_send_callback: an optional function, called as ``post_send_callback(ids, force=False)``, with the mail ids that have been sent; calls with redundant ids are possible :return: True """ for mail_server_id, alias_domain_id, smtp_from, batch_ids in self._split_by_mail_configuration(): mail_server = self.env["ir.mail_server"].browse(mail_server_id) if mail_server and mail_server.owner_user_id: # Throttle the sending that use personal mail servers batch_ids = self.browse(batch_ids)._split_by_delayed_batch(mail_server).ids if not batch_ids: continue smtp_session = None try: smtp_session = self.env['ir.mail_server']._connect__(mail_server_id=mail_server_id, smtp_from=smtp_from) except Exception as exc: if raise_exception: # To be consistent and backward compatible with mail_mail.send() raised # exceptions, it is encapsulated into an Odoo MailDeliveryException raise MailDeliveryException(_('Unable to connect to SMTP Server'), exc) else: batch = self.browse(batch_ids) batch.write({'state': 'exception', 'failure_reason': tools.exception_to_unicode(exc)}) batch._postprocess_sent_message(success_pids=[], success_emails=[], failure_type="mail_smtp") else: self.browse(batch_ids)._send( auto_commit=auto_commit, raise_exception=raise_exception, smtp_session=smtp_session, alias_domain_id=alias_domain_id, mail_server=mail_server, post_send_callback=post_send_callback, ) if not modules.module.current_test: _logger.info( "Processed batch of %s mail.mail records via mail server ID #%s", len(batch_ids), mail_server_id) finally: if smtp_session: try: smtp_session.quit() except smtplib.SMTPServerDisconnected: _logger.info( "Ignoring SMTPServerDisconnected while trying to quit non open session" ) def action_send_and_close(self): """ An action sending the selected mail and redirecting to mail.mail list view. """ self.send() return { 'name': _('Emails'), 'res_model': 'mail.mail', 'view_mode': 'list', 'views': [[False, 'list'], [False, 'form']], 'target': 'main', 'type': 'ir.actions.act_window', } def _send(self, auto_commit=False, raise_exception=False, smtp_session=None, alias_domain_id=False, mail_server=False, post_send_callback=None): IrMailServer = self.env['ir.mail_server'] if IrMailServer._disable_send(): # during testing skip sending e-mails unless monkeypatched return True # check that every email is allowed on this mail server if mail_server and not self._filter_mail_mail_servers(mail_server): raise UserError(_('Unauthorized server for some of the sending mails.')) # Only retrieve recipient followers of the mails if needed mails_with_unfollow_link = self.filtered(lambda m: m.body_html and '/mail/unfollow' in m.body_html) doc_to_followers = self.env['mail.followers']._get_mail_doc_to_followers(mails_with_unfollow_link.ids) for mail_id in self.ids: success_pids = [] success_emails = [] failure_reason = None failure_type = None mail = None try: mail = self.browse(mail_id) if mail.state != 'outgoing': continue no_recipients = (not (mail.email_to or '').strip() and not mail.recipient_ids and not (mail.email_cc or '').strip()) # Writing on the mail object may fail (e.g. lock on user) which # would trigger a rollback *after* actually sending the email. # To avoid sending twice the same email, provoke the failure earlier mail.write({ 'state': 'exception', 'failure_reason': IrMailServer.NO_VALID_RECIPIENT if no_recipients else _('Error without exception. Probably due to sending an email without computed recipients.'), 'failure_type': 'mail_email_missing' if no_recipients else 'unknown', }) # Update notification in a transient exception state to avoid concurrent # update in case an email bounces while sending all emails related to current # mail record. notifs = self.env['mail.notification'].search([ ('notification_type', '=', 'email'), ('mail_mail_id', 'in', mail.ids), ('notification_status', 'not in', ('sent', 'canceled')) ]) if notifs: notif_msg = _('Error without exception. Probably due to concurrent access update of notification records. Please see with an administrator.') notifs.sudo().write({ 'notification_status': 'exception', 'failure_type': 'unknown', 'failure_reason': notif_msg, }) # `test_mail_bounce_during_send`, force immediate update to obtain the lock. # see rev. 56596e5240ef920df14d99087451ce6f06ac6d36 notifs.flush_recordset(['notification_status', 'failure_type', 'failure_reason']) # protect against ill-formatted email_from when formataddr was used on an already formatted email emails_from = tools.mail.email_split_and_format_normalize(mail.email_from) email_from = emails_from[0] if emails_from else mail.email_from # build an RFC2822 email.message.Message object and send it without queuing res = None # TDE note: could be great to pre-detect missing to/cc and skip sending it # to go directly to failed state update email_list = mail._prepare_outgoing_list( mail_server=mail_server or mail.mail_server_id, doc_to_followers=doc_to_followers, ) # send each sub-email for email in email_list: # give indication to 'send_mail' about emails already considered # as being valid email_to_normalized = email.pop('email_to_normalized', []) # if given, contextualize sending using alias domains if alias_domain_id: alias_domain = self.env['mail.alias.domain'].sudo().browse(alias_domain_id) SendIrMailServer = IrMailServer.with_context( domain_notifications_email=alias_domain.default_from_email, domain_bounce_address=email['headers'].get('Return-Path') or alias_domain.bounce_email, send_validated_to=email_to_normalized, ) else: SendIrMailServer = IrMailServer.with_context(send_validated_to=email_to_normalized) msg = SendIrMailServer._build_email__( email_from=email_from, email_to=email['email_to'], subject=email['subject'], body=email['body'], body_alternative=email['body_alternative'], email_cc=email['email_cc'], reply_to=email['reply_to'], attachments=email['attachments'], message_id=email['message_id'], references=email['references'], object_id=email['object_id'], subtype='html', subtype_alternative='plain', headers=email['headers'], ) processing_pid = email.pop("partner_id", None) try: res = SendIrMailServer.send_email( msg, mail_server_id=mail.mail_server_id.id, smtp_session=smtp_session) if processing_pid: success_pids.append(processing_pid) else: success_emails.extend(email['email_to'] or []) processing_pid = None except AssertionError as error: if str(error) == IrMailServer.NO_VALID_RECIPIENT: # if we have a list of void emails for email_list -> email missing, otherwise generic email failure if not email.get('email_to') and failure_type != "mail_email_invalid": failure_type = "mail_email_missing" else: failure_type = "mail_email_invalid" failure_reason = tools.exception_to_unicode(error) # No valid recipient found for this particular # mail item -> ignore error to avoid blocking # delivery to next recipients, if any. If this is # the only recipient, the mail will show as failed. _logger.info("Ignoring invalid recipients for mail.mail %s: %s", mail.message_id, email.get('email_to')) else: raise if res: # mail has been sent at least once, no major exception occurred mail.write({'state': 'sent', 'message_id': res, 'failure_type': False, 'failure_reason': False}) if not modules.module.current_test: _logger.info( "Mail (mail.mail) with ID %r and Message-Id %r from %r to (redacted) %s successfully sent", mail.id, mail.message_id, tools.email_normalize(msg['from']), # FROM should not change, so last msg good enough ', '.join( repr(tools.mail.email_anonymize(tools.email_normalize(m['email_to']))) for m in email_list ), ) _logger.info("Total emails tried by SMTP: %s", len(email_list)) # /!\ can't use mail.state here, as mail.refresh() will cause an error # see revid:odo@openerp.com-20120622152536-42b2s28lvdv3odyr in 6.1 else: mail_vals = {} if failure_reason: mail_vals['failure_reason'] = failure_reason if failure_type: mail_vals['failure_type'] = failure_type if mail_vals: mail.write(mail_vals) mail._postprocess_sent_message(success_pids=success_pids, success_emails=success_emails, failure_type=failure_type, failure_reason=failure_reason) except MemoryError: # prevent catching transient MemoryErrors, bubble up to notify user or abort cron job # instead of marking the mail as failed _logger.exception( 'MemoryError while processing mail with ID %r and Msg-Id %r. Consider raising the --limit-memory-hard startup option', mail.id, mail.message_id) # mail status will stay on ongoing since transaction will be rollback raise except (psycopg2.Error, smtplib.SMTPServerDisconnected): # If an error with the database or SMTP session occurs, chances are that the cursor # or SMTP session are unusable, causing further errors when trying to save the state. _logger.exception( 'Exception while processing mail with ID %r and Msg-Id %r.', mail.id, mail.message_id) raise except Exception as e: if isinstance(e, AssertionError): # Handle assert raised in IrMailServer to try to catch notably from-specific errors. # Note that assert may raise several args, a generic error string then a specific # message for logging in failure type error_code = e.args[0] if len(e.args) > 1 and error_code == IrMailServer.NO_VALID_FROM: # log failing email in additional arguments message failure_reason = str(e.args[1]) else: failure_reason = error_code if error_code == IrMailServer.NO_VALID_FROM: failure_type = "mail_from_invalid" elif error_code in (IrMailServer.NO_FOUND_FROM, IrMailServer.NO_FOUND_SMTP_FROM): failure_type = "mail_from_missing" if isinstance(e, MailDeliveryException) and "OutboundSpamException" in str(e): # OutboundSpamException: Outlook spam error failure_type = "mail_spam" # generic (unknown) error as fallback if not failure_reason: failure_reason = tools.exception_to_unicode(e) if not failure_type: failure_type = "unknown" _logger.exception('failed sending mail (id: %s) due to %s', mail.id, failure_reason) mail.write({ "failure_reason": failure_reason, "failure_type": failure_type, "state": "exception", }) mail._postprocess_sent_message( success_pids=success_pids, success_emails=success_emails, failure_reason=failure_reason, failure_type=failure_type ) if raise_exception: if isinstance(e, (AssertionError, UnicodeEncodeError)): if isinstance(e, UnicodeEncodeError): value = "Invalid text: %s" % e.object else: value = '. '.join(e.args) raise MailDeliveryException(value) raise if auto_commit is True: if post_send_callback: post_send_callback([mail_id]) self.env.cr.commit() if post_send_callback: post_send_callback(self.ids) return True # ============================================================ # Mail -> Notification Helpers # ============================================================ def _get_notification_values(self): """Get list of base notification values to create a notification for existing emails. Recipient-specific values should be added separately. """ return [ { 'author_id': mail.author_id.id, 'is_read': True, # no mechanism to update this for outgoing emails 'mail_mail_id': mail.id, 'mail_message_id': mail.mail_message_id.id, 'notification_type': 'email', 'notification_status': mail._get_notification_status(), 'failure_type': mail.failure_type, } for mail in self ] def _get_notification_status(self): """Return the equivalent status for notifications based on state.""" return { 'outgoing': 'ready', 'sent': 'sent', 'received': 'sent', 'exception': 'exception', 'cancel': 'canceled', }.get(self.state, 'ready')