2933 lines
148 KiB
Python
2933 lines
148 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
# from odoo import models, fields, api
|
|
|
|
|
|
# class inbox_notif_email(models.Model):
|
|
# _name = 'inbox_notif_email.inbox_notif_email'
|
|
# _description = 'inbox_notif_email.inbox_notif_email'
|
|
|
|
# name = fields.Char()
|
|
# value = fields.Integer()
|
|
# value2 = fields.Float(compute="_value_pc", store=True)
|
|
# description = fields.Text()
|
|
#
|
|
# @api.depends('value')
|
|
# def _value_pc(self):
|
|
# for record in self:
|
|
# record.value2 = float(record.value) / 100
|
|
import ast
|
|
import base64
|
|
import datetime
|
|
import inspect
|
|
|
|
import dateutil
|
|
import email
|
|
import email.policy
|
|
import hashlib
|
|
import hmac
|
|
import lxml
|
|
import logging
|
|
import pytz
|
|
import re
|
|
import socket
|
|
import time
|
|
import threading
|
|
|
|
from collections import namedtuple
|
|
from email.message import EmailMessage
|
|
from email import message_from_string, policy
|
|
from lxml import etree
|
|
from werkzeug import urls
|
|
from xmlrpc import client as xmlrpclib
|
|
|
|
from odoo import _, api, exceptions, fields, models, tools, registry, SUPERUSER_ID
|
|
from odoo.exceptions import MissingError
|
|
from odoo.osv import expression
|
|
|
|
from odoo.tools import ustr
|
|
from odoo.tools.misc import clean_context, split_every
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
|
|
class Users(models.Model):
|
|
_name = 'res.users'
|
|
_inherit = ['res.users']
|
|
notification_type = fields.Selection([
|
|
('email', 'Handle by Emails'),
|
|
('inbox', 'Handle in Odoo'),
|
|
('both', 'Handle by both')
|
|
],
|
|
'Notification', required=True, default='email',
|
|
help="Policy on how to handle Chatter notifications:\n"
|
|
"- Handle by Emails: notifications are sent to your email address\n"
|
|
"- Handle in Odoo: notifications appear in your Odoo Inbox")
|
|
|
|
|
|
class MailNotification(models.Model):
|
|
_inherit = 'mail.notification'
|
|
notification_type = fields.Selection([
|
|
('inbox', 'Inbox'), ('email', 'Email'),('both', 'both')
|
|
], string='Notification Type', default='inbox', index=True, required=True)
|
|
# _sql_constraints = [
|
|
# # email notification;: partner is required
|
|
# ('notification_partner_required',
|
|
# "CHECK(notification_type NOT IN ('email', 'inbox','both') OR res_partner_id IS NOT NULL)",
|
|
# 'Customer is required for inbox / email notification'),
|
|
# ]
|
|
|
|
|
|
class MailThread(models.AbstractModel):
|
|
''' mail_thread model is meant to be inherited by any model that needs to
|
|
act as a discussion topic on which messages can be attached. Public
|
|
methods are prefixed with ``message_`` in order to avoid name
|
|
collisions with methods of the models that will inherit from this class.
|
|
|
|
``mail.thread`` defines fields used to handle and display the
|
|
communication history. ``mail.thread`` also manages followers of
|
|
inheriting classes. All features and expected behavior are managed
|
|
by mail.thread. Widgets has been designed for the 7.0 and following
|
|
versions of Odoo.
|
|
|
|
Inheriting classes are not required to implement any method, as the
|
|
default implementation will work for any model. However it is common
|
|
to override at least the ``message_new`` and ``message_update``
|
|
methods (calling ``super``) to add model-specific behavior at
|
|
creation and update of a thread when processing incoming emails.
|
|
|
|
Options:
|
|
- _mail_flat_thread: if set to True, all messages without parent_id
|
|
are automatically attached to the first message posted on the
|
|
ressource. If set to False, the display of Chatter is done using
|
|
threads, and no parent_id is automatically set.
|
|
|
|
MailThread features can be somewhat controlled through context keys :
|
|
|
|
- ``mail_create_nosubscribe``: at create or message_post, do not subscribe
|
|
uid to the record thread
|
|
- ``mail_create_nolog``: at create, do not log the automatic '<Document>
|
|
created' message
|
|
- ``mail_notrack``: at create and write, do not perform the value tracking
|
|
creating messages
|
|
- ``tracking_disable``: at create and write, perform no MailThread features
|
|
(auto subscription, tracking, post, ...)
|
|
- ``mail_notify_force_send``: if less than 50 email notifications to send,
|
|
send them directly instead of using the queue; True by default
|
|
'''
|
|
_inherit = 'mail.thread'
|
|
_description = 'Email Thread'
|
|
_mail_flat_thread = True # flatten the discussino history
|
|
_mail_post_access = 'write' # access required on the document to post on it
|
|
_Attachment = namedtuple('Attachment', ('fname', 'content', 'info'))
|
|
|
|
message_is_follower = fields.Boolean(
|
|
'Is Follower', compute='_compute_is_follower', search='_search_is_follower')
|
|
message_follower_ids = fields.One2many(
|
|
'mail.followers', 'res_id', string='Followers', groups='base.group_user')
|
|
message_partner_ids = fields.Many2many(
|
|
comodel_name='res.partner', string='Followers (Partners)',
|
|
compute='_get_followers', search='_search_follower_partners',
|
|
groups='base.group_user')
|
|
message_channel_ids = fields.Many2many(
|
|
comodel_name='mail.channel', string='Followers (Channels)',
|
|
compute='_get_followers', search='_search_follower_channels',
|
|
groups='base.group_user')
|
|
message_ids = fields.One2many(
|
|
'mail.message', 'res_id', string='Messages',
|
|
domain=lambda self: [('message_type', '!=', 'user_notification')], auto_join=True)
|
|
message_unread = fields.Boolean(
|
|
'Unread Messages', compute='_get_message_unread',
|
|
help="If checked, new messages require your attention.")
|
|
message_unread_counter = fields.Integer(
|
|
'Unread Messages Counter', compute='_get_message_unread',
|
|
help="Number of unread messages")
|
|
message_needaction = fields.Boolean(
|
|
'Action Needed', compute='_get_message_needaction', search='_search_message_needaction',
|
|
help="If checked, new messages require your attention.")
|
|
message_needaction_counter = fields.Integer(
|
|
'Number of Actions', compute='_get_message_needaction',
|
|
help="Number of messages which requires an action")
|
|
message_has_error = fields.Boolean(
|
|
'Message Delivery error', compute='_compute_message_has_error', search='_search_message_has_error',
|
|
help="If checked, some messages have a delivery error.")
|
|
message_has_error_counter = fields.Integer(
|
|
'Number of errors', compute='_compute_message_has_error',
|
|
help="Number of messages with delivery error")
|
|
message_attachment_count = fields.Integer('Attachment Count', compute='_compute_message_attachment_count', groups="base.group_user")
|
|
message_main_attachment_id = fields.Many2one(string="Main Attachment", comodel_name='ir.attachment', index=True, copy=False)
|
|
|
|
@api.depends('message_follower_ids')
|
|
def _get_followers(self):
|
|
for thread in self:
|
|
thread.message_partner_ids = thread.message_follower_ids.mapped('partner_id')
|
|
thread.message_channel_ids = thread.message_follower_ids.mapped('channel_id')
|
|
|
|
@api.model
|
|
def _search_follower_partners(self, operator, operand):
|
|
"""Search function for message_follower_ids
|
|
|
|
Do not use with operator 'not in'. Use instead message_is_followers
|
|
"""
|
|
# TOFIX make it work with not in
|
|
assert operator != "not in", "Do not search message_follower_ids with 'not in'"
|
|
followers = self.env['mail.followers'].sudo().search([
|
|
('res_model', '=', self._name),
|
|
('partner_id', operator, operand)])
|
|
# using read() below is much faster than followers.mapped('res_id')
|
|
return [('id', 'in', [res['res_id'] for res in followers.read(['res_id'])])]
|
|
|
|
@api.model
|
|
def _search_follower_channels(self, operator, operand):
|
|
"""Search function for message_follower_ids
|
|
|
|
Do not use with operator 'not in'. Use instead message_is_followers
|
|
"""
|
|
# TOFIX make it work with not in
|
|
assert operator != "not in", "Do not search message_follower_ids with 'not in'"
|
|
followers = self.env['mail.followers'].sudo().search([
|
|
('res_model', '=', self._name),
|
|
('channel_id', operator, operand)])
|
|
# using read() below is much faster than followers.mapped('res_id')
|
|
return [('id', 'in', [res['res_id'] for res in followers.read(['res_id'])])]
|
|
|
|
@api.depends('message_follower_ids')
|
|
def _compute_is_follower(self):
|
|
followers = self.env['mail.followers'].sudo().search([
|
|
('res_model', '=', self._name),
|
|
('res_id', 'in', self.ids),
|
|
('partner_id', '=', self.env.user.partner_id.id),
|
|
])
|
|
print(followers);
|
|
# using read() below is much faster than followers.mapped('res_id')
|
|
following_ids = [res['res_id'] for res in followers.read(['res_id'])]
|
|
for record in self:
|
|
record.message_is_follower = record.id in following_ids
|
|
|
|
@api.model
|
|
def _search_is_follower(self, operator, operand):
|
|
followers = self.env['mail.followers'].sudo().search([
|
|
('res_model', '=', self._name),
|
|
('partner_id', '=', self.env.user.partner_id.id),
|
|
])
|
|
# Cases ('message_is_follower', '=', True) or ('message_is_follower', '!=', False)
|
|
if (operator == '=' and operand) or (operator == '!=' and not operand):
|
|
# using read() below is much faster than followers.mapped('res_id')
|
|
return [('id', 'in', [res['res_id'] for res in followers.read(['res_id'])])]
|
|
else:
|
|
# using read() below is much faster than followers.mapped('res_id')
|
|
return [('id', 'not in', [res['res_id'] for res in followers.read(['res_id'])])]
|
|
|
|
def _get_message_unread(self):
|
|
partner_id = self.env.user.partner_id.id
|
|
res = dict.fromkeys(self.ids, 0)
|
|
if self.ids:
|
|
# search for unread messages, directly in SQL to improve performances
|
|
self._cr.execute(""" SELECT msg.res_id FROM mail_message msg
|
|
RIGHT JOIN mail_message_mail_channel_rel rel
|
|
ON rel.mail_message_id = msg.id
|
|
RIGHT JOIN mail_channel_partner cp
|
|
ON (cp.channel_id = rel.mail_channel_id AND cp.partner_id = %s AND
|
|
(cp.seen_message_id IS NULL OR cp.seen_message_id < msg.id))
|
|
WHERE msg.model = %s AND msg.res_id = ANY(%s) AND
|
|
msg.message_type != 'user_notification' AND
|
|
(msg.author_id IS NULL OR msg.author_id != %s) AND
|
|
(msg.message_type not in ('notification', 'user_notification') OR msg.model != 'mail.channel')""",
|
|
(partner_id, self._name, list(self.ids), partner_id,))
|
|
for result in self._cr.fetchall():
|
|
res[result[0]] += 1
|
|
|
|
for record in self:
|
|
record.message_unread_counter = res.get(record._origin.id, 0)
|
|
record.message_unread = bool(record.message_unread_counter)
|
|
|
|
def _get_message_needaction(self):
|
|
res = dict.fromkeys(self.ids, 0)
|
|
if self.ids:
|
|
# search for unread messages, directly in SQL to improve performances
|
|
self._cr.execute(""" SELECT msg.res_id FROM mail_message msg
|
|
RIGHT JOIN mail_message_res_partner_needaction_rel rel
|
|
ON rel.mail_message_id = msg.id AND rel.res_partner_id = %s AND (rel.is_read = false OR rel.is_read IS NULL)
|
|
WHERE msg.model = %s AND msg.res_id in %s AND msg.message_type != 'user_notification'""",
|
|
(self.env.user.partner_id.id, self._name, tuple(self.ids),))
|
|
for result in self._cr.fetchall():
|
|
res[result[0]] += 1
|
|
|
|
for record in self:
|
|
record.message_needaction_counter = res.get(record._origin.id, 0)
|
|
record.message_needaction = bool(record.message_needaction_counter)
|
|
|
|
@api.model
|
|
def _search_message_needaction(self, operator, operand):
|
|
return [('message_ids.needaction', operator, operand)]
|
|
|
|
def _compute_message_has_error(self):
|
|
res = {}
|
|
if self.ids:
|
|
self._cr.execute(""" SELECT msg.res_id, COUNT(msg.res_id) FROM mail_message msg
|
|
RIGHT JOIN mail_message_res_partner_needaction_rel rel
|
|
ON rel.mail_message_id = msg.id AND rel.notification_status in ('exception','bounce')
|
|
WHERE msg.author_id = %s AND msg.model = %s AND msg.res_id in %s AND msg.message_type != 'user_notification'
|
|
GROUP BY msg.res_id""",
|
|
(self.env.user.partner_id.id, self._name, tuple(self.ids),))
|
|
res.update(self._cr.fetchall())
|
|
|
|
for record in self:
|
|
record.message_has_error_counter = res.get(record._origin.id, 0)
|
|
record.message_has_error = bool(record.message_has_error_counter)
|
|
|
|
@api.model
|
|
def _search_message_has_error(self, operator, operand):
|
|
message_ids = self.env['mail.message']._search([('has_error', operator, operand), ('author_id', '=', self.env.user.partner_id.id)])
|
|
return [('message_ids', 'in', message_ids)]
|
|
|
|
def _compute_message_attachment_count(self):
|
|
read_group_var = self.env['ir.attachment'].read_group([('res_id', 'in', self.ids), ('res_model', '=', self._name)],
|
|
fields=['res_id'],
|
|
groupby=['res_id'])
|
|
|
|
attachment_count_dict = dict((d['res_id'], d['res_id_count']) for d in read_group_var)
|
|
for record in self:
|
|
record.message_attachment_count = attachment_count_dict.get(record.id, 0)
|
|
|
|
# ------------------------------------------------------------
|
|
# CRUD
|
|
# ------------------------------------------------------------
|
|
|
|
# @api.model_create_multi
|
|
# def create(self, vals_list):
|
|
# """ Chatter override :
|
|
# - subscribe uid
|
|
# - subscribe followers of parent
|
|
# - log a creation message
|
|
# """
|
|
# if self._context.get('tracking_disable'):
|
|
# threads = super(MailThread, self).create(vals_list)
|
|
# threads._discard_tracking()
|
|
# return threads
|
|
# curframe = inspect.currentframe()
|
|
# calframe = inspect.getouterframes(curframe, 2)
|
|
# print("vals_list : ", vals_list)
|
|
# print('caller name:', calframe)
|
|
#
|
|
# threads = super(MailThread, self).create(vals_list)
|
|
#
|
|
#
|
|
# # subscribe uid unless asked not to
|
|
# if not self._context.get('mail_create_nosubscribe'):
|
|
# for thread in threads:
|
|
# self.env['mail.followers']._insert_followers(
|
|
# thread._name, thread.ids, self.env.user.partner_id.ids,
|
|
# None, None, None,
|
|
# customer_ids=[],
|
|
# check_existing=False
|
|
# )
|
|
#
|
|
# # auto_subscribe: take values and defaults into account
|
|
# create_values_list = {}
|
|
# for thread, values in zip(threads, vals_list):
|
|
# create_values = dict(values)
|
|
# for key, val in self._context.items():
|
|
# if key.startswith('default_') and key[8:] not in create_values:
|
|
# create_values[key[8:]] = val
|
|
# thread._message_auto_subscribe(create_values, followers_existing_policy='update')
|
|
# create_values_list[thread.id] = create_values
|
|
#
|
|
# # automatic logging unless asked not to (mainly for various testing purpose)
|
|
# if not self._context.get('mail_create_nolog'):
|
|
# threads_no_subtype = self.env[self._name]
|
|
# for thread in threads:
|
|
# subtype = thread._creation_subtype()
|
|
# if subtype: # if we have a subtype, post message to notify users from _message_auto_subscribe
|
|
# thread.sudo().message_post(subtype_id=subtype.id, author_id=self.env.user.partner_id.id)
|
|
# else:
|
|
# threads_no_subtype += thread
|
|
# if threads_no_subtype:
|
|
# bodies = dict(
|
|
# (thread.id, thread._creation_message())
|
|
# for thread in threads_no_subtype)
|
|
# threads_no_subtype._message_log_batch(bodies=bodies)
|
|
#
|
|
# # post track template if a tracked field changed
|
|
# threads._discard_tracking()
|
|
# if not self._context.get('mail_notrack'):
|
|
# fnames = self._get_tracked_fields()
|
|
# for thread in threads:
|
|
# create_values = create_values_list[thread.id]
|
|
# changes = [fname for fname in fnames if create_values.get(fname)]
|
|
# # based on tracked field to stay consistent with write
|
|
# # we don't consider that a falsy field is a change, to stay consistent with previous implementation,
|
|
# # but we may want to change that behaviour later.
|
|
# thread._message_track_post_template(changes)
|
|
#
|
|
# return threads
|
|
|
|
def write(self, values):
|
|
if self._context.get('tracking_disable'):
|
|
return super(MailThread, self).write(values)
|
|
|
|
if not self._context.get('mail_notrack'):
|
|
self._prepare_tracking(self._fields)
|
|
|
|
# Perform write
|
|
result = super(MailThread, self).write(values)
|
|
|
|
# update followers
|
|
self._message_auto_subscribe(values)
|
|
|
|
return result
|
|
|
|
def unlink(self):
|
|
""" Override unlink to delete messages and followers. This cannot be
|
|
cascaded, because link is done through (res_model, res_id). """
|
|
if not self:
|
|
return True
|
|
# discard pending tracking
|
|
self._discard_tracking()
|
|
self.env['mail.message'].search([('model', '=', self._name), ('res_id', 'in', self.ids)]).sudo().unlink()
|
|
res = super(MailThread, self).unlink()
|
|
self.env['mail.followers'].sudo().search(
|
|
[('res_model', '=', self._name), ('res_id', 'in', self.ids)]
|
|
).unlink()
|
|
return res
|
|
|
|
def copy_data(self, default=None):
|
|
# avoid tracking multiple temporary changes during copy
|
|
return super(MailThread, self.with_context(mail_notrack=True)).copy_data(default=default)
|
|
|
|
@api.model
|
|
def get_empty_list_help(self, help):
|
|
""" Override of BaseModel.get_empty_list_help() to generate an help message
|
|
that adds alias information. """
|
|
model = self._context.get('empty_list_help_model')
|
|
res_id = self._context.get('empty_list_help_id')
|
|
catchall_domain = self.env['ir.config_parameter'].sudo().get_param("mail.catchall.domain")
|
|
document_name = self._context.get('empty_list_help_document_name', _('document'))
|
|
nothing_here = not help
|
|
alias = None
|
|
|
|
if catchall_domain and model and res_id: # specific res_id -> find its alias (i.e. section_id specified)
|
|
record = self.env[model].sudo().browse(res_id)
|
|
# check that the alias effectively creates new records
|
|
if record.alias_id and record.alias_id.alias_name and \
|
|
record.alias_id.alias_model_id and \
|
|
record.alias_id.alias_model_id.model == self._name and \
|
|
record.alias_id.alias_force_thread_id == 0:
|
|
alias = record.alias_id
|
|
if not alias and catchall_domain and model: # no res_id or res_id not linked to an alias -> generic help message, take a generic alias of the model
|
|
Alias = self.env['mail.alias']
|
|
aliases = Alias.search([
|
|
("alias_parent_model_id.model", "=", model),
|
|
("alias_name", "!=", False),
|
|
('alias_force_thread_id', '=', False),
|
|
('alias_parent_thread_id', '=', False)], order='id ASC')
|
|
if aliases and len(aliases) == 1:
|
|
alias = aliases[0]
|
|
|
|
if alias:
|
|
email_link = "<a href='mailto:%(email)s'>%(email)s</a>" % {'email': alias.display_name}
|
|
if nothing_here:
|
|
return "<p class='o_view_nocontent_smiling_face'>%(dyn_help)s</p>" % {
|
|
'dyn_help': _("Add a new %(document)s or send an email to %(email_link)s",
|
|
document=document_name,
|
|
email_link=email_link,
|
|
)
|
|
}
|
|
# do not add alias two times if it was added previously
|
|
if "oe_view_nocontent_alias" not in help:
|
|
return "%(static_help)s<p class='oe_view_nocontent_alias'>%(dyn_help)s</p>" % {
|
|
'static_help': help,
|
|
'dyn_help': _("Create new %(document)s by sending an email to %(email_link)s",
|
|
document=document_name,
|
|
email_link=email_link,
|
|
)
|
|
}
|
|
|
|
if nothing_here:
|
|
return "<p class='o_view_nocontent_smiling_face'>%(dyn_help)s</p>" % {
|
|
'dyn_help': _("Create new %(document)s", document=document_name),
|
|
}
|
|
|
|
return help
|
|
|
|
# ------------------------------------------------------
|
|
# MODELS / CRUD HELPERS
|
|
# ------------------------------------------------------
|
|
|
|
def _compute_field_value(self, field):
|
|
if not self._context.get('tracking_disable') and not self._context.get('mail_notrack'):
|
|
self._prepare_tracking(f.name for f in self.pool.field_computed[field] if f.store)
|
|
|
|
return super()._compute_field_value(field)
|
|
|
|
def _creation_subtype(self):
|
|
""" Give the subtypes triggered by the creation of a record
|
|
|
|
:returns: a subtype browse record (empty if no subtype is triggered)
|
|
"""
|
|
return self.env['mail.message.subtype']
|
|
|
|
def _get_creation_message(self):
|
|
""" Deprecated, remove in 14+ """
|
|
return self._creation_message()
|
|
|
|
def _creation_message(self):
|
|
""" Get the creation message to log into the chatter at the record's creation.
|
|
:returns: The message's body to log.
|
|
"""
|
|
self.ensure_one()
|
|
doc_name = self.env['ir.model']._get(self._name).name
|
|
return _('%s created', doc_name)
|
|
|
|
@api.model
|
|
def get_mail_message_access(self, res_ids, operation, model_name=None):
|
|
""" Deprecated, remove with v14+ """
|
|
return self._get_mail_message_access(res_ids, operation, model_name=model_name)
|
|
|
|
@api.model
|
|
def _get_mail_message_access(self, res_ids, operation, model_name=None):
|
|
""" mail.message check permission rules for related document. This method is
|
|
meant to be inherited in order to implement addons-specific behavior.
|
|
A common behavior would be to allow creating messages when having read
|
|
access rule on the document, for portal document such as issues. """
|
|
|
|
DocModel = self.env[model_name] if model_name else self
|
|
create_allow = getattr(DocModel, '_mail_post_access', 'write')
|
|
|
|
if operation in ['write', 'unlink']:
|
|
check_operation = 'write'
|
|
elif operation == 'create' and create_allow in ['create', 'read', 'write', 'unlink']:
|
|
check_operation = create_allow
|
|
elif operation == 'create':
|
|
check_operation = 'write'
|
|
else:
|
|
check_operation = operation
|
|
return check_operation
|
|
|
|
def _valid_field_parameter(self, field, name):
|
|
# allow tracking on models inheriting from 'mail.thread'
|
|
return name == 'tracking' or super()._valid_field_parameter(field, name)
|
|
|
|
def with_lang(self):
|
|
""" Deprecated, remove in 14+ """
|
|
return self._fallback_lang()
|
|
|
|
def _fallback_lang(self):
|
|
if not self._context.get("lang"):
|
|
return self.with_context(lang=self.env.user.lang)
|
|
return self
|
|
|
|
# ------------------------------------------------------
|
|
# WRAPPERS AND TOOLS
|
|
# ------------------------------------------------------
|
|
|
|
def message_change_thread(self, new_thread):
|
|
"""
|
|
Transfer the list of the mail thread messages from an model to another
|
|
|
|
:param id : the old res_id of the mail.message
|
|
:param new_res_id : the new res_id of the mail.message
|
|
:param new_model : the name of the new model of the mail.message
|
|
|
|
Example : my_lead.message_change_thread(my_project_task)
|
|
will transfer the context of the thread of my_lead to my_project_task
|
|
"""
|
|
self.ensure_one()
|
|
# get the subtype of the comment Message
|
|
subtype_comment = self.env['ir.model.data'].xmlid_to_res_id('mail.mt_comment')
|
|
|
|
# get the ids of the comment and not-comment of the thread
|
|
# TDE check: sudo on mail.message, to be sure all messages are moved ?
|
|
MailMessage = self.env['mail.message']
|
|
msg_comment = MailMessage.search([
|
|
('model', '=', self._name),
|
|
('res_id', '=', self.id),
|
|
('message_type', '!=', 'user_notification'),
|
|
('subtype_id', '=', subtype_comment)])
|
|
msg_not_comment = MailMessage.search([
|
|
('model', '=', self._name),
|
|
('res_id', '=', self.id),
|
|
('message_type', '!=', 'user_notification'),
|
|
('subtype_id', '!=', subtype_comment)])
|
|
|
|
# update the messages
|
|
msg_comment.write({"res_id": new_thread.id, "model": new_thread._name})
|
|
msg_not_comment.write({"res_id": new_thread.id, "model": new_thread._name, "subtype_id": None})
|
|
return True
|
|
|
|
# ------------------------------------------------------
|
|
# TRACKING / LOG
|
|
# ------------------------------------------------------
|
|
|
|
def _prepare_tracking(self, fields):
|
|
""" Prepare the tracking of ``fields`` for ``self``.
|
|
|
|
:param fields: iterable of fields names to potentially track
|
|
"""
|
|
fnames = self._get_tracked_fields().intersection(fields)
|
|
if not fnames:
|
|
return
|
|
self.env.cr.precommit.add(self._finalize_tracking)
|
|
initial_values = self.env.cr.precommit.data.setdefault(f'mail.tracking.{self._name}', {})
|
|
for record in self:
|
|
if not record.id:
|
|
continue
|
|
values = initial_values.setdefault(record.id, {})
|
|
if values is not None:
|
|
for fname in fnames:
|
|
values.setdefault(fname, record[fname])
|
|
|
|
def _discard_tracking(self):
|
|
""" Prevent any tracking of fields on ``self``. """
|
|
if not self._get_tracked_fields():
|
|
return
|
|
self.env.cr.precommit.add(self._finalize_tracking)
|
|
initial_values = self.env.cr.precommit.data.setdefault(f'mail.tracking.{self._name}', {})
|
|
# disable tracking by setting initial values to None
|
|
for id_ in self.ids:
|
|
initial_values[id_] = None
|
|
|
|
def _finalize_tracking(self):
|
|
""" Generate the tracking messages for the records that have been
|
|
prepared with ``_prepare_tracking``.
|
|
"""
|
|
initial_values = self.env.cr.precommit.data.pop(f'mail.tracking.{self._name}', {})
|
|
ids = [id_ for id_, vals in initial_values.items() if vals]
|
|
if not ids:
|
|
return
|
|
records = self.browse(ids).sudo()
|
|
fnames = self._get_tracked_fields()
|
|
context = clean_context(self._context)
|
|
tracking = records.with_context(context).message_track(fnames, initial_values)
|
|
for record in records:
|
|
changes, tracking_value_ids = tracking.get(record.id, (None, None))
|
|
record._message_track_post_template(changes)
|
|
# this method is called after the main flush() and just before commit();
|
|
# we have to flush() again in case we triggered some recomputations
|
|
self.flush()
|
|
|
|
@tools.ormcache('self.env.uid', 'self.env.su')
|
|
def _get_tracked_fields(self):
|
|
""" Return the set of tracked fields names for the current model. """
|
|
fields = {
|
|
name
|
|
for name, field in self._fields.items()
|
|
if getattr(field, 'tracking', None) or getattr(field, 'track_visibility', None)
|
|
}
|
|
|
|
return fields and set(self.fields_get(fields))
|
|
|
|
def _message_track_post_template(self, changes):
|
|
if not changes:
|
|
return True
|
|
# Clean the context to get rid of residual default_* keys
|
|
# that could cause issues afterward during the mail.message
|
|
# generation. Example: 'default_parent_id' would refer to
|
|
# the parent_id of the current record that was used during
|
|
# its creation, but could refer to wrong parent message id,
|
|
# leading to a traceback in case the related message_id
|
|
# doesn't exist
|
|
self = self.with_context(clean_context(self._context))
|
|
templates = self._track_template(changes)
|
|
for field_name, (template, post_kwargs) in templates.items():
|
|
if not template:
|
|
continue
|
|
if isinstance(template, str):
|
|
self._fallback_lang().message_post_with_view(template, **post_kwargs)
|
|
else:
|
|
self._fallback_lang().message_post_with_template(template.id, **post_kwargs)
|
|
return True
|
|
|
|
def _track_template(self, changes):
|
|
return dict()
|
|
|
|
def message_track(self, tracked_fields, initial_values):
|
|
""" Track updated values. Comparing the initial and current values of
|
|
the fields given in tracked_fields, it generates a message containing
|
|
the updated values. This message can be linked to a mail.message.subtype
|
|
given by the ``_track_subtype`` method.
|
|
|
|
:param tracked_fields: iterable of field names to track
|
|
:param initial_values: mapping {record_id: {field_name: value}}
|
|
:return: mapping {record_id: (changed_field_names, tracking_value_ids)}
|
|
containing existing records only
|
|
"""
|
|
if not tracked_fields:
|
|
return True
|
|
|
|
tracked_fields = self.fields_get(tracked_fields)
|
|
tracking = dict()
|
|
for record in self:
|
|
try:
|
|
tracking[record.id] = record._message_track(tracked_fields, initial_values[record.id])
|
|
except MissingError:
|
|
continue
|
|
|
|
for record in self:
|
|
changes, tracking_value_ids = tracking.get(record.id, (None, None))
|
|
if not changes:
|
|
continue
|
|
|
|
# find subtypes and post messages or log if no subtype found
|
|
subtype = False
|
|
# By passing this key, that allows to let the subtype empty and so don't sent email because partners_to_notify from mail_message._notify will be empty
|
|
if not self._context.get('mail_track_log_only'):
|
|
subtype = record._track_subtype(dict((col_name, initial_values[record.id][col_name]) for col_name in changes))
|
|
if subtype:
|
|
if not subtype.exists():
|
|
_logger.debug('subtype "%s" not found' % subtype.name)
|
|
continue
|
|
record.message_post(subtype_id=subtype.id, tracking_value_ids=tracking_value_ids)
|
|
elif tracking_value_ids:
|
|
record._message_log(tracking_value_ids=tracking_value_ids)
|
|
|
|
return tracking
|
|
|
|
def static_message_track(self, record, tracked_fields, initial):
|
|
""" Deprecated, remove in v14+ """
|
|
return record._mail_track(tracked_fields, initial)
|
|
|
|
def _message_track(self, tracked_fields, initial):
|
|
""" Moved to ``BaseModel._mail_track()`` """
|
|
return self._mail_track(tracked_fields, initial)
|
|
|
|
def _track_subtype(self, init_values):
|
|
""" Give the subtypes triggered by the changes on the record according
|
|
to values that have been updated.
|
|
|
|
:param init_values: the original values of the record; only modified fields
|
|
are present in the dict
|
|
:type init_values: dict
|
|
:returns: a subtype browse record or False if no subtype is trigerred
|
|
"""
|
|
return False
|
|
|
|
# ------------------------------------------------------
|
|
# MAIL GATEWAY
|
|
# ------------------------------------------------------
|
|
|
|
def _routing_warn(self, error_message, message_id, route, raise_exception=True):
|
|
""" Tools method used in _routing_check_route: whether to log a warning or raise an error """
|
|
short_message = _("Mailbox unavailable - %s", error_message)
|
|
full_message = ('Routing mail with Message-Id %s: route %s: %s' %
|
|
(message_id, route, error_message))
|
|
_logger.info(full_message)
|
|
if raise_exception:
|
|
# sender should not see private diagnostics info, just the error
|
|
raise ValueError(short_message)
|
|
|
|
def _routing_create_bounce_email(self, email_from, body_html, message, **mail_values):
|
|
bounce_to = tools.decode_message_header(message, 'Return-Path') or email_from
|
|
bounce_mail_values = {
|
|
'author_id': False,
|
|
'body_html': body_html,
|
|
'subject': 'Re: %s' % message.get('subject'),
|
|
'email_to': bounce_to,
|
|
'auto_delete': True,
|
|
}
|
|
bounce_from = self.env['ir.mail_server']._get_default_bounce_address()
|
|
if bounce_from:
|
|
bounce_mail_values['email_from'] = tools.formataddr(('MAILER-DAEMON', bounce_from))
|
|
elif self.env['ir.config_parameter'].sudo().get_param("mail.catchall.alias") not in message['To']:
|
|
bounce_mail_values['email_from'] = tools.decode_message_header(message, 'To')
|
|
else:
|
|
bounce_mail_values['email_from'] = tools.formataddr(('MAILER-DAEMON', self.env.user.email_normalized))
|
|
bounce_mail_values.update(mail_values)
|
|
self.env['mail.mail'].sudo().create(bounce_mail_values).send()
|
|
|
|
@api.model
|
|
def _routing_handle_bounce(self, email_message, message_dict):
|
|
""" Handle bounce of incoming email. Based on values of the bounce (email
|
|
and related partner, send message and its messageID)
|
|
|
|
* find blacklist-enabled records with email_normalized = bounced email
|
|
and call ``_message_receive_bounce`` on each of them to propagate
|
|
bounce information through various records linked to same email;
|
|
* if not already done (i.e. if original record is not blacklist enabled
|
|
like a bounce on an applicant), find record linked to bounced message
|
|
and call ``_message_receive_bounce``;
|
|
|
|
:param email_message: incoming email;
|
|
:type email_message: email.message;
|
|
:param message_dict: dictionary holding already-parsed values and in
|
|
which bounce-related values will be added;
|
|
:type message_dict: dictionary;
|
|
"""
|
|
bounced_record, bounced_record_done = False, False
|
|
bounced_email, bounced_partner = message_dict['bounced_email'], message_dict['bounced_partner']
|
|
bounced_msg_id, bounced_message = message_dict['bounced_msg_id'], message_dict['bounced_message']
|
|
|
|
if bounced_email:
|
|
bounced_model, bounced_res_id = bounced_message.model, bounced_message.res_id
|
|
|
|
if bounced_model and bounced_model in self.env and bounced_res_id:
|
|
bounced_record = self.env[bounced_model].sudo().browse(bounced_res_id).exists()
|
|
|
|
bl_models = self.env['ir.model'].sudo().search(['&', ('is_mail_blacklist', '=', True), ('model', '!=', 'mail.thread.blacklist')])
|
|
for model in [bl_model for bl_model in bl_models if bl_model.model in self.env]: # transient test mode
|
|
rec_bounce_w_email = self.env[model.model].sudo().search([('email_normalized', '=', bounced_email)])
|
|
rec_bounce_w_email._message_receive_bounce(bounced_email, bounced_partner)
|
|
bounced_record_done = bool(bounced_record and model.model == bounced_model and bounced_record in rec_bounce_w_email)
|
|
|
|
# set record as bounced unless already done due to blacklist mixin
|
|
if bounced_record and not bounced_record_done and issubclass(type(bounced_record), self.pool['mail.thread']):
|
|
bounced_record._message_receive_bounce(bounced_email, bounced_partner)
|
|
|
|
if bounced_partner and bounced_message:
|
|
self.env['mail.notification'].sudo().search([
|
|
('mail_message_id', '=', bounced_message.id),
|
|
('res_partner_id', 'in', bounced_partner.ids)]
|
|
).write({'notification_status': 'bounce'})
|
|
|
|
if bounced_record:
|
|
_logger.info('Routing mail from %s to %s with Message-Id %s: not routing bounce email from %s replying to %s (model %s ID %s)',
|
|
message_dict['email_from'], message_dict['to'], message_dict['message_id'], bounced_email, bounced_msg_id, bounced_model, bounced_res_id)
|
|
elif bounced_email:
|
|
_logger.info('Routing mail from %s to %s with Message-Id %s: not routing bounce email from %s replying to %s (no document found)',
|
|
message_dict['email_from'], message_dict['to'], message_dict['message_id'], bounced_email, bounced_msg_id)
|
|
else:
|
|
_logger.info('Routing mail from %s to %s with Message-Id %s: not routing bounce email.',
|
|
message_dict['email_from'], message_dict['to'], message_dict['message_id'])
|
|
|
|
@api.model
|
|
def _routing_check_route(self, message, message_dict, route, raise_exception=True):
|
|
""" Verify route validity. Check and rules:
|
|
1 - if thread_id -> check that document effectively exists; otherwise
|
|
fallback on a message_new by resetting thread_id
|
|
2 - check that message_update exists if thread_id is set; or at least
|
|
that message_new exist
|
|
3 - if there is an alias, check alias_contact:
|
|
'followers' and thread_id:
|
|
check on target document that the author is in the followers
|
|
'followers' and alias_parent_thread_id:
|
|
check on alias parent document that the author is in the
|
|
followers
|
|
'partners': check that author_id id set
|
|
|
|
:param message: an email.message instance
|
|
:param message_dict: dictionary of values that will be given to
|
|
mail_message.create()
|
|
:param route: route to check which is a tuple (model, thread_id,
|
|
custom_values, uid, alias)
|
|
:param raise_exception: if an error occurs, tell whether to raise an error
|
|
or just log a warning and try other processing or
|
|
invalidate route
|
|
"""
|
|
|
|
assert isinstance(route, (list, tuple)), 'A route should be a list or a tuple'
|
|
assert len(route) == 5, 'A route should contain 5 elements: model, thread_id, custom_values, uid, alias record'
|
|
|
|
message_id = message_dict['message_id']
|
|
email_from = message_dict['email_from']
|
|
author_id = message_dict.get('author_id')
|
|
model, thread_id, alias = route[0], route[1], route[4]
|
|
record_set = None
|
|
|
|
# Wrong model
|
|
if not model:
|
|
self._routing_warn(_('target model unspecified'), message_id, route, raise_exception)
|
|
return ()
|
|
elif model not in self.env:
|
|
self._routing_warn(_('unknown target model %s', model), message_id, route, raise_exception)
|
|
return ()
|
|
record_set = self.env[model].browse(thread_id) if thread_id else self.env[model]
|
|
|
|
# Existing Document: check if exists and model accepts the mailgateway; if not, fallback on create if allowed
|
|
if thread_id:
|
|
if not record_set.exists():
|
|
self._routing_warn(
|
|
_('reply to missing document (%(model)s,%(thread)s), fall back on document creation', model=model, thread=thread_id),
|
|
message_id,
|
|
route,
|
|
False
|
|
)
|
|
thread_id = None
|
|
elif not hasattr(record_set, 'message_update'):
|
|
self._routing_warn(_('reply to model %s that does not accept document update, fall back on document creation', model), message_id, route, False)
|
|
thread_id = None
|
|
|
|
# New Document: check model accepts the mailgateway
|
|
if not thread_id and model and not hasattr(record_set, 'message_new'):
|
|
self._routing_warn(_('model %s does not accept document creation', model), message_id, route, raise_exception)
|
|
return ()
|
|
|
|
# Update message author. We do it now because we need it for aliases (contact settings)
|
|
if not author_id:
|
|
if record_set:
|
|
authors = self._mail_find_partner_from_emails([email_from], records=record_set)
|
|
elif alias and alias.alias_parent_model_id and alias.alias_parent_thread_id:
|
|
records = self.env[alias.alias_parent_model_id.model].browse(alias.alias_parent_thread_id)
|
|
authors = self._mail_find_partner_from_emails([email_from], records=records)
|
|
else:
|
|
authors = self._mail_find_partner_from_emails([email_from], records=None)
|
|
if authors:
|
|
message_dict['author_id'] = authors[0].id
|
|
|
|
# Alias: check alias_contact settings
|
|
if alias:
|
|
if thread_id:
|
|
obj = record_set[0]
|
|
elif alias.alias_parent_model_id and alias.alias_parent_thread_id:
|
|
obj = self.env[alias.alias_parent_model_id.model].browse(alias.alias_parent_thread_id)
|
|
else:
|
|
obj = self.env[model]
|
|
error_message = obj._alias_get_error_message(message, message_dict, alias)
|
|
if error_message:
|
|
self._routing_warn(
|
|
_('alias %(name)s: %(error)s', name=alias.alias_name, error=error_message or _('unknown error')),
|
|
message_id,
|
|
route,
|
|
False
|
|
)
|
|
body = alias._get_alias_bounced_body(message_dict)
|
|
self._routing_create_bounce_email(email_from, body, message, references=message_id)
|
|
return False
|
|
|
|
return (model, thread_id, route[2], route[3], route[4])
|
|
|
|
@api.model
|
|
def _routing_reset_bounce(self, email_message, message_dict):
|
|
"""Called by ``message_process`` when a new mail is received from an email address.
|
|
If the email is related to a partner, we consider that the number of message_bounce
|
|
is not relevant anymore as the email is valid - as we received an email from this
|
|
address. The model is here hardcoded because we cannot know with which model the
|
|
incomming mail match. We consider that if a mail arrives, we have to clear bounce for
|
|
each model having bounce count.
|
|
|
|
:param email_from: email address that sent the incoming email."""
|
|
valid_email = message_dict['email_from']
|
|
if valid_email:
|
|
bl_models = self.env['ir.model'].sudo().search(['&', ('is_mail_blacklist', '=', True), ('model', '!=', 'mail.thread.blacklist')])
|
|
for model in [bl_model for bl_model in bl_models if bl_model.model in self.env]: # transient test mode
|
|
self.env[model.model].sudo().search([('message_bounce', '>', 0), ('email_normalized', '=', valid_email)])._message_reset_bounce(valid_email)
|
|
|
|
@api.model
|
|
def message_route(self, message, message_dict, model=None, thread_id=None, custom_values=None):
|
|
""" Attempt to figure out the correct target model, thread_id,
|
|
custom_values and user_id to use for an incoming message.
|
|
Multiple values may be returned, if a message had multiple
|
|
recipients matching existing mail.aliases, for example.
|
|
|
|
The following heuristics are used, in this order:
|
|
|
|
* if the message replies to an existing thread by having a Message-Id
|
|
that matches an existing mail_message.message_id, we take the original
|
|
message model/thread_id pair and ignore custom_value as no creation will
|
|
take place;
|
|
* look for a mail.alias entry matching the message recipients and use the
|
|
corresponding model, thread_id, custom_values and user_id. This could
|
|
lead to a thread update or creation depending on the alias;
|
|
* fallback on provided ``model``, ``thread_id`` and ``custom_values``;
|
|
* raise an exception as no route has been found
|
|
|
|
:param string message: an email.message instance
|
|
:param dict message_dict: dictionary holding parsed message variables
|
|
:param string model: the fallback model to use if the message does not match
|
|
any of the currently configured mail aliases (may be None if a matching
|
|
alias is supposed to be present)
|
|
:type dict custom_values: optional dictionary of default field values
|
|
to pass to ``message_new`` if a new record needs to be created.
|
|
Ignored if the thread record already exists, and also if a matching
|
|
mail.alias was found (aliases define their own defaults)
|
|
:param int thread_id: optional ID of the record/thread from ``model`` to
|
|
which this mail should be attached. Only used if the message does not
|
|
reply to an existing thread and does not match any mail alias.
|
|
:return: list of routes [(model, thread_id, custom_values, user_id, alias)]
|
|
|
|
:raises: ValueError, TypeError
|
|
"""
|
|
if not isinstance(message, EmailMessage):
|
|
raise TypeError('message must be an email.message.EmailMessage at this point')
|
|
catchall_alias = self.env['ir.config_parameter'].sudo().get_param("mail.catchall.alias")
|
|
bounce_alias = self.env['ir.config_parameter'].sudo().get_param("mail.bounce.alias")
|
|
fallback_model = model
|
|
|
|
# get email.message.Message variables for future processing
|
|
local_hostname = socket.gethostname()
|
|
message_id = message_dict['message_id']
|
|
|
|
# compute references to find if message is a reply to an existing thread
|
|
thread_references = message_dict['references'] or message_dict['in_reply_to']
|
|
msg_references = [
|
|
re.sub(r'[\r\n\t ]+', r'', ref) # "Unfold" buggy references
|
|
for ref in tools.mail_header_msgid_re.findall(thread_references)
|
|
if 'reply_to' not in ref
|
|
]
|
|
mail_messages = self.env['mail.message'].sudo().search([('message_id', 'in', msg_references)], limit=1, order='id desc, message_id')
|
|
is_a_reply = bool(mail_messages)
|
|
reply_model, reply_thread_id = mail_messages.model, mail_messages.res_id
|
|
|
|
# author and recipients
|
|
email_from = message_dict['email_from']
|
|
email_from_localpart = (tools.email_split(email_from) or [''])[0].split('@', 1)[0].lower()
|
|
email_to = message_dict['to']
|
|
email_to_localparts = [
|
|
e.split('@', 1)[0].lower()
|
|
for e in (tools.email_split(email_to) or [''])
|
|
]
|
|
# Delivered-To is a safe bet in most modern MTAs, but we have to fallback on To + Cc values
|
|
# for all the odd MTAs out there, as there is no standard header for the envelope's `rcpt_to` value.
|
|
rcpt_tos_localparts = [
|
|
e.split('@')[0].lower()
|
|
for e in tools.email_split(message_dict['recipients'])
|
|
]
|
|
rcpt_tos_valid_localparts = [to for to in rcpt_tos_localparts]
|
|
|
|
# 0. Handle bounce: verify whether this is a bounced email and use it to collect bounce data and update notifications for customers
|
|
# Bounce regex: typical form of bounce is bounce_alias+128-crm.lead-34@domain
|
|
# group(1) = the mail ID; group(2) = the model (if any); group(3) = the record ID
|
|
# Bounce message (not alias)
|
|
# See http://datatracker.ietf.org/doc/rfc3462/?include_text=1
|
|
# As all MTA does not respect this RFC (googlemail is one of them),
|
|
# we also need to verify if the message come from "mailer-daemon"
|
|
# If not a bounce: reset bounce information
|
|
if bounce_alias and any(email.startswith(bounce_alias) for email in email_to_localparts):
|
|
bounce_re = re.compile("%s\+(\d+)-?([\w.]+)?-?(\d+)?" % re.escape(bounce_alias), re.UNICODE)
|
|
bounce_match = bounce_re.search(email_to)
|
|
if bounce_match:
|
|
self._routing_handle_bounce(message, message_dict)
|
|
return []
|
|
if message.get_content_type() == 'multipart/report' or email_from_localpart == 'mailer-daemon':
|
|
self._routing_handle_bounce(message, message_dict)
|
|
return []
|
|
self._routing_reset_bounce(message, message_dict)
|
|
|
|
# 1. Handle reply
|
|
# if destination = alias with different model -> consider it is a forward and not a reply
|
|
# if destination = alias with same model -> check contact settings as they still apply
|
|
if reply_model and reply_thread_id:
|
|
other_model_aliases = self.env['mail.alias'].search([
|
|
'&', '&',
|
|
('alias_name', '!=', False),
|
|
('alias_name', 'in', email_to_localparts),
|
|
('alias_model_id.model', '!=', reply_model),
|
|
])
|
|
if other_model_aliases:
|
|
is_a_reply = False
|
|
rcpt_tos_valid_localparts = [to for to in rcpt_tos_valid_localparts if to in other_model_aliases.mapped('alias_name')]
|
|
|
|
if is_a_reply:
|
|
dest_aliases = self.env['mail.alias'].search([
|
|
('alias_name', 'in', rcpt_tos_localparts),
|
|
('alias_model_id.model', '=', reply_model)
|
|
], limit=1)
|
|
|
|
user_id = self._mail_find_user_for_gateway(email_from, alias=dest_aliases).id or self._uid
|
|
route = self._routing_check_route(
|
|
message, message_dict,
|
|
(reply_model, reply_thread_id, custom_values, user_id, dest_aliases),
|
|
raise_exception=False)
|
|
if route:
|
|
_logger.info(
|
|
'Routing mail from %s to %s with Message-Id %s: direct reply to msg: model: %s, thread_id: %s, custom_values: %s, uid: %s',
|
|
email_from, email_to, message_id, reply_model, reply_thread_id, custom_values, self._uid)
|
|
return [route]
|
|
elif route is False:
|
|
return []
|
|
|
|
# 2. Handle new incoming email by checking aliases and applying their settings
|
|
if rcpt_tos_localparts:
|
|
# no route found for a matching reference (or reply), so parent is invalid
|
|
message_dict.pop('parent_id', None)
|
|
|
|
# check it does not directly contact catchall
|
|
if catchall_alias and email_to_localparts and all(email_localpart == catchall_alias for email_localpart in email_to_localparts):
|
|
_logger.info('Routing mail from %s to %s with Message-Id %s: direct write to catchall, bounce', email_from, email_to, message_id)
|
|
body = self.env.ref('mail.mail_bounce_catchall')._render({
|
|
'message': message,
|
|
}, engine='ir.qweb')
|
|
self._routing_create_bounce_email(email_from, body, message, references=message_id, reply_to=self.env.company.email)
|
|
return []
|
|
|
|
dest_aliases = self.env['mail.alias'].search([('alias_name', 'in', rcpt_tos_valid_localparts)])
|
|
if dest_aliases:
|
|
routes = []
|
|
for alias in dest_aliases:
|
|
user_id = self._mail_find_user_for_gateway(email_from, alias=alias).id or self._uid
|
|
route = (alias.alias_model_id.model, alias.alias_force_thread_id, ast.literal_eval(alias.alias_defaults), user_id, alias)
|
|
route = self._routing_check_route(message, message_dict, route, raise_exception=True)
|
|
if route:
|
|
_logger.info(
|
|
'Routing mail from %s to %s with Message-Id %s: direct alias match: %r',
|
|
email_from, email_to, message_id, route)
|
|
routes.append(route)
|
|
return routes
|
|
|
|
# 3. Fallback to the provided parameters, if they work
|
|
if fallback_model:
|
|
# no route found for a matching reference (or reply), so parent is invalid
|
|
message_dict.pop('parent_id', None)
|
|
user_id = self._mail_find_user_for_gateway(email_from).id or self._uid
|
|
route = self._routing_check_route(
|
|
message, message_dict,
|
|
(fallback_model, thread_id, custom_values, user_id, None),
|
|
raise_exception=True)
|
|
if route:
|
|
_logger.info(
|
|
'Routing mail from %s to %s with Message-Id %s: fallback to model:%s, thread_id:%s, custom_values:%s, uid:%s',
|
|
email_from, email_to, message_id, fallback_model, thread_id, custom_values, user_id)
|
|
return [route]
|
|
|
|
# ValueError if no routes found and if no bounce occured
|
|
raise ValueError(
|
|
'No possible route found for incoming message from %s to %s (Message-Id %s:). '
|
|
'Create an appropriate mail.alias or force the destination model.' %
|
|
(email_from, email_to, message_id)
|
|
)
|
|
|
|
@api.model
|
|
def _message_route_process(self, message, message_dict, routes):
|
|
self = self.with_context(attachments_mime_plainxml=True) # import XML attachments as text
|
|
# postpone setting message_dict.partner_ids after message_post, to avoid double notifications
|
|
original_partner_ids = message_dict.pop('partner_ids', [])
|
|
thread_id = False
|
|
for model, thread_id, custom_values, user_id, alias in routes or ():
|
|
subtype_id = False
|
|
related_user = self.env['res.users'].browse(user_id)
|
|
Model = self.env[model].with_context(mail_create_nosubscribe=True, mail_create_nolog=True)
|
|
if not (thread_id and hasattr(Model, 'message_update') or hasattr(Model, 'message_new')):
|
|
raise ValueError(
|
|
"Undeliverable mail with Message-Id %s, model %s does not accept incoming emails" %
|
|
(message_dict['message_id'], model)
|
|
)
|
|
|
|
# disabled subscriptions during message_new/update to avoid having the system user running the
|
|
# email gateway become a follower of all inbound messages
|
|
ModelCtx = Model.with_user(related_user).sudo()
|
|
if thread_id and hasattr(ModelCtx, 'message_update'):
|
|
thread = ModelCtx.browse(thread_id)
|
|
thread.message_update(message_dict)
|
|
else:
|
|
# if a new thread is created, parent is irrelevant
|
|
message_dict.pop('parent_id', None)
|
|
thread = ModelCtx.message_new(message_dict, custom_values)
|
|
thread_id = thread.id
|
|
subtype_id = thread._creation_subtype().id
|
|
|
|
# replies to internal message are considered as notes, but parent message
|
|
# author is added in recipients to ensure he is notified of a private answer
|
|
parent_message = False
|
|
if message_dict.get('parent_id'):
|
|
parent_message = self.env['mail.message'].sudo().browse(message_dict['parent_id'])
|
|
partner_ids = []
|
|
if not subtype_id:
|
|
if message_dict.get('is_internal'):
|
|
subtype_id = self.env['ir.model.data'].xmlid_to_res_id('mail.mt_note')
|
|
if parent_message and parent_message.author_id:
|
|
partner_ids = [parent_message.author_id.id]
|
|
else:
|
|
subtype_id = self.env['ir.model.data'].xmlid_to_res_id('mail.mt_comment')
|
|
|
|
post_params = dict(subtype_id=subtype_id, partner_ids=partner_ids, **message_dict)
|
|
# remove computational values not stored on mail.message and avoid warnings when creating it
|
|
for x in ('from', 'to', 'cc', 'recipients', 'references', 'in_reply_to', 'bounced_email', 'bounced_message', 'bounced_msg_id', 'bounced_partner'):
|
|
post_params.pop(x, None)
|
|
new_msg = False
|
|
if thread._name == 'mail.thread': # message with parent_id not linked to record
|
|
new_msg = thread.message_notify(**post_params)
|
|
else:
|
|
# parsing should find an author independently of user running mail gateway, and ensure it is not odoobot
|
|
partner_from_found = message_dict.get('author_id') and message_dict['author_id'] != self.env['ir.model.data'].xmlid_to_res_id('base.partner_root')
|
|
thread = thread.with_context(mail_create_nosubscribe=not partner_from_found)
|
|
new_msg = thread.message_post(**post_params)
|
|
|
|
if new_msg and original_partner_ids:
|
|
# postponed after message_post, because this is an external message and we don't want to create
|
|
# duplicate emails due to notifications
|
|
new_msg.write({'partner_ids': original_partner_ids})
|
|
return thread_id
|
|
|
|
@api.model
|
|
def message_process(self, model, message, custom_values=None,
|
|
save_original=False, strip_attachments=False,
|
|
thread_id=None):
|
|
""" Process an incoming RFC2822 email message, relying on
|
|
``mail.message.parse()`` for the parsing operation,
|
|
and ``message_route()`` to figure out the target model.
|
|
|
|
Once the target model is known, its ``message_new`` method
|
|
is called with the new message (if the thread record did not exist)
|
|
or its ``message_update`` method (if it did).
|
|
|
|
:param string model: the fallback model to use if the message
|
|
does not match any of the currently configured mail aliases
|
|
(may be None if a matching alias is supposed to be present)
|
|
:param message: source of the RFC2822 message
|
|
:type message: string or xmlrpclib.Binary
|
|
:type dict custom_values: optional dictionary of field values
|
|
to pass to ``message_new`` if a new record needs to be created.
|
|
Ignored if the thread record already exists, and also if a
|
|
matching mail.alias was found (aliases define their own defaults)
|
|
:param bool save_original: whether to keep a copy of the original
|
|
email source attached to the message after it is imported.
|
|
:param bool strip_attachments: whether to strip all attachments
|
|
before processing the message, in order to save some space.
|
|
:param int thread_id: optional ID of the record/thread from ``model``
|
|
to which this mail should be attached. When provided, this
|
|
overrides the automatic detection based on the message
|
|
headers.
|
|
"""
|
|
# extract message bytes - we are forced to pass the message as binary because
|
|
# we don't know its encoding until we parse its headers and hence can't
|
|
# convert it to utf-8 for transport between the mailgate script and here.
|
|
if isinstance(message, xmlrpclib.Binary):
|
|
message = bytes(message.data)
|
|
if isinstance(message, str):
|
|
message = message.encode('utf-8')
|
|
message = email.message_from_bytes(message, policy=email.policy.SMTP)
|
|
|
|
# parse the message, verify we are not in a loop by checking message_id is not duplicated
|
|
msg_dict = self.message_parse(message, save_original=save_original)
|
|
if strip_attachments:
|
|
msg_dict.pop('attachments', None)
|
|
|
|
existing_msg_ids = self.env['mail.message'].search([('message_id', '=', msg_dict['message_id'])], limit=1)
|
|
if existing_msg_ids:
|
|
_logger.info('Ignored mail from %s to %s with Message-Id %s: found duplicated Message-Id during processing',
|
|
msg_dict.get('email_from'), msg_dict.get('to'), msg_dict.get('message_id'))
|
|
return False
|
|
|
|
# find possible routes for the message
|
|
routes = self.message_route(message, msg_dict, model, thread_id, custom_values)
|
|
thread_id = self._message_route_process(message, msg_dict, routes)
|
|
return thread_id
|
|
|
|
@api.model
|
|
def message_new(self, msg_dict, custom_values=None):
|
|
"""Called by ``message_process`` when a new message is received
|
|
for a given thread model, if the message did not belong to
|
|
an existing thread.
|
|
The default behavior is to create a new record of the corresponding
|
|
model (based on some very basic info extracted from the message).
|
|
Additional behavior may be implemented by overriding this method.
|
|
|
|
:param dict msg_dict: a map containing the email details and
|
|
attachments. See ``message_process`` and
|
|
``mail.message.parse`` for details.
|
|
:param dict custom_values: optional dictionary of additional
|
|
field values to pass to create()
|
|
when creating the new thread record.
|
|
Be careful, these values may override
|
|
any other values coming from the message.
|
|
:rtype: int
|
|
:return: the id of the newly created thread object
|
|
"""
|
|
data = {}
|
|
if isinstance(custom_values, dict):
|
|
data = custom_values.copy()
|
|
fields = self.fields_get()
|
|
name_field = self._rec_name or 'name'
|
|
if name_field in fields and not data.get('name'):
|
|
data[name_field] = msg_dict.get('subject', '')
|
|
return self.create(data)
|
|
|
|
def message_update(self, msg_dict, update_vals=None):
|
|
"""Called by ``message_process`` when a new message is received
|
|
for an existing thread. The default behavior is to update the record
|
|
with update_vals taken from the incoming email.
|
|
Additional behavior may be implemented by overriding this
|
|
method.
|
|
:param dict msg_dict: a map containing the email details and
|
|
attachments. See ``message_process`` and
|
|
``mail.message.parse()`` for details.
|
|
:param dict update_vals: a dict containing values to update records
|
|
given their ids; if the dict is None or is
|
|
void, no write operation is performed.
|
|
"""
|
|
if update_vals:
|
|
self.write(update_vals)
|
|
return True
|
|
|
|
def _message_receive_bounce(self, email, partner):
|
|
"""Called by ``message_process`` when a bounce email (such as Undelivered
|
|
Mail Returned to Sender) is received for an existing thread. The default
|
|
behavior is to do nothing. This method is meant to be overridden in various
|
|
modules to add some specific behavior like blacklist management or mass
|
|
mailing statistics update. check is an integer ``message_bounce`` column exists.
|
|
If it is the case, its content is incremented.
|
|
|
|
:param string email: email that caused the bounce;
|
|
:param record partner: partner matching the bounced email address, if any;
|
|
"""
|
|
pass
|
|
|
|
def _message_reset_bounce(self, email):
|
|
"""Called by ``message_process`` when an email is considered as not being
|
|
a bounce. The default behavior is to do nothing. This method is meant to
|
|
be overridden in various modules to add some specific behavior like
|
|
blacklist management.
|
|
|
|
:param string email: email for which to reset bounce information
|
|
"""
|
|
pass
|
|
|
|
def _message_parse_extract_payload_postprocess(self, message, payload_dict):
|
|
""" Perform some cleaning / postprocess in the body and attachments
|
|
extracted from the email. Note that this processing is specific to the
|
|
mail module, and should not contain security or generic html cleaning.
|
|
Indeed those aspects should be covered by the html_sanitize method
|
|
located in tools. """
|
|
body, attachments = payload_dict['body'], payload_dict['attachments']
|
|
if not body:
|
|
return payload_dict
|
|
try:
|
|
root = lxml.html.fromstring(body)
|
|
except ValueError:
|
|
# In case the email client sent XHTML, fromstring will fail because 'Unicode strings
|
|
# with encoding declaration are not supported'.
|
|
root = lxml.html.fromstring(body.encode('utf-8'))
|
|
|
|
postprocessed = False
|
|
to_remove = []
|
|
for node in root.iter():
|
|
if 'o_mail_notification' in (node.get('class') or '') or 'o_mail_notification' in (node.get('summary') or ''):
|
|
postprocessed = True
|
|
if node.getparent() is not None:
|
|
to_remove.append(node)
|
|
if node.tag == 'img' and node.get('src', '').startswith('cid:'):
|
|
cid = node.get('src').split(':', 1)[1]
|
|
related_attachment = [attach for attach in attachments if attach[2] and attach[2].get('cid') == cid]
|
|
if related_attachment:
|
|
node.set('data-filename', related_attachment[0][0])
|
|
postprocessed = True
|
|
|
|
for node in to_remove:
|
|
node.getparent().remove(node)
|
|
if postprocessed:
|
|
body = etree.tostring(root, pretty_print=False, encoding='unicode')
|
|
return {'body': body, 'attachments': attachments}
|
|
|
|
def _message_parse_extract_payload(self, message, save_original=False):
|
|
"""Extract body as HTML and attachments from the mail message"""
|
|
attachments = []
|
|
body = u''
|
|
if save_original:
|
|
attachments.append(self._Attachment('original_email.eml', message.as_string(), {}))
|
|
|
|
# Be careful, content-type may contain tricky content like in the
|
|
# following example so test the MIME type with startswith()
|
|
#
|
|
# Content-Type: multipart/related;
|
|
# boundary="_004_3f1e4da175f349248b8d43cdeb9866f1AMSPR06MB343eurprd06pro_";
|
|
# type="text/html"
|
|
if message.get_content_maintype() == 'text':
|
|
encoding = message.get_content_charset()
|
|
body = message.get_content()
|
|
body = tools.ustr(body, encoding, errors='replace')
|
|
if message.get_content_type() == 'text/plain':
|
|
# text/plain -> <pre/>
|
|
body = tools.append_content_to_html(u'', body, preserve=True)
|
|
else:
|
|
alternative = False
|
|
mixed = False
|
|
html = u''
|
|
for part in message.walk():
|
|
if part.get_content_type() == 'multipart/alternative':
|
|
alternative = True
|
|
if part.get_content_type() == 'multipart/mixed':
|
|
mixed = True
|
|
if part.get_content_maintype() == 'multipart':
|
|
continue # skip container
|
|
|
|
filename = part.get_filename() # I may not properly handle all charsets
|
|
encoding = part.get_content_charset() # None if attachment
|
|
|
|
# 0) Inline Attachments -> attachments, with a third part in the tuple to match cid / attachment
|
|
if filename and part.get('content-id'):
|
|
inner_cid = part.get('content-id').strip('><')
|
|
attachments.append(self._Attachment(filename, part.get_content(), {'cid': inner_cid}))
|
|
continue
|
|
# 1) Explicit Attachments -> attachments
|
|
if filename or part.get('content-disposition', '').strip().startswith('attachment'):
|
|
attachments.append(self._Attachment(filename or 'attachment', part.get_content(), {}))
|
|
continue
|
|
# 2) text/plain -> <pre/>
|
|
if part.get_content_type() == 'text/plain' and (not alternative or not body):
|
|
body = tools.append_content_to_html(body, tools.ustr(part.get_content(),
|
|
encoding, errors='replace'), preserve=True)
|
|
# 3) text/html -> raw
|
|
elif part.get_content_type() == 'text/html':
|
|
# mutlipart/alternative have one text and a html part, keep only the second
|
|
# mixed allows several html parts, append html content
|
|
append_content = not alternative or (html and mixed)
|
|
html = tools.ustr(part.get_content(), encoding, errors='replace')
|
|
if not append_content:
|
|
body = html
|
|
else:
|
|
body = tools.append_content_to_html(body, html, plaintext=False)
|
|
# we only strip_classes here everything else will be done in by html field of mail.message
|
|
body = tools.html_sanitize(body, sanitize_tags=False, strip_classes=True)
|
|
# 4) Anything else -> attachment
|
|
else:
|
|
attachments.append(self._Attachment(filename or 'attachment', part.get_content(), {}))
|
|
|
|
return self._message_parse_extract_payload_postprocess(message, {'body': body, 'attachments': attachments})
|
|
|
|
def _message_parse_extract_bounce(self, email_message, message_dict):
|
|
""" Parse email and extract bounce information to be used in future
|
|
processing.
|
|
|
|
:param email_message: an email.message instance;
|
|
:param message_dict: dictionary holding already-parsed values;
|
|
|
|
:return dict: bounce-related values will be added, containing
|
|
|
|
* bounced_email: email that bounced (normalized);
|
|
* bounce_partner: res.partner recordset whose email_normalized =
|
|
bounced_email;
|
|
* bounced_msg_id: list of message_ID references (<...@myserver>) linked
|
|
to the email that bounced;
|
|
* bounced_message: if found, mail.message recordset matching bounced_msg_id;
|
|
"""
|
|
if not isinstance(email_message, EmailMessage):
|
|
raise TypeError('message must be an email.message.EmailMessage at this point')
|
|
|
|
email_part = next((part for part in email_message.walk() if part.get_content_type() in {'message/rfc822', 'text/rfc822-headers'}), None)
|
|
dsn_part = next((part for part in email_message.walk() if part.get_content_type() == 'message/delivery-status'), None)
|
|
|
|
bounced_email = False
|
|
bounced_partner = self.env['res.partner'].sudo()
|
|
if dsn_part and len(dsn_part.get_payload()) > 1:
|
|
dsn = dsn_part.get_payload()[1]
|
|
final_recipient_data = tools.decode_message_header(dsn, 'Final-Recipient')
|
|
bounced_email = tools.email_normalize(final_recipient_data.split(';', 1)[1].strip())
|
|
if bounced_email:
|
|
bounced_partner = self.env['res.partner'].sudo().search([('email_normalized', '=', bounced_email)])
|
|
|
|
bounced_msg_id = False
|
|
bounced_message = self.env['mail.message'].sudo()
|
|
if email_part:
|
|
if email_part.get_content_type() == 'text/rfc822-headers':
|
|
# Convert the message body into a message itself
|
|
email_payload = message_from_string(email_part.get_payload(), policy=policy.SMTP)
|
|
else:
|
|
email_payload = email_part.get_payload()[0]
|
|
bounced_msg_id = tools.mail_header_msgid_re.findall(tools.decode_message_header(email_payload, 'Message-Id'))
|
|
if bounced_msg_id:
|
|
bounced_message = self.env['mail.message'].sudo().search([('message_id', 'in', bounced_msg_id)])
|
|
|
|
return {
|
|
'bounced_email': bounced_email,
|
|
'bounced_partner': bounced_partner,
|
|
'bounced_msg_id': bounced_msg_id,
|
|
'bounced_message': bounced_message,
|
|
}
|
|
|
|
@api.model
|
|
def message_parse(self, message, save_original=False):
|
|
""" Parses an email.message.Message representing an RFC-2822 email
|
|
and returns a generic dict holding the message details.
|
|
|
|
:param message: email to parse
|
|
:type message: email.message.Message
|
|
:param bool save_original: whether the returned dict should include
|
|
an ``original`` attachment containing the source of the message
|
|
:rtype: dict
|
|
:return: A dict with the following structure, where each field may not
|
|
be present if missing in original message::
|
|
|
|
{ 'message_id': msg_id,
|
|
'subject': subject,
|
|
'email_from': from,
|
|
'to': to + delivered-to,
|
|
'cc': cc,
|
|
'recipients': delivered-to + to + cc + resent-to + resent-cc,
|
|
'partner_ids': partners found based on recipients emails,
|
|
'body': unified_body,
|
|
'references': references,
|
|
'in_reply_to': in-reply-to,
|
|
'parent_id': parent mail.message based on in_reply_to or references,
|
|
'is_internal': answer to an internal message (note),
|
|
'date': date,
|
|
'attachments': [('file1', 'bytes'),
|
|
('file2', 'bytes')}
|
|
}
|
|
"""
|
|
if not isinstance(message, EmailMessage):
|
|
raise ValueError(_('Message should be a valid EmailMessage instance'))
|
|
msg_dict = {'message_type': 'email'}
|
|
|
|
message_id = message.get('Message-Id')
|
|
if not message_id:
|
|
# Very unusual situation, be we should be fault-tolerant here
|
|
message_id = "<%s@localhost>" % time.time()
|
|
_logger.debug('Parsing Message without message-id, generating a random one: %s', message_id)
|
|
msg_dict['message_id'] = message_id.strip()
|
|
|
|
if message.get('Subject'):
|
|
msg_dict['subject'] = tools.decode_message_header(message, 'Subject')
|
|
|
|
email_from = tools.decode_message_header(message, 'From')
|
|
email_cc = tools.decode_message_header(message, 'cc')
|
|
email_from_list = tools.email_split_and_format(email_from)
|
|
email_cc_list = tools.email_split_and_format(email_cc)
|
|
msg_dict['email_from'] = email_from_list[0] if email_from_list else email_from
|
|
msg_dict['from'] = msg_dict['email_from'] # compatibility for message_new
|
|
msg_dict['cc'] = ','.join(email_cc_list) if email_cc_list else email_cc
|
|
# Delivered-To is a safe bet in most modern MTAs, but we have to fallback on To + Cc values
|
|
# for all the odd MTAs out there, as there is no standard header for the envelope's `rcpt_to` value.
|
|
msg_dict['recipients'] = ','.join(set(formatted_email
|
|
for address in [
|
|
tools.decode_message_header(message, 'Delivered-To'),
|
|
tools.decode_message_header(message, 'To'),
|
|
tools.decode_message_header(message, 'Cc'),
|
|
tools.decode_message_header(message, 'Resent-To'),
|
|
tools.decode_message_header(message, 'Resent-Cc')
|
|
] if address
|
|
for formatted_email in tools.email_split_and_format(address))
|
|
)
|
|
msg_dict['to'] = ','.join(set(formatted_email
|
|
for address in [
|
|
tools.decode_message_header(message, 'Delivered-To'),
|
|
tools.decode_message_header(message, 'To')
|
|
] if address
|
|
for formatted_email in tools.email_split_and_format(address))
|
|
)
|
|
partner_ids = [x.id for x in self._mail_find_partner_from_emails(tools.email_split(msg_dict['recipients']), records=self) if x]
|
|
msg_dict['partner_ids'] = partner_ids
|
|
# compute references to find if email_message is a reply to an existing thread
|
|
msg_dict['references'] = tools.decode_message_header(message, 'References')
|
|
msg_dict['in_reply_to'] = tools.decode_message_header(message, 'In-Reply-To').strip()
|
|
|
|
if message.get('Date'):
|
|
try:
|
|
date_hdr = tools.decode_message_header(message, 'Date')
|
|
parsed_date = dateutil.parser.parse(date_hdr, fuzzy=True)
|
|
if parsed_date.utcoffset() is None:
|
|
# naive datetime, so we arbitrarily decide to make it
|
|
# UTC, there's no better choice. Should not happen,
|
|
# as RFC2822 requires timezone offset in Date headers.
|
|
stored_date = parsed_date.replace(tzinfo=pytz.utc)
|
|
else:
|
|
stored_date = parsed_date.astimezone(tz=pytz.utc)
|
|
except Exception:
|
|
_logger.info('Failed to parse Date header %r in incoming mail '
|
|
'with message-id %r, assuming current date/time.',
|
|
message.get('Date'), message_id)
|
|
stored_date = datetime.datetime.now()
|
|
msg_dict['date'] = stored_date.strftime(tools.DEFAULT_SERVER_DATETIME_FORMAT)
|
|
|
|
parent_ids = False
|
|
if msg_dict['in_reply_to']:
|
|
parent_ids = self.env['mail.message'].search([('message_id', '=', msg_dict['in_reply_to'])], limit=1)
|
|
if msg_dict['references'] and not parent_ids:
|
|
references_msg_id_list = tools.mail_header_msgid_re.findall(msg_dict['references'])
|
|
parent_ids = self.env['mail.message'].search([('message_id', 'in', [x.strip() for x in references_msg_id_list])], limit=1)
|
|
if parent_ids:
|
|
msg_dict['parent_id'] = parent_ids.id
|
|
msg_dict['is_internal'] = parent_ids.subtype_id and parent_ids.subtype_id.internal or False
|
|
|
|
msg_dict.update(self._message_parse_extract_payload(message, save_original=save_original))
|
|
msg_dict.update(self._message_parse_extract_bounce(message, msg_dict))
|
|
return msg_dict
|
|
|
|
# ------------------------------------------------------
|
|
# RECIPIENTS MANAGEMENT TOOLS
|
|
# ------------------------------------------------------
|
|
|
|
@api.model
|
|
def _message_get_default_recipients_on_records(self, records):
|
|
""" Moved to ``BaseModel._message_get_default_recipients()`` """
|
|
return records._message_get_default_recipients()
|
|
|
|
def _message_add_suggested_recipient(self, result, partner=None, email=None, reason=''):
|
|
""" Called by _message_get_suggested_recipients, to add a suggested
|
|
recipient in the result dictionary. The form is :
|
|
partner_id, partner_name<partner_email> or partner_name, reason """
|
|
self.ensure_one()
|
|
if email and not partner:
|
|
# get partner info from email
|
|
partner_info = self._message_partner_info_from_emails([email])[0]
|
|
if partner_info.get('partner_id'):
|
|
partner = self.env['res.partner'].sudo().browse([partner_info['partner_id']])[0]
|
|
if email and email in [val[1] for val in result[self.ids[0]]]: # already existing email -> skip
|
|
return result
|
|
if partner and partner in self.message_partner_ids: # recipient already in the followers -> skip
|
|
return result
|
|
if partner and partner.id in [val[0] for val in result[self.ids[0]]]: # already existing partner ID -> skip
|
|
return result
|
|
if partner and partner.email: # complete profile: id, name <email>
|
|
result[self.ids[0]].append((partner.id, partner.email_formatted, reason))
|
|
elif partner: # incomplete profile: id, name
|
|
result[self.ids[0]].append((partner.id, '%s' % (partner.name), reason))
|
|
else: # unknown partner, we are probably managing an email address
|
|
result[self.ids[0]].append((False, email, reason))
|
|
return result
|
|
|
|
def _message_get_suggested_recipients(self):
|
|
""" Returns suggested recipients for ids. Those are a list of
|
|
tuple (partner_id, partner_name, reason), to be managed by Chatter. """
|
|
result = dict((res_id, []) for res_id in self.ids)
|
|
if 'user_id' in self._fields:
|
|
for obj in self.sudo(): # SUPERUSER because of a read on res.users that would crash otherwise
|
|
if not obj.user_id or not obj.user_id.partner_id:
|
|
continue
|
|
obj._message_add_suggested_recipient(result, partner=obj.user_id.partner_id, reason=self._fields['user_id'].string)
|
|
return result
|
|
|
|
def _mail_search_on_user(self, normalized_emails, extra_domain=False):
|
|
""" Find partners linked to users, given an email address that will
|
|
be normalized. Search is done as sudo on res.users model to avoid domain
|
|
on partner like ('user_ids', '!=', False) that would not be efficient. """
|
|
domain = [('email_normalized', 'in', normalized_emails)]
|
|
if extra_domain:
|
|
domain = expression.AND([domain, extra_domain])
|
|
partners = self.env['res.users'].sudo().search(domain, order='name ASC').mapped('partner_id')
|
|
# return a search on partner to filter results current user should not see (multi company for example)
|
|
return self.env['res.partner'].search([('id', 'in', partners.ids)])
|
|
|
|
def _mail_search_on_partner(self, normalized_emails, extra_domain=False):
|
|
domain = [('email_normalized', 'in', normalized_emails)]
|
|
if extra_domain:
|
|
domain = expression.AND([domain, extra_domain])
|
|
return self.env['res.partner'].search(domain)
|
|
|
|
def _mail_find_user_for_gateway(self, email, alias=None):
|
|
""" Utility method to find user from email address that can create documents
|
|
in the target model. Purpose is to link document creation to users whenever
|
|
possible, for example when creating document through mailgateway.
|
|
|
|
Heuristic
|
|
|
|
* alias owner record: fetch in its followers for user with matching email;
|
|
* find any user with matching emails;
|
|
* try alias owner as fallback;
|
|
|
|
Note that standard search order is applied.
|
|
|
|
:param str email: will be sanitized and parsed to find email;
|
|
:param mail.alias alias: optional alias. Used to fetch owner followers
|
|
or fallback user (alias owner);
|
|
:param fallback_model: if not alias, related model to check access rights;
|
|
|
|
:return res.user user: user matching email or void recordset if none found
|
|
"""
|
|
# find normalized emails and exclude aliases (to avoid subscribing alias emails to records)
|
|
normalized_email = tools.email_normalize(email)
|
|
catchall_domain = self.env['ir.config_parameter'].sudo().get_param("mail.catchall.domain")
|
|
if normalized_email and catchall_domain:
|
|
left_part = normalized_email.split('@')[0] if normalized_email.split('@')[1] == catchall_domain.lower() else False
|
|
if left_part:
|
|
if self.env['mail.alias'].sudo().search_count([('alias_name', '=', left_part)]):
|
|
return self.env['res.users']
|
|
|
|
if alias and alias.alias_parent_model_id and alias.alias_parent_thread_id:
|
|
followers = self.env['mail.followers'].search([
|
|
('res_model', '=', alias.alias_parent_model_id.model),
|
|
('res_id', '=', alias.alias_parent_thread_id)]
|
|
).mapped('partner_id')
|
|
else:
|
|
followers = self.env['res.partner']
|
|
|
|
follower_users = self.env['res.users'].search([
|
|
('partner_id', 'in', followers.ids), ('email_normalized', '=', normalized_email)
|
|
], limit=1) if followers else self.env['res.users']
|
|
matching_user = follower_users[0] if follower_users else self.env['res.users']
|
|
if matching_user:
|
|
return matching_user
|
|
|
|
if not matching_user:
|
|
std_users = self.env['res.users'].sudo().search([('email_normalized', '=', normalized_email)], limit=1, order='name ASC')
|
|
matching_user = std_users[0] if std_users else self.env['res.users']
|
|
if matching_user:
|
|
return matching_user
|
|
|
|
if not matching_user and alias and alias.alias_user_id:
|
|
matching_user = alias and alias.alias_user_id
|
|
if matching_user:
|
|
return matching_user
|
|
|
|
return matching_user
|
|
|
|
@api.model
|
|
def _mail_find_partner_from_emails(self, emails, records=None, force_create=False):
|
|
""" Utility method to find partners from email addresses. If no partner is
|
|
found, create new partners if force_create is enabled. Search heuristics
|
|
|
|
* 1: check in records (record set) followers if records is mail.thread
|
|
enabled and if check_followers parameter is enabled;
|
|
* 2: search for partners with user;
|
|
* 3: search for partners;
|
|
|
|
:param records: record set on which to check followers;
|
|
:param list emails: list of email addresses for finding partner;
|
|
:param boolean force_create: create a new partner if not found
|
|
|
|
:return list partners: a list of partner records ordered as given emails.
|
|
If no partner has been found and/or created for a given emails its
|
|
matching partner is an empty record.
|
|
"""
|
|
if records and issubclass(type(records), self.pool['mail.thread']):
|
|
followers = records.mapped('message_partner_ids')
|
|
else:
|
|
followers = self.env['res.partner']
|
|
catchall_domain = self.env['ir.config_parameter'].sudo().get_param("mail.catchall.domain")
|
|
|
|
# first, build a normalized email list and remove those linked to aliases to avoid adding aliases as partners
|
|
normalized_emails = [tools.email_normalize(contact) for contact in emails if tools.email_normalize(contact)]
|
|
if catchall_domain:
|
|
domain_left_parts = [email.split('@')[0] for email in normalized_emails if email and email.split('@')[1] == catchall_domain.lower()]
|
|
if domain_left_parts:
|
|
found_alias_names = self.env['mail.alias'].sudo().search([('alias_name', 'in', domain_left_parts)]).mapped('alias_name')
|
|
normalized_emails = [email for email in normalized_emails if email.split('@')[0] not in found_alias_names]
|
|
|
|
done_partners = [follower for follower in followers if follower.email_normalized in normalized_emails]
|
|
remaining = [email for email in normalized_emails if email not in [partner.email_normalized for partner in done_partners]]
|
|
|
|
user_partners = self._mail_search_on_user(remaining)
|
|
done_partners += [user_partner for user_partner in user_partners]
|
|
remaining = [email for email in normalized_emails if email not in [partner.email_normalized for partner in done_partners]]
|
|
|
|
partners = self._mail_search_on_partner(remaining)
|
|
done_partners += [partner for partner in partners]
|
|
remaining = [email for email in normalized_emails if email not in [partner.email_normalized for partner in done_partners]]
|
|
|
|
# iterate and keep ordering
|
|
partners = []
|
|
for contact in emails:
|
|
normalized_email = tools.email_normalize(contact)
|
|
partner = next((partner for partner in done_partners if partner.email_normalized == normalized_email), self.env['res.partner'])
|
|
if not partner and force_create and normalized_email in normalized_emails:
|
|
partner = self.env['res.partner'].browse(self.env['res.partner'].name_create(contact)[0])
|
|
partners.append(partner)
|
|
return partners
|
|
|
|
def _message_partner_info_from_emails(self, emails, link_mail=False):
|
|
""" Convert a list of emails into a list partner_ids and a list
|
|
new_partner_ids. The return value is non conventional because
|
|
it is meant to be used by the mail widget.
|
|
|
|
:return dict: partner_ids and new_partner_ids """
|
|
self.ensure_one()
|
|
MailMessage = self.env['mail.message'].sudo()
|
|
partners = self._mail_find_partner_from_emails(emails, records=self)
|
|
result = list()
|
|
for idx, contact in enumerate(emails):
|
|
partner = partners[idx]
|
|
partner_info = {'full_name': partner.email_formatted if partner else contact, 'partner_id': partner.id}
|
|
result.append(partner_info)
|
|
# link mail with this from mail to the new partner id
|
|
if link_mail and partner:
|
|
MailMessage.search([
|
|
('email_from', '=ilike', partner.email_normalized),
|
|
('author_id', '=', False)
|
|
]).write({'author_id': partner.id})
|
|
return result
|
|
|
|
# ------------------------------------------------------
|
|
# MESSAGE POST API
|
|
# ------------------------------------------------------
|
|
|
|
def _message_post_process_attachments(self, attachments, attachment_ids, message_values):
|
|
""" Preprocess attachments for mail_thread.message_post() or mail_mail.create().
|
|
|
|
:param list attachments: list of attachment tuples in the form ``(name,content)``, #todo xdo update that
|
|
where content is NOT base64 encoded
|
|
:param list attachment_ids: a list of attachment ids, not in tomany command form
|
|
:param dict message_data: model: the model of the attachments parent record,
|
|
res_id: the id of the attachments parent record
|
|
"""
|
|
return_values = {}
|
|
body = message_values.get('body')
|
|
model = message_values['model']
|
|
res_id = message_values['res_id']
|
|
|
|
m2m_attachment_ids = []
|
|
if attachment_ids:
|
|
# taking advantage of cache looks better in this case, to check
|
|
filtered_attachment_ids = self.env['ir.attachment'].sudo().browse(attachment_ids).filtered(
|
|
lambda a: a.res_model == 'mail.compose.message' and a.create_uid.id == self._uid)
|
|
# update filtered (pending) attachments to link them to the proper record
|
|
if filtered_attachment_ids:
|
|
filtered_attachment_ids.write({'res_model': model, 'res_id': res_id})
|
|
# prevent public and portal users from using attachments that are not theirs
|
|
if not self.env.user.has_group('base.group_user'):
|
|
attachment_ids = filtered_attachment_ids.ids
|
|
|
|
m2m_attachment_ids += [(4, id) for id in attachment_ids]
|
|
# Handle attachments parameter, that is a dictionary of attachments
|
|
|
|
if attachments: # generate
|
|
cids_in_body = set()
|
|
names_in_body = set()
|
|
cid_list = []
|
|
name_list = []
|
|
|
|
if body:
|
|
root = lxml.html.fromstring(tools.ustr(body))
|
|
# first list all attachments that will be needed in body
|
|
for node in root.iter('img'):
|
|
if node.get('src', '').startswith('cid:'):
|
|
cids_in_body.add(node.get('src').split('cid:')[1])
|
|
elif node.get('data-filename'):
|
|
names_in_body.add(node.get('data-filename'))
|
|
attachement_values_list = []
|
|
|
|
# generate values
|
|
for attachment in attachments:
|
|
cid = False
|
|
if len(attachment) == 2:
|
|
name, content = attachment
|
|
elif len(attachment) == 3:
|
|
name, content, info = attachment
|
|
cid = info and info.get('cid')
|
|
else:
|
|
continue
|
|
if isinstance(content, str):
|
|
content = content.encode('utf-8')
|
|
elif isinstance(content, EmailMessage):
|
|
content = content.as_bytes()
|
|
elif content is None:
|
|
continue
|
|
attachement_values= {
|
|
'name': name,
|
|
'datas': base64.b64encode(content),
|
|
'type': 'binary',
|
|
'description': name,
|
|
'res_model': model,
|
|
'res_id': res_id,
|
|
}
|
|
if body and (cid and cid in cids_in_body or name in names_in_body):
|
|
attachement_values['access_token'] = self.env['ir.attachment']._generate_access_token()
|
|
attachement_values_list.append(attachement_values)
|
|
# keep cid and name list synced with attachement_values_list length to match ids latter
|
|
cid_list.append(cid)
|
|
name_list.append(name)
|
|
new_attachments = self.env['ir.attachment'].create(attachement_values_list)
|
|
cid_mapping = {}
|
|
name_mapping = {}
|
|
for counter, new_attachment in enumerate(new_attachments):
|
|
cid = cid_list[counter]
|
|
if 'access_token' in attachement_values_list[counter]:
|
|
if cid:
|
|
cid_mapping[cid] = (new_attachment.id, attachement_values_list[counter]['access_token'])
|
|
name = name_list[counter]
|
|
name_mapping[name] = (new_attachment.id, attachement_values_list[counter]['access_token'])
|
|
m2m_attachment_ids.append((4, new_attachment.id))
|
|
|
|
# note: right know we are only taking attachments and ignoring attachment_ids.
|
|
if (cid_mapping or name_mapping) and body:
|
|
postprocessed = False
|
|
for node in root.iter('img'):
|
|
attachment_data = False
|
|
if node.get('src', '').startswith('cid:'):
|
|
cid = node.get('src').split('cid:')[1]
|
|
attachment_data = cid_mapping.get(cid)
|
|
if not attachment_data and node.get('data-filename'):
|
|
attachment_data = name_mapping.get(node.get('data-filename'), False)
|
|
if attachment_data:
|
|
node.set('src', '/web/image/%s?access_token=%s' % attachment_data)
|
|
postprocessed = True
|
|
if postprocessed:
|
|
return_values['body'] = lxml.html.tostring(root, pretty_print=False, encoding='UTF-8')
|
|
return_values['attachment_ids'] = m2m_attachment_ids
|
|
return return_values
|
|
|
|
@api.returns('mail.message', lambda value: value.id)
|
|
def message_post(self, *,
|
|
body='', subject=None, message_type='notification',
|
|
email_from=None, author_id=None, parent_id=False,
|
|
subtype_xmlid=None, subtype_id=False, partner_ids=None, channel_ids=None,
|
|
attachments=None, attachment_ids=None,
|
|
add_sign=True, record_name=False,
|
|
**kwargs):
|
|
""" Post a new message in an existing thread, returning the new
|
|
mail.message ID.
|
|
:param str body: body of the message, usually raw HTML that will
|
|
be sanitized
|
|
:param str subject: subject of the message
|
|
:param str message_type: see mail_message.message_type field. Can be anything but
|
|
user_notification, reserved for message_notify
|
|
:param int parent_id: handle thread formation
|
|
:param int subtype_id: subtype_id of the message, mainly use fore
|
|
followers mechanism
|
|
:param list(int) partner_ids: partner_ids to notify
|
|
:param list(int) channel_ids: channel_ids to notify
|
|
:param list(tuple(str,str), tuple(str,str, dict) or int) attachments : list of attachment tuples in the form
|
|
``(name,content)`` or ``(name,content, info)``, where content is NOT base64 encoded
|
|
:param list id attachment_ids: list of existing attachement to link to this message
|
|
-Should only be setted by chatter
|
|
-Attachement object attached to mail.compose.message(0) will be attached
|
|
to the related document.
|
|
Extra keyword arguments will be used as default column values for the
|
|
new mail.message record.
|
|
:return int: ID of newly created mail.message
|
|
"""
|
|
self.ensure_one() # should always be posted on a record, use message_notify if no record
|
|
# split message additional values from notify additional values
|
|
msg_kwargs = dict((key, val) for key, val in kwargs.items() if key in self.env['mail.message']._fields)
|
|
notif_kwargs = dict((key, val) for key, val in kwargs.items() if key not in msg_kwargs)
|
|
|
|
if self._name == 'mail.thread' or not self.id or message_type == 'user_notification':
|
|
raise ValueError('message_post should only be call to post message on record. Use message_notify instead')
|
|
|
|
if 'model' in msg_kwargs or 'res_id' in msg_kwargs:
|
|
raise ValueError("message_post doesn't support model and res_id parameters anymore. Please call message_post on record.")
|
|
if 'subtype' in kwargs:
|
|
raise ValueError("message_post doesn't support subtype parameter anymore. Please give a valid subtype_id or subtype_xmlid value instead.")
|
|
|
|
self = self._fallback_lang() # add lang to context imediatly since it will be usefull in various flows latter.
|
|
|
|
# Explicit access rights check, because display_name is computed as sudo.
|
|
self.check_access_rights('read')
|
|
self.check_access_rule('read')
|
|
record_name = record_name or self.display_name
|
|
|
|
partner_ids = set(partner_ids or [])
|
|
channel_ids = set(channel_ids or [])
|
|
|
|
if any(not isinstance(pc_id, int) for pc_id in partner_ids | channel_ids):
|
|
raise ValueError('message_post partner_ids and channel_ids must be integer list, not commands')
|
|
|
|
# Find the message's author
|
|
author_id, email_from = self._message_compute_author(author_id, email_from, raise_exception=True)
|
|
|
|
if subtype_xmlid:
|
|
subtype_id = self.env['ir.model.data'].xmlid_to_res_id(subtype_xmlid)
|
|
if not subtype_id:
|
|
subtype_id = self.env['ir.model.data'].xmlid_to_res_id('mail.mt_note')
|
|
|
|
# automatically subscribe recipients if asked to
|
|
if self._context.get('mail_post_autofollow') and partner_ids:
|
|
self.message_subscribe(list(partner_ids))
|
|
|
|
MailMessage_sudo = self.env['mail.message'].sudo()
|
|
if self._mail_flat_thread and not parent_id:
|
|
parent_message = MailMessage_sudo.search([('res_id', '=', self.id), ('model', '=', self._name), ('message_type', '!=', 'user_notification')], order="id ASC", limit=1)
|
|
# parent_message searched in sudo for performance, only used for id.
|
|
# Note that with sudo we will match message with internal subtypes.
|
|
parent_id = parent_message.id if parent_message else False
|
|
elif parent_id:
|
|
old_parent_id = parent_id
|
|
parent_message = MailMessage_sudo.search([('id', '=', parent_id), ('parent_id', '!=', False)], limit=1)
|
|
# avoid loops when finding ancestors
|
|
processed_list = []
|
|
if parent_message:
|
|
new_parent_id = parent_message.parent_id and parent_message.parent_id.id
|
|
while (new_parent_id and new_parent_id not in processed_list):
|
|
processed_list.append(new_parent_id)
|
|
parent_message = parent_message.parent_id
|
|
parent_id = parent_message.id
|
|
|
|
values = dict(msg_kwargs)
|
|
values.update({
|
|
'author_id': author_id,
|
|
'email_from': email_from,
|
|
'model': self._name,
|
|
'res_id': self.id,
|
|
'body': body,
|
|
'subject': subject or False,
|
|
'message_type': message_type,
|
|
'parent_id': parent_id,
|
|
'subtype_id': subtype_id,
|
|
'partner_ids': partner_ids,
|
|
'channel_ids': channel_ids,
|
|
'add_sign': add_sign,
|
|
'record_name': record_name,
|
|
})
|
|
attachments = attachments or []
|
|
attachment_ids = attachment_ids or []
|
|
attachement_values = self._message_post_process_attachments(attachments, attachment_ids, values)
|
|
values.update(attachement_values) # attachement_ids, [body]
|
|
|
|
new_message = self._message_create(values)
|
|
|
|
# Set main attachment field if necessary
|
|
self._message_set_main_attachment_id(values['attachment_ids'])
|
|
|
|
if values['author_id'] and values['message_type'] != 'notification' and not self._context.get('mail_create_nosubscribe'):
|
|
if self.env['res.partner'].browse(values['author_id']).active: # we dont want to add odoobot/inactive as a follower
|
|
self._message_subscribe([values['author_id']])
|
|
|
|
self._message_post_after_hook(new_message, values)
|
|
self._notify_thread(new_message, values, **notif_kwargs)
|
|
return new_message
|
|
|
|
def _message_set_main_attachment_id(self, attachment_ids): # todo move this out of mail.thread
|
|
if not self._abstract and attachment_ids and not self.message_main_attachment_id:
|
|
all_attachments = self.env['ir.attachment'].browse([attachment_tuple[1] for attachment_tuple in attachment_ids])
|
|
prioritary_attachments = all_attachments.filtered(lambda x: x.mimetype.endswith('pdf')) \
|
|
or all_attachments.filtered(lambda x: x.mimetype.startswith('image')) \
|
|
or all_attachments
|
|
self.sudo().with_context(tracking_disable=True).write({'message_main_attachment_id': prioritary_attachments[0].id})
|
|
|
|
def _message_post_after_hook(self, message, msg_vals):
|
|
""" Hook to add custom behavior after having posted the message. Both
|
|
message and computed value are given, to try to lessen query count by
|
|
using already-computed values instead of having to rebrowse things. """
|
|
pass
|
|
|
|
# ------------------------------------------------------
|
|
# MESSAGE POST TOOLS
|
|
# ------------------------------------------------------
|
|
|
|
def message_post_with_view(self, views_or_xmlid, **kwargs):
|
|
""" Helper method to send a mail / post a message using a view_id to
|
|
render using the ir.qweb engine. This method is stand alone, because
|
|
there is nothing in template and composer that allows to handle
|
|
views in batch. This method should probably disappear when templates
|
|
handle ir ui views. """
|
|
values = kwargs.pop('values', None) or dict()
|
|
try:
|
|
from odoo.addons.http_routing.models.ir_http import slug
|
|
values['slug'] = slug
|
|
except ImportError:
|
|
values['slug'] = lambda self: self.id
|
|
if isinstance(views_or_xmlid, str):
|
|
views = self.env.ref(views_or_xmlid, raise_if_not_found=False)
|
|
else:
|
|
views = views_or_xmlid
|
|
if not views:
|
|
return
|
|
for record in self:
|
|
values['object'] = record
|
|
rendered_template = views._render(values, engine='ir.qweb', minimal_qcontext=True)
|
|
kwargs['body'] = rendered_template
|
|
record.message_post_with_template(False, **kwargs)
|
|
|
|
def message_post_with_template(self, template_id, email_layout_xmlid=None, auto_commit=False, **kwargs):
|
|
""" Helper method to send a mail with a template
|
|
:param template_id : the id of the template to render to create the body of the message
|
|
:param **kwargs : parameter to create a mail.compose.message woaerd (which inherit from mail.message)
|
|
"""
|
|
# Get composition mode, or force it according to the number of record in self
|
|
if not kwargs.get('composition_mode'):
|
|
kwargs['composition_mode'] = 'comment' if len(self.ids) == 1 else 'mass_mail'
|
|
if not kwargs.get('message_type'):
|
|
kwargs['message_type'] = 'notification'
|
|
res_id = kwargs.get('res_id', self.ids and self.ids[0] or 0)
|
|
res_ids = kwargs.get('res_id') and [kwargs['res_id']] or self.ids
|
|
|
|
# Create the composer
|
|
composer = self.env['mail.compose.message'].with_context(
|
|
active_id=res_id,
|
|
active_ids=res_ids,
|
|
active_model=kwargs.get('model', self._name),
|
|
default_composition_mode=kwargs['composition_mode'],
|
|
default_model=kwargs.get('model', self._name),
|
|
default_res_id=res_id,
|
|
default_template_id=template_id,
|
|
custom_layout=email_layout_xmlid,
|
|
).create(kwargs)
|
|
# Simulate the onchange (like trigger in form the view) only
|
|
# when having a template in single-email mode
|
|
if template_id:
|
|
update_values = composer.onchange_template_id(template_id, kwargs['composition_mode'], self._name, res_id)['value']
|
|
composer.write(update_values)
|
|
return composer.send_mail(auto_commit=auto_commit)
|
|
|
|
def message_notify(self, *,
|
|
partner_ids=False, parent_id=False, model=False, res_id=False,
|
|
author_id=None, email_from=None, body='', subject=False, **kwargs):
|
|
""" Shortcut allowing to notify partners of messages that shouldn't be
|
|
displayed on a document. It pushes notifications on inbox or by email depending
|
|
on the user configuration, like other notifications. """
|
|
if self:
|
|
self.ensure_one()
|
|
# split message additional values from notify additional values
|
|
msg_kwargs = dict((key, val) for key, val in kwargs.items() if key in self.env['mail.message']._fields)
|
|
notif_kwargs = dict((key, val) for key, val in kwargs.items() if key not in msg_kwargs)
|
|
|
|
author_id, email_from = self._message_compute_author(author_id, email_from, raise_exception=True)
|
|
|
|
if not partner_ids:
|
|
_logger.warning('Message notify called without recipient_ids, skipping')
|
|
return self.env['mail.message']
|
|
|
|
if not (model and res_id): # both value should be set or none should be set (record)
|
|
model = False
|
|
res_id = False
|
|
|
|
MailThread = self.env['mail.thread']
|
|
values = {
|
|
'parent_id': parent_id,
|
|
'model': self._name if self else False,
|
|
'res_id': self.id if self else False,
|
|
'message_type': 'user_notification',
|
|
'subject': subject,
|
|
'body': body,
|
|
'author_id': author_id,
|
|
'email_from': email_from,
|
|
'partner_ids': partner_ids,
|
|
'subtype_id': self.env['ir.model.data'].xmlid_to_res_id('mail.mt_note'),
|
|
'is_internal': True,
|
|
'record_name': False,
|
|
'reply_to': MailThread._notify_get_reply_to(default=email_from, records=None)[False],
|
|
'message_id': tools.generate_tracking_message_id('message-notify'),
|
|
}
|
|
values.update(msg_kwargs)
|
|
new_message = MailThread._message_create(values)
|
|
MailThread._notify_thread(new_message, values, **notif_kwargs)
|
|
return new_message
|
|
|
|
def _message_log(self, *, body='', author_id=None, email_from=None, subject=False, message_type='notification', **kwargs):
|
|
""" Shortcut allowing to post note on a document. It does not perform
|
|
any notification and pre-computes some values to have a short code
|
|
as optimized as possible. This method is private as it does not check
|
|
access rights and perform the message creation as sudo to speedup
|
|
the log process. This method should be called within methods where
|
|
access rights are already granted to avoid privilege escalation. """
|
|
self.ensure_one()
|
|
author_id, email_from = self._message_compute_author(author_id, email_from, raise_exception=False)
|
|
|
|
message_values = {
|
|
'subject': subject,
|
|
'body': body,
|
|
'author_id': author_id,
|
|
'email_from': email_from,
|
|
'message_type': message_type,
|
|
'model': kwargs.get('model', self._name),
|
|
'res_id': self.ids[0] if self.ids else False,
|
|
'subtype_id': self.env['ir.model.data'].xmlid_to_res_id('mail.mt_note'),
|
|
'is_internal': True,
|
|
'record_name': False,
|
|
'reply_to': self.env['mail.thread']._notify_get_reply_to(default=email_from, records=None)[False],
|
|
'message_id': tools.generate_tracking_message_id('message-notify'), # why? this is all but a notify
|
|
}
|
|
message_values.update(kwargs)
|
|
return self.sudo()._message_create(message_values)
|
|
|
|
def _message_log_batch(self, bodies, author_id=None, email_from=None, subject=False, message_type='notification'):
|
|
""" Shortcut allowing to post notes on a batch of documents. It achieve the
|
|
same purpose as _message_log, done in batch to speedup quick note log.
|
|
|
|
:param bodies: dict {record_id: body}
|
|
"""
|
|
author_id, email_from = self._message_compute_author(author_id, email_from, raise_exception=False)
|
|
|
|
base_message_values = {
|
|
'subject': subject,
|
|
'author_id': author_id,
|
|
'email_from': email_from,
|
|
'message_type': message_type,
|
|
'model': self._name,
|
|
'subtype_id': self.env['ir.model.data'].xmlid_to_res_id('mail.mt_note'),
|
|
'is_internal': True,
|
|
'record_name': False,
|
|
'reply_to': self.env['mail.thread']._notify_get_reply_to(default=email_from, records=None)[False],
|
|
'message_id': tools.generate_tracking_message_id('message-notify'), # why? this is all but a notify
|
|
}
|
|
values_list = [dict(base_message_values,
|
|
res_id=record.id,
|
|
body=bodies.get(record.id, ''))
|
|
for record in self]
|
|
return self.sudo()._message_create(values_list)
|
|
|
|
def _message_compute_author(self, author_id=None, email_from=None, raise_exception=True):
|
|
""" Tool method computing author information for messages. Purpose is
|
|
to ensure maximum coherence between author / current user / email_from
|
|
when sending emails. """
|
|
if author_id is None:
|
|
if email_from:
|
|
author = self._mail_find_partner_from_emails([email_from])[0]
|
|
else:
|
|
author = self.env.user.partner_id
|
|
email_from = author.email_formatted
|
|
author_id = author.id
|
|
|
|
if email_from is None:
|
|
if author_id:
|
|
author = self.env['res.partner'].browse(author_id)
|
|
email_from = author.email_formatted
|
|
|
|
# superuser mode without author email -> probably public user; anyway we don't want to crash
|
|
if not email_from and not self.env.su and raise_exception:
|
|
raise exceptions.UserError(_("Unable to log message, please configure the sender's email address."))
|
|
|
|
return author_id, email_from
|
|
|
|
def _message_create(self, values_list):
|
|
if not isinstance(values_list, (list)):
|
|
values_list = [values_list]
|
|
create_values_list = []
|
|
for values in values_list:
|
|
create_values = dict(values)
|
|
# Avoid warnings about non-existing fields
|
|
for x in ('from', 'to', 'cc', 'canned_response_ids'):
|
|
create_values.pop(x, None)
|
|
create_values['partner_ids'] = [(4, pid) for pid in create_values.get('partner_ids', [])]
|
|
create_values['channel_ids'] = [(4, cid) for cid in create_values.get('channel_ids', [])]
|
|
create_values_list.append(create_values)
|
|
if 'default_child_ids' in self._context:
|
|
ctx = {key: val for key, val in self._context.items() if key != 'default_child_ids'}
|
|
self = self.with_context(ctx)
|
|
return self.env['mail.message'].create(create_values_list)
|
|
|
|
# ------------------------------------------------------
|
|
# NOTIFICATION API
|
|
# ------------------------------------------------------
|
|
|
|
def _notify_thread(self, message, msg_vals=False, notify_by_email=True, **kwargs):
|
|
""" Main notification method. This method basically does two things
|
|
|
|
* call ``_notify_compute_recipients`` that computes recipients to
|
|
notify based on message record or message creation values if given
|
|
(to optimize performance if we already have data computed);
|
|
* performs the notification process by calling the various notification
|
|
methods implemented;
|
|
|
|
This method cnn be overridden to intercept and postpone notification
|
|
mechanism like mail.channel moderation.
|
|
|
|
:param message: mail.message record to notify;
|
|
:param msg_vals: dictionary of values used to create the message. If given
|
|
it is used instead of accessing ``self`` to lessen query count in some
|
|
simple cases where no notification is actually required;
|
|
|
|
Kwargs allow to pass various parameters that are given to sub notification
|
|
methods. See those methods for more details about the additional parameters.
|
|
Parameters used for email-style notifications
|
|
"""
|
|
msg_vals = msg_vals if msg_vals else {}
|
|
rdata = self._notify_compute_recipients(message, msg_vals)
|
|
if not rdata:
|
|
return False
|
|
|
|
message_values = {}
|
|
if rdata['channels']:
|
|
message_values['channel_ids'] = [(6, 0, [r['id'] for r in rdata['channels']])]
|
|
|
|
self._notify_record_by_inbox(message, rdata, msg_vals=msg_vals, **kwargs)
|
|
if notify_by_email:
|
|
self._notify_record_by_email(message, rdata, msg_vals=msg_vals, **kwargs)
|
|
|
|
return rdata
|
|
|
|
def _notify_record_by_inbox(self, message, recipients_data, msg_vals=False, **kwargs):
|
|
""" Notification method: inbox. Do two main things
|
|
|
|
* create an inbox notification for users;
|
|
* create channel / message link (channel_ids field of mail.message);
|
|
* send bus notifications;
|
|
|
|
TDE/XDO TODO: flag rdata directly, with for example r['notif'] = 'ocn_client' and r['needaction']=False
|
|
and correctly override notify_recipients
|
|
"""
|
|
channel_ids = [r['id'] for r in recipients_data['channels']]
|
|
if channel_ids:
|
|
message.write({'channel_ids': [(6, 0, channel_ids)]})
|
|
|
|
inbox_pids = [r['id'] for r in recipients_data['partners'] if r['notif'] in('inbox','both')]
|
|
if inbox_pids:
|
|
notif_create_values = [{
|
|
'mail_message_id': message.id,
|
|
'res_partner_id': pid,
|
|
'notification_type': 'inbox',
|
|
'notification_status': 'sent',
|
|
} for pid in inbox_pids]
|
|
self.env['mail.notification'].sudo().create(notif_create_values)
|
|
|
|
bus_notifications = []
|
|
if inbox_pids or channel_ids:
|
|
message_format_values = False
|
|
if inbox_pids:
|
|
message_format_values = message.message_format()[0]
|
|
for partner_id in inbox_pids:
|
|
bus_notifications.append([(self._cr.dbname, 'ir.needaction', partner_id), dict(message_format_values)])
|
|
if channel_ids:
|
|
channels = self.env['mail.channel'].sudo().browse(channel_ids)
|
|
bus_notifications += channels._channel_message_notifications(message, message_format_values)
|
|
|
|
if bus_notifications:
|
|
self.env['bus.bus'].sudo().sendmany(bus_notifications)
|
|
|
|
def _notify_record_by_email(self, message, recipients_data, msg_vals=False,
|
|
model_description=False, mail_auto_delete=True, check_existing=False,
|
|
force_send=True, send_after_commit=True,
|
|
**kwargs):
|
|
""" Method to send email linked to notified messages.
|
|
|
|
:param message: mail.message record to notify;
|
|
:param recipients_data: see ``_notify_thread``;
|
|
:param msg_vals: see ``_notify_thread``;
|
|
|
|
:param model_description: model description used in email notification process
|
|
(computed if not given);
|
|
:param mail_auto_delete: delete notification emails once sent;
|
|
:param check_existing: check for existing notifications to update based on
|
|
mailed recipient, otherwise create new notifications;
|
|
|
|
:param force_send: send emails directly instead of using queue;
|
|
:param send_after_commit: if force_send, tells whether to send emails after
|
|
the transaction has been committed using a post-commit hook;
|
|
"""
|
|
partners_data = [r for r in recipients_data['partners'] if r['notif'] in ('email','both')]
|
|
if not partners_data:
|
|
return True
|
|
|
|
model = msg_vals.get('model') if msg_vals else message.model
|
|
model_name = model_description or (self._fallback_lang().env['ir.model']._get(model).display_name if model else False) # one query for display name
|
|
recipients_groups_data = self._notify_classify_recipients(partners_data, model_name, msg_vals=msg_vals)
|
|
|
|
if not recipients_groups_data:
|
|
return True
|
|
force_send = self.env.context.get('mail_notify_force_send', force_send)
|
|
|
|
template_values = self._notify_prepare_template_context(message, msg_vals, model_description=model_description) # 10 queries
|
|
|
|
email_layout_xmlid = msg_vals.get('email_layout_xmlid') if msg_vals else message.email_layout_xmlid
|
|
template_xmlid = email_layout_xmlid if email_layout_xmlid else 'mail.message_notification_email'
|
|
try:
|
|
base_template = self.env.ref(template_xmlid, raise_if_not_found=True).with_context(lang=template_values['lang']) # 1 query
|
|
except ValueError:
|
|
_logger.warning('QWeb template %s not found when sending notification emails. Sending without layouting.' % (template_xmlid))
|
|
base_template = False
|
|
|
|
mail_subject = message.subject or (message.record_name and 'Re: %s' % message.record_name) # in cache, no queries
|
|
# prepare notification mail values
|
|
base_mail_values = {
|
|
'mail_message_id': message.id,
|
|
'mail_server_id': message.mail_server_id.id, # 2 query, check acces + read, may be useless, Falsy, when will it be used?
|
|
'auto_delete': mail_auto_delete,
|
|
# due to ir.rule, user have no right to access parent message if message is not published
|
|
'references': message.parent_id.sudo().message_id if message.parent_id else False,
|
|
'subject': mail_subject,
|
|
}
|
|
base_mail_values = self._notify_by_email_add_values(base_mail_values)
|
|
|
|
# Clean the context to get rid of residual default_* keys that could cause issues during
|
|
# the mail.mail creation.
|
|
# Example: 'default_state' would refer to the default state of a previously created record
|
|
# from another model that in turns triggers an assignation notification that ends up here.
|
|
# This will lead to a traceback when trying to create a mail.mail with this state value that
|
|
# doesn't exist.
|
|
SafeMail = self.env['mail.mail'].sudo().with_context(clean_context(self._context))
|
|
SafeNotification = self.env['mail.notification'].sudo().with_context(clean_context(self._context))
|
|
emails = self.env['mail.mail'].sudo()
|
|
|
|
# loop on groups (customer, portal, user, ... + model specific like group_sale_salesman)
|
|
notif_create_values = []
|
|
recipients_max = 50
|
|
for recipients_group_data in recipients_groups_data:
|
|
# generate notification email content
|
|
recipients_ids = recipients_group_data.pop('recipients')
|
|
render_values = {**template_values, **recipients_group_data}
|
|
# {company, is_discussion, lang, message, model_description, record, record_name, signature, subtype, tracking_values, website_url}
|
|
# {actions, button_access, has_button_access, recipients}
|
|
|
|
if base_template:
|
|
mail_body = base_template._render(render_values, engine='ir.qweb', minimal_qcontext=True)
|
|
else:
|
|
mail_body = message.body
|
|
mail_body = self.env['mail.render.mixin']._replace_local_links(mail_body)
|
|
|
|
# create email
|
|
for recipients_ids_chunk in split_every(recipients_max, recipients_ids):
|
|
recipient_values = self._notify_email_recipient_values(recipients_ids_chunk)
|
|
email_to = recipient_values['email_to']
|
|
recipient_ids = recipient_values['recipient_ids']
|
|
|
|
create_values = {
|
|
'body_html': mail_body,
|
|
'subject': mail_subject,
|
|
'recipient_ids': [(4, pid) for pid in recipient_ids],
|
|
}
|
|
if email_to:
|
|
create_values['email_to'] = email_to
|
|
create_values.update(base_mail_values) # mail_message_id, mail_server_id, auto_delete, references, headers
|
|
email = SafeMail.create(create_values)
|
|
|
|
if email and recipient_ids:
|
|
tocreate_recipient_ids = list(recipient_ids)
|
|
if check_existing:
|
|
existing_notifications = self.env['mail.notification'].sudo().search([
|
|
('mail_message_id', '=', message.id),
|
|
('notification_type', '=', 'email'),
|
|
('res_partner_id', 'in', tocreate_recipient_ids)
|
|
])
|
|
if existing_notifications:
|
|
tocreate_recipient_ids = [rid for rid in recipient_ids if rid not in existing_notifications.mapped('res_partner_id.id')]
|
|
existing_notifications.write({
|
|
'notification_status': 'ready',
|
|
'mail_id': email.id,
|
|
})
|
|
notif_create_values += [{
|
|
'mail_message_id': message.id,
|
|
'res_partner_id': recipient_id,
|
|
'notification_type': 'email',
|
|
'mail_id': email.id,
|
|
'is_read': True, # discard Inbox notification
|
|
'notification_status': 'ready',
|
|
} for recipient_id in tocreate_recipient_ids]
|
|
emails |= email
|
|
|
|
if notif_create_values:
|
|
SafeNotification.create(notif_create_values)
|
|
|
|
# NOTE:
|
|
# 1. for more than 50 followers, use the queue system
|
|
# 2. do not send emails immediately if the registry is not loaded,
|
|
# to prevent sending email during a simple update of the database
|
|
# using the command-line.
|
|
test_mode = getattr(threading.currentThread(), 'testing', False)
|
|
if force_send and len(emails) < recipients_max and (not self.pool._init or test_mode):
|
|
# unless asked specifically, send emails after the transaction to
|
|
# avoid side effects due to emails being sent while the transaction fails
|
|
if not test_mode and send_after_commit:
|
|
email_ids = emails.ids
|
|
dbname = self.env.cr.dbname
|
|
_context = self._context
|
|
|
|
@self.env.cr.postcommit.add
|
|
def send_notifications():
|
|
db_registry = registry(dbname)
|
|
with api.Environment.manage(), db_registry.cursor() as cr:
|
|
env = api.Environment(cr, SUPERUSER_ID, _context)
|
|
env['mail.mail'].browse(email_ids).send()
|
|
else:
|
|
emails.send()
|
|
|
|
return True
|
|
|
|
@api.model
|
|
def _notify_prepare_template_context(self, message, msg_vals, model_description=False, mail_auto_delete=True):
|
|
# compute send user and its related signature
|
|
signature = ''
|
|
user = self.env.user
|
|
author = message.env['res.partner'].browse(msg_vals.get('author_id')) if msg_vals else message.author_id
|
|
model = msg_vals.get('model') if msg_vals else message.model
|
|
add_sign = msg_vals.get('add_sign') if msg_vals else message.add_sign
|
|
subtype_id = msg_vals.get('subtype_id') if msg_vals else message.subtype_id.id
|
|
message_id = message.id
|
|
record_name = msg_vals.get('record_name') if msg_vals else message.record_name
|
|
author_user = user if user.partner_id == author else author.user_ids[0] if author and author.user_ids else False
|
|
# trying to use user (self.env.user) instead of browing user_ids if he is the author will give a sudo user,
|
|
# improving access performances and cache usage.
|
|
if author_user:
|
|
user = author_user
|
|
if add_sign:
|
|
signature = user.signature
|
|
else:
|
|
if add_sign:
|
|
signature = "<p>-- <br/>%s</p>" % author.name
|
|
|
|
company = self.company_id.sudo() if self and 'company_id' in self else user.company_id
|
|
if company.website:
|
|
website_url = 'http://%s' % company.website if not company.website.lower().startswith(('http:', 'https:')) else company.website
|
|
else:
|
|
website_url = False
|
|
|
|
# Retrieve the language in which the template was rendered, in order to render the custom
|
|
# layout in the same language.
|
|
# TDE FIXME: this whole brol should be cleaned !
|
|
lang = self.env.context.get('lang')
|
|
if {'default_template_id', 'default_model', 'default_res_id'} <= self.env.context.keys():
|
|
template = self.env['mail.template'].browse(self.env.context['default_template_id'])
|
|
if template and template.lang:
|
|
lang = template._render_lang([self.env.context['default_res_id']])[self.env.context['default_res_id']]
|
|
|
|
if not model_description and model:
|
|
model_description = self.env['ir.model'].with_context(lang=lang)._get(model).display_name
|
|
|
|
tracking = []
|
|
if msg_vals.get('tracking_value_ids', True) if msg_vals else bool(self): # could be tracking
|
|
for tracking_value in self.env['mail.tracking.value'].sudo().search([('mail_message_id', '=', message.id)]):
|
|
groups = tracking_value.field_groups
|
|
if not groups or self.env.is_superuser() or self.user_has_groups(groups):
|
|
tracking.append((tracking_value.field_desc,
|
|
tracking_value.get_old_display_value()[0],
|
|
tracking_value.get_new_display_value()[0]))
|
|
|
|
is_discussion = subtype_id == self.env['ir.model.data'].xmlid_to_res_id('mail.mt_comment')
|
|
|
|
return {
|
|
'message': message,
|
|
'signature': signature,
|
|
'website_url': website_url,
|
|
'company': company,
|
|
'model_description': model_description,
|
|
'record': self,
|
|
'record_name': record_name,
|
|
'tracking_values': tracking,
|
|
'is_discussion': is_discussion,
|
|
'subtype': message.subtype_id,
|
|
'lang': lang,
|
|
}
|
|
|
|
def _notify_by_email_add_values(self, base_mail_values):
|
|
""" Add model-specific values to the dictionary used to create the
|
|
notification email. Its base behavior is to compute model-specific
|
|
headers.
|
|
|
|
:param dict base_mail_values: base mail.mail values, holding message
|
|
to notify (mail_message_id and its fields), server, references, subject.
|
|
"""
|
|
headers = self._notify_email_headers()
|
|
if headers:
|
|
base_mail_values['headers'] = headers
|
|
return base_mail_values
|
|
|
|
def _notify_compute_recipients(self, message, msg_vals):
|
|
""" Compute recipients to notify based on subtype and followers. This
|
|
method returns data structured as expected for ``_notify_recipients``. """
|
|
msg_sudo = message.sudo()
|
|
# get values from msg_vals or from message if msg_vals doen't exists
|
|
pids = msg_vals.get('partner_ids', []) if msg_vals else msg_sudo.partner_ids.ids
|
|
cids = msg_vals.get('channel_ids', []) if msg_vals else msg_sudo.channel_ids.ids
|
|
message_type = msg_vals.get('message_type') if msg_vals else msg_sudo.message_type
|
|
subtype_id = msg_vals.get('subtype_id') if msg_vals else msg_sudo.subtype_id.id
|
|
# is it possible to have record but no subtype_id ?
|
|
recipient_data = {
|
|
'partners': [],
|
|
'channels': [],
|
|
}
|
|
res = self.env['mail.followers']._get_recipient_data(self, message_type, subtype_id, pids, cids)
|
|
if not res:
|
|
return recipient_data
|
|
|
|
author_id = msg_vals.get('author_id') or message.author_id.id
|
|
for pid, cid, active, pshare, ctype, notif, groups in res:
|
|
if pid and pid == author_id and not self.env.context.get('mail_notify_author'): # do not notify the author of its own messages
|
|
continue
|
|
if pid:
|
|
if active is False:
|
|
continue
|
|
pdata = {'id': pid, 'active': active, 'share': pshare, 'groups': groups or []}
|
|
if notif == 'inbox':
|
|
recipient_data['partners'].append(dict(pdata, notif=notif, type='user'))
|
|
elif not pshare and notif: # has an user and is not shared, is therefore user
|
|
recipient_data['partners'].append(dict(pdata, notif=notif, type='user'))
|
|
elif pshare and notif: # has an user but is shared, is therefore portal
|
|
recipient_data['partners'].append(dict(pdata, notif=notif, type='portal'))
|
|
else: # has no user, is therefore customer
|
|
recipient_data['partners'].append(dict(pdata, notif=notif if notif else 'email', type='customer'))
|
|
elif cid:
|
|
recipient_data['channels'].append({'id': cid, 'notif': notif, 'type': ctype})
|
|
|
|
# add partner ids in email channels
|
|
email_cids = [r['id'] for r in recipient_data['channels'] if r['notif'] == 'email']
|
|
if email_cids:
|
|
# we are doing a similar search in ocn_client
|
|
# Could be interesting to make everything in a single query.
|
|
# ocn_client: (searching all partners linked to channels of type chat).
|
|
# here : (searching all partners linked to channels with notif email if email is not the author one)
|
|
# TDE FIXME: use email_sanitized
|
|
email_from = msg_vals.get('email_from') or message.email_from
|
|
email_from = self.env['res.partner']._parse_partner_name(email_from)[1]
|
|
exept_partner = [r['id'] for r in recipient_data['partners']]
|
|
if author_id:
|
|
exept_partner.append(author_id)
|
|
|
|
sql_query = """ select distinct on (p.id) p.id from res_partner p
|
|
left join mail_channel_partner mcp on p.id = mcp.partner_id
|
|
left join mail_channel c on c.id = mcp.channel_id
|
|
left join res_users u on p.id = u.partner_id
|
|
where (u.notification_type != 'inbox' or u.id is null)
|
|
and (p.email != ANY(%s) or p.email is null)
|
|
and c.id = ANY(%s)
|
|
and p.id != ANY(%s)"""
|
|
|
|
self.env.cr.execute(sql_query, (([email_from], ), (email_cids, ), (exept_partner, )))
|
|
for partner_id in self._cr.fetchall():
|
|
# ocn_client: will add partners to recipient recipient_data. more ocn notifications. We neeed to filter them maybe
|
|
recipient_data['partners'].append({'id': partner_id[0], 'share': True, 'active': True, 'notif': 'email', 'type': 'channel_email', 'groups': []})
|
|
|
|
return recipient_data
|
|
|
|
@api.model
|
|
def _notify_encode_link(self, base_link, params):
|
|
secret = self.env['ir.config_parameter'].sudo().get_param('database.secret')
|
|
token = '%s?%s' % (base_link, ' '.join('%s=%s' % (key, params[key]) for key in sorted(params)))
|
|
hm = hmac.new(secret.encode('utf-8'), token.encode('utf-8'), hashlib.sha1).hexdigest()
|
|
return hm
|
|
|
|
def _notify_get_action_link(self, link_type, **kwargs):
|
|
""" Prepare link to an action: view document, follow document, ... """
|
|
params = {
|
|
'model': kwargs.get('model', self._name),
|
|
'res_id': kwargs.get('res_id', self.ids and self.ids[0] or False),
|
|
}
|
|
# whitelist accepted parameters: action (deprecated), token (assign), access_token
|
|
# (view), auth_signup_token and auth_login (for auth_signup support)
|
|
params.update(dict(
|
|
(key, value)
|
|
for key, value in kwargs.items()
|
|
if key in ('action', 'token', 'access_token', 'auth_signup_token', 'auth_login')
|
|
))
|
|
|
|
if link_type in ['view', 'assign', 'follow', 'unfollow']:
|
|
base_link = '/mail/%s' % link_type
|
|
elif link_type == 'controller':
|
|
controller = kwargs.get('controller')
|
|
params.pop('model')
|
|
base_link = '%s' % controller
|
|
else:
|
|
return ''
|
|
|
|
if link_type not in ['view']:
|
|
token = self._notify_encode_link(base_link, params)
|
|
params['token'] = token
|
|
|
|
link = '%s?%s' % (base_link, urls.url_encode(params))
|
|
if self:
|
|
link = self[0].get_base_url() + link
|
|
|
|
return link
|
|
|
|
def _notify_get_groups(self, msg_vals=None):
|
|
""" Return groups used to classify recipients of a notification email.
|
|
Groups is a list of tuple containing of form (group_name, group_func,
|
|
group_data) where
|
|
* group_name is an identifier used only to be able to override and manipulate
|
|
groups. Default groups are user (recipients linked to an employee user),
|
|
portal (recipients linked to a portal user) and customer (recipients not
|
|
linked to any user). An example of override use would be to add a group
|
|
linked to a res.groups like Hr Officers to set specific action buttons to
|
|
them.
|
|
* group_func is a function pointer taking a partner record as parameter. This
|
|
method will be applied on recipients to know whether they belong to a given
|
|
group or not. Only first matching group is kept. Evaluation order is the
|
|
list order.
|
|
* group_data is a dict containing parameters for the notification email
|
|
* has_button_access: whether to display Access <Document> in email. True
|
|
by default for new groups, False for portal / customer.
|
|
* button_access: dict with url and title of the button
|
|
* actions: list of action buttons to display in the notification email.
|
|
Each action is a dict containing url and title of the button.
|
|
Groups has a default value that you can find in mail_thread
|
|
``_notify_classify_recipients`` method.
|
|
"""
|
|
return [
|
|
(
|
|
'user',
|
|
lambda pdata: pdata['type'] == 'user',
|
|
{}
|
|
), (
|
|
'portal',
|
|
lambda pdata: pdata['type'] == 'portal',
|
|
{'has_button_access': False}
|
|
), (
|
|
'customer',
|
|
lambda pdata: True,
|
|
{'has_button_access': False}
|
|
)
|
|
]
|
|
|
|
def _notify_classify_recipients(self, recipient_data, model_name, msg_vals=None):
|
|
""" Classify recipients to be notified of a message in groups to have
|
|
specific rendering depending on their group. For example users could
|
|
have access to buttons customers should not have in their emails.
|
|
Module-specific grouping should be done by overriding ``_notify_get_groups``
|
|
method defined here-under.
|
|
:param recipient_data:todo xdo UPDATE ME
|
|
return example:
|
|
[{
|
|
'actions': [],
|
|
'button_access': {'title': 'View Simple Chatter Model',
|
|
'url': '/mail/view?model=mail.test.simple&res_id=1497'},
|
|
'has_button_access': False,
|
|
'recipients': [11]
|
|
},
|
|
{
|
|
'actions': [],
|
|
'button_access': {'title': 'View Simple Chatter Model',
|
|
'url': '/mail/view?model=mail.test.simple&res_id=1497'},
|
|
'has_button_access': False,
|
|
'recipients': [4, 5, 6]
|
|
},
|
|
{
|
|
'actions': [],
|
|
'button_access': {'title': 'View Simple Chatter Model',
|
|
'url': '/mail/view?model=mail.test.simple&res_id=1497'},
|
|
'has_button_access': True,
|
|
'recipients': [10, 11, 12]
|
|
}]
|
|
only return groups with recipients
|
|
"""
|
|
# keep a local copy of msg_vals as it may be modified to include more information about groups or links
|
|
local_msg_vals = dict(msg_vals) if msg_vals else {}
|
|
groups = self._notify_get_groups(msg_vals=local_msg_vals)
|
|
access_link = self._notify_get_action_link('view', **local_msg_vals)
|
|
|
|
if model_name:
|
|
view_title = _('View %s', model_name)
|
|
else:
|
|
view_title = _('View')
|
|
|
|
# fill group_data with default_values if they are not complete
|
|
for group_name, group_func, group_data in groups:
|
|
group_data.setdefault('notification_group_name', group_name)
|
|
group_data.setdefault('notification_is_customer', False)
|
|
group_data.setdefault('has_button_access', True)
|
|
group_button_access = group_data.setdefault('button_access', {})
|
|
group_button_access.setdefault('url', access_link)
|
|
group_button_access.setdefault('title', view_title)
|
|
group_data.setdefault('actions', list())
|
|
group_data.setdefault('recipients', list())
|
|
|
|
# classify recipients in each group
|
|
for recipient in recipient_data:
|
|
for group_name, group_func, group_data in groups:
|
|
if group_func(recipient):
|
|
group_data['recipients'].append(recipient['id'])
|
|
break
|
|
|
|
result = []
|
|
for group_name, group_method, group_data in groups:
|
|
if group_data['recipients']:
|
|
result.append(group_data)
|
|
|
|
return result
|
|
|
|
@api.model
|
|
def _notify_get_reply_to_on_records(self, default=None, records=None, company=None, doc_names=None):
|
|
""" Moved to ``BaseModel._notify_get_reply_to()`` """
|
|
records = records if records else self
|
|
return records._notify_get_reply_to(default=default, company=company, doc_names=doc_names)
|
|
|
|
def _notify_email_recipient_values(self, recipient_ids):
|
|
""" Format email notification recipient values to store on the notification
|
|
mail.mail. Basic method just set the recipient partners as mail_mail
|
|
recipients. Override to generate other mail values like email_to or
|
|
email_cc.
|
|
:param recipient_ids: res.partner recordset to notify
|
|
"""
|
|
return {
|
|
'email_to': False,
|
|
'recipient_ids': recipient_ids,
|
|
}
|
|
|
|
# ------------------------------------------------------
|
|
# FOLLOWERS API
|
|
# ------------------------------------------------------
|
|
|
|
def message_subscribe(self, partner_ids=None, channel_ids=None, subtype_ids=None):
|
|
""" Main public API to add followers to a record set. Its main purpose is
|
|
to perform access rights checks before calling ``_message_subscribe``. """
|
|
if not self or (not partner_ids and not channel_ids):
|
|
return True
|
|
|
|
partner_ids = partner_ids or []
|
|
channel_ids = channel_ids or []
|
|
adding_current = set(partner_ids) == set([self.env.user.partner_id.id])
|
|
customer_ids = [] if adding_current else None
|
|
|
|
if not channel_ids and partner_ids and adding_current:
|
|
try:
|
|
self.check_access_rights('read')
|
|
self.check_access_rule('read')
|
|
except exceptions.AccessError:
|
|
return False
|
|
else:
|
|
self.check_access_rights('write')
|
|
self.check_access_rule('write')
|
|
|
|
# filter inactive and private addresses
|
|
if partner_ids and not adding_current:
|
|
partner_ids = self.env['res.partner'].sudo().search([('id', 'in', partner_ids), ('active', '=', True), ('type', '!=', 'private')]).ids
|
|
|
|
return self._message_subscribe(partner_ids, channel_ids, subtype_ids, customer_ids=customer_ids)
|
|
|
|
def _message_subscribe(self, partner_ids=None, channel_ids=None, subtype_ids=None, customer_ids=None):
|
|
""" Main private API to add followers to a record set. This method adds
|
|
partners and channels, given their IDs, as followers of all records
|
|
contained in the record set.
|
|
|
|
If subtypes are given existing followers are erased with new subtypes.
|
|
If default one have to be computed only missing followers will be added
|
|
with default subtypes matching the record set model.
|
|
|
|
This private method does not specifically check for access right. Use
|
|
``message_subscribe`` public API when not sure about access rights.
|
|
|
|
:param customer_ids: see ``_insert_followers`` """
|
|
if not self:
|
|
return True
|
|
curframe = inspect.currentframe()
|
|
calframe = inspect.getouterframes(curframe, 2)
|
|
print('caller name:', calframe)
|
|
|
|
if not subtype_ids:
|
|
self.env['mail.followers']._insert_followers(
|
|
self._name, self.ids, partner_ids, None, channel_ids, None,
|
|
customer_ids=customer_ids, check_existing=True, existing_policy='skip')
|
|
else:
|
|
self.env['mail.followers']._insert_followers(
|
|
self._name, self.ids,
|
|
partner_ids, dict((pid, subtype_ids) for pid in partner_ids),
|
|
channel_ids, dict((cid, subtype_ids) for cid in channel_ids),
|
|
customer_ids=customer_ids, check_existing=True, existing_policy='replace')
|
|
|
|
return True
|
|
|
|
def message_unsubscribe(self, partner_ids=None, channel_ids=None):
|
|
""" Remove partners from the records followers. """
|
|
# not necessary for computation, but saves an access right check
|
|
if not partner_ids and not channel_ids:
|
|
return True
|
|
user_pid = self.env.user.partner_id.id
|
|
if not channel_ids and set(partner_ids) == set([user_pid]):
|
|
self.check_access_rights('read')
|
|
self.check_access_rule('read')
|
|
else:
|
|
self.check_access_rights('write')
|
|
self.check_access_rule('write')
|
|
self.env['mail.followers'].sudo().search([
|
|
('res_model', '=', self._name),
|
|
('res_id', 'in', self.ids),
|
|
'|',
|
|
('partner_id', 'in', partner_ids or []),
|
|
('channel_id', 'in', channel_ids or [])
|
|
]).unlink()
|
|
|
|
def _message_auto_subscribe_followers(self, updated_values, default_subtype_ids):
|
|
""" Optional method to override in addons inheriting from mail.thread.
|
|
Return a list tuples containing (
|
|
partner ID,
|
|
subtype IDs (or False if model-based default subtypes),
|
|
QWeb template XML ID for notification (or False is no specific
|
|
notification is required),
|
|
), aka partners and their subtype and possible notification to send
|
|
using the auto subscription mechanism linked to updated values.
|
|
|
|
Default value of this method is to return the new responsible of
|
|
documents. This is done using relational fields linking to res.users
|
|
with track_visibility set. Since OpenERP v7 it is considered as being
|
|
responsible for the document and therefore standard behavior is to
|
|
subscribe the user and send him a notification.
|
|
|
|
Override this method to change that behavior and/or to add people to
|
|
notify, using possible custom notification.
|
|
|
|
:param updated_values: see ``_message_auto_subscribe``
|
|
:param default_subtype_ids: coming from ``_get_auto_subscription_subtypes``
|
|
"""
|
|
fnames = []
|
|
field = self._fields.get('user_id')
|
|
user_id = updated_values.get('user_id')
|
|
if field and user_id and field.comodel_name == 'res.users' and (getattr(field, 'track_visibility', False) or getattr(field, 'tracking', False)):
|
|
user = self.env['res.users'].sudo().browse(user_id)
|
|
try: # avoid to make an exists, lets be optimistic and try to read it.
|
|
if user.active:
|
|
return [(user.partner_id.id, default_subtype_ids, 'mail.message_user_assigned' if user != self.env.user else False)]
|
|
except:
|
|
pass
|
|
return []
|
|
|
|
def _message_auto_subscribe_notify(self, partner_ids, template):
|
|
""" Notify new followers, using a template to render the content of the
|
|
notification message. Notifications pushed are done using the standard
|
|
notification mechanism in mail.thread. It is either inbox either email
|
|
depending on the partner state: no user (email, customer), share user
|
|
(email, customer) or classic user (notification_type)
|
|
|
|
:param partner_ids: IDs of partner to notify;
|
|
:param template: XML ID of template used for the notification;
|
|
"""
|
|
if not self or self.env.context.get('mail_auto_subscribe_no_notify'):
|
|
return
|
|
if not self.env.registry.ready: # Don't send notification during install
|
|
return
|
|
|
|
view = self.env['ir.ui.view'].browse(self.env['ir.model.data'].xmlid_to_res_id(template))
|
|
|
|
for record in self:
|
|
model_description = self.env['ir.model']._get(record._name).display_name
|
|
values = {
|
|
'object': record,
|
|
'model_description': model_description,
|
|
'access_link': record._notify_get_action_link('view'),
|
|
}
|
|
assignation_msg = view._render(values, engine='ir.qweb', minimal_qcontext=True)
|
|
assignation_msg = self.env['mail.render.mixin']._replace_local_links(assignation_msg)
|
|
record.message_notify(
|
|
subject=_('You have been assigned to %s', record.display_name),
|
|
body=assignation_msg,
|
|
partner_ids=partner_ids,
|
|
record_name=record.display_name,
|
|
email_layout_xmlid='mail.mail_notification_light',
|
|
model_description=model_description,
|
|
)
|
|
|
|
def _message_auto_subscribe(self, updated_values, followers_existing_policy='skip'):
|
|
""" Handle auto subscription. Auto subscription is done based on two
|
|
main mechanisms
|
|
|
|
* using subtypes parent relationship. For example following a parent record
|
|
(i.e. project) with subtypes linked to child records (i.e. task). See
|
|
mail.message.subtype ``_get_auto_subscription_subtypes``;
|
|
* calling _message_auto_subscribe_notify that returns a list of partner
|
|
to subscribe, as well as data about the subtypes and notification
|
|
to send. Base behavior is to subscribe responsible and notify them;
|
|
|
|
Adding application-specific auto subscription should be done by overriding
|
|
``_message_auto_subscribe_followers``. It should return structured data
|
|
for new partner to subscribe, with subtypes and eventual notification
|
|
to perform. See that method for more details.
|
|
|
|
:param updated_values: values modifying the record trigerring auto subscription
|
|
"""
|
|
curframe = inspect.currentframe()
|
|
calframe = inspect.getouterframes(curframe, 2)
|
|
print('caller name:', calframe)
|
|
if not self:
|
|
return True
|
|
|
|
new_partners, new_channels = dict(), dict()
|
|
|
|
# return data related to auto subscription based on subtype matching (aka:
|
|
# default task subtypes or subtypes from project triggering task subtypes)
|
|
updated_relation = dict()
|
|
child_ids, def_ids, all_int_ids, parent, relation = self.env['mail.message.subtype']._get_auto_subscription_subtypes(self._name)
|
|
|
|
# check effectively modified relation field
|
|
for res_model, fnames in relation.items():
|
|
for field in (fname for fname in fnames if updated_values.get(fname)):
|
|
updated_relation.setdefault(res_model, set()).add(field)
|
|
udpated_fields = [fname for fnames in updated_relation.values() for fname in fnames if updated_values.get(fname)]
|
|
|
|
if udpated_fields:
|
|
# fetch "parent" subscription data (aka: subtypes on project to propagate on task)
|
|
doc_data = [(model, [updated_values[fname] for fname in fnames]) for model, fnames in updated_relation.items()]
|
|
res = self.env['mail.followers']._get_subscription_data(doc_data, None, None, include_pshare=True, include_active=True)
|
|
for fid, rid, pid, cid, subtype_ids, pshare, active in res:
|
|
# use project.task_new -> task.new link
|
|
sids = [parent[sid] for sid in subtype_ids if parent.get(sid)]
|
|
# add checked subtypes matching model_name
|
|
sids += [sid for sid in subtype_ids if sid not in parent and sid in child_ids]
|
|
if pid and active: # auto subscribe only active partners
|
|
if pshare: # remove internal subtypes for customers
|
|
new_partners[pid] = set(sids) - set(all_int_ids)
|
|
else:
|
|
new_partners[pid] = set(sids)
|
|
if cid: # never subscribe channels to internal subtypes
|
|
new_channels[cid] = set(sids) - set(all_int_ids)
|
|
|
|
notify_data = dict()
|
|
res = self._message_auto_subscribe_followers(updated_values, def_ids)
|
|
for pid, sids, template in res:
|
|
new_partners.setdefault(pid, sids)
|
|
if template:
|
|
partner = self.env['res.partner'].browse(pid)
|
|
lang = partner.lang if partner else None
|
|
notify_data.setdefault((template, lang), list()).append(pid)
|
|
|
|
self.env['mail.followers']._insert_followers(
|
|
self._name, self.ids,
|
|
list(new_partners), new_partners,
|
|
list(new_channels), new_channels,
|
|
check_existing=True, existing_policy=followers_existing_policy)
|
|
|
|
# notify people from auto subscription, for example like assignation
|
|
for (template, lang), pids in notify_data.items():
|
|
self.with_context(lang=lang)._message_auto_subscribe_notify(pids, template)
|
|
|
|
return True
|
|
|
|
# ------------------------------------------------------
|
|
# CONTROLLERS
|
|
# ------------------------------------------------------
|
|
|
|
def _get_mail_redirect_suggested_company(self):
|
|
""" Return the suggested company to be set on the context
|
|
in case of a mail redirection to the record. To avoid multi
|
|
company issues when clicking on a link sent by email, this
|
|
could be called to try setting the most suited company on
|
|
the allowed_company_ids in the context. This method can be
|
|
overridden, for example on the hr.leave model, where the
|
|
most suited company is the company of the leave type, as
|
|
specified by the ir.rule.
|
|
"""
|
|
if 'company_id' in self:
|
|
return self.company_id
|
|
return False |