Lucas LefèvreandYannick Tivisse
3e97cff779
Purpose ======= Fields `customer` and `supplier` on `res.partner` are mostly used in domains of many2x fields. Those domains can confuse end users because they don't see the partner they are looking for; and it's not obvious why. Some identified problems: 1. It can lead to duplicated partners: the user does not find the partner, so he creates a new one. 2. The user imports supplier contacts in the Contacts app, so they don't get the `supplier` flag. Then the user wants to make a purchase order, and cannot find the new suppliers in the list 3. A user removes the customer flag on a prospect, because they don't think it's a customer yet - except now they can't make a quote for that customer... Specification ============= Remove the two mentioned fields. Since fields `customer` and `supplier` have been removed, all partners are now shown in many2one dropdowns. But in some cases, not all partners are relevant or some are more likely to be relevant than others. e.g. when creating a PO, top suppliers have a higher priority than other partners. So, adapt the places where those fields were used with the new mechanism to display the searched the partners, according to the number purchase/sales orders they made. TaskID: 2031147 Co-authored-by: Yannick Tivisse <yti@odoo.com>
251 lines
11 KiB
Python
251 lines
11 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
import logging
|
|
|
|
from ast import literal_eval
|
|
from collections import defaultdict
|
|
from dateutil.relativedelta import relativedelta
|
|
|
|
from odoo import api, fields, models, _
|
|
from odoo.exceptions import UserError
|
|
from odoo.osv import expression
|
|
from odoo.tools.misc import ustr
|
|
|
|
from odoo.addons.base.models.ir_mail_server import MailDeliveryException
|
|
from odoo.addons.auth_signup.models.res_partner import SignupError, now
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
class ResUsers(models.Model):
|
|
_inherit = 'res.users'
|
|
|
|
state = fields.Selection(compute='_compute_state', search='_search_state', string='Status',
|
|
selection=[('new', 'Never Connected'), ('active', 'Confirmed')])
|
|
|
|
def _search_state(self, operator, value):
|
|
negative = operator in expression.NEGATIVE_TERM_OPERATORS
|
|
|
|
# In case we have no value
|
|
if not value:
|
|
return expression.TRUE_DOMAIN if negative else expression.FALSE_DOMAIN
|
|
|
|
if operator in ['in', 'not in']:
|
|
if len(value) > 1:
|
|
return expression.FALSE_DOMAIN if negative else expression.TRUE_DOMAIN
|
|
if value[0] == 'new':
|
|
comp = '!=' if negative else '='
|
|
if value[0] == 'active':
|
|
comp = '=' if negative else '!='
|
|
return [('log_ids', comp, False)]
|
|
|
|
if operator in ['=', '!=']:
|
|
# In case we search against anything else than new, we have to invert the operator
|
|
if value != 'new':
|
|
operator = expression.TERM_OPERATORS_NEGATION[operator]
|
|
|
|
return [('log_ids', operator, False)]
|
|
|
|
return expression.TRUE_DOMAIN
|
|
|
|
def _compute_state(self):
|
|
for user in self:
|
|
user.state = 'active' if user.login_date else 'new'
|
|
|
|
@api.model
|
|
def signup(self, values, token=None):
|
|
""" signup a user, to either:
|
|
- create a new user (no token), or
|
|
- create a user for a partner (with token, but no user for partner), or
|
|
- change the password of a user (with token, and existing user).
|
|
:param values: a dictionary with field values that are written on user
|
|
:param token: signup token (optional)
|
|
:return: (dbname, login, password) for the signed up user
|
|
"""
|
|
if token:
|
|
# signup with a token: find the corresponding partner id
|
|
partner = self.env['res.partner']._signup_retrieve_partner(token, check_validity=True, raise_exception=True)
|
|
# invalidate signup token
|
|
partner.write({'signup_token': False, 'signup_type': False, 'signup_expiration': False})
|
|
|
|
partner_user = partner.user_ids and partner.user_ids[0] or False
|
|
|
|
# avoid overwriting existing (presumably correct) values with geolocation data
|
|
if partner.country_id or partner.zip or partner.city:
|
|
values.pop('city', None)
|
|
values.pop('country_id', None)
|
|
if partner.lang:
|
|
values.pop('lang', None)
|
|
|
|
if partner_user:
|
|
# user exists, modify it according to values
|
|
values.pop('login', None)
|
|
values.pop('name', None)
|
|
partner_user.write(values)
|
|
if not partner_user.login_date:
|
|
partner_user._notify_inviter()
|
|
return (self.env.cr.dbname, partner_user.login, values.get('password'))
|
|
else:
|
|
# user does not exist: sign up invited user
|
|
values.update({
|
|
'name': partner.name,
|
|
'partner_id': partner.id,
|
|
'email': values.get('email') or values.get('login'),
|
|
})
|
|
if partner.company_id:
|
|
values['company_id'] = partner.company_id.id
|
|
values['company_ids'] = [(6, 0, [partner.company_id.id])]
|
|
partner_user = self._signup_create_user(values)
|
|
partner_user._notify_inviter()
|
|
else:
|
|
# no token, sign up an external user
|
|
values['email'] = values.get('email') or values.get('login')
|
|
self._signup_create_user(values)
|
|
|
|
return (self.env.cr.dbname, values.get('login'), values.get('password'))
|
|
|
|
@api.model
|
|
def _get_signup_invitation_scope(self):
|
|
return self.env['ir.config_parameter'].sudo().get_param('auth_signup.invitation_scope', 'b2b')
|
|
|
|
@api.model
|
|
def _signup_create_user(self, values):
|
|
""" signup a new user using the template user """
|
|
|
|
# check that uninvited users may sign up
|
|
if 'partner_id' not in values:
|
|
if self._get_signup_invitation_scope() != 'b2c':
|
|
raise SignupError(_('Signup is not allowed for uninvited users'))
|
|
return self._create_user_from_template(values)
|
|
|
|
def _notify_inviter(self):
|
|
for user in self:
|
|
invite_partner = user.create_uid.partner_id
|
|
if invite_partner:
|
|
# notify invite user that new user is connected
|
|
title = _("%s connected") % user.name
|
|
message = _("This is his first connection. Wish him welcome")
|
|
self.env['bus.bus'].sendone(
|
|
(self._cr.dbname, 'res.partner', invite_partner.id),
|
|
{'type': 'user_connection', 'title': title,
|
|
'message': message, 'partner_id': user.partner_id.id}
|
|
)
|
|
|
|
def _create_user_from_template(self, values):
|
|
template_user_id = literal_eval(self.env['ir.config_parameter'].sudo().get_param('base.template_portal_user_id', 'False'))
|
|
template_user = self.browse(template_user_id)
|
|
if not template_user.exists():
|
|
raise ValueError(_('Signup: invalid template user'))
|
|
|
|
if not values.get('login'):
|
|
raise ValueError(_('Signup: no login given for new user'))
|
|
if not values.get('partner_id') and not values.get('name'):
|
|
raise ValueError(_('Signup: no name or partner given for new user'))
|
|
|
|
# create a copy of the template user (attached to a specific partner_id if given)
|
|
values['active'] = True
|
|
try:
|
|
with self.env.cr.savepoint():
|
|
return template_user.with_context(no_reset_password=True).copy(values)
|
|
except Exception as e:
|
|
# copy may failed if asked login is not available.
|
|
raise SignupError(ustr(e))
|
|
|
|
def reset_password(self, login):
|
|
""" retrieve the user corresponding to login (login or email),
|
|
and reset their password
|
|
"""
|
|
users = self.search([('login', '=', login)])
|
|
if not users:
|
|
users = self.search([('email', '=', login)])
|
|
if len(users) != 1:
|
|
raise Exception(_('Reset password: invalid username or email'))
|
|
return users.action_reset_password()
|
|
|
|
def action_reset_password(self):
|
|
""" create signup token for each user, and send their signup url by email """
|
|
# prepare reset password signup
|
|
create_mode = bool(self.env.context.get('create_user'))
|
|
|
|
# no time limit for initial invitation, only for reset password
|
|
expiration = False if create_mode else now(days=+1)
|
|
|
|
self.mapped('partner_id').signup_prepare(signup_type="reset", expiration=expiration)
|
|
|
|
# send email to users with their signup url
|
|
template = False
|
|
if create_mode:
|
|
try:
|
|
template = self.env.ref('auth_signup.set_password_email', raise_if_not_found=False)
|
|
except ValueError:
|
|
pass
|
|
if not template:
|
|
template = self.env.ref('auth_signup.reset_password_email')
|
|
assert template._name == 'mail.template'
|
|
|
|
template_values = {
|
|
'email_to': '${object.email|safe}',
|
|
'email_cc': False,
|
|
'auto_delete': True,
|
|
'partner_to': False,
|
|
'scheduled_date': False,
|
|
}
|
|
template.write(template_values)
|
|
|
|
for user in self:
|
|
if not user.email:
|
|
raise UserError(_("Cannot send email: user %s has no email address.") % user.name)
|
|
with self.env.cr.savepoint():
|
|
template.with_context(lang=user.lang).send_mail(user.id, force_send=True, raise_exception=True)
|
|
_logger.info("Password reset email sent for user <%s> to <%s>", user.login, user.email)
|
|
|
|
def send_unregistered_user_reminder(self, after_days=5):
|
|
datetime_min = fields.Datetime.today() - relativedelta(days=after_days)
|
|
datetime_max = datetime_min + relativedelta(hours=23, minutes=59, seconds=59)
|
|
|
|
res_users_with_details = self.env['res.users'].search_read([
|
|
('share', '=', False),
|
|
('create_uid.email', '!=', False),
|
|
('create_date', '>=', datetime_min),
|
|
('create_date', '<=', datetime_max),
|
|
('log_ids', '=', False)], ['create_uid', 'name', 'login'])
|
|
|
|
# group by invited by
|
|
invited_users = defaultdict(list)
|
|
for user in res_users_with_details:
|
|
invited_users[user.get('create_uid')[0]].append("%s (%s)" % (user.get('name'), user.get('login')))
|
|
|
|
# For sending mail to all the invitors about their invited users
|
|
for user in invited_users:
|
|
template = self.env.ref('auth_signup.mail_template_data_unregistered_users').with_context(dbname=self._cr.dbname, invited_users=invited_users[user])
|
|
template.send_mail(user, notif_layout='mail.mail_notification_light', force_send=False)
|
|
|
|
@api.model
|
|
def web_create_users(self, emails):
|
|
inactive_users = self.search([('state', '=', 'new'), '|', ('login', 'in', emails), ('email', 'in', emails)])
|
|
new_emails = set(emails) - set(inactive_users.mapped('email'))
|
|
res = super(ResUsers, self).web_create_users(list(new_emails))
|
|
if inactive_users:
|
|
inactive_users.with_context(create_user=True).action_reset_password()
|
|
return res
|
|
|
|
@api.model
|
|
def create(self, values):
|
|
# overridden to automatically invite user to sign up
|
|
user = super(ResUsers, self).create(values)
|
|
if user.email and not self.env.context.get('no_reset_password'):
|
|
try:
|
|
user.with_context(create_user=True).action_reset_password()
|
|
except MailDeliveryException:
|
|
user.partner_id.with_context(create_user=True).signup_cancel()
|
|
return user
|
|
|
|
@api.returns('self', lambda value: value.id)
|
|
def copy(self, default=None):
|
|
self.ensure_one()
|
|
sup = super(ResUsers, self)
|
|
if not default or not default.get('email'):
|
|
# avoid sending email to the user we are duplicating
|
|
sup = super(ResUsers, self.with_context(no_reset_password=True))
|
|
return sup.copy(default=default)
|