328 lines
15 KiB
Python
328 lines
15 KiB
Python
|
# -*- coding: utf-8 -*-
|
||
|
|
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||
|
|
|
||
|
|
import re
|
||
|
|
|
||
|
|
import odoo
|
||
|
|
from odoo import _, api, fields, models, tools
|
||
|
|
from odoo.osv import expression
|
||
|
|
|
||
|
|
class Partner(models.Model):
|
||
|
|
""" Update partner to add a field about notification preferences. Add a generic opt-out field that can be used
|
||
|
|
to restrict usage of automatic email templates. """
|
||
|
|
_name = "res.partner"
|
||
|
|
_inherit = ['res.partner', 'mail.activity.mixin', 'mail.thread.blacklist']
|
||
|
|
_mail_flat_thread = False
|
||
|
|
|
||
|
|
# override to add and order tracking
|
||
|
|
email = fields.Char(tracking=1)
|
||
|
|
phone = fields.Char(tracking=2)
|
||
|
|
parent_id = fields.Many2one(tracking=3)
|
||
|
|
user_id = fields.Many2one(tracking=4)
|
||
|
|
vat = fields.Char(tracking=5)
|
||
|
|
# tracked field used for chatter logging purposes
|
||
|
|
# we need this to be readable inline as tracking messages use inline HTML nodes
|
||
|
|
contact_address_inline = fields.Char(compute='_compute_contact_address_inline', string='Inlined Complete Address', tracking=True)
|
||
|
|
starred_message_ids = fields.Many2many('mail.message', 'mail_message_res_partner_starred_rel')
|
||
|
|
|
||
|
|
@api.depends('contact_address')
|
||
|
|
def _compute_contact_address_inline(self):
|
||
|
|
"""Compute an inline-friendly address based on contact_address."""
|
||
|
|
for partner in self:
|
||
|
|
# replace any successive \n with a single comma
|
||
|
|
partner.contact_address_inline = re.sub(r'\n(\s|\n)*', ', ', partner.contact_address).strip().strip(',')
|
||
|
|
|
||
|
|
def _compute_im_status(self):
|
||
|
|
super()._compute_im_status()
|
||
|
|
odoobot_id = self.env['ir.model.data']._xmlid_to_res_id('base.partner_root')
|
||
|
|
odoobot = self.env['res.partner'].browse(odoobot_id)
|
||
|
|
if odoobot in self:
|
||
|
|
odoobot.im_status = 'bot'
|
||
|
|
|
||
|
|
# pseudo computes
|
||
|
|
|
||
|
|
def _get_needaction_count(self):
|
||
|
|
""" compute the number of needaction of the current partner """
|
||
|
|
self.ensure_one()
|
||
|
|
self.env['mail.notification'].flush_model(['is_read', 'res_partner_id'])
|
||
|
|
self.env.cr.execute("""
|
||
|
|
SELECT count(*) as needaction_count
|
||
|
|
FROM mail_notification R
|
||
|
|
WHERE R.res_partner_id = %s AND (R.is_read = false OR R.is_read IS NULL)""", (self.id,))
|
||
|
|
return self.env.cr.dictfetchall()[0].get('needaction_count')
|
||
|
|
|
||
|
|
# ------------------------------------------------------------
|
||
|
|
# MESSAGING
|
||
|
|
# ------------------------------------------------------------
|
||
|
|
|
||
|
|
def _mail_get_partners(self, introspect_fields=False):
|
||
|
|
return dict((partner.id, partner) for partner in self)
|
||
|
|
|
||
|
|
def _message_get_suggested_recipients(self):
|
||
|
|
recipients = super(Partner, self)._message_get_suggested_recipients()
|
||
|
|
for partner in self:
|
||
|
|
partner._message_add_suggested_recipient(recipients, partner=partner, reason=_('Partner Profile'))
|
||
|
|
return recipients
|
||
|
|
|
||
|
|
def _message_get_default_recipients(self):
|
||
|
|
return {
|
||
|
|
r.id:
|
||
|
|
{'partner_ids': [r.id],
|
||
|
|
'email_to': False,
|
||
|
|
'email_cc': False
|
||
|
|
}
|
||
|
|
for r in self
|
||
|
|
}
|
||
|
|
|
||
|
|
# ------------------------------------------------------------
|
||
|
|
# ORM
|
||
|
|
# ------------------------------------------------------------
|
||
|
|
@api.model
|
||
|
|
def _get_view_cache_key(self, view_id=None, view_type='form', **options):
|
||
|
|
"""Add context variable force_email in the key as _get_view depends on it."""
|
||
|
|
key = super()._get_view_cache_key(view_id, view_type, **options)
|
||
|
|
return key + (self._context.get('force_email'),)
|
||
|
|
|
||
|
|
@api.model
|
||
|
|
@api.returns('self', lambda value: value.id)
|
||
|
|
def find_or_create(self, email, assert_valid_email=False):
|
||
|
|
""" Override to use the email_normalized field. """
|
||
|
|
if not email:
|
||
|
|
raise ValueError(_('An email is required for find_or_create to work'))
|
||
|
|
|
||
|
|
parsed_name, parsed_email_normalized = tools.parse_contact_from_email(email)
|
||
|
|
if not parsed_email_normalized and assert_valid_email:
|
||
|
|
raise ValueError(_('%(email)s is not recognized as a valid email. This is required to create a new customer.'))
|
||
|
|
if parsed_email_normalized:
|
||
|
|
partners = self.search([('email_normalized', '=', parsed_email_normalized)], limit=1)
|
||
|
|
if partners:
|
||
|
|
return partners
|
||
|
|
|
||
|
|
# We don't want to call `super()` to avoid searching twice on the email
|
||
|
|
# Especially when the search `email =ilike` cannot be as efficient as
|
||
|
|
# a search on email_normalized with a btree index
|
||
|
|
# If you want to override `find_or_create()` your module should depend on `mail`
|
||
|
|
create_values = {self._rec_name: parsed_name or parsed_email_normalized}
|
||
|
|
if parsed_email_normalized: # otherwise keep default_email in context
|
||
|
|
create_values['email'] = parsed_email_normalized
|
||
|
|
return self.create(create_values)
|
||
|
|
|
||
|
|
@api.model
|
||
|
|
def _find_or_create_from_emails(self, emails, additional_values=None):
|
||
|
|
""" Based on a list of emails, find or create partners. Additional values
|
||
|
|
can be given to newly created partners. If an email is not unique (e.g.
|
||
|
|
multi-email input), only the first found email is considered.
|
||
|
|
|
||
|
|
Additional values allow to customize the created partner when context
|
||
|
|
allows to give more information. It data is based on email normalized
|
||
|
|
as it is the main information used in this method to distinguish or
|
||
|
|
find partners.
|
||
|
|
|
||
|
|
If no valid email is found for a given item, the given value is used to
|
||
|
|
find partners with same invalid email or create a new one with the wrong
|
||
|
|
value. It allows updating it afterwards. Notably with notifications
|
||
|
|
resend it is possible to update emails, if only a typo prevents from
|
||
|
|
having a real email for example.
|
||
|
|
|
||
|
|
:param list emails: list of emails that may be formatted (each input
|
||
|
|
will be parsed and normalized);
|
||
|
|
:param dict additional_values: additional values per normalized email
|
||
|
|
given to create if the partner is not found. Typically used to
|
||
|
|
propagate a company_id and customer information from related record.
|
||
|
|
Values for key 'False' are used when creating partner for invalid
|
||
|
|
emails;
|
||
|
|
|
||
|
|
:return: res.partner records in a list, following order of emails. It
|
||
|
|
is not a recordset, to keep Falsy values.
|
||
|
|
"""
|
||
|
|
additional_values = additional_values if additional_values else {}
|
||
|
|
partners, tocreate_vals_list = self.env['res.partner'], []
|
||
|
|
name_emails = [tools.parse_contact_from_email(email) for email in emails]
|
||
|
|
|
||
|
|
# find valid emails_normalized, filtering out false / void values, and search
|
||
|
|
# for existing partners based on those emails
|
||
|
|
emails_normalized = {email_normalized
|
||
|
|
for _name, email_normalized in name_emails
|
||
|
|
if email_normalized}
|
||
|
|
# find partners for invalid (but not void) emails, aka either invalid email
|
||
|
|
# either no email and a name that will be used as email
|
||
|
|
names = {
|
||
|
|
name.strip()
|
||
|
|
for name, email_normalized in name_emails
|
||
|
|
if not email_normalized and name.strip()
|
||
|
|
}
|
||
|
|
if emails_normalized or names:
|
||
|
|
domains = []
|
||
|
|
if emails_normalized:
|
||
|
|
domains.append([('email_normalized', 'in', list(emails_normalized))])
|
||
|
|
if names:
|
||
|
|
domains.append([('email', 'in', list(names))])
|
||
|
|
partners += self.search(expression.OR(domains))
|
||
|
|
|
||
|
|
# create partners for valid email without any existing partner. Keep
|
||
|
|
# only first found occurrence of each normalized email, aka: ('Norbert',
|
||
|
|
# 'norbert@gmail.com'), ('Norbert With Surname', 'norbert@gmail.com')'
|
||
|
|
# -> a single partner is created for email 'norbert@gmail.com'
|
||
|
|
seen = set()
|
||
|
|
notfound_emails = (emails_normalized - set(partners.mapped('email_normalized'))) if partners else emails_normalized
|
||
|
|
notfound_name_emails = [
|
||
|
|
name_email
|
||
|
|
for name_email in name_emails
|
||
|
|
if name_email[1] in notfound_emails and name_email[1] not in seen
|
||
|
|
and not seen.add(name_email[1])
|
||
|
|
]
|
||
|
|
tocreate_vals_list += [
|
||
|
|
{
|
||
|
|
self._rec_name: name or email_normalized,
|
||
|
|
'email': email_normalized,
|
||
|
|
**additional_values.get(email_normalized, {}),
|
||
|
|
}
|
||
|
|
for name, email_normalized in notfound_name_emails
|
||
|
|
]
|
||
|
|
|
||
|
|
# create partners for invalid emails (aka name and not email_normalized)
|
||
|
|
# without any existing partner
|
||
|
|
tocreate_vals_list += [
|
||
|
|
{
|
||
|
|
self._rec_name: name,
|
||
|
|
'email': name,
|
||
|
|
**additional_values.get(False, {}),
|
||
|
|
}
|
||
|
|
for name in names if name not in partners.mapped('email')
|
||
|
|
]
|
||
|
|
|
||
|
|
# create partners once
|
||
|
|
if tocreate_vals_list:
|
||
|
|
partners += self.create(tocreate_vals_list)
|
||
|
|
|
||
|
|
return [
|
||
|
|
next(
|
||
|
|
(partner for partner in partners
|
||
|
|
if (email_normalized and partner.email_normalized == email_normalized)
|
||
|
|
or (not email_normalized and email and partner.email == email)
|
||
|
|
or (not email_normalized and name and partner.name == name)
|
||
|
|
),
|
||
|
|
self.env['res.partner']
|
||
|
|
)
|
||
|
|
for (name, email_normalized), email in zip(name_emails, emails)
|
||
|
|
]
|
||
|
|
|
||
|
|
# ------------------------------------------------------------
|
||
|
|
# DISCUSS
|
||
|
|
# ------------------------------------------------------------
|
||
|
|
|
||
|
|
def mail_partner_format(self, fields=None):
|
||
|
|
partners_format = dict()
|
||
|
|
if not fields:
|
||
|
|
fields = {'id': True, 'name': True, 'email': True, 'active': True, 'im_status': True, 'is_company': True, 'user': {}, "write_date": True}
|
||
|
|
for partner in self:
|
||
|
|
data = {}
|
||
|
|
if 'id' in fields:
|
||
|
|
data['id'] = partner.id
|
||
|
|
if 'name' in fields:
|
||
|
|
data['name'] = partner.name
|
||
|
|
if 'email' in fields:
|
||
|
|
data['email'] = partner.email
|
||
|
|
if 'active' in fields:
|
||
|
|
data['active'] = partner.active
|
||
|
|
if 'im_status' in fields:
|
||
|
|
data['im_status'] = partner.im_status
|
||
|
|
if 'is_company' in fields:
|
||
|
|
data['is_company'] = partner.is_company
|
||
|
|
if "write_date" in fields:
|
||
|
|
data["write_date"] = odoo.fields.Datetime.to_string(partner.write_date)
|
||
|
|
if 'user' in fields:
|
||
|
|
users = partner.with_context(active_test=False).user_ids
|
||
|
|
internal_users = users - users.filtered('share')
|
||
|
|
main_user = internal_users[0] if len(internal_users) > 0 else users[0] if len(users) > 0 else self.env['res.users']
|
||
|
|
data['user'] = {
|
||
|
|
"id": main_user.id,
|
||
|
|
"isInternalUser": not main_user.share,
|
||
|
|
} if main_user else False
|
||
|
|
if not self.env.user._is_internal():
|
||
|
|
data.pop('email', None)
|
||
|
|
data['type'] = "partner"
|
||
|
|
partners_format[partner] = data
|
||
|
|
return partners_format
|
||
|
|
|
||
|
|
def _message_fetch_failed(self):
|
||
|
|
"""Returns first 100 messages, sent by the current partner, that have errors, in
|
||
|
|
the format expected by the web client."""
|
||
|
|
self.ensure_one()
|
||
|
|
notifications = self.env['mail.notification'].search([
|
||
|
|
('author_id', '=', self.id),
|
||
|
|
('notification_status', 'in', ('bounce', 'exception')),
|
||
|
|
('mail_message_id.message_type', '!=', 'user_notification'),
|
||
|
|
('mail_message_id.model', '!=', False),
|
||
|
|
('mail_message_id.res_id', '!=', 0),
|
||
|
|
], limit=100)
|
||
|
|
return notifications.mail_message_id._message_notification_format()
|
||
|
|
|
||
|
|
@api.model
|
||
|
|
def get_mention_suggestions(self, search, limit=8):
|
||
|
|
""" Return 'limit'-first partners' such that the name or email matches a 'search' string.
|
||
|
|
Prioritize partners that are also (internal) users, and then extend the research to all partners.
|
||
|
|
The return format is a list of partner data (as per returned by `mail_partner_format()`).
|
||
|
|
"""
|
||
|
|
domain = self._get_mention_suggestions_domain(search)
|
||
|
|
partners = self._search_mention_suggestions(domain, limit)
|
||
|
|
return list(partners.mail_partner_format().values())
|
||
|
|
|
||
|
|
@api.model
|
||
|
|
def _get_mention_suggestions_domain(self, search):
|
||
|
|
return expression.AND([
|
||
|
|
expression.OR([
|
||
|
|
[('name', 'ilike', search)],
|
||
|
|
[('email', 'ilike', search)],
|
||
|
|
]),
|
||
|
|
[('active', '=', True)],
|
||
|
|
])
|
||
|
|
|
||
|
|
@api.model
|
||
|
|
def _search_mention_suggestions(self, domain, limit):
|
||
|
|
domain_is_user = expression.AND([[('user_ids', '!=', False)], [('user_ids.active', '=', True)], domain])
|
||
|
|
priority_conditions = [
|
||
|
|
expression.AND([domain_is_user, [('partner_share', '=', False)]]), # Search partners that are internal users
|
||
|
|
domain_is_user, # Search partners that are users
|
||
|
|
domain, # Search partners that are not users
|
||
|
|
]
|
||
|
|
partners = self.env['res.partner']
|
||
|
|
for domain in priority_conditions:
|
||
|
|
remaining_limit = limit - len(partners)
|
||
|
|
if remaining_limit <= 0:
|
||
|
|
break
|
||
|
|
# We are using _search to avoid the default order that is
|
||
|
|
# automatically added by the search method. "Order by" makes the query
|
||
|
|
# really slow.
|
||
|
|
query = self._search(expression.AND([[('id', 'not in', partners.ids)], domain]), limit=remaining_limit)
|
||
|
|
partners |= self.browse(query)
|
||
|
|
return partners
|
||
|
|
|
||
|
|
@api.model
|
||
|
|
def im_search(self, name, limit=20, excluded_ids=None):
|
||
|
|
""" Search partner with a name and return its id, name and im_status.
|
||
|
|
Note : the user must be logged
|
||
|
|
:param name : the partner name to search
|
||
|
|
:param limit : the limit of result to return
|
||
|
|
:param excluded_ids : the ids of excluded partners
|
||
|
|
"""
|
||
|
|
# This method is supposed to be used only in the context of channel creation or
|
||
|
|
# extension via an invite. As both of these actions require the 'create' access
|
||
|
|
# right, we check this specific ACL.
|
||
|
|
if excluded_ids is None:
|
||
|
|
excluded_ids = []
|
||
|
|
users = self.env['res.users'].search([
|
||
|
|
('id', '!=', self.env.user.id),
|
||
|
|
('name', 'ilike', name),
|
||
|
|
('active', '=', True),
|
||
|
|
('share', '=', False),
|
||
|
|
('partner_id', 'not in', excluded_ids)
|
||
|
|
], order='name, id', limit=limit)
|
||
|
|
return list(users.partner_id.mail_partner_format().values())
|
||
|
|
|
||
|
|
@api.model
|
||
|
|
def _get_current_persona(self):
|
||
|
|
if not self.env.user or self.env.user._is_public():
|
||
|
|
return (self.env["res.partner"], self.env["mail.guest"]._get_guest_from_context())
|
||
|
|
return (self.env.user.partner_id, self.env["mail.guest"])
|