983 lines
45 KiB
Python
983 lines
45 KiB
Python
# -*- coding: utf-8 -*-
|
||
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||
|
||
import base64
|
||
import collections
|
||
import datetime
|
||
import hashlib
|
||
import pytz
|
||
import threading
|
||
import re
|
||
|
||
from email.utils import formataddr
|
||
|
||
import requests
|
||
from lxml import etree
|
||
from werkzeug import urls
|
||
|
||
from odoo import api, fields, models, tools, SUPERUSER_ID, _
|
||
from odoo.modules import get_module_resource
|
||
from odoo.osv.expression import get_unaccent_wrapper
|
||
from odoo.exceptions import UserError, ValidationError
|
||
|
||
# Global variables used for the warning fields declared on the res.partner
|
||
# in the following modules : sale, purchase, account, stock
|
||
WARNING_MESSAGE = [
|
||
('no-message','No Message'),
|
||
('warning','Warning'),
|
||
('block','Blocking Message')
|
||
]
|
||
WARNING_HELP = _('Selecting the "Warning" option will notify user with the message, Selecting "Blocking Message" will throw an exception with the message and block the flow. The Message has to be written in the next field.')
|
||
|
||
|
||
ADDRESS_FIELDS = ('street', 'street2', 'zip', 'city', 'state_id', 'country_id')
|
||
@api.model
|
||
def _lang_get(self):
|
||
return self.env['res.lang'].get_installed()
|
||
|
||
|
||
# put POSIX 'Etc/*' entries at the end to avoid confusing users - see bug 1086728
|
||
_tzs = [(tz, tz) for tz in sorted(pytz.all_timezones, key=lambda tz: tz if not tz.startswith('Etc/') else '_')]
|
||
def _tz_get(self):
|
||
return _tzs
|
||
|
||
|
||
class FormatAddressMixin(models.AbstractModel):
|
||
_name = "format.address.mixin"
|
||
_description = 'Fomat Address'
|
||
|
||
def _fields_view_get_address(self, arch):
|
||
# consider the country of the user, not the country of the partner we want to display
|
||
address_view_id = self.env.user.company_id.country_id.address_view_id
|
||
if address_view_id and not self._context.get('no_address_format'):
|
||
#render the partner address accordingly to address_view_id
|
||
doc = etree.fromstring(arch)
|
||
for address_node in doc.xpath("//div[hasclass('o_address_format')]"):
|
||
Partner = self.env['res.partner'].with_context(no_address_format=True)
|
||
sub_view = Partner.fields_view_get(
|
||
view_id=address_view_id.id, view_type='form', toolbar=False, submenu=False)
|
||
sub_view_node = etree.fromstring(sub_view['arch'])
|
||
#if the model is different than res.partner, there are chances that the view won't work
|
||
#(e.g fields not present on the model). In that case we just return arch
|
||
if self._name != 'res.partner':
|
||
try:
|
||
self.env['ir.ui.view'].postprocess_and_fields(self._name, sub_view_node, None)
|
||
except ValueError:
|
||
return arch
|
||
address_node.getparent().replace(address_node, sub_view_node)
|
||
arch = etree.tostring(doc, encoding='unicode')
|
||
return arch
|
||
|
||
class PartnerCategory(models.Model):
|
||
_description = 'Partner Tags'
|
||
_name = 'res.partner.category'
|
||
_order = 'name'
|
||
_parent_store = True
|
||
|
||
name = fields.Char(string='Tag Name', required=True, translate=True)
|
||
color = fields.Integer(string='Color Index')
|
||
parent_id = fields.Many2one('res.partner.category', string='Parent Category', index=True, ondelete='cascade')
|
||
child_ids = fields.One2many('res.partner.category', 'parent_id', string='Child Tags')
|
||
active = fields.Boolean(default=True, help="The active field allows you to hide the category without removing it.")
|
||
parent_path = fields.Char(index=True)
|
||
partner_ids = fields.Many2many('res.partner', column1='category_id', column2='partner_id', string='Partners')
|
||
|
||
@api.constrains('parent_id')
|
||
def _check_parent_id(self):
|
||
if not self._check_recursion():
|
||
raise ValidationError(_('You can not create recursive tags.'))
|
||
|
||
@api.multi
|
||
def name_get(self):
|
||
""" Return the categories' display name, including their direct
|
||
parent by default.
|
||
|
||
If ``context['partner_category_display']`` is ``'short'``, the short
|
||
version of the category name (without the direct parent) is used.
|
||
The default is the long version.
|
||
"""
|
||
if self._context.get('partner_category_display') == 'short':
|
||
return super(PartnerCategory, self).name_get()
|
||
|
||
res = []
|
||
for category in self:
|
||
names = []
|
||
current = category
|
||
while current:
|
||
names.append(current.name)
|
||
current = current.parent_id
|
||
res.append((category.id, ' / '.join(reversed(names))))
|
||
return res
|
||
|
||
@api.model
|
||
def _name_search(self, name, args=None, operator='ilike', limit=100, name_get_uid=None):
|
||
args = args or []
|
||
if name:
|
||
# Be sure name_search is symetric to name_get
|
||
name = name.split(' / ')[-1]
|
||
args = [('name', operator, name)] + args
|
||
partner_category_ids = self._search(args, limit=limit, access_rights_uid=name_get_uid)
|
||
return self.browse(partner_category_ids).name_get()
|
||
|
||
|
||
class PartnerTitle(models.Model):
|
||
_name = 'res.partner.title'
|
||
_order = 'name'
|
||
_description = 'Partner Title'
|
||
|
||
name = fields.Char(string='Title', required=True, translate=True)
|
||
shortcut = fields.Char(string='Abbreviation', translate=True)
|
||
|
||
|
||
class Partner(models.Model):
|
||
_description = 'Contact'
|
||
_inherit = ['format.address.mixin']
|
||
_name = "res.partner"
|
||
_order = "display_name"
|
||
|
||
def _default_category(self):
|
||
return self.env['res.partner.category'].browse(self._context.get('category_id'))
|
||
|
||
def _default_company(self):
|
||
return self.env['res.company']._company_default_get('res.partner')
|
||
|
||
def _split_street_with_params(self, street_raw, street_format):
|
||
return {'street': street_raw}
|
||
|
||
name = fields.Char(index=True)
|
||
display_name = fields.Char(compute='_compute_display_name', store=True, index=True)
|
||
date = fields.Date(index=True)
|
||
title = fields.Many2one('res.partner.title')
|
||
parent_id = fields.Many2one('res.partner', string='Related Company', index=True)
|
||
parent_name = fields.Char(related='parent_id.name', readonly=True, string='Parent name')
|
||
child_ids = fields.One2many('res.partner', 'parent_id', string='Contacts', domain=[('active', '=', True)]) # force "active_test" domain to bypass _search() override
|
||
ref = fields.Char(string='Reference', index=True)
|
||
lang = fields.Selection(_lang_get, string='Language', default=lambda self: self.env.lang,
|
||
help="All the emails and documents sent to this contact will be translated in this language.")
|
||
tz = fields.Selection(_tz_get, string='Timezone', default=lambda self: self._context.get('tz'),
|
||
help="The partner's timezone, used to output proper date and time values "
|
||
"inside printed reports. It is important to set a value for this field. "
|
||
"You should use the same timezone that is otherwise used to pick and "
|
||
"render date and time values: your computer's timezone.")
|
||
tz_offset = fields.Char(compute='_compute_tz_offset', string='Timezone offset', invisible=True)
|
||
user_id = fields.Many2one('res.users', string='Salesperson',
|
||
help='The internal user in charge of this contact.')
|
||
vat = fields.Char(string='Tax ID', help="The Tax Identification Number. Complete it if the contact is subjected to government taxes. Used in some legal statements.")
|
||
bank_ids = fields.One2many('res.partner.bank', 'partner_id', string='Banks')
|
||
website = fields.Char()
|
||
comment = fields.Text(string='Notes')
|
||
|
||
category_id = fields.Many2many('res.partner.category', column1='partner_id',
|
||
column2='category_id', string='Tags', default=_default_category)
|
||
credit_limit = fields.Float(string='Credit Limit')
|
||
barcode = fields.Char(oldname='ean13', help="Use a barcode to identify this contact from the Point of Sale.")
|
||
active = fields.Boolean(default=True)
|
||
customer = fields.Boolean(string='Is a Customer', default=True,
|
||
help="Check this box if this contact is a customer. It can be selected in sales orders.")
|
||
supplier = fields.Boolean(string='Is a Vendor',
|
||
help="Check this box if this contact is a vendor. It can be selected in purchase orders.")
|
||
employee = fields.Boolean(help="Check this box if this contact is an Employee.")
|
||
function = fields.Char(string='Job Position')
|
||
type = fields.Selection(
|
||
[('contact', 'Contact'),
|
||
('invoice', 'Invoice Address'),
|
||
('delivery', 'Shipping Address'),
|
||
('other', 'Other Address'),
|
||
("private", "Private Address"),
|
||
], string='Address Type',
|
||
default='contact',
|
||
help="Invoice & Shipping addresses are used in sales orders. Private addresses are only visible by authorized users.")
|
||
street = fields.Char()
|
||
street2 = fields.Char()
|
||
zip = fields.Char(change_default=True)
|
||
city = fields.Char()
|
||
state_id = fields.Many2one("res.country.state", string='State', ondelete='restrict', domain="[('country_id', '=?', country_id)]")
|
||
country_id = fields.Many2one('res.country', string='Country', ondelete='restrict')
|
||
email = fields.Char()
|
||
email_formatted = fields.Char(
|
||
'Formatted Email', compute='_compute_email_formatted',
|
||
help='Format email address "Name <email@domain>"')
|
||
phone = fields.Char()
|
||
mobile = fields.Char()
|
||
is_company = fields.Boolean(string='Is a Company', default=False,
|
||
help="Check if the contact is a company, otherwise it is a person")
|
||
industry_id = fields.Many2one('res.partner.industry', 'Industry')
|
||
# company_type is only an interface field, do not use it in business logic
|
||
company_type = fields.Selection(string='Company Type',
|
||
selection=[('person', 'Individual'), ('company', 'Company')],
|
||
compute='_compute_company_type', inverse='_write_company_type')
|
||
company_id = fields.Many2one('res.company', 'Company', index=True, default=_default_company)
|
||
color = fields.Integer(string='Color Index', default=0)
|
||
user_ids = fields.One2many('res.users', 'partner_id', string='Users', auto_join=True)
|
||
partner_share = fields.Boolean(
|
||
'Share Partner', compute='_compute_partner_share', store=True,
|
||
help="Either customer (not a user), either shared user. Indicated the current partner is a customer without "
|
||
"access or with a limited access created for sharing data.")
|
||
contact_address = fields.Char(compute='_compute_contact_address', string='Complete Address')
|
||
|
||
# technical field used for managing commercial fields
|
||
commercial_partner_id = fields.Many2one('res.partner', compute='_compute_commercial_partner',
|
||
string='Commercial Entity', store=True, index=True)
|
||
commercial_company_name = fields.Char('Company Name Entity', compute='_compute_commercial_company_name',
|
||
store=True)
|
||
company_name = fields.Char('Company Name')
|
||
|
||
# image: all image fields are base64 encoded and PIL-supported
|
||
image = fields.Binary("Image", attachment=True,
|
||
help="This field holds the image used as avatar for this contact, limited to 1024x1024px",)
|
||
image_medium = fields.Binary("Medium-sized image", attachment=True,
|
||
help="Medium-sized image of this contact. It is automatically "\
|
||
"resized as a 128x128px image, with aspect ratio preserved. "\
|
||
"Use this field in form views or some kanban views.")
|
||
image_small = fields.Binary("Small-sized image", attachment=True,
|
||
help="Small-sized image of this contact. It is automatically "\
|
||
"resized as a 64x64px image, with aspect ratio preserved. "\
|
||
"Use this field anywhere a small image is required.")
|
||
# hack to allow using plain browse record in qweb views, and used in ir.qweb.field.contact
|
||
self = fields.Many2one(comodel_name=_name, compute='_compute_get_ids')
|
||
|
||
_sql_constraints = [
|
||
('check_name', "CHECK( (type='contact' AND name IS NOT NULL) or (type!='contact') )", 'Contacts require a name.'),
|
||
]
|
||
|
||
@api.model_cr
|
||
def init(self):
|
||
self._cr.execute("""SELECT indexname FROM pg_indexes WHERE indexname = 'res_partner_vat_index'""")
|
||
if not self._cr.fetchone():
|
||
self._cr.execute("""CREATE INDEX res_partner_vat_index ON res_partner (regexp_replace(upper(vat), '[^A-Z0-9]+', '', 'g'))""")
|
||
|
||
@api.depends('is_company', 'name', 'parent_id.name', 'type', 'company_name')
|
||
def _compute_display_name(self):
|
||
diff = dict(show_address=None, show_address_only=None, show_email=None)
|
||
names = dict(self.with_context(**diff).name_get())
|
||
for partner in self:
|
||
partner.display_name = names.get(partner.id)
|
||
|
||
@api.depends('tz')
|
||
def _compute_tz_offset(self):
|
||
for partner in self:
|
||
partner.tz_offset = datetime.datetime.now(pytz.timezone(partner.tz or 'GMT')).strftime('%z')
|
||
|
||
@api.depends('user_ids.share', 'user_ids.active')
|
||
def _compute_partner_share(self):
|
||
for partner in self:
|
||
partner.partner_share = not partner.user_ids or not any(not user.share for user in partner.user_ids)
|
||
|
||
@api.depends(lambda self: self._display_address_depends())
|
||
def _compute_contact_address(self):
|
||
for partner in self:
|
||
partner.contact_address = partner._display_address()
|
||
|
||
@api.one
|
||
def _compute_get_ids(self):
|
||
self.self = self.id
|
||
|
||
@api.depends('is_company', 'parent_id.commercial_partner_id')
|
||
def _compute_commercial_partner(self):
|
||
self.env.cr.execute("""
|
||
WITH RECURSIVE cpid(id, parent_id, commercial_partner_id, final) AS (
|
||
SELECT
|
||
id, parent_id, id,
|
||
(coalesce(is_company, false) OR parent_id IS NULL) as final
|
||
FROM res_partner
|
||
WHERE id = ANY(%s)
|
||
UNION
|
||
SELECT
|
||
cpid.id, p.parent_id, p.id,
|
||
(coalesce(is_company, false) OR p.parent_id IS NULL) as final
|
||
FROM res_partner p
|
||
JOIN cpid ON (cpid.parent_id = p.id)
|
||
WHERE NOT cpid.final
|
||
)
|
||
SELECT cpid.id, cpid.commercial_partner_id
|
||
FROM cpid
|
||
WHERE final AND id = ANY(%s);
|
||
""", [self.ids, self.ids])
|
||
|
||
d = dict(self.env.cr.fetchall())
|
||
for partner in self:
|
||
fetched = d.get(partner.id)
|
||
if fetched is not None:
|
||
partner.commercial_partner_id = fetched
|
||
elif partner.is_company or not partner.parent_id:
|
||
partner.commercial_partner_id = partner
|
||
else:
|
||
partner.commercial_partner_id = partner.parent_id.commercial_partner_id
|
||
|
||
@api.depends('company_name', 'parent_id.is_company', 'commercial_partner_id.name')
|
||
def _compute_commercial_company_name(self):
|
||
for partner in self:
|
||
p = partner.commercial_partner_id
|
||
partner.commercial_company_name = p.is_company and p.name or partner.company_name
|
||
|
||
@api.model
|
||
def _get_default_image(self, partner_type, is_company, parent_id):
|
||
if getattr(threading.currentThread(), 'testing', False) or self._context.get('install_mode'):
|
||
return False
|
||
|
||
colorize, img_path, image = False, False, False
|
||
|
||
if partner_type in ['other'] and parent_id:
|
||
parent_image = self.browse(parent_id).image
|
||
image = parent_image and base64.b64decode(parent_image) or None
|
||
|
||
if not image and partner_type == 'invoice':
|
||
img_path = get_module_resource('base', 'static/img', 'money.png')
|
||
elif not image and partner_type == 'delivery':
|
||
img_path = get_module_resource('base', 'static/img', 'truck.png')
|
||
elif not image and is_company:
|
||
img_path = get_module_resource('base', 'static/img', 'company_image.png')
|
||
elif not image:
|
||
img_path = get_module_resource('base', 'static/img', 'avatar.png')
|
||
colorize = True
|
||
|
||
if img_path:
|
||
with open(img_path, 'rb') as f:
|
||
image = f.read()
|
||
if image and colorize:
|
||
image = tools.image_colorize(image)
|
||
|
||
return tools.image_resize_image_big(base64.b64encode(image))
|
||
|
||
@api.model
|
||
def _fields_view_get(self, view_id=None, view_type='form', toolbar=False, submenu=False):
|
||
if (not view_id) and (view_type == 'form') and self._context.get('force_email'):
|
||
view_id = self.env.ref('base.view_partner_simple_form').id
|
||
res = super(Partner, self)._fields_view_get(view_id=view_id, view_type=view_type, toolbar=toolbar, submenu=submenu)
|
||
if view_type == 'form':
|
||
res['arch'] = self._fields_view_get_address(res['arch'])
|
||
return res
|
||
|
||
@api.constrains('parent_id')
|
||
def _check_parent_id(self):
|
||
if not self._check_recursion():
|
||
raise ValidationError(_('You cannot create recursive Partner hierarchies.'))
|
||
|
||
@api.multi
|
||
def copy(self, default=None):
|
||
self.ensure_one()
|
||
chosen_name = default.get('name') if default else ''
|
||
new_name = chosen_name or _('%s (copy)') % self.name
|
||
default = dict(default or {}, name=new_name)
|
||
return super(Partner, self).copy(default)
|
||
|
||
@api.onchange('parent_id')
|
||
def onchange_parent_id(self):
|
||
# return values in result, as this method is used by _fields_sync()
|
||
if not self.parent_id:
|
||
return
|
||
result = {}
|
||
partner = getattr(self, '_origin', self)
|
||
if partner.parent_id and partner.parent_id != self.parent_id:
|
||
result['warning'] = {
|
||
'title': _('Warning'),
|
||
'message': _('Changing the company of a contact should only be done if it '
|
||
'was never correctly set. If an existing contact starts working for a new '
|
||
'company then a new contact should be created under that new '
|
||
'company. You can use the "Discard" button to abandon this change.')}
|
||
if partner.type == 'contact' or self.type == 'contact':
|
||
# for contacts: copy the parent address, if set (aka, at least one
|
||
# value is set in the address: otherwise, keep the one from the
|
||
# contact)
|
||
address_fields = self._address_fields()
|
||
if any(self.parent_id[key] for key in address_fields):
|
||
def convert(value):
|
||
return value.id if isinstance(value, models.BaseModel) else value
|
||
result['value'] = {key: convert(self.parent_id[key]) for key in address_fields}
|
||
return result
|
||
|
||
@api.onchange('country_id')
|
||
def _onchange_country_id(self):
|
||
if self.country_id and self.country_id != self.state_id.country_id:
|
||
self.state_id = False
|
||
|
||
@api.onchange('state_id')
|
||
def _onchange_state(self):
|
||
if self.state_id.country_id:
|
||
self.country_id = self.state_id.country_id
|
||
|
||
@api.onchange('email')
|
||
def onchange_email(self):
|
||
if not self.image and self._context.get('gravatar_image') and self.email:
|
||
self.image = self._get_gravatar_image(self.email)
|
||
|
||
@api.depends('name', 'email')
|
||
def _compute_email_formatted(self):
|
||
for partner in self:
|
||
if partner.email:
|
||
partner.email_formatted = formataddr((partner.name or u"False", partner.email or u"False"))
|
||
else:
|
||
partner.email_formatted = ''
|
||
|
||
@api.depends('is_company')
|
||
def _compute_company_type(self):
|
||
for partner in self:
|
||
partner.company_type = 'company' if partner.is_company else 'person'
|
||
|
||
def _write_company_type(self):
|
||
for partner in self:
|
||
partner.is_company = partner.company_type == 'company'
|
||
|
||
@api.onchange('company_type')
|
||
def onchange_company_type(self):
|
||
self.is_company = (self.company_type == 'company')
|
||
|
||
@api.multi
|
||
def _update_fields_values(self, fields):
|
||
""" Returns dict of write() values for synchronizing ``fields`` """
|
||
values = {}
|
||
for fname in fields:
|
||
field = self._fields[fname]
|
||
if field.type == 'many2one':
|
||
values[fname] = self[fname].id
|
||
elif field.type == 'one2many':
|
||
raise AssertionError(_('One2Many fields cannot be synchronized as part of `commercial_fields` or `address fields`'))
|
||
elif field.type == 'many2many':
|
||
values[fname] = [(6, 0, self[fname].ids)]
|
||
else:
|
||
values[fname] = self[fname]
|
||
return values
|
||
|
||
@api.model
|
||
def _address_fields(self):
|
||
"""Returns the list of address fields that are synced from the parent."""
|
||
return list(ADDRESS_FIELDS)
|
||
|
||
@api.model
|
||
def _formatting_address_fields(self):
|
||
"""Returns the list of address fields usable to format addresses."""
|
||
return self._address_fields()
|
||
|
||
@api.multi
|
||
def update_address(self, vals):
|
||
addr_vals = {key: vals[key] for key in self._address_fields() if key in vals}
|
||
if addr_vals:
|
||
return super(Partner, self).write(addr_vals)
|
||
|
||
@api.model
|
||
def _commercial_fields(self):
|
||
""" Returns the list of fields that are managed by the commercial entity
|
||
to which a partner belongs. These fields are meant to be hidden on
|
||
partners that aren't `commercial entities` themselves, and will be
|
||
delegated to the parent `commercial entity`. The list is meant to be
|
||
extended by inheriting classes. """
|
||
return ['vat', 'credit_limit']
|
||
|
||
@api.multi
|
||
def _commercial_sync_from_company(self):
|
||
""" Handle sync of commercial fields when a new parent commercial entity is set,
|
||
as if they were related fields """
|
||
commercial_partner = self.commercial_partner_id
|
||
if commercial_partner != self:
|
||
sync_vals = commercial_partner.with_prefetch()._update_fields_values(self._commercial_fields())
|
||
self.write(sync_vals)
|
||
|
||
@api.multi
|
||
def _commercial_sync_to_children(self):
|
||
""" Handle sync of commercial fields to descendants """
|
||
commercial_partner = self.commercial_partner_id
|
||
sync_vals = commercial_partner._update_fields_values(self._commercial_fields())
|
||
sync_children = self.child_ids.filtered(lambda c: not c.is_company)
|
||
for child in sync_children:
|
||
child._commercial_sync_to_children()
|
||
sync_children._compute_commercial_partner()
|
||
return sync_children.write(sync_vals)
|
||
|
||
@api.multi
|
||
def _fields_sync(self, values):
|
||
""" Sync commercial fields and address fields from company and to children after create/update,
|
||
just as if those were all modeled as fields.related to the parent """
|
||
# 1. From UPSTREAM: sync from parent
|
||
if values.get('parent_id') or values.get('type') == 'contact':
|
||
# 1a. Commercial fields: sync if parent changed
|
||
if values.get('parent_id'):
|
||
self._commercial_sync_from_company()
|
||
# 1b. Address fields: sync if parent or use_parent changed *and* both are now set
|
||
if self.parent_id and self.type == 'contact':
|
||
onchange_vals = self.onchange_parent_id().get('value', {})
|
||
self.update_address(onchange_vals)
|
||
|
||
# 2. To DOWNSTREAM: sync children
|
||
self._children_sync(values)
|
||
|
||
def _children_sync(self, values):
|
||
if not self.child_ids:
|
||
return
|
||
# 2a. Commercial Fields: sync if commercial entity
|
||
if self.commercial_partner_id == self:
|
||
commercial_fields = self._commercial_fields()
|
||
if any(field in values for field in commercial_fields):
|
||
self._commercial_sync_to_children()
|
||
for child in self.child_ids.filtered(lambda c: not c.is_company):
|
||
if child.commercial_partner_id != self.commercial_partner_id:
|
||
self._commercial_sync_to_children()
|
||
break
|
||
# 2b. Address fields: sync if address changed
|
||
address_fields = self._address_fields()
|
||
if any(field in values for field in address_fields):
|
||
contacts = self.child_ids.filtered(lambda c: c.type == 'contact')
|
||
contacts.update_address(values)
|
||
|
||
@api.multi
|
||
def _handle_first_contact_creation(self):
|
||
""" On creation of first contact for a company (or root) that has no address, assume contact address
|
||
was meant to be company address """
|
||
parent = self.parent_id
|
||
address_fields = self._address_fields()
|
||
if (parent.is_company or not parent.parent_id) and len(parent.child_ids) == 1 and \
|
||
any(self[f] for f in address_fields) and not any(parent[f] for f in address_fields):
|
||
addr_vals = self._update_fields_values(address_fields)
|
||
parent.update_address(addr_vals)
|
||
|
||
def _clean_website(self, website):
|
||
url = urls.url_parse(website)
|
||
if not url.scheme:
|
||
if not url.netloc:
|
||
url = url.replace(netloc=url.path, path='')
|
||
website = url.replace(scheme='http').to_url()
|
||
return website
|
||
|
||
@api.multi
|
||
def write(self, vals):
|
||
if vals.get('active') is False:
|
||
for partner in self:
|
||
if partner.active and partner.user_ids:
|
||
raise ValidationError(_('You cannot archive a contact linked to an internal user.'))
|
||
# res.partner must only allow to set the company_id of a partner if it
|
||
# is the same as the company of all users that inherit from this partner
|
||
# (this is to allow the code from res_users to write to the partner!) or
|
||
# if setting the company_id to False (this is compatible with any user
|
||
# company)
|
||
if vals.get('website'):
|
||
vals['website'] = self._clean_website(vals['website'])
|
||
if vals.get('parent_id'):
|
||
vals['company_name'] = False
|
||
if vals.get('company_id'):
|
||
company = self.env['res.company'].browse(vals['company_id'])
|
||
for partner in self:
|
||
if partner.user_ids:
|
||
companies = set(user.company_id for user in partner.user_ids)
|
||
if len(companies) > 1 or company not in companies:
|
||
raise UserError(
|
||
("The selected company is not compatible with the companies of the related user(s)"))
|
||
tools.image_resize_images(vals, sizes={'image': (1024, None)})
|
||
|
||
result = True
|
||
# To write in SUPERUSER on field is_company and avoid access rights problems.
|
||
if 'is_company' in vals and self.user_has_groups('base.group_partner_manager') and not self.env.uid == SUPERUSER_ID:
|
||
result = super(Partner, self.sudo()).write({'is_company': vals.get('is_company')})
|
||
del vals['is_company']
|
||
result = result and super(Partner, self).write(vals)
|
||
for partner in self:
|
||
if any(u.has_group('base.group_user') for u in partner.user_ids if u != self.env.user):
|
||
self.env['res.users'].check_access_rights('write')
|
||
partner._fields_sync(vals)
|
||
return result
|
||
|
||
@api.model_create_multi
|
||
def create(self, vals_list):
|
||
if self.env.context.get('import_file'):
|
||
self._check_import_consistency(vals_list)
|
||
for vals in vals_list:
|
||
if vals.get('website'):
|
||
vals['website'] = self._clean_website(vals['website'])
|
||
if vals.get('parent_id'):
|
||
vals['company_name'] = False
|
||
# compute default image in create, because computing gravatar in the onchange
|
||
# cannot be easily performed if default images are in the way
|
||
if not vals.get('image'):
|
||
vals['image'] = self._get_default_image(vals.get('type'), vals.get('is_company'), vals.get('parent_id'))
|
||
tools.image_resize_images(vals, sizes={'image': (1024, None)})
|
||
partners = super(Partner, self).create(vals_list)
|
||
|
||
if self.env.context.get('_partners_skip_fields_sync'):
|
||
return partners
|
||
|
||
for partner, vals in zip(partners, vals_list):
|
||
partner._fields_sync(vals)
|
||
partner._handle_first_contact_creation()
|
||
return partners
|
||
|
||
def _load_records_create(self, vals_list):
|
||
partners = super(Partner, self.with_context(_partners_skip_fields_sync=True))._load_records_create(vals_list)
|
||
|
||
# batch up first part of _fields_sync
|
||
# group partners by commercial_partner_id (if not self) and parent_id (if type == contact)
|
||
groups = collections.defaultdict(list)
|
||
for partner, vals in zip(partners, vals_list):
|
||
cp_id = None
|
||
if vals.get('parent_id') and partner.commercial_partner_id != partner:
|
||
cp_id = partner.commercial_partner_id.id
|
||
|
||
add_id = None
|
||
if partner.parent_id and partner.type == 'contact':
|
||
add_id = partner.parent_id.id
|
||
groups[(cp_id, add_id)].append(partner.id)
|
||
|
||
for (cp_id, add_id), children in groups.items():
|
||
# values from parents (commercial, regular) written to their common children
|
||
to_write = {}
|
||
# commercial fields from commercial partner
|
||
if cp_id:
|
||
to_write = self.browse(cp_id)._update_fields_values(self._commercial_fields())
|
||
# address fields from parent
|
||
if add_id:
|
||
parent = self.browse(add_id)
|
||
for f in self._address_fields():
|
||
v = parent[f]
|
||
if v:
|
||
to_write[f] = v.id if isinstance(v, models.BaseModel) else v
|
||
if to_write:
|
||
self.browse(children).write(to_write)
|
||
|
||
# do the second half of _fields_sync the "normal" way
|
||
for partner, vals in zip(partners, vals_list):
|
||
partner._children_sync(vals)
|
||
partner._handle_first_contact_creation()
|
||
return partners
|
||
|
||
@api.multi
|
||
def create_company(self):
|
||
self.ensure_one()
|
||
if self.company_name:
|
||
# Create parent company
|
||
values = dict(name=self.company_name, is_company=True, vat=self.vat)
|
||
values.update(self._update_fields_values(self._address_fields()))
|
||
new_company = self.create(values)
|
||
# Set new company as my parent
|
||
self.write({
|
||
'parent_id': new_company.id,
|
||
'child_ids': [(1, partner_id, dict(parent_id=new_company.id)) for partner_id in self.child_ids.ids]
|
||
})
|
||
return True
|
||
|
||
@api.multi
|
||
def open_commercial_entity(self):
|
||
""" Utility method used to add an "Open Company" button in partner views """
|
||
self.ensure_one()
|
||
return {'type': 'ir.actions.act_window',
|
||
'res_model': 'res.partner',
|
||
'view_mode': 'form',
|
||
'res_id': self.commercial_partner_id.id,
|
||
'target': 'current',
|
||
'flags': {'form': {'action_buttons': True}}}
|
||
|
||
@api.multi
|
||
def open_parent(self):
|
||
""" Utility method used to add an "Open Parent" button in partner views """
|
||
self.ensure_one()
|
||
address_form_id = self.env.ref('base.view_partner_address_form').id
|
||
return {'type': 'ir.actions.act_window',
|
||
'res_model': 'res.partner',
|
||
'view_mode': 'form',
|
||
'views': [(address_form_id, 'form')],
|
||
'res_id': self.parent_id.id,
|
||
'target': 'new',
|
||
'flags': {'form': {'action_buttons': True}}}
|
||
|
||
def _get_name(self):
|
||
""" Utility method to allow name_get to be overrided without re-browse the partner """
|
||
partner = self
|
||
name = partner.name or ''
|
||
|
||
if partner.company_name or partner.parent_id:
|
||
if not name and partner.type in ['invoice', 'delivery', 'other']:
|
||
name = dict(self.fields_get(['type'])['type']['selection'])[partner.type]
|
||
if not partner.is_company:
|
||
name = "%s, %s" % (partner.commercial_company_name or partner.parent_id.name, name)
|
||
if self._context.get('show_address_only'):
|
||
name = partner._display_address(without_company=True)
|
||
if self._context.get('show_address'):
|
||
name = name + "\n" + partner._display_address(without_company=True)
|
||
name = name.replace('\n\n', '\n')
|
||
name = name.replace('\n\n', '\n')
|
||
if self._context.get('address_inline'):
|
||
name = name.replace('\n', ', ')
|
||
if self._context.get('show_email') and partner.email:
|
||
name = "%s <%s>" % (name, partner.email)
|
||
if self._context.get('html_format'):
|
||
name = name.replace('\n', '<br/>')
|
||
if self._context.get('show_vat') and partner.vat:
|
||
name = "%s ‒ %s" % (name, partner.vat)
|
||
return name
|
||
|
||
@api.multi
|
||
def name_get(self):
|
||
res = []
|
||
for partner in self:
|
||
name = partner._get_name()
|
||
res.append((partner.id, name))
|
||
return res
|
||
|
||
def _parse_partner_name(self, text, context=None):
|
||
""" Supported syntax:
|
||
- 'Raoul <raoul@grosbedon.fr>': will find name and email address
|
||
- otherwise: default, everything is set as the name """
|
||
emails = tools.email_split(text.replace(' ', ','))
|
||
if emails:
|
||
email = emails[0]
|
||
name = text[:text.index(email)].replace('"', '').replace('<', '').strip()
|
||
else:
|
||
name, email = text, ''
|
||
return name, email
|
||
|
||
@api.model
|
||
def name_create(self, name):
|
||
""" Override of orm's name_create method for partners. The purpose is
|
||
to handle some basic formats to create partners using the
|
||
name_create.
|
||
If only an email address is received and that the regex cannot find
|
||
a name, the name will have the email value.
|
||
If 'force_email' key in context: must find the email address. """
|
||
name, email = self._parse_partner_name(name)
|
||
if self._context.get('force_email') and not email:
|
||
raise UserError(_("Couldn't create contact without email address!"))
|
||
if not name and email:
|
||
name = email
|
||
partner = self.create({self._rec_name: name or email, 'email': email or self.env.context.get('default_email', False)})
|
||
return partner.name_get()[0]
|
||
|
||
@api.model
|
||
def _search(self, args, offset=0, limit=None, order=None, count=False, access_rights_uid=None):
|
||
""" Override search() to always show inactive children when searching via ``child_of`` operator. The ORM will
|
||
always call search() with a simple domain of the form [('parent_id', 'in', [ids])]. """
|
||
# a special ``domain`` is set on the ``child_ids`` o2m to bypass this logic, as it uses similar domain expressions
|
||
if len(args) == 1 and len(args[0]) == 3 and args[0][:2] == ('parent_id','in') \
|
||
and args[0][2] != [False]:
|
||
self = self.with_context(active_test=False)
|
||
return super(Partner, self)._search(args, offset=offset, limit=limit, order=order,
|
||
count=count, access_rights_uid=access_rights_uid)
|
||
|
||
@api.model
|
||
def _name_search(self, name, args=None, operator='ilike', limit=100, name_get_uid=None):
|
||
self = self.sudo(name_get_uid or self.env.uid)
|
||
if args is None:
|
||
args = []
|
||
if name and operator in ('=', 'ilike', '=ilike', 'like', '=like'):
|
||
self.check_access_rights('read')
|
||
where_query = self._where_calc(args)
|
||
self._apply_ir_rules(where_query, 'read')
|
||
from_clause, where_clause, where_clause_params = where_query.get_sql()
|
||
from_str = from_clause if from_clause else 'res_partner'
|
||
where_str = where_clause and (" WHERE %s AND " % where_clause) or ' WHERE '
|
||
|
||
# search on the name of the contacts and of its company
|
||
search_name = name
|
||
if operator in ('ilike', 'like'):
|
||
search_name = '%%%s%%' % name
|
||
if operator in ('=ilike', '=like'):
|
||
operator = operator[1:]
|
||
|
||
unaccent = get_unaccent_wrapper(self.env.cr)
|
||
|
||
query = """SELECT res_partner.id
|
||
FROM {from_str}
|
||
{where} ({email} {operator} {percent}
|
||
OR {display_name} {operator} {percent}
|
||
OR {reference} {operator} {percent}
|
||
OR {vat} {operator} {percent})
|
||
-- don't panic, trust postgres bitmap
|
||
ORDER BY {display_name} {operator} {percent} desc,
|
||
{display_name}
|
||
""".format(from_str=from_str,
|
||
where=where_str,
|
||
operator=operator,
|
||
email=unaccent('res_partner.email'),
|
||
display_name=unaccent('res_partner.display_name'),
|
||
reference=unaccent('res_partner.ref'),
|
||
percent=unaccent('%s'),
|
||
vat=unaccent('res_partner.vat'),)
|
||
|
||
where_clause_params += [search_name]*3 # for email / display_name, reference
|
||
where_clause_params += [re.sub('[^a-zA-Z0-9]+', '', search_name) or None] # for vat
|
||
where_clause_params += [search_name] # for order by
|
||
if limit:
|
||
query += ' limit %s'
|
||
where_clause_params.append(limit)
|
||
self.env.cr.execute(query, where_clause_params)
|
||
partner_ids = [row[0] for row in self.env.cr.fetchall()]
|
||
|
||
if partner_ids:
|
||
return models.lazy_name_get(self.browse(partner_ids))
|
||
else:
|
||
return []
|
||
return super(Partner, self)._name_search(name, args, operator=operator, limit=limit, name_get_uid=name_get_uid)
|
||
|
||
@api.model
|
||
def find_or_create(self, email):
|
||
""" Find a partner with the given ``email`` or use :py:method:`~.name_create`
|
||
to create one
|
||
|
||
:param str email: email-like string, which should contain at least one email,
|
||
e.g. ``"Raoul Grosbedon <r.g@grosbedon.fr>"``"""
|
||
assert email, 'an email is required for find_or_create to work'
|
||
emails = tools.email_split(email)
|
||
if emails:
|
||
email = emails[0]
|
||
partners = self.search([('email', '=ilike', email)], limit=1)
|
||
return partners.id or self.name_create(email)[0]
|
||
|
||
def _get_gravatar_image(self, email):
|
||
email_hash = hashlib.md5(email.lower().encode('utf-8')).hexdigest()
|
||
url = "https://www.gravatar.com/avatar/" + email_hash
|
||
try:
|
||
res = requests.get(url, params={'d': '404', 's': '128'}, timeout=5)
|
||
if res.status_code != requests.codes.ok:
|
||
return False
|
||
except requests.exceptions.ConnectionError as e:
|
||
return False
|
||
except requests.exceptions.Timeout as e:
|
||
return False
|
||
return base64.b64encode(res.content)
|
||
|
||
@api.multi
|
||
def _email_send(self, email_from, subject, body, on_error=None):
|
||
for partner in self.filtered('email'):
|
||
tools.email_send(email_from, [partner.email], subject, body, on_error)
|
||
return True
|
||
|
||
@api.multi
|
||
def address_get(self, adr_pref=None):
|
||
""" Find contacts/addresses of the right type(s) by doing a depth-first-search
|
||
through descendants within company boundaries (stop at entities flagged ``is_company``)
|
||
then continuing the search at the ancestors that are within the same company boundaries.
|
||
Defaults to partners of type ``'default'`` when the exact type is not found, or to the
|
||
provided partner itself if no type ``'default'`` is found either. """
|
||
adr_pref = set(adr_pref or [])
|
||
if 'contact' not in adr_pref:
|
||
adr_pref.add('contact')
|
||
result = {}
|
||
visited = set()
|
||
for partner in self:
|
||
current_partner = partner
|
||
while current_partner:
|
||
to_scan = [current_partner]
|
||
# Scan descendants, DFS
|
||
while to_scan:
|
||
record = to_scan.pop(0)
|
||
visited.add(record)
|
||
if record.type in adr_pref and not result.get(record.type):
|
||
result[record.type] = record.id
|
||
if len(result) == len(adr_pref):
|
||
return result
|
||
to_scan = [c for c in record.child_ids
|
||
if c not in visited
|
||
if not c.is_company] + to_scan
|
||
|
||
# Continue scanning at ancestor if current_partner is not a commercial entity
|
||
if current_partner.is_company or not current_partner.parent_id:
|
||
break
|
||
current_partner = current_partner.parent_id
|
||
|
||
# default to type 'contact' or the partner itself
|
||
default = result.get('contact', self.id or False)
|
||
for adr_type in adr_pref:
|
||
result[adr_type] = result.get(adr_type) or default
|
||
return result
|
||
|
||
@api.model
|
||
def view_header_get(self, view_id, view_type):
|
||
res = super(Partner, self).view_header_get(view_id, view_type)
|
||
if res: return res
|
||
if not self._context.get('category_id'):
|
||
return False
|
||
return _('Partners: ') + self.env['res.partner.category'].browse(self._context['category_id']).name
|
||
|
||
@api.model
|
||
@api.returns('self')
|
||
def main_partner(self):
|
||
''' Return the main partner '''
|
||
return self.env.ref('base.main_partner')
|
||
|
||
@api.model
|
||
def _get_default_address_format(self):
|
||
return "%(street)s\n%(street2)s\n%(city)s %(state_code)s %(zip)s\n%(country_name)s"
|
||
|
||
@api.model
|
||
def _get_address_format(self):
|
||
return self.country_id.address_format or self._get_default_address_format()
|
||
|
||
@api.multi
|
||
def _display_address(self, without_company=False):
|
||
|
||
'''
|
||
The purpose of this function is to build and return an address formatted accordingly to the
|
||
standards of the country where it belongs.
|
||
|
||
:param address: browse record of the res.partner to format
|
||
:returns: the address formatted in a display that fit its country habits (or the default ones
|
||
if not country is specified)
|
||
:rtype: string
|
||
'''
|
||
# get the information that will be injected into the display format
|
||
# get the address format
|
||
address_format = self._get_address_format()
|
||
args = {
|
||
'state_code': self.state_id.code or '',
|
||
'state_name': self.state_id.name or '',
|
||
'country_code': self.country_id.code or '',
|
||
'country_name': self._get_country_name(),
|
||
'company_name': self.commercial_company_name or '',
|
||
}
|
||
for field in self._formatting_address_fields():
|
||
args[field] = getattr(self, field) or ''
|
||
if without_company:
|
||
args['company_name'] = ''
|
||
elif self.commercial_company_name:
|
||
address_format = '%(company_name)s\n' + address_format
|
||
return address_format % args
|
||
|
||
def _display_address_depends(self):
|
||
# field dependencies of method _display_address()
|
||
return self._formatting_address_fields() + [
|
||
'country_id.address_format', 'country_id.code', 'country_id.name',
|
||
'company_name', 'state_id.code', 'state_id.name',
|
||
]
|
||
|
||
@api.model
|
||
def get_import_templates(self):
|
||
return [{
|
||
'label': _('Import Template for Customers'),
|
||
'template': '/base/static/xls/res_partner.xls'
|
||
}]
|
||
|
||
@api.model
|
||
def _check_import_consistency(self, vals_list):
|
||
"""
|
||
The values created by an import are generated by a name search, field by field.
|
||
As a result there is no check that the field values are consistent with each others.
|
||
We check that if the state is given a value, it does belong to the given country, or we remove it.
|
||
"""
|
||
States = self.env['res.country.state']
|
||
states_ids = {vals['state_id'] for vals in vals_list if vals.get('state_id')}
|
||
state_to_country = States.search([('id', 'in', list(states_ids))]).read(['country_id'])
|
||
for vals in vals_list:
|
||
if vals.get('state_id'):
|
||
country_id = next(c['country_id'][0] for c in state_to_country if c['id'] == vals.get('state_id'))
|
||
state = States.browse(vals['state_id'])
|
||
if state.country_id.id != country_id:
|
||
state_domain = [('code', '=', state.code),
|
||
('country_id', '=', country_id)]
|
||
state = States.search(state_domain, limit=1)
|
||
vals['state_id'] = state.id # replace state or remove it if not found
|
||
|
||
@api.multi
|
||
def _get_country_name(self):
|
||
return self.country_id.name or ''
|
||
|
||
@api.multi
|
||
def get_base_url(self):
|
||
"""Get the base URL for the current partner."""
|
||
self.ensure_one()
|
||
return self.env['ir.config_parameter'].sudo().get_param('web.base.url')
|
||
|
||
|
||
class ResPartnerIndustry(models.Model):
|
||
_description = 'Industry'
|
||
_name = "res.partner.industry"
|
||
_order = "name"
|
||
|
||
name = fields.Char('Name', translate=True)
|
||
full_name = fields.Char('Full Name', translate=True)
|
||
active = fields.Boolean('Active', default=True)
|