Thibault Francois
f001e026a2
Behavior before the commit -------------------------- find_or_create define in mail module called super if no partner is found based on the email_normalized super call find_or_create define in base that make a search again on the email before the creation This cost two search every time a new partner should be created and the search on email is less efficient than the search on email_normalized after the commit ---------------- Only the search on email_normalized is done before the creation drawback: if a module that does not depends on mail module override find_or_create the code will not be triggered anymore the module should depends on mail module closes odoo/odoo#65565 X-original-commit: 49d5b3813e57f2cd91d582de9b9bb534f05d2dc3 Signed-off-by: Thibault Delavallee (tde) <tde@openerp.com>
174 lines
7.6 KiB
Python
174 lines
7.6 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
import logging
|
|
|
|
from odoo import _, api, fields, models, tools
|
|
from odoo.addons.bus.models.bus_presence import AWAY_TIMER
|
|
from odoo.addons.bus.models.bus_presence import DISCONNECTION_TIMER
|
|
from odoo.osv import expression
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
|
|
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
|
|
|
|
email = fields.Char(tracking=1)
|
|
phone = fields.Char(tracking=2)
|
|
|
|
channel_ids = fields.Many2many('mail.channel', 'mail_channel_partner', 'partner_id', 'channel_id', string='Channels', copy=False)
|
|
# override the field to track the visibility of user
|
|
user_id = fields.Many2one(tracking=True)
|
|
|
|
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'
|
|
|
|
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}
|
|
|
|
@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 = self._parse_partner_name(email)
|
|
if parsed_email:
|
|
email_normalized = tools.email_normalize(parsed_email)
|
|
if email_normalized:
|
|
partners = self.search([('email_normalized', '=', 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}
|
|
if parsed_email: # otherwise keep default_email in context
|
|
create_values['email'] = parsed_email
|
|
return self.create(create_values)
|
|
|
|
def mail_partner_format(self):
|
|
self.ensure_one()
|
|
return {
|
|
"id": self.name_get()[0][0],
|
|
"display_name": self.name_get()[0][1],
|
|
"name": self.name,
|
|
"active": self.active,
|
|
"im_status": self.im_status,
|
|
}
|
|
|
|
@api.model
|
|
def get_needaction_count(self):
|
|
""" compute the number of needaction of the current user """
|
|
if self.env.user.partner_id:
|
|
self.env['mail.notification'].flush(['is_read', 'res_partner_id'])
|
|
self.env.cr.execute("""
|
|
SELECT count(*) as needaction_count
|
|
FROM mail_message_res_partner_needaction_rel R
|
|
WHERE R.res_partner_id = %s AND (R.is_read = false OR R.is_read IS NULL)""", (self.env.user.partner_id.id,))
|
|
return self.env.cr.dictfetchall()[0].get('needaction_count')
|
|
_logger.error('Call to needaction_count without partner_id')
|
|
return 0
|
|
|
|
@api.model
|
|
def get_starred_count(self):
|
|
""" compute the number of starred of the current user """
|
|
if self.env.user.partner_id:
|
|
self.env.cr.execute("""
|
|
SELECT count(*) as starred_count
|
|
FROM mail_message_res_partner_starred_rel R
|
|
WHERE R.res_partner_id = %s """, (self.env.user.partner_id.id,))
|
|
return self.env.cr.dictfetchall()[0].get('starred_count')
|
|
_logger.error('Call to starred_count without partner_id')
|
|
return 0
|
|
|
|
@api.model
|
|
def get_static_mention_suggestions(self):
|
|
""" To be overwritten to return the id, name and email of partners used as static mention
|
|
suggestions loaded once at webclient initialization and stored client side. """
|
|
return []
|
|
|
|
@api.model
|
|
def get_mention_suggestions(self, search, limit=8):
|
|
""" Return 'limit'-first partners' id, name and email such that the name or email matches a
|
|
'search' string. Prioritize users, and then extend the research to all partners. """
|
|
search_dom = expression.OR([[('name', 'ilike', search)], [('email', 'ilike', search)]])
|
|
search_dom = expression.AND([[('active', '=', True)], search_dom])
|
|
fields = ['id', 'name', 'email']
|
|
|
|
# Search users
|
|
domain = expression.AND([[('user_ids.id', '!=', False), ('user_ids.active', '=', True)], search_dom])
|
|
users = self.search_read(domain, fields, limit=limit)
|
|
|
|
# Search partners if less than 'limit' users found
|
|
partners = []
|
|
if len(users) < limit:
|
|
partners = self.search_read(search_dom, fields, limit=limit)
|
|
# Remove duplicates
|
|
partners = [p for p in partners if not len([u for u in users if u['id'] == p['id']])]
|
|
|
|
# add OdooBot even if its partner is archived
|
|
if len(partners) + len(users) < limit and "odoobot".startswith(search.lower()):
|
|
odoobot = self.env.ref("base.partner_root")
|
|
if not any(elem['id'] == odoobot.id for elem in partners):
|
|
partners.append(odoobot.read(fields)[0])
|
|
|
|
return [users, partners]
|
|
|
|
@api.model
|
|
def im_search(self, name, limit=20):
|
|
""" 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
|
|
"""
|
|
# 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 self.env['mail.channel'].check_access_rights('create', raise_exception=False):
|
|
name = '%' + name + '%'
|
|
excluded_partner_ids = [self.env.user.partner_id.id]
|
|
self.env.cr.execute("""
|
|
SELECT
|
|
U.id as user_id,
|
|
P.id as id,
|
|
P.name as name,
|
|
CASE WHEN B.last_poll IS NULL THEN 'offline'
|
|
WHEN age(now() AT TIME ZONE 'UTC', B.last_poll) > interval %s THEN 'offline'
|
|
WHEN age(now() AT TIME ZONE 'UTC', B.last_presence) > interval %s THEN 'away'
|
|
ELSE 'online'
|
|
END as im_status
|
|
FROM res_users U
|
|
JOIN res_partner P ON P.id = U.partner_id
|
|
LEFT JOIN bus_presence B ON B.user_id = U.id
|
|
WHERE P.name ILIKE %s
|
|
AND P.id NOT IN %s
|
|
AND U.active = 't'
|
|
LIMIT %s
|
|
""", ("%s seconds" % DISCONNECTION_TIMER, "%s seconds" % AWAY_TIMER, name, tuple(excluded_partner_ids), limit))
|
|
return self.env.cr.dictfetchall()
|
|
else:
|
|
return {}
|