Thibault Delavallée
52ac7f2ddb
Currently there are several limitations in visitor email and phone
computation, notably phone of partner is not taken into account (only mobile)
and computation does not work in website_crm if there are no leads.
In this commit we
* support both mobile and phone fields of partner. Indeed generally all
SMS flows check for those two fields and not only for mobile;
* replace the SQL by standard ORM computation. As those fields are not stored
and displayed in list views ORM should be capable of managing them;
* avoid crash when creating visitors through the UI (no ids -> don't go
into raw SQL);
* correctly keep partner-based values when no lead is linked to the visitor;
Tests are also added in order to ensure behavior.
Task ID 2196869
closes odoo/odoo#48369
X-original-commit: 02ceb42e204be2b40b334b4e554eef6dfaffd228
Signed-off-by: Thibault Delavallee (tde) <tde@openerp.com>
267 lines
14 KiB
Python
267 lines
14 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
from datetime import datetime, timedelta
|
|
import uuid
|
|
|
|
from odoo import fields, models, api, registry, _
|
|
from odoo.addons.base.models.res_partner import _tz_get
|
|
from odoo.exceptions import UserError
|
|
from odoo.tools.misc import _format_time_ago
|
|
from odoo.http import request
|
|
from odoo.osv import expression
|
|
|
|
|
|
class WebsiteTrack(models.Model):
|
|
_name = 'website.track'
|
|
_description = 'Visited Pages'
|
|
_order = 'visit_datetime DESC'
|
|
_log_access = False
|
|
|
|
visitor_id = fields.Many2one('website.visitor', ondelete="cascade", index=True, required=True, readonly=True)
|
|
page_id = fields.Many2one('website.page', index=True, ondelete='cascade', readonly=True)
|
|
url = fields.Text('Url', index=True)
|
|
visit_datetime = fields.Datetime('Visit Date', default=fields.Datetime.now, required=True, readonly=True)
|
|
|
|
|
|
class WebsiteVisitor(models.Model):
|
|
_name = 'website.visitor'
|
|
_description = 'Website Visitor'
|
|
_order = 'last_connection_datetime DESC'
|
|
|
|
name = fields.Char('Name')
|
|
access_token = fields.Char(required=True, default=lambda x: uuid.uuid4().hex, index=True, copy=False, groups='base.group_website_publisher')
|
|
active = fields.Boolean('Active', default=True)
|
|
website_id = fields.Many2one('website', "Website", readonly=True)
|
|
partner_id = fields.Many2one('res.partner', string="Linked Partner", help="Partner of the last logged in user.")
|
|
partner_image = fields.Binary(related='partner_id.image_1920')
|
|
|
|
# localisation and info
|
|
country_id = fields.Many2one('res.country', 'Country', readonly=True)
|
|
country_flag = fields.Binary(related="country_id.image", string="Country Flag")
|
|
lang_id = fields.Many2one('res.lang', string='Language', help="Language from the website when visitor has been created")
|
|
timezone = fields.Selection(_tz_get, string='Timezone')
|
|
email = fields.Char(string='Email', compute='_compute_email_phone')
|
|
mobile = fields.Char(string='Mobile Phone', compute='_compute_email_phone')
|
|
|
|
# Visit fields
|
|
visit_count = fields.Integer('Number of visits', default=1, readonly=True, help="A new visit is considered if last connection was more than 8 hours ago.")
|
|
website_track_ids = fields.One2many('website.track', 'visitor_id', string='Visited Pages History', readonly=True)
|
|
visitor_page_count = fields.Integer('Page Views', compute="_compute_page_statistics", help="Total number of visits on tracked pages")
|
|
page_ids = fields.Many2many('website.page', string="Visited Pages", compute="_compute_page_statistics")
|
|
page_count = fields.Integer('# Visited Pages', compute="_compute_page_statistics", help="Total number of tracked page visited")
|
|
last_visited_page_id = fields.Many2one('website.page', string="Last Visited Page", compute="_compute_last_visited_page_id")
|
|
|
|
# Time fields
|
|
create_date = fields.Datetime('First connection date', readonly=True)
|
|
last_connection_datetime = fields.Datetime('Last Connection', default=fields.Datetime.now, help="Last page view date", readonly=True)
|
|
time_since_last_action = fields.Char('Last action', compute="_compute_time_statistics", help='Time since last page view. E.g.: 2 minutes ago')
|
|
is_connected = fields.Boolean('Is connected ?', compute='_compute_time_statistics', help='A visitor is considered as connected if his last page view was within the last 5 minutes.')
|
|
|
|
_sql_constraints = [
|
|
('access_token_unique', 'unique(access_token)', 'Access token should be unique.'),
|
|
('partner_uniq', 'unique(partner_id)', 'A partner is linked to only one visitor.'),
|
|
]
|
|
|
|
@api.depends('name')
|
|
def name_get(self):
|
|
return [(
|
|
record.id,
|
|
(record.name or _('Website Visitor #%s') % record.id)
|
|
) for record in self]
|
|
|
|
@api.depends('partner_id.email_normalized', 'partner_id.mobile', 'partner_id.phone')
|
|
def _compute_email_phone(self):
|
|
results = self.env['res.partner'].search_read(
|
|
[('id', 'in', self.partner_id.ids)],
|
|
['id', 'email_normalized', 'mobile', 'phone'],
|
|
)
|
|
mapped_data = {
|
|
result['id']: {
|
|
'email_normalized': result['email_normalized'],
|
|
'mobile': result['mobile'] if result['mobile'] else result['phone']
|
|
} for result in results
|
|
}
|
|
|
|
for visitor in self:
|
|
visitor.email = mapped_data.get(visitor.partner_id.id, {}).get('email_normalized')
|
|
visitor.mobile = mapped_data.get(visitor.partner_id.id, {}).get('mobile')
|
|
|
|
@api.depends('website_track_ids')
|
|
def _compute_page_statistics(self):
|
|
results = self.env['website.track'].read_group(
|
|
[('visitor_id', 'in', self.ids), ('url', '!=', False)], ['visitor_id', 'page_id', 'url'], ['visitor_id', 'page_id', 'url'], lazy=False)
|
|
mapped_data = {}
|
|
for result in results:
|
|
visitor_info = mapped_data.get(result['visitor_id'][0], {'page_count': 0, 'visitor_page_count': 0, 'page_ids': set()})
|
|
visitor_info['visitor_page_count'] += result['__count']
|
|
visitor_info['page_count'] += 1
|
|
if result['page_id']:
|
|
visitor_info['page_ids'].add(result['page_id'][0])
|
|
mapped_data[result['visitor_id'][0]] = visitor_info
|
|
|
|
for visitor in self:
|
|
visitor_info = mapped_data.get(visitor.id, {'page_count': 0, 'visitor_page_count': 0, 'page_ids': set()})
|
|
visitor.page_ids = [(6, 0, visitor_info['page_ids'])]
|
|
visitor.visitor_page_count = visitor_info['visitor_page_count']
|
|
visitor.page_count = visitor_info['page_count']
|
|
|
|
@api.depends('website_track_ids.page_id')
|
|
def _compute_last_visited_page_id(self):
|
|
results = self.env['website.track'].read_group([('visitor_id', 'in', self.ids)],
|
|
['visitor_id', 'page_id', 'visit_datetime:max'],
|
|
['visitor_id', 'page_id'], lazy=False)
|
|
mapped_data = {result['visitor_id'][0]: result['page_id'][0] for result in results if result['page_id']}
|
|
for visitor in self:
|
|
visitor.last_visited_page_id = mapped_data.get(visitor.id, False)
|
|
|
|
@api.depends('last_connection_datetime')
|
|
def _compute_time_statistics(self):
|
|
for visitor in self:
|
|
visitor.time_since_last_action = _format_time_ago(self.env, (datetime.now() - visitor.last_connection_datetime))
|
|
visitor.is_connected = (datetime.now() - visitor.last_connection_datetime) < timedelta(minutes=5)
|
|
|
|
def _check_for_message_composer(self):
|
|
""" Purpose of this method is to actualize visitor model prior to contacting
|
|
him. Used notably for inheritance purpose, when dealing with leads that
|
|
could update the visitor model. """
|
|
return bool(self.partner_id and self.partner_id.email)
|
|
|
|
def _prepare_message_composer_context(self):
|
|
return {
|
|
'default_model': 'res.partner',
|
|
'default_res_id': self.partner_id.id,
|
|
'default_partner_ids': [self.partner_id.id],
|
|
}
|
|
|
|
def action_send_mail(self):
|
|
self.ensure_one()
|
|
if not self._check_for_message_composer():
|
|
raise UserError(_("There is no contact and/or no email linked this visitor."))
|
|
visitor_composer_ctx = self._prepare_message_composer_context()
|
|
compose_form = self.env.ref('mail.email_compose_message_wizard_form', False)
|
|
compose_ctx = dict(
|
|
default_use_template=False,
|
|
default_composition_mode='comment',
|
|
)
|
|
compose_ctx.update(**visitor_composer_ctx)
|
|
return {
|
|
'name': _('Contact Visitor'),
|
|
'type': 'ir.actions.act_window',
|
|
'view_mode': 'form',
|
|
'res_model': 'mail.compose.message',
|
|
'views': [(compose_form.id, 'form')],
|
|
'view_id': compose_form.id,
|
|
'target': 'new',
|
|
'context': compose_ctx,
|
|
}
|
|
|
|
def _get_visitor_from_request(self, force_create=False):
|
|
""" Return the visitor as sudo from the request if there is a visitor_uuid cookie.
|
|
It is possible that the partner has changed or has disconnected.
|
|
In that case the cookie is still referencing the old visitor and need to be replaced
|
|
with the one of the visitor returned !!!. """
|
|
|
|
# This function can be called in json with mobile app.
|
|
# In case of mobile app, no uid is set on the jsonRequest env.
|
|
# In case of multi db, _env is None on request, and request.env unbound.
|
|
if not request:
|
|
return None
|
|
Visitor = self.env['website.visitor'].sudo()
|
|
visitor = Visitor
|
|
access_token = request.httprequest.cookies.get('visitor_uuid')
|
|
if access_token:
|
|
visitor = Visitor.with_context(active_test=False).search([('access_token', '=', access_token)])
|
|
# Prefetch access_token and other fields. Since access_token has a restricted group and we access
|
|
# a non restricted field (partner_id) first it is not fetched and will require an additional query to be retrieved.
|
|
visitor.access_token
|
|
|
|
if not self.env.user._is_public():
|
|
partner_id = self.env.user.partner_id
|
|
if not visitor or visitor.partner_id and visitor.partner_id != partner_id:
|
|
# Partner and no cookie or wrong cookie
|
|
visitor = Visitor.with_context(active_test=False).search([('partner_id', '=', partner_id.id)])
|
|
elif visitor and visitor.partner_id:
|
|
# Cookie associated to a Partner
|
|
visitor = Visitor
|
|
|
|
if force_create and not visitor:
|
|
visitor = self._create_visitor()
|
|
|
|
return visitor
|
|
|
|
def _handle_webpage_dispatch(self, response, website_page):
|
|
# get visitor. Done here to avoid having to do it multiple times in case of override.
|
|
visitor_sudo = self._get_visitor_from_request(force_create=True)
|
|
if request.httprequest.cookies.get('visitor_uuid', '') != visitor_sudo.access_token:
|
|
expiration_date = datetime.now() + timedelta(days=365)
|
|
response.set_cookie('visitor_uuid', visitor_sudo.access_token, expires=expiration_date)
|
|
self._handle_website_page_visit(website_page, visitor_sudo)
|
|
|
|
def _handle_website_page_visit(self, website_page, visitor_sudo):
|
|
""" Called on dispatch. This will create a website.visitor if the http request object
|
|
is a tracked website page or a tracked view. Only on tracked elements to avoid having
|
|
too much operations done on every page or other http requests.
|
|
Note: The side effect is that the last_connection_datetime is updated ONLY on tracked elements."""
|
|
url = request.httprequest.url
|
|
website_track_values = {
|
|
'url': url,
|
|
'visit_datetime': datetime.now(),
|
|
}
|
|
if website_page:
|
|
website_track_values['page_id'] = website_page.id
|
|
domain = [('page_id', '=', website_page.id)]
|
|
else:
|
|
domain = [('url', '=', url)]
|
|
visitor_sudo._add_tracking(domain, website_track_values)
|
|
if visitor_sudo.lang_id.id != request.lang.id:
|
|
visitor_sudo.write({'lang_id': request.lang.id})
|
|
|
|
def _add_tracking(self, domain, website_track_values):
|
|
""" Add the track and update the visitor"""
|
|
domain = expression.AND([domain, [('visitor_id', '=', self.id)]])
|
|
last_view = self.env['website.track'].sudo().search(domain, limit=1)
|
|
if not last_view or last_view.visit_datetime < datetime.now() - timedelta(minutes=30):
|
|
website_track_values['visitor_id'] = self.id
|
|
self.env['website.track'].create(website_track_values)
|
|
self._update_visitor_last_visit()
|
|
|
|
def _create_visitor(self):
|
|
""" Create a visitor. Tracking is added after the visitor has been created."""
|
|
country_code = request.session.get('geoip', {}).get('country_code', False)
|
|
country_id = request.env['res.country'].sudo().search([('code', '=', country_code)], limit=1).id if country_code else False
|
|
vals = {
|
|
'lang_id': request.lang.id,
|
|
'country_id': country_id,
|
|
'website_id': request.website.id,
|
|
}
|
|
if not self.env.user._is_public():
|
|
vals['partner_id'] = self.env.user.partner_id.id
|
|
vals['name'] = self.env.user.partner_id.name
|
|
return self.sudo().create(vals)
|
|
|
|
def _cron_archive_visitors(self):
|
|
one_week_ago = datetime.now() - timedelta(days=7)
|
|
visitors_to_archive = self.env['website.visitor'].sudo().search([('last_connection_datetime', '<', one_week_ago)])
|
|
visitors_to_archive.write({'active': False})
|
|
|
|
def _update_visitor_last_visit(self):
|
|
""" We need to do this part here to avoid concurrent updates error. """
|
|
try:
|
|
with self.env.cr.savepoint():
|
|
query_lock = "SELECT * FROM website_visitor where id = %s FOR NO KEY UPDATE NOWAIT"
|
|
self.env.cr.execute(query_lock, (self.id,), log_exceptions=False)
|
|
|
|
date_now = datetime.now()
|
|
query = "UPDATE website_visitor SET "
|
|
if self.last_connection_datetime < (date_now - timedelta(hours=8)):
|
|
query += "visit_count = visit_count + 1,"
|
|
query += """
|
|
active = True,
|
|
last_connection_datetime = %s
|
|
WHERE id = %s
|
|
"""
|
|
self.env.cr.execute(query, (date_now, self.id), log_exceptions=False)
|
|
except Exception:
|
|
pass
|