709 lines
35 KiB
Python
709 lines
35 KiB
Python
# -*- coding: utf-8 -*-
|
||
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||
|
||
import re
|
||
from collections import defaultdict
|
||
|
||
from odoo import api, fields, models, tools, _
|
||
from odoo.exceptions import ValidationError
|
||
from odoo.osv import expression
|
||
from odoo.tools import float_compare
|
||
|
||
|
||
class ProductProduct(models.Model):
|
||
_name = "product.product"
|
||
_description = "Product Variant"
|
||
_inherits = {'product.template': 'product_tmpl_id'}
|
||
_inherit = ['mail.thread', 'mail.activity.mixin']
|
||
_order = 'priority desc, default_code, name, id'
|
||
|
||
# price_extra: catalog extra value only, sum of variant extra attributes
|
||
price_extra = fields.Float(
|
||
'Variant Price Extra', compute='_compute_product_price_extra',
|
||
digits='Product Price',
|
||
help="This is the sum of the extra price of all attributes")
|
||
# lst_price: catalog value + extra, context dependent (uom)
|
||
lst_price = fields.Float(
|
||
'Sales Price', compute='_compute_product_lst_price',
|
||
digits='Product Price', inverse='_set_product_lst_price',
|
||
help="The sale price is managed from the product template. Click on the 'Configure Variants' button to set the extra attribute prices.")
|
||
|
||
default_code = fields.Char('Internal Reference', index=True)
|
||
code = fields.Char('Reference', compute='_compute_product_code')
|
||
partner_ref = fields.Char('Customer Ref', compute='_compute_partner_ref')
|
||
|
||
active = fields.Boolean(
|
||
'Active', default=True,
|
||
help="If unchecked, it will allow you to hide the product without removing it.")
|
||
product_tmpl_id = fields.Many2one(
|
||
'product.template', 'Product Template',
|
||
auto_join=True, index=True, ondelete="cascade", required=True)
|
||
barcode = fields.Char(
|
||
'Barcode', copy=False, index='btree_not_null',
|
||
help="International Article Number used for product identification.")
|
||
product_template_attribute_value_ids = fields.Many2many('product.template.attribute.value', relation='product_variant_combination', string="Attribute Values", ondelete='restrict')
|
||
product_template_variant_value_ids = fields.Many2many('product.template.attribute.value', relation='product_variant_combination',
|
||
domain=[('attribute_line_id.value_count', '>', 1)], string="Variant Values", ondelete='restrict')
|
||
combination_indices = fields.Char(compute='_compute_combination_indices', store=True, index=True)
|
||
is_product_variant = fields.Boolean(compute='_compute_is_product_variant')
|
||
|
||
standard_price = fields.Float(
|
||
'Cost', company_dependent=True,
|
||
digits='Product Price',
|
||
groups="base.group_user",
|
||
help="""In Standard Price & AVCO: value of the product (automatically computed in AVCO).
|
||
In FIFO: value of the next unit that will leave the stock (automatically computed).
|
||
Used to value the product when the purchase cost is not known (e.g. inventory adjustment).
|
||
Used to compute margins on sale orders.""")
|
||
volume = fields.Float('Volume', digits='Volume')
|
||
weight = fields.Float('Weight', digits='Stock Weight')
|
||
|
||
pricelist_item_count = fields.Integer("Number of price rules", compute="_compute_variant_item_count")
|
||
|
||
packaging_ids = fields.One2many(
|
||
'product.packaging', 'product_id', 'Product Packages',
|
||
help="Gives the different ways to package the same product.")
|
||
|
||
additional_product_tag_ids = fields.Many2many('product.tag', 'product_tag_product_product_rel')
|
||
all_product_tag_ids = fields.Many2many('product.tag', compute='_compute_all_product_tag_ids', search='_search_all_product_tag_ids')
|
||
|
||
# all image fields are base64 encoded and PIL-supported
|
||
|
||
# all image_variant fields are technical and should not be displayed to the user
|
||
image_variant_1920 = fields.Image("Variant Image", max_width=1920, max_height=1920)
|
||
|
||
# resized fields stored (as attachment) for performance
|
||
image_variant_1024 = fields.Image("Variant Image 1024", related="image_variant_1920", max_width=1024, max_height=1024, store=True)
|
||
image_variant_512 = fields.Image("Variant Image 512", related="image_variant_1920", max_width=512, max_height=512, store=True)
|
||
image_variant_256 = fields.Image("Variant Image 256", related="image_variant_1920", max_width=256, max_height=256, store=True)
|
||
image_variant_128 = fields.Image("Variant Image 128", related="image_variant_1920", max_width=128, max_height=128, store=True)
|
||
can_image_variant_1024_be_zoomed = fields.Boolean("Can Variant Image 1024 be zoomed", compute='_compute_can_image_variant_1024_be_zoomed', store=True)
|
||
|
||
# Computed fields that are used to create a fallback to the template if
|
||
# necessary, it's recommended to display those fields to the user.
|
||
image_1920 = fields.Image("Image", compute='_compute_image_1920', inverse='_set_image_1920')
|
||
image_1024 = fields.Image("Image 1024", compute='_compute_image_1024')
|
||
image_512 = fields.Image("Image 512", compute='_compute_image_512')
|
||
image_256 = fields.Image("Image 256", compute='_compute_image_256')
|
||
image_128 = fields.Image("Image 128", compute='_compute_image_128')
|
||
can_image_1024_be_zoomed = fields.Boolean("Can Image 1024 be zoomed", compute='_compute_can_image_1024_be_zoomed')
|
||
|
||
@api.depends('image_variant_1920', 'image_variant_1024')
|
||
def _compute_can_image_variant_1024_be_zoomed(self):
|
||
for record in self:
|
||
record.can_image_variant_1024_be_zoomed = record.image_variant_1920 and tools.is_image_size_above(record.image_variant_1920, record.image_variant_1024)
|
||
|
||
def _set_template_field(self, template_field, variant_field):
|
||
for record in self:
|
||
if (
|
||
# We are trying to remove a field from the variant even though it is already
|
||
# not set on the variant, remove it from the template instead.
|
||
(not record[template_field] and not record[variant_field])
|
||
# We are trying to add a field to the variant, but the template field is
|
||
# not set, write on the template instead.
|
||
or (record[template_field] and not record.product_tmpl_id[template_field])
|
||
# There is only one variant, always write on the template.
|
||
or self.search_count([
|
||
('product_tmpl_id', '=', record.product_tmpl_id.id),
|
||
('active', '=', True),
|
||
]) <= 1
|
||
):
|
||
record[variant_field] = False
|
||
record.product_tmpl_id[template_field] = record[template_field]
|
||
else:
|
||
record[variant_field] = record[template_field]
|
||
|
||
@api.depends("create_date", "write_date", "product_tmpl_id.create_date", "product_tmpl_id.write_date")
|
||
def _compute_concurrency_field(self):
|
||
# Intentionally not calling super() to involve all fields explicitly
|
||
for record in self:
|
||
record[self.CONCURRENCY_CHECK_FIELD] = max(filter(None, (
|
||
record.product_tmpl_id.write_date or record.product_tmpl_id.create_date,
|
||
record.write_date or record.create_date or fields.Datetime.now(),
|
||
)))
|
||
|
||
def _compute_image_1920(self):
|
||
"""Get the image from the template if no image is set on the variant."""
|
||
for record in self:
|
||
record.image_1920 = record.image_variant_1920 or record.product_tmpl_id.image_1920
|
||
|
||
def _set_image_1920(self):
|
||
return self._set_template_field('image_1920', 'image_variant_1920')
|
||
|
||
def _compute_image_1024(self):
|
||
"""Get the image from the template if no image is set on the variant."""
|
||
for record in self:
|
||
record.image_1024 = record.image_variant_1024 or record.product_tmpl_id.image_1024
|
||
|
||
def _compute_image_512(self):
|
||
"""Get the image from the template if no image is set on the variant."""
|
||
for record in self:
|
||
record.image_512 = record.image_variant_512 or record.product_tmpl_id.image_512
|
||
|
||
def _compute_image_256(self):
|
||
"""Get the image from the template if no image is set on the variant."""
|
||
for record in self:
|
||
record.image_256 = record.image_variant_256 or record.product_tmpl_id.image_256
|
||
|
||
def _compute_image_128(self):
|
||
"""Get the image from the template if no image is set on the variant."""
|
||
for record in self:
|
||
record.image_128 = record.image_variant_128 or record.product_tmpl_id.image_128
|
||
|
||
def _compute_can_image_1024_be_zoomed(self):
|
||
"""Get the image from the template if no image is set on the variant."""
|
||
for record in self:
|
||
record.can_image_1024_be_zoomed = record.can_image_variant_1024_be_zoomed if record.image_variant_1920 else record.product_tmpl_id.can_image_1024_be_zoomed
|
||
|
||
def _get_placeholder_filename(self, field):
|
||
image_fields = ['image_%s' % size for size in [1920, 1024, 512, 256, 128]]
|
||
if field in image_fields:
|
||
return 'product/static/img/placeholder.png'
|
||
return super()._get_placeholder_filename(field)
|
||
|
||
def init(self):
|
||
"""Ensure there is at most one active variant for each combination.
|
||
|
||
There could be no variant for a combination if using dynamic attributes.
|
||
"""
|
||
self.env.cr.execute("CREATE UNIQUE INDEX IF NOT EXISTS product_product_combination_unique ON %s (product_tmpl_id, combination_indices) WHERE active is true"
|
||
% self._table)
|
||
|
||
@api.constrains('barcode')
|
||
def _check_barcode_uniqueness(self):
|
||
""" With GS1 nomenclature, products and packagings use the same pattern. Therefore, we need
|
||
to ensure the uniqueness between products' barcodes and packagings' ones"""
|
||
all_barcode = [b for b in self.mapped('barcode') if b]
|
||
domain = [('barcode', 'in', all_barcode)]
|
||
matched_products = self.sudo().search(domain, order='id')
|
||
if len(matched_products) > len(all_barcode): # It means that you find more than `self` -> there are duplicates
|
||
products_by_barcode = defaultdict(list)
|
||
for product in matched_products:
|
||
products_by_barcode[product.barcode].append(product)
|
||
|
||
duplicates_as_str = "\n".join(
|
||
_("- Barcode \"%s\" already assigned to product(s): %s", barcode, ", ".join(p.display_name for p in products))
|
||
for barcode, products in products_by_barcode.items() if len(products) > 1
|
||
)
|
||
raise ValidationError(_("Barcode(s) already assigned:\n\n%s", duplicates_as_str))
|
||
|
||
if self.env['product.packaging'].search(domain, order="id", limit=1):
|
||
raise ValidationError(_("A packaging already uses the barcode"))
|
||
|
||
def _get_invoice_policy(self):
|
||
return False
|
||
|
||
@api.depends('product_template_attribute_value_ids')
|
||
def _compute_combination_indices(self):
|
||
for product in self:
|
||
product.combination_indices = product.product_template_attribute_value_ids._ids2str()
|
||
|
||
def _compute_is_product_variant(self):
|
||
self.is_product_variant = True
|
||
|
||
@api.onchange('lst_price')
|
||
def _set_product_lst_price(self):
|
||
for product in self:
|
||
if self._context.get('uom'):
|
||
value = self.env['uom.uom'].browse(self._context['uom'])._compute_price(product.lst_price, product.uom_id)
|
||
else:
|
||
value = product.lst_price
|
||
value -= product.price_extra
|
||
product.write({'list_price': value})
|
||
|
||
@api.depends("product_template_attribute_value_ids.price_extra")
|
||
def _compute_product_price_extra(self):
|
||
for product in self:
|
||
product.price_extra = sum(product.product_template_attribute_value_ids.mapped('price_extra'))
|
||
|
||
@api.depends('list_price', 'price_extra')
|
||
@api.depends_context('uom')
|
||
def _compute_product_lst_price(self):
|
||
to_uom = None
|
||
if 'uom' in self._context:
|
||
to_uom = self.env['uom.uom'].browse(self._context['uom'])
|
||
|
||
for product in self:
|
||
if to_uom:
|
||
list_price = product.uom_id._compute_price(product.list_price, to_uom)
|
||
else:
|
||
list_price = product.list_price
|
||
product.lst_price = list_price + product.price_extra
|
||
|
||
@api.depends_context('partner_id')
|
||
def _compute_product_code(self):
|
||
for product in self:
|
||
product.code = product.default_code
|
||
if self.env['ir.model.access'].check('product.supplierinfo', 'read', False):
|
||
for supplier_info in product.seller_ids:
|
||
if supplier_info.partner_id.id == product._context.get('partner_id'):
|
||
product.code = supplier_info.product_code or product.default_code
|
||
break
|
||
|
||
@api.depends_context('partner_id')
|
||
def _compute_partner_ref(self):
|
||
for product in self:
|
||
for supplier_info in product.seller_ids:
|
||
if supplier_info.partner_id.id == product._context.get('partner_id'):
|
||
product_name = supplier_info.product_name or product.default_code or product.name
|
||
product.partner_ref = '%s%s' % (product.code and '[%s] ' % product.code or '', product_name)
|
||
break
|
||
else:
|
||
product.partner_ref = product.display_name
|
||
|
||
def _compute_variant_item_count(self):
|
||
for product in self:
|
||
domain = ['|',
|
||
'&', ('product_tmpl_id', '=', product.product_tmpl_id.id), ('applied_on', '=', '1_product'),
|
||
'&', ('product_id', '=', product.id), ('applied_on', '=', '0_product_variant')]
|
||
product.pricelist_item_count = self.env['product.pricelist.item'].search_count(domain)
|
||
|
||
@api.depends('product_tag_ids', 'additional_product_tag_ids')
|
||
def _compute_all_product_tag_ids(self):
|
||
for product in self:
|
||
product.all_product_tag_ids = product.product_tag_ids | product.additional_product_tag_ids
|
||
|
||
def _search_all_product_tag_ids(self, operator, operand):
|
||
if operator in expression.NEGATIVE_TERM_OPERATORS:
|
||
return [('product_tag_ids', operator, operand), ('additional_product_tag_ids', operator, operand)]
|
||
return ['|', ('product_tag_ids', operator, operand), ('additional_product_tag_ids', operator, operand)]
|
||
|
||
@api.onchange('uom_id')
|
||
def _onchange_uom_id(self):
|
||
if self.uom_id:
|
||
self.uom_po_id = self.uom_id.id
|
||
|
||
@api.onchange('uom_po_id')
|
||
def _onchange_uom(self):
|
||
if self.uom_id and self.uom_po_id and self.uom_id.category_id != self.uom_po_id.category_id:
|
||
self.uom_po_id = self.uom_id
|
||
|
||
@api.onchange('default_code')
|
||
def _onchange_default_code(self):
|
||
if not self.default_code:
|
||
return
|
||
|
||
domain = [('default_code', '=', self.default_code)]
|
||
if self.id.origin:
|
||
domain.append(('id', '!=', self.id.origin))
|
||
|
||
if self.env['product.product'].search(domain, limit=1):
|
||
return {'warning': {
|
||
'title': _("Note:"),
|
||
'message': _("The Internal Reference '%s' already exists.", self.default_code),
|
||
}}
|
||
|
||
@api.model_create_multi
|
||
def create(self, vals_list):
|
||
for vals in vals_list:
|
||
self.product_tmpl_id._sanitize_vals(vals)
|
||
products = super(ProductProduct, self.with_context(create_product_product=True)).create(vals_list)
|
||
# `_get_variant_id_for_combination` depends on existing variants
|
||
self.clear_caches()
|
||
return products
|
||
|
||
def write(self, values):
|
||
self.product_tmpl_id._sanitize_vals(values)
|
||
res = super(ProductProduct, self).write(values)
|
||
if 'product_template_attribute_value_ids' in values:
|
||
# `_get_variant_id_for_combination` depends on `product_template_attribute_value_ids`
|
||
self.clear_caches()
|
||
elif 'active' in values:
|
||
# `_get_first_possible_variant_id` depends on variants active state
|
||
self.clear_caches()
|
||
return res
|
||
|
||
def unlink(self):
|
||
unlink_products = self.env['product.product']
|
||
unlink_templates = self.env['product.template']
|
||
self.packaging_ids.unlink()
|
||
for product in self:
|
||
# If there is an image set on the variant and no image set on the
|
||
# template, move the image to the template.
|
||
if product.image_variant_1920 and not product.product_tmpl_id.image_1920:
|
||
product.product_tmpl_id.image_1920 = product.image_variant_1920
|
||
# Check if product still exists, in case it has been unlinked by unlinking its template
|
||
if not product.exists():
|
||
continue
|
||
# Check if the product is last product of this template...
|
||
other_products = self.search([('product_tmpl_id', '=', product.product_tmpl_id.id), ('id', '!=', product.id)])
|
||
# ... and do not delete product template if it's configured to be created "on demand"
|
||
if not other_products and not product.product_tmpl_id.has_dynamic_attributes():
|
||
unlink_templates |= product.product_tmpl_id
|
||
unlink_products |= product
|
||
res = super(ProductProduct, unlink_products).unlink()
|
||
# delete templates after calling super, as deleting template could lead to deleting
|
||
# products due to ondelete='cascade'
|
||
unlink_templates.unlink()
|
||
# `_get_variant_id_for_combination` depends on existing variants
|
||
self.clear_caches()
|
||
return res
|
||
|
||
def _filter_to_unlink(self, check_access=True):
|
||
return self
|
||
|
||
def _unlink_or_archive(self, check_access=True):
|
||
"""Unlink or archive products.
|
||
Try in batch as much as possible because it is much faster.
|
||
Use dichotomy when an exception occurs.
|
||
"""
|
||
|
||
# Avoid access errors in case the products is shared amongst companies
|
||
# but the underlying objects are not. If unlink fails because of an
|
||
# AccessError (e.g. while recomputing fields), the 'write' call will
|
||
# fail as well for the same reason since the field has been set to
|
||
# recompute.
|
||
if check_access:
|
||
self.check_access_rights('unlink')
|
||
self.check_access_rule('unlink')
|
||
self.check_access_rights('write')
|
||
self.check_access_rule('write')
|
||
self = self.sudo()
|
||
to_unlink = self._filter_to_unlink()
|
||
to_archive = self - to_unlink
|
||
to_archive.write({'active': False})
|
||
self = to_unlink
|
||
|
||
try:
|
||
with self.env.cr.savepoint(), tools.mute_logger('odoo.sql_db'):
|
||
self.unlink()
|
||
except Exception:
|
||
# We catch all kind of exceptions to be sure that the operation
|
||
# doesn't fail.
|
||
if len(self) > 1:
|
||
self[:len(self) // 2]._unlink_or_archive(check_access=False)
|
||
self[len(self) // 2:]._unlink_or_archive(check_access=False)
|
||
else:
|
||
if self.active:
|
||
# Note: this can still fail if something is preventing
|
||
# from archiving.
|
||
# This is the case from existing stock reordering rules.
|
||
self.write({'active': False})
|
||
|
||
@api.returns('self', lambda value: value.id)
|
||
def copy(self, default=None):
|
||
"""Variants are generated depending on the configuration of attributes
|
||
and values on the template, so copying them does not make sense.
|
||
|
||
For convenience the template is copied instead and its first variant is
|
||
returned.
|
||
"""
|
||
# copy variant is disabled in https://github.com/odoo/odoo/pull/38303
|
||
# this returns the first possible combination of variant to make it
|
||
# works for now, need to be fixed to return product_variant_id if it's
|
||
# possible in the future
|
||
template = self.product_tmpl_id.copy(default=default)
|
||
return template.product_variant_id or template._create_first_product_variant()
|
||
|
||
@api.model
|
||
def _search(self, args, offset=0, limit=None, order=None, count=False, access_rights_uid=None):
|
||
# TDE FIXME: strange
|
||
if self._context.get('search_default_categ_id'):
|
||
args = args.copy()
|
||
args.append((('categ_id', 'child_of', self._context['search_default_categ_id'])))
|
||
return super(ProductProduct, self)._search(args, offset=offset, limit=limit, order=order, count=count, access_rights_uid=access_rights_uid)
|
||
|
||
@api.depends_context('display_default_code', 'seller_id')
|
||
def _compute_display_name(self):
|
||
# `display_name` is calling `name_get()`` which is overidden on product
|
||
# to depend on `display_default_code` and `seller_id`
|
||
return super()._compute_display_name()
|
||
|
||
def name_get(self):
|
||
# TDE: this could be cleaned a bit I think
|
||
|
||
def _name_get(d):
|
||
name = d.get('name', '')
|
||
code = self._context.get('display_default_code', True) and d.get('default_code', False) or False
|
||
if code:
|
||
name = '[%s] %s' % (code,name)
|
||
return (d['id'], name)
|
||
|
||
partner_id = self._context.get('partner_id')
|
||
if partner_id:
|
||
partner_ids = [partner_id, self.env['res.partner'].browse(partner_id).commercial_partner_id.id]
|
||
else:
|
||
partner_ids = []
|
||
company_id = self.env.context.get('company_id')
|
||
|
||
# all user don't have access to seller and partner
|
||
# check access and use superuser
|
||
self.check_access_rights("read")
|
||
self.check_access_rule("read")
|
||
|
||
result = []
|
||
|
||
# Prefetch the fields used by the `name_get`, so `browse` doesn't fetch other fields
|
||
# Use `load=False` to not call `name_get` for the `product_tmpl_id`
|
||
self.sudo().read(['name', 'default_code', 'product_tmpl_id'], load=False)
|
||
|
||
product_template_ids = self.sudo().mapped('product_tmpl_id').ids
|
||
|
||
if partner_ids:
|
||
supplier_info = self.env['product.supplierinfo'].sudo().search([
|
||
('product_tmpl_id', 'in', product_template_ids),
|
||
('partner_id', 'in', partner_ids),
|
||
])
|
||
# Prefetch the fields used by the `name_get`, so `browse` doesn't fetch other fields
|
||
# Use `load=False` to not call `name_get` for the `product_tmpl_id` and `product_id`
|
||
supplier_info.sudo().read(['product_tmpl_id', 'product_id', 'product_name', 'product_code'], load=False)
|
||
supplier_info_by_template = {}
|
||
for r in supplier_info:
|
||
supplier_info_by_template.setdefault(r.product_tmpl_id, []).append(r)
|
||
for product in self.sudo():
|
||
variant = product.product_template_attribute_value_ids._get_combination_name()
|
||
|
||
name = variant and "%s (%s)" % (product.name, variant) or product.name
|
||
sellers = self.env['product.supplierinfo'].sudo().browse(self.env.context.get('seller_id')) or []
|
||
if not sellers and partner_ids:
|
||
product_supplier_info = supplier_info_by_template.get(product.product_tmpl_id, [])
|
||
sellers = [x for x in product_supplier_info if x.product_id and x.product_id == product]
|
||
if not sellers:
|
||
sellers = [x for x in product_supplier_info if not x.product_id]
|
||
# Filter out sellers based on the company. This is done afterwards for a better
|
||
# code readability. At this point, only a few sellers should remain, so it should
|
||
# not be a performance issue.
|
||
if company_id:
|
||
sellers = [x for x in sellers if x.company_id.id in [company_id, False]]
|
||
if sellers:
|
||
for s in sellers:
|
||
seller_variant = s.product_name and (
|
||
variant and "%s (%s)" % (s.product_name, variant) or s.product_name
|
||
) or False
|
||
mydict = {
|
||
'id': product.id,
|
||
'name': seller_variant or name,
|
||
'default_code': s.product_code or product.default_code,
|
||
}
|
||
temp = _name_get(mydict)
|
||
if temp not in result:
|
||
result.append(temp)
|
||
else:
|
||
mydict = {
|
||
'id': product.id,
|
||
'name': name,
|
||
'default_code': product.default_code,
|
||
}
|
||
result.append(_name_get(mydict))
|
||
return result
|
||
|
||
@api.model
|
||
def _name_search(self, name, args=None, operator='ilike', limit=100, name_get_uid=None):
|
||
if not args:
|
||
args = []
|
||
if name:
|
||
positive_operators = ['=', 'ilike', '=ilike', 'like', '=like']
|
||
product_ids = []
|
||
if operator in positive_operators:
|
||
product_ids = list(self._search([('default_code', '=', name)] + args, limit=limit, access_rights_uid=name_get_uid))
|
||
if not product_ids:
|
||
product_ids = list(self._search([('barcode', '=', name)] + args, limit=limit, access_rights_uid=name_get_uid))
|
||
if not product_ids and operator not in expression.NEGATIVE_TERM_OPERATORS:
|
||
# Do not merge the 2 next lines into one single search, SQL search performance would be abysmal
|
||
# on a database with thousands of matching products, due to the huge merge+unique needed for the
|
||
# OR operator (and given the fact that the 'name' lookup results come from the ir.translation table
|
||
# Performing a quick memory merge of ids in Python will give much better performance
|
||
product_ids = list(self._search(args + [('default_code', operator, name)], limit=limit))
|
||
if not limit or len(product_ids) < limit:
|
||
# we may underrun the limit because of dupes in the results, that's fine
|
||
limit2 = (limit - len(product_ids)) if limit else False
|
||
product2_ids = self._search(args + [('name', operator, name), ('id', 'not in', product_ids)], limit=limit2, access_rights_uid=name_get_uid)
|
||
product_ids.extend(product2_ids)
|
||
elif not product_ids and operator in expression.NEGATIVE_TERM_OPERATORS:
|
||
domain = expression.OR([
|
||
['&', ('default_code', operator, name), ('name', operator, name)],
|
||
['&', ('default_code', '=', False), ('name', operator, name)],
|
||
])
|
||
domain = expression.AND([args, domain])
|
||
product_ids = list(self._search(domain, limit=limit, access_rights_uid=name_get_uid))
|
||
if not product_ids and operator in positive_operators:
|
||
ptrn = re.compile(r'(\[(.*?)\])')
|
||
res = ptrn.search(name)
|
||
if res:
|
||
product_ids = list(self._search([('default_code', '=', res.group(2))] + args, limit=limit, access_rights_uid=name_get_uid))
|
||
# still no results, partner in context: search on supplier info as last hope to find something
|
||
if not product_ids and self._context.get('partner_id'):
|
||
suppliers_ids = self.env['product.supplierinfo']._search([
|
||
('partner_id', '=', self._context.get('partner_id')),
|
||
'|',
|
||
('product_code', operator, name),
|
||
('product_name', operator, name)], access_rights_uid=name_get_uid)
|
||
if suppliers_ids:
|
||
product_ids = self._search([('product_tmpl_id.seller_ids', 'in', suppliers_ids)], limit=limit, access_rights_uid=name_get_uid)
|
||
else:
|
||
product_ids = self._search(args, limit=limit, access_rights_uid=name_get_uid)
|
||
return product_ids
|
||
|
||
@api.model
|
||
def view_header_get(self, view_id, view_type):
|
||
if self._context.get('categ_id'):
|
||
return _(
|
||
'Products: %(category)s',
|
||
category=self.env['product.category'].browse(self.env.context['categ_id']).name,
|
||
)
|
||
return super().view_header_get(view_id, view_type)
|
||
|
||
def action_open_label_layout(self):
|
||
action = self.env['ir.actions.act_window']._for_xml_id('product.action_open_label_layout')
|
||
action['context'] = {'default_product_ids': self.ids}
|
||
return action
|
||
|
||
def open_pricelist_rules(self):
|
||
self.ensure_one()
|
||
domain = ['|',
|
||
'&', ('product_tmpl_id', '=', self.product_tmpl_id.id), ('applied_on', '=', '1_product'),
|
||
'&', ('product_id', '=', self.id), ('applied_on', '=', '0_product_variant')]
|
||
return {
|
||
'name': _('Price Rules'),
|
||
'view_mode': 'tree,form',
|
||
'views': [(self.env.ref('product.product_pricelist_item_tree_view_from_product').id, 'tree')],
|
||
'res_model': 'product.pricelist.item',
|
||
'type': 'ir.actions.act_window',
|
||
'target': 'current',
|
||
'domain': domain,
|
||
'context': {
|
||
'default_product_id': self.id,
|
||
'default_applied_on': '0_product_variant',
|
||
}
|
||
}
|
||
|
||
def open_product_template(self):
|
||
""" Utility method used to add an "Open Template" button in product views """
|
||
self.ensure_one()
|
||
return {'type': 'ir.actions.act_window',
|
||
'res_model': 'product.template',
|
||
'view_mode': 'form',
|
||
'res_id': self.product_tmpl_id.id,
|
||
'target': 'new'}
|
||
|
||
def _prepare_sellers(self, params=False):
|
||
return self.seller_ids.filtered(lambda s: s.partner_id.active).sorted(lambda s: (s.sequence, -s.min_qty, s.price, s.id))
|
||
|
||
def _get_filtered_sellers(self, partner_id=False, quantity=0.0, date=None, uom_id=False, params=False):
|
||
self.ensure_one()
|
||
if date is None:
|
||
date = fields.Date.context_today(self)
|
||
precision = self.env['decimal.precision'].precision_get('Product Unit of Measure')
|
||
|
||
sellers_filtered = self._prepare_sellers(params)
|
||
sellers_filtered = sellers_filtered.filtered(lambda s: not s.company_id or s.company_id.id == self.env.company.id)
|
||
sellers = self.env['product.supplierinfo']
|
||
for seller in sellers_filtered:
|
||
# Set quantity in UoM of seller
|
||
quantity_uom_seller = quantity
|
||
if quantity_uom_seller and uom_id and uom_id != seller.product_uom:
|
||
quantity_uom_seller = uom_id._compute_quantity(quantity_uom_seller, seller.product_uom)
|
||
|
||
if seller.date_start and seller.date_start > date:
|
||
continue
|
||
if seller.date_end and seller.date_end < date:
|
||
continue
|
||
if partner_id and seller.partner_id not in [partner_id, partner_id.parent_id]:
|
||
continue
|
||
if quantity is not None and float_compare(quantity_uom_seller, seller.min_qty, precision_digits=precision) == -1:
|
||
continue
|
||
if seller.product_id and seller.product_id != self:
|
||
continue
|
||
sellers |= seller
|
||
return sellers
|
||
|
||
def _select_seller(self, partner_id=False, quantity=0.0, date=None, uom_id=False, params=False):
|
||
sellers = self._get_filtered_sellers(partner_id=partner_id, quantity=quantity, date=date, uom_id=uom_id, params=params)
|
||
res = self.env['product.supplierinfo']
|
||
for seller in sellers:
|
||
if not res or res.partner_id == seller.partner_id:
|
||
res |= seller
|
||
return res and res.sorted('price')[:1]
|
||
|
||
def price_compute(self, price_type, uom=None, currency=None, company=None, date=False):
|
||
company = company or self.env.company
|
||
date = date or fields.Date.context_today(self)
|
||
|
||
self = self.with_company(company)
|
||
if price_type == 'standard_price':
|
||
# standard_price field can only be seen by users in base.group_user
|
||
# Thus, in order to compute the sale price from the cost for users not in this group
|
||
# We fetch the standard price as the superuser
|
||
self = self.sudo()
|
||
|
||
prices = dict.fromkeys(self.ids, 0.0)
|
||
for product in self:
|
||
price = product[price_type] or 0.0
|
||
price_currency = product.currency_id
|
||
if price_type == 'standard_price':
|
||
price_currency = product.cost_currency_id
|
||
|
||
if price_type == 'list_price':
|
||
price += product.price_extra
|
||
# we need to add the price from the attributes that do not generate variants
|
||
# (see field product.attribute create_variant)
|
||
if self._context.get('no_variant_attributes_price_extra'):
|
||
# we have a list of price_extra that comes from the attribute values, we need to sum all that
|
||
price += sum(self._context.get('no_variant_attributes_price_extra'))
|
||
|
||
if uom:
|
||
price = product.uom_id._compute_price(price, uom)
|
||
|
||
# Convert from current user company currency to asked one
|
||
# This is right cause a field cannot be in more than one currency
|
||
if currency:
|
||
price = price_currency._convert(price, currency, company, date)
|
||
|
||
prices[product.id] = price
|
||
|
||
return prices
|
||
|
||
@api.model
|
||
def get_empty_list_help(self, help):
|
||
self = self.with_context(
|
||
empty_list_help_document_name=_("product"),
|
||
)
|
||
return super(ProductProduct, self).get_empty_list_help(help)
|
||
|
||
def get_product_multiline_description_sale(self):
|
||
""" Compute a multiline description of this product, in the context of sales
|
||
(do not use for purchases or other display reasons that don't intend to use "description_sale").
|
||
It will often be used as the default description of a sale order line referencing this product.
|
||
"""
|
||
name = self.display_name
|
||
if self.description_sale:
|
||
name += '\n' + self.description_sale
|
||
|
||
return name
|
||
|
||
def _is_variant_possible(self, parent_combination=None):
|
||
"""Return whether the variant is possible based on its own combination,
|
||
and optionally a parent combination.
|
||
|
||
See `_is_combination_possible` for more information.
|
||
|
||
:param parent_combination: combination from which `self` is an
|
||
optional or accessory product.
|
||
:type parent_combination: recordset `product.template.attribute.value`
|
||
|
||
:return: ẁhether the variant is possible based on its own combination
|
||
:rtype: bool
|
||
"""
|
||
self.ensure_one()
|
||
return self.product_tmpl_id._is_combination_possible(self.product_template_attribute_value_ids, parent_combination=parent_combination, ignore_no_variant=True)
|
||
|
||
def toggle_active(self):
|
||
""" Archiving related product.template if there is not any more active product.product
|
||
(and vice versa, unarchiving the related product template if there is now an active product.product) """
|
||
result = super().toggle_active()
|
||
# We deactivate product templates which are active with no active variants.
|
||
tmpl_to_deactivate = self.filtered(lambda product: (product.product_tmpl_id.active
|
||
and not product.product_tmpl_id.product_variant_ids)).mapped('product_tmpl_id')
|
||
# We activate product templates which are inactive with active variants.
|
||
tmpl_to_activate = self.filtered(lambda product: (not product.product_tmpl_id.active
|
||
and product.product_tmpl_id.product_variant_ids)).mapped('product_tmpl_id')
|
||
(tmpl_to_deactivate + tmpl_to_activate).toggle_active()
|
||
return result
|
||
|
||
def get_contextual_price(self):
|
||
return self._get_contextual_price()
|
||
|
||
def _get_contextual_price(self):
|
||
self.ensure_one()
|
||
return self.product_tmpl_id._get_contextual_price(self)
|