Adrien Widart
ee66e43133
When returning a kit, the margin of the related SO decreases
To reproduce the issue:
(Need sale_management)
1. In Settings, enable "Margins"
2. Create a Product Category PC:
- Costing Method: FIFO
3. Create two products P_kit, P_compo:
- Both:
- Type: Storable
- Category: PC
- P_compo:
- Cost: 10
4. Update P_compo quantity: 1
5. Create a BoM:
- Product: P_kit
- Type: Kit
- Components: 1 x P_compo
6. Update P_kit's cost
7. Create and confirm a SO with 1 x P_kit, unit price = $100
- Note that the margin is correct: $90
8. Process the related picking
9. Create a return R
10. Go back to the SO
Error: the margin is now $80
When computing the cost of the kit, the move linked to R are considered.
Therefore, the cost becomes $20 and thus the margin becomes $80
OPW-2679473
closes odoo/odoo#83008
X-original-commit: 2f34669f9dc3c9abfcbb13198f90f37405ffc258
Signed-off-by: Arnold Moyaux <arm@odoo.com>
Signed-off-by: Adrien Widart <awt@odoo.com>
109 lines
5.3 KiB
Python
109 lines
5.3 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
from odoo import models
|
|
from odoo.tools import float_round, groupby
|
|
|
|
|
|
class ProductTemplate(models.Model):
|
|
_name = 'product.template'
|
|
_inherit = 'product.template'
|
|
|
|
def action_bom_cost(self):
|
|
templates = self.filtered(lambda t: t.product_variant_count == 1 and t.bom_count > 0)
|
|
if templates:
|
|
return templates.mapped('product_variant_id').action_bom_cost()
|
|
|
|
def button_bom_cost(self):
|
|
templates = self.filtered(lambda t: t.product_variant_count == 1 and t.bom_count > 0)
|
|
if templates:
|
|
return templates.mapped('product_variant_id').button_bom_cost()
|
|
|
|
|
|
class ProductProduct(models.Model):
|
|
_name = 'product.product'
|
|
_inherit = 'product.product'
|
|
_description = 'Product'
|
|
|
|
def button_bom_cost(self):
|
|
self.ensure_one()
|
|
self._set_price_from_bom()
|
|
|
|
def action_bom_cost(self):
|
|
boms_to_recompute = self.env['mrp.bom'].search(['|', ('product_id', 'in', self.ids), '&', ('product_id', '=', False), ('product_tmpl_id', 'in', self.mapped('product_tmpl_id').ids)])
|
|
for product in self:
|
|
product._set_price_from_bom(boms_to_recompute)
|
|
|
|
def _set_price_from_bom(self, boms_to_recompute=False):
|
|
self.ensure_one()
|
|
bom = self.env['mrp.bom']._bom_find(self)[self]
|
|
if bom:
|
|
self.standard_price = self._compute_bom_price(bom, boms_to_recompute=boms_to_recompute)
|
|
else:
|
|
bom = self.env['mrp.bom'].search([('byproduct_ids.product_id', '=', self.id)], order='sequence, product_id, id', limit=1)
|
|
if bom:
|
|
price = self._compute_bom_price(bom, boms_to_recompute=boms_to_recompute, byproduct_bom=True)
|
|
if price:
|
|
self.standard_price = price
|
|
|
|
def _compute_average_price(self, qty_invoiced, qty_to_invoice, stock_moves, is_returned=False):
|
|
self.ensure_one()
|
|
if stock_moves.product_id == self:
|
|
return super()._compute_average_price(qty_invoiced, qty_to_invoice, stock_moves, is_returned=is_returned)
|
|
bom = self.env['mrp.bom']._bom_find(self, company_id=stock_moves.company_id.id, bom_type='phantom')[self]
|
|
if not bom:
|
|
return super()._compute_average_price(qty_invoiced, qty_to_invoice, stock_moves, is_returned=is_returned)
|
|
value = 0
|
|
dummy, bom_lines = bom.explode(self, 1)
|
|
bom_lines = {line: data for line, data in bom_lines}
|
|
for bom_line, moves_list in groupby(stock_moves.filtered(lambda sm: sm.state != 'cancel'), lambda sm: sm.bom_line_id):
|
|
if bom_line not in bom_lines:
|
|
for move in moves_list:
|
|
value += move.product_qty * move.product_id._compute_average_price(qty_invoiced * move.product_qty, qty_to_invoice * move.product_qty, move, is_returned=is_returned)
|
|
continue
|
|
line_qty = bom_line.product_uom_id._compute_quantity(bom_line.product_qty, bom_line.product_id.uom_id)
|
|
moves = self.env['stock.move'].concat(*moves_list)
|
|
value += line_qty * bom_line.product_id._compute_average_price(qty_invoiced * line_qty, qty_to_invoice * line_qty, moves, is_returned=is_returned)
|
|
return value
|
|
|
|
def _compute_bom_price(self, bom, boms_to_recompute=False, byproduct_bom=False):
|
|
self.ensure_one()
|
|
if not bom:
|
|
return 0
|
|
if not boms_to_recompute:
|
|
boms_to_recompute = []
|
|
total = 0
|
|
for opt in bom.operation_ids:
|
|
if opt._skip_operation_line(self):
|
|
continue
|
|
|
|
duration_expected = (
|
|
opt.workcenter_id.time_start +
|
|
opt.workcenter_id.time_stop +
|
|
opt.time_cycle)
|
|
total += (duration_expected / 60) * opt.workcenter_id.costs_hour
|
|
|
|
for line in bom.bom_line_ids:
|
|
if line._skip_bom_line(self):
|
|
continue
|
|
|
|
# Compute recursive if line has `child_line_ids`
|
|
if line.child_bom_id and line.child_bom_id in boms_to_recompute:
|
|
child_total = line.product_id._compute_bom_price(line.child_bom_id, boms_to_recompute=boms_to_recompute)
|
|
total += line.product_id.uom_id._compute_price(child_total, line.product_uom_id) * line.product_qty
|
|
else:
|
|
total += line.product_id.uom_id._compute_price(line.product_id.standard_price, line.product_uom_id) * line.product_qty
|
|
if byproduct_bom:
|
|
byproduct_lines = bom.byproduct_ids.filtered(lambda b: b.product_id == self and b.cost_share != 0)
|
|
product_uom_qty = 0
|
|
for line in byproduct_lines:
|
|
product_uom_qty += line.product_uom_id._compute_quantity(line.product_qty, self.uom_id, round=False)
|
|
byproduct_cost_share = sum(byproduct_lines.mapped('cost_share'))
|
|
if byproduct_cost_share and product_uom_qty:
|
|
return total * byproduct_cost_share / 100 / product_uom_qty
|
|
else:
|
|
byproduct_cost_share = sum(bom.byproduct_ids.mapped('cost_share'))
|
|
if byproduct_cost_share:
|
|
total *= float_round(1 - byproduct_cost_share / 100, precision_rounding=0.0001)
|
|
return bom.product_uom_id._compute_price(total / bom.product_qty, self.uom_id)
|