Sébastien Theys
5b32f1b5cd
Change the domain to not include `.id` and to use `in` to prevent subqueries to be ran by the ORM for each attribute value. On the filter, directly use `attribute_value_ids` instead of the computed field `product_template_attribute_value_ids` that leads to the same result, to prevent unnecessary compute of that non-stored field. Cache the result of the method. The cache is invalidated when the configuration of attributes and values change. We can remove all cache invalidation from the tests since it is done at the appropriate times in the business code now. opw-1923999 task-1922055 PR: #30274
271 lines
13 KiB
Python
271 lines
13 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
from odoo import api, fields, models, _
|
|
from odoo.addons import decimal_precision as dp
|
|
from odoo.exceptions import UserError, ValidationError
|
|
from odoo.osv import expression
|
|
|
|
|
|
class ProductAttribute(models.Model):
|
|
_name = "product.attribute"
|
|
_description = "Product Attribute"
|
|
# if you change this _order, keep it in sync with the method
|
|
# `_sort_key_attribute_value` in `product.template`
|
|
_order = 'sequence, id'
|
|
|
|
name = fields.Char('Attribute', required=True, translate=True)
|
|
value_ids = fields.One2many('product.attribute.value', 'attribute_id', 'Values', copy=True)
|
|
sequence = fields.Integer('Sequence', help="Determine the display order", index=True)
|
|
attribute_line_ids = fields.One2many('product.template.attribute.line', 'attribute_id', 'Lines')
|
|
create_variant = fields.Selection([
|
|
('no_variant', 'Never'),
|
|
('always', 'Always'),
|
|
('dynamic', 'Only when the product is added to a sales order')],
|
|
default='always',
|
|
string="Create Variants",
|
|
help="Check this if you want to create multiple variants for this attribute.", required=True)
|
|
|
|
@api.multi
|
|
def _without_no_variant_attributes(self):
|
|
return self.filtered(lambda pa: pa.create_variant != 'no_variant')
|
|
|
|
@api.multi
|
|
def write(self, vals):
|
|
"""Override to make sure attribute type can't be changed if it's used on
|
|
a product template.
|
|
|
|
This is important to prevent because changing the type would make
|
|
existing combinations invalid without recomputing them, and recomputing
|
|
them might take too long and we don't want to change products without
|
|
the user knowing about it."""
|
|
if 'create_variant' in vals:
|
|
products = self._get_related_product_templates()
|
|
if products:
|
|
message = ', '.join(products.mapped('name'))
|
|
raise UserError(_('You are trying to change the type of an attribute value still referenced on at least one product template: %s') % message)
|
|
invalidate_cache = 'sequence' in vals and any(record.sequence != vals['sequence'] for record in self)
|
|
res = super(ProductAttribute, self).write(vals)
|
|
if invalidate_cache:
|
|
# prefetched o2m have to be resequenced
|
|
# (eg. product.template: attribute_line_ids)
|
|
self.invalidate_cache()
|
|
return res
|
|
|
|
@api.multi
|
|
def _get_related_product_templates(self):
|
|
return self.env['product.template'].with_context(active_test=False).search([
|
|
('attribute_line_ids.attribute_id', 'in', self.ids),
|
|
])
|
|
|
|
|
|
class ProductAttributeValue(models.Model):
|
|
_name = "product.attribute.value"
|
|
# if you change this _order, keep it in sync with the method
|
|
# `_sort_key_variant` in `product.template'
|
|
_order = 'attribute_id, sequence, id'
|
|
_description = 'Attribute Value'
|
|
|
|
name = fields.Char(string='Value', required=True, translate=True)
|
|
sequence = fields.Integer(string='Sequence', help="Determine the display order", index=True)
|
|
attribute_id = fields.Many2one('product.attribute', string='Attribute', ondelete='cascade', required=True, index=True)
|
|
|
|
_sql_constraints = [
|
|
('value_company_uniq', 'unique (name, attribute_id)', 'This attribute value already exists !')
|
|
]
|
|
|
|
@api.multi
|
|
def name_get(self):
|
|
if not self._context.get('show_attribute', True): # TDE FIXME: not used
|
|
return super(ProductAttributeValue, self).name_get()
|
|
return [(value.id, "%s: %s" % (value.attribute_id.name, value.name)) for value in self]
|
|
|
|
@api.multi
|
|
def _variant_name(self, variable_attributes):
|
|
return ", ".join([v.name for v in self if v.attribute_id in variable_attributes])
|
|
|
|
@api.multi
|
|
def write(self, values):
|
|
invalidate_cache = 'sequence' in values and any(record.sequence != values['sequence'] for record in self)
|
|
res = super(ProductAttributeValue, self).write(values)
|
|
if invalidate_cache:
|
|
# prefetched o2m have to be resequenced
|
|
# (eg. product.template.attribute.line: value_ids)
|
|
self.invalidate_cache()
|
|
return res
|
|
|
|
@api.multi
|
|
def unlink(self):
|
|
linked_products = self._get_related_product_templates()
|
|
if linked_products:
|
|
raise UserError(_('The operation cannot be completed:\nYou are trying to delete an attribute value with a reference on a product variant.'))
|
|
return super(ProductAttributeValue, self).unlink()
|
|
|
|
@api.multi
|
|
def _without_no_variant_attributes(self):
|
|
return self.filtered(lambda pav: pav.attribute_id.create_variant != 'no_variant')
|
|
|
|
@api.multi
|
|
def _get_related_product_templates(self):
|
|
return self.env['product.template'].with_context(active_test=False).search([
|
|
('attribute_line_ids.value_ids', 'in', self.ids),
|
|
])
|
|
|
|
|
|
class ProductTemplateAttributeLine(models.Model):
|
|
"""Attributes available on product.template with their selected values in a m2m.
|
|
Used as a configuration model to generate the appropriate product.template.attribute.value"""
|
|
|
|
_name = "product.template.attribute.line"
|
|
_rec_name = 'attribute_id'
|
|
_description = 'Product Template Attribute Line'
|
|
_order = 'attribute_id, id'
|
|
|
|
product_tmpl_id = fields.Many2one('product.template', string='Product Template', ondelete='cascade', required=True, index=True)
|
|
attribute_id = fields.Many2one('product.attribute', string='Attribute', ondelete='restrict', required=True, index=True)
|
|
value_ids = fields.Many2many('product.attribute.value', string='Attribute Values')
|
|
product_template_value_ids = fields.Many2many(
|
|
'product.template.attribute.value',
|
|
string='Product Attribute Values',
|
|
compute="_set_product_template_value_ids",
|
|
store=False)
|
|
|
|
@api.constrains('value_ids', 'attribute_id')
|
|
def _check_valid_attribute(self):
|
|
if any(not line.value_ids or line.value_ids > line.attribute_id.value_ids for line in self):
|
|
raise ValidationError(_('You cannot use this attribute with the following value.'))
|
|
return True
|
|
|
|
@api.model
|
|
def create(self, values):
|
|
res = super(ProductTemplateAttributeLine, self).create(values)
|
|
res._update_product_template_attribute_values()
|
|
return res
|
|
|
|
def write(self, values):
|
|
res = super(ProductTemplateAttributeLine, self).write(values)
|
|
self._update_product_template_attribute_values()
|
|
return res
|
|
|
|
@api.depends('value_ids')
|
|
def _set_product_template_value_ids(self):
|
|
for product_template_attribute_line in self:
|
|
product_template_attribute_line.product_template_value_ids = self.env['product.template.attribute.value'].search([
|
|
('product_tmpl_id', 'in', product_template_attribute_line.product_tmpl_id.ids),
|
|
('product_attribute_value_id', 'in', product_template_attribute_line.value_ids.ids)]
|
|
)
|
|
|
|
@api.multi
|
|
def unlink(self):
|
|
for product_template_attribute_line in self:
|
|
self.env['product.template.attribute.value'].search([
|
|
('product_tmpl_id', 'in', product_template_attribute_line.product_tmpl_id.ids),
|
|
('product_attribute_value_id.attribute_id', 'in', product_template_attribute_line.value_ids.mapped('attribute_id').ids)]).unlink()
|
|
|
|
return super(ProductTemplateAttributeLine, self).unlink()
|
|
|
|
def _update_product_template_attribute_values(self):
|
|
"""
|
|
Create or unlink product.template.attribute.value based on the attribute lines.
|
|
If the product.attribute.value is removed, remove the corresponding product.template.attribute.value
|
|
If no product.template.attribute.value exists for the newly added product.attribute.value, create it.
|
|
"""
|
|
for attribute_line in self:
|
|
# All existing product.template.attribute.value for this template
|
|
product_template_attribute_values_to_remove = self.env['product.template.attribute.value'].search([
|
|
('product_tmpl_id', '=', attribute_line.product_tmpl_id.id),
|
|
('product_attribute_value_id.attribute_id', 'in', attribute_line.value_ids.mapped('attribute_id').ids)])
|
|
# All existing product.attribute.value shared by all products
|
|
# eg (Yellow, Red, Blue, Small, Large)
|
|
existing_product_attribute_values = product_template_attribute_values_to_remove.mapped('product_attribute_value_id')
|
|
|
|
# Loop on product.attribute.values for the line (eg: Yellow, Red, Blue)
|
|
for product_attribute_value in attribute_line.value_ids:
|
|
if product_attribute_value in existing_product_attribute_values:
|
|
# property is already existing: don't touch, remove it from list to avoid unlinking it
|
|
product_template_attribute_values_to_remove = product_template_attribute_values_to_remove.filtered(
|
|
lambda value: product_attribute_value not in value.mapped('product_attribute_value_id')
|
|
)
|
|
else:
|
|
# property does not exist: create it
|
|
self.env['product.template.attribute.value'].create({
|
|
'product_attribute_value_id': product_attribute_value.id,
|
|
'product_tmpl_id': attribute_line.product_tmpl_id.id})
|
|
|
|
# at this point, existing properties can be removed to reflect the modifications on value_ids
|
|
if product_template_attribute_values_to_remove:
|
|
product_template_attribute_values_to_remove.unlink()
|
|
|
|
@api.model
|
|
def _name_search(self, name, args=None, operator='ilike', limit=100, name_get_uid=None):
|
|
# TDE FIXME: currently overriding the domain; however as it includes a
|
|
# search on a m2o and one on a m2m, probably this will quickly become
|
|
# difficult to compute - check if performance optimization is required
|
|
if name and operator in ('=', 'ilike', '=ilike', 'like', '=like'):
|
|
args = args or []
|
|
domain = ['|', ('attribute_id', operator, name), ('value_ids', operator, name)]
|
|
attribute_ids = self._search(expression.AND([domain, args]), limit=limit, access_rights_uid=name_get_uid)
|
|
return self.browse(attribute_ids).name_get()
|
|
return super(ProductTemplateAttributeLine, self)._name_search(name=name, args=args, operator=operator, limit=limit, name_get_uid=name_get_uid)
|
|
|
|
@api.multi
|
|
def _without_no_variant_attributes(self):
|
|
return self.filtered(lambda ptal: ptal.attribute_id.create_variant != 'no_variant')
|
|
|
|
|
|
class ProductTemplateAttributeValue(models.Model):
|
|
"""Materialized relationship between attribute values
|
|
and product template generated by the product.template.attribute.line"""
|
|
|
|
_name = "product.template.attribute.value"
|
|
_order = 'product_attribute_value_id, id'
|
|
_description = 'Product Attribute Value'
|
|
|
|
name = fields.Char('Value', related="product_attribute_value_id.name")
|
|
product_attribute_value_id = fields.Many2one(
|
|
'product.attribute.value', string='Attribute Value',
|
|
required=True, ondelete='cascade', index=True)
|
|
product_tmpl_id = fields.Many2one(
|
|
'product.template', string='Product Template',
|
|
required=True, ondelete='cascade', index=True)
|
|
attribute_id = fields.Many2one(
|
|
'product.attribute', string='Attribute',
|
|
related="product_attribute_value_id.attribute_id")
|
|
sequence = fields.Integer('Sequence', related="product_attribute_value_id.sequence")
|
|
price_extra = fields.Float(
|
|
string='Attribute Price Extra',
|
|
default=0.0,
|
|
digits=dp.get_precision('Product Price'),
|
|
help="""Price Extra: Extra price for the variant with
|
|
this attribute value on sale price. eg. 200 price extra, 1000 + 200 = 1200.""")
|
|
exclude_for = fields.One2many(
|
|
'product.template.attribute.exclusion',
|
|
'product_template_attribute_value_id',
|
|
string="Exclude for",
|
|
relation="product_template_attribute_exclusion",
|
|
help="""Make this attribute value not compatible with
|
|
other values of the product or some attribute values of optional and accessory products.""")
|
|
|
|
@api.multi
|
|
def name_get(self):
|
|
if not self._context.get('show_attribute', True): # TDE FIXME: not used
|
|
return super(ProductTemplateAttributeValue, self).name_get()
|
|
return [(value.id, "%s: %s" % (value.attribute_id.name, value.name)) for value in self]
|
|
|
|
@api.multi
|
|
def _without_no_variant_attributes(self):
|
|
return self.filtered(lambda ptav: ptav.attribute_id.create_variant != 'no_variant')
|
|
|
|
|
|
class ProductTemplateAttributeExclusion(models.Model):
|
|
_name = "product.template.attribute.exclusion"
|
|
_description = 'Product Template Attribute Exclusion'
|
|
|
|
product_template_attribute_value_id = fields.Many2one(
|
|
'product.template.attribute.value', string="Attribute Value", ondelete='cascade', index=True)
|
|
product_tmpl_id = fields.Many2one(
|
|
'product.template', string='Product Template', ondelete='cascade', required=True, index=True)
|
|
value_ids = fields.Many2many(
|
|
'product.template.attribute.value', relation="product_attr_exclusion_value_ids_rel",
|
|
string='Attribute Values', domain="[('product_tmpl_id', '=', product_tmpl_id)]")
|