Bruno-brsy
4b569dba98
Step to reproduce: 1) create a product with, the "Product Type" as "Storable Product" + A "Product Category" with a "Costing Method" set in "FIFO" mode and the Inventory Valuation in "Automated". 2) create a Purchase Order for 1 unit of that product and set the unit price to 10.00. Confirm Order -> Receive Products -> Validate (the delivery) -> Apply 3) create a second Purchase Order for 1 unit of the same product but set the unit price to a different price, like 20.00. Confirm Order -> Receive Products -> Validate (the delivery) -> Apply 4) create a Sales Orders for 1 unit -> Confirm -> Smart button Delivery -> Validate -> Apply 5) check the cost on the product form of that product. On the V13 it will be $10, so its the last unit that left the stock On V14 and upper, it will be $20, so the next product that will leave the stock. The help popup for the field "standard_price" doesn't reflect the correct behavior. It's the standard price for the next unit instead of the last one. closes odoo/odoo#84289 X-original-commit: 9e0a529b603302653dac2a8fb692472fc500c147 Signed-off-by: William Henrotin (whe) <whe@odoo.com> Signed-off-by: Bruno-brsy <brsy@odoo.com>
892 lines
44 KiB
Python
892 lines
44 KiB
Python
# -*- coding: utf-8 -*-
|
||
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||
|
||
import re
|
||
|
||
from odoo import api, fields, models, tools, _
|
||
from odoo.exceptions import UserError, ValidationError
|
||
from odoo.osv import expression
|
||
|
||
|
||
from odoo.tools import float_compare, float_round
|
||
|
||
|
||
class ProductCategory(models.Model):
|
||
_name = "product.category"
|
||
_description = "Product Category"
|
||
_parent_name = "parent_id"
|
||
_parent_store = True
|
||
_rec_name = 'complete_name'
|
||
_order = 'complete_name'
|
||
|
||
name = fields.Char('Name', index='trigram', required=True)
|
||
complete_name = fields.Char(
|
||
'Complete Name', compute='_compute_complete_name', recursive=True,
|
||
store=True)
|
||
parent_id = fields.Many2one('product.category', 'Parent Category', index=True, ondelete='cascade')
|
||
parent_path = fields.Char(index=True, unaccent=False)
|
||
child_id = fields.One2many('product.category', 'parent_id', 'Child Categories')
|
||
product_count = fields.Integer(
|
||
'# Products', compute='_compute_product_count',
|
||
help="The number of products under this category (Does not consider the children categories)")
|
||
|
||
@api.depends('name', 'parent_id.complete_name')
|
||
def _compute_complete_name(self):
|
||
for category in self:
|
||
if category.parent_id:
|
||
category.complete_name = '%s / %s' % (category.parent_id.complete_name, category.name)
|
||
else:
|
||
category.complete_name = category.name
|
||
|
||
def _compute_product_count(self):
|
||
read_group_res = self.env['product.template'].read_group([('categ_id', 'child_of', self.ids)], ['categ_id'], ['categ_id'])
|
||
group_data = dict((data['categ_id'][0], data['categ_id_count']) for data in read_group_res)
|
||
for categ in self:
|
||
product_count = 0
|
||
for sub_categ_id in categ.search([('id', 'child_of', categ.ids)]).ids:
|
||
product_count += group_data.get(sub_categ_id, 0)
|
||
categ.product_count = product_count
|
||
|
||
@api.constrains('parent_id')
|
||
def _check_category_recursion(self):
|
||
if not self._check_recursion():
|
||
raise ValidationError(_('You cannot create recursive categories.'))
|
||
|
||
@api.model
|
||
def name_create(self, name):
|
||
return self.create({'name': name}).name_get()[0]
|
||
|
||
def name_get(self):
|
||
if not self.env.context.get('hierarchical_naming', True):
|
||
return [(record.id, record.name) for record in self]
|
||
return super().name_get()
|
||
|
||
@api.ondelete(at_uninstall=False)
|
||
def _unlink_except_default_category(self):
|
||
main_category = self.env.ref('product.product_category_all')
|
||
if main_category in self:
|
||
raise UserError(_("You cannot delete this product category, it is the default generic category."))
|
||
|
||
|
||
class ProductProduct(models.Model):
|
||
_name = "product.product"
|
||
_description = "Product"
|
||
_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,
|
||
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)
|
||
|
||
_sql_constraints = [
|
||
('barcode_uniq', 'unique(barcode)', "A barcode can only be assigned to one product !"),
|
||
]
|
||
|
||
@api.constrains('barcode')
|
||
def _check_barcode_uniqueness(self):
|
||
""" With GS1 nomenclature, products and packagins use the same pattern. Therefore, we need
|
||
to ensure the uniqueness between products' barcodes and packagings' ones"""
|
||
condition = expression.OR([[('barcode', '=', b)] for b in self.mapped('barcode') if b])
|
||
if self.env['product.packaging'].search(condition, 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})
|
||
|
||
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:
|
||
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
|
||
else:
|
||
product.code = product.default_code
|
||
|
||
@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']
|
||
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.
|
||
"""
|
||
return self.product_tmpl_id.copy(default=default).product_variant_id
|
||
|
||
@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.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('(\[(.*?)\])')
|
||
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'), (False, 'form')],
|
||
'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 _select_seller(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')
|
||
|
||
res = self.env['product.supplierinfo']
|
||
sellers = self._prepare_sellers(params)
|
||
sellers = sellers.filtered(lambda s: not s.company_id or s.company_id.id == self.env.company.id)
|
||
for seller in sellers:
|
||
# 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
|
||
if not res or res.partner_id == seller.partner_id:
|
||
res |= seller
|
||
return 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):
|
||
self.ensure_one()
|
||
# YTI TODO: During website_sale cleaning, we should get rid of those crappy context thing
|
||
if not self._context.get('pricelist'):
|
||
return 0.0
|
||
pricelist = self.env['product.pricelist'].browse(self._context.get('pricelist'))
|
||
|
||
quantity = self.env.context.get('quantity', 1.0)
|
||
uom = self.env['uom.uom'].browse(self.env.context.get('uom'))
|
||
date = self.env.context.get('date')
|
||
return pricelist._get_product_price(self, quantity, uom=uom, date=date)
|
||
|
||
|
||
class ProductPackaging(models.Model):
|
||
_name = "product.packaging"
|
||
_description = "Product Packaging"
|
||
_order = 'product_id, sequence, id'
|
||
_check_company_auto = True
|
||
|
||
name = fields.Char('Product Packaging', required=True)
|
||
sequence = fields.Integer('Sequence', default=1, help="The first in the sequence is the default one.")
|
||
product_id = fields.Many2one('product.product', string='Product', check_company=True)
|
||
qty = fields.Float('Contained Quantity', default=1, digits='Product Unit of Measure', help="Quantity of products contained in the packaging.")
|
||
barcode = fields.Char('Barcode', copy=False, help="Barcode used for packaging identification. Scan this packaging barcode from a transfer in the Barcode app to move all the contained units")
|
||
product_uom_id = fields.Many2one('uom.uom', related='product_id.uom_id', readonly=True)
|
||
company_id = fields.Many2one('res.company', 'Company', index=True)
|
||
|
||
_sql_constraints = [
|
||
('positive_qty', 'CHECK(qty > 0)', 'Contained Quantity should be positive.'),
|
||
('barcode_uniq', 'unique(barcode)', 'A barcode can only be assigned to one packaging.'),
|
||
]
|
||
|
||
@api.constrains('barcode')
|
||
def _check_barcode_uniqueness(self):
|
||
""" With GS1 nomenclature, products and packagins use the same pattern. Therefore, we need
|
||
to ensure the uniqueness between products' barcodes and packagings' ones"""
|
||
condition = expression.OR([[('barcode', '=', b)] for b in self.mapped('barcode') if b])
|
||
if self.env['product.product'].search(condition, limit=1):
|
||
raise ValidationError(_("A product already uses the barcode"))
|
||
|
||
def _check_qty(self, product_qty, uom_id, rounding_method="HALF-UP"):
|
||
"""Check if product_qty in given uom is a multiple of the packaging qty.
|
||
If not, rounding the product_qty to closest multiple of the packaging qty
|
||
according to the rounding_method "UP", "HALF-UP or "DOWN".
|
||
"""
|
||
self.ensure_one()
|
||
default_uom = self.product_id.uom_id
|
||
packaging_qty = default_uom._compute_quantity(self.qty, uom_id)
|
||
# We do not use the modulo operator to check if qty is a mltiple of q. Indeed the quantity
|
||
# per package might be a float, leading to incorrect results. For example:
|
||
# 8 % 1.6 = 1.5999999999999996
|
||
# 5.4 % 1.8 = 2.220446049250313e-16
|
||
if (
|
||
product_qty
|
||
and packaging_qty
|
||
and float_compare(
|
||
product_qty / packaging_qty,
|
||
float_round(product_qty / packaging_qty, precision_rounding=1.0),
|
||
precision_rounding=default_uom.rounding
|
||
)
|
||
!= 0
|
||
):
|
||
return float_round(
|
||
product_qty / packaging_qty, precision_rounding=1.0, rounding_method=rounding_method
|
||
) * packaging_qty
|
||
return product_qty
|
||
|
||
def _find_suitable_product_packaging(self, product_qty, uom_id):
|
||
""" try find in `self` if a packaging's qty in given uom is a divisor of
|
||
the given product_qty. If so, return the one with greatest divisor.
|
||
"""
|
||
packagings = self.sorted(lambda p: p.qty, reverse=True)
|
||
for packaging in packagings:
|
||
new_qty = packaging._check_qty(product_qty, uom_id)
|
||
if new_qty == product_qty:
|
||
return packaging
|
||
return self.env['product.packaging']
|
||
|
||
|
||
class SupplierInfo(models.Model):
|
||
_name = "product.supplierinfo"
|
||
_description = "Supplier Pricelist"
|
||
_order = 'sequence, min_qty DESC, price, id'
|
||
_rec_name = 'partner_id'
|
||
|
||
def _default_product_id(self):
|
||
product_id = self.env.get('default_product_id')
|
||
if not product_id:
|
||
model, active_id = [self.env.context.get(k) for k in ['model', 'active_id']]
|
||
if model == 'product.product' and active_id:
|
||
product_id = self.env[model].browse(active_id).exists()
|
||
return product_id
|
||
|
||
def _domain_product_id(self):
|
||
domain = "product_tmpl_id and [('product_tmpl_id', '=', product_tmpl_id)] or []"
|
||
if self.env.context.get('base_model_name') == 'product.template':
|
||
domain = "[('product_tmpl_id', '=', parent.id)]"
|
||
elif self.env.context.get('base_model_name') == 'product.product':
|
||
domain = "[('product_tmpl_id', '=', parent.product_tmpl_id)]"
|
||
return domain
|
||
|
||
partner_id = fields.Many2one(
|
||
'res.partner', 'Vendor',
|
||
ondelete='cascade', required=True,
|
||
help="Vendor of this product", check_company=True)
|
||
product_name = fields.Char(
|
||
'Vendor Product Name',
|
||
help="This vendor's product name will be used when printing a request for quotation. Keep empty to use the internal one.")
|
||
product_code = fields.Char(
|
||
'Vendor Product Code',
|
||
help="This vendor's product code will be used when printing a request for quotation. Keep empty to use the internal one.")
|
||
sequence = fields.Integer(
|
||
'Sequence', default=1, help="Assigns the priority to the list of product vendor.")
|
||
product_uom = fields.Many2one(
|
||
'uom.uom', 'Unit of Measure',
|
||
related='product_tmpl_id.uom_po_id',
|
||
help="This comes from the product form.")
|
||
min_qty = fields.Float(
|
||
'Quantity', default=0.0, required=True, digits="Product Unit Of Measure",
|
||
help="The quantity to purchase from this vendor to benefit from the price, expressed in the vendor Product Unit of Measure if not any, in the default unit of measure of the product otherwise.")
|
||
price = fields.Float(
|
||
'Price', default=0.0, digits='Product Price',
|
||
required=True, help="The price to purchase a product")
|
||
company_id = fields.Many2one(
|
||
'res.company', 'Company',
|
||
default=lambda self: self.env.company.id, index=1)
|
||
currency_id = fields.Many2one(
|
||
'res.currency', 'Currency',
|
||
default=lambda self: self.env.company.currency_id.id,
|
||
required=True)
|
||
date_start = fields.Date('Start Date', help="Start date for this vendor price")
|
||
date_end = fields.Date('End Date', help="End date for this vendor price")
|
||
product_id = fields.Many2one(
|
||
'product.product', 'Product Variant', check_company=True,
|
||
domain=_domain_product_id, default=_default_product_id,
|
||
help="If not set, the vendor price will apply to all variants of this product.")
|
||
product_tmpl_id = fields.Many2one(
|
||
'product.template', 'Product Template', check_company=True,
|
||
index=True, ondelete='cascade')
|
||
product_variant_count = fields.Integer('Variant Count', related='product_tmpl_id.product_variant_count')
|
||
delay = fields.Integer(
|
||
'Delivery Lead Time', default=1, required=True,
|
||
help="Lead time in days between the confirmation of the purchase order and the receipt of the products in your warehouse. Used by the scheduler for automatic computation of the purchase order planning.")
|
||
|
||
@api.onchange('product_tmpl_id')
|
||
def _onchange_product_tmpl_id(self):
|
||
if self.product_id and self.product_tmpl_id and self.product_id not in self.product_tmpl_id.product_variant_ids:
|
||
self.product_id = False
|
||
|
||
@api.model
|
||
def get_import_templates(self):
|
||
return [{
|
||
'label': _('Import Template for Vendor Pricelists'),
|
||
'template': '/product/static/xls/product_supplierinfo.xls'
|
||
}]
|