[FIX] stock_currency_valuation: fix revaluation in secondary currency

Three defects on the revaluation of a product whose category has a secondary
valuation currency.

1. The cost in currency was never written. The 18.0 migration rewrote
   action_validate_revaluation() as a copy of the new native method and dropped
   the line that updated standard_price_in_currency, so the valuation layer and
   the journal entry were right but the product form kept the old value. The
   other path that writes that field,
   stock.valuation.layer._update_currency_standard_price(), only runs for layers
   with a landed cost and the revaluation layer has none. The added value in
   currency is divided by product_id.quantity_svl, the same divisor the native
   code uses on the line above for standard_price, so both costs stay on the
   same basis when the revaluation targets specific layers.

2. The wizard preview added a unit cost to a total value:
   standard_price_in_currency + added_value_in_currency. The native code adds
   current_value_svl (a total) to added_value, so the figures shown on screen did
   not match the cost that ended up on the product. With 10 units at 10 and an
   added value of 50 it showed 60 (6 by unit) instead of 150 (15 by unit).

3. new_value_in_currency_by_qty declared _compute_new_value as its compute
   method, which never assigns it. It only resolved because reading
   new_value_in_currency first filled the cache.

Also add standard_price_in_currency to the depends of the product.template
compute. It only tracked the variant standard_price, so a change that moved only
the cost in currency left the template showing a stale value. The existing
standard_price dependency is kept: the field is not stored and that dependency
drives the onchange in the product form.

Add a test covering the four cases.

closes #993

Signed-off-by: Filoquin adhoc <maq@adhoc.com.ar>

Author: feg-adhoc

stock_currency_valuation/models/product_template.py

@@ -47,7 +47,11 @@ def _compute_replenishment_cost(self):
             )
 
     @api.depends_context("company")
-    @api.depends("product_variant_ids", "product_variant_ids.standard_price")
+    @api.depends(
+        "product_variant_ids",
+        "product_variant_ids.standard_price",
+        "product_variant_ids.standard_price_in_currency",
+    )
     def _compute_standard_price_in_currency(self):
         # Por ahora hacemos esto porque replishment cost no es compatible al 100% con variantes
         # obtenemos el precio del primer producto

stock_currency_valuation/tests/__init__.py

@@ -0,0 +1 @@
+from . import test_revaluation_in_currency

stock_currency_valuation/tests/test_revaluation_in_currency.py

@@ -0,0 +1,54 @@
+from odoo.tests.common import TransactionCase, tagged
+
+
+@tagged("post_install", "-at_install")
+class TestRevaluationInCurrency(TransactionCase):
+    def test_revaluation_updates_standard_price_in_currency(self):
+        """La revaluacion tiene que impactar el costo en moneda secundaria de la ficha."""
+        company = self.env.company
+        categ = self.env["product.category"].create(
+            {
+                "name": "Categoria valuada en moneda",
+                "property_cost_method": "average",
+                "property_valuation": "manual_periodic",
+                "valuation_currency_id": self.env.ref("base.USD").id,
+            }
+        )
+        product = (
+            self.env["product.product"]
+            .create({"name": "Producto valuado en moneda", "is_storable": True, "categ_id": categ.id})
+            .with_company(company)
+        )
+        product.standard_price = 1000.0
+        product.standard_price_in_currency = 1.0
+
+        # ingreso 2 unidades por ajuste de inventario para tener layers con remaining_qty
+        warehouse = self.env["stock.warehouse"].search([("company_id", "=", company.id)], limit=1)
+        self.env["stock.quant"].with_context(inventory_mode=True).create(
+            {
+                "product_id": product.id,
+                "location_id": warehouse.lot_stock_id.id,
+                "inventory_quantity": 2.0,
+            }
+        ).action_apply_inventory()
+
+        wizard = (
+            self.env["stock.valuation.layer.revaluation"]
+            .with_company(company)
+            .create({"product_id": product.id, "added_value": 2000.0, "reason": "test"})
+        )
+        expected = 1.0 + wizard.added_value_in_currency / 2.0
+        # el preview del wizard tiene que anticipar el costo que va a quedar en la ficha
+        self.assertAlmostEqual(wizard.new_value_in_currency, expected * 2.0, places=2)
+        self.assertAlmostEqual(wizard.new_value_in_currency_by_qty, expected, places=2)
+
+        wizard.action_validate_revaluation()
+
+        self.assertAlmostEqual(product.standard_price, 2000.0, places=2)
+        self.assertAlmostEqual(product.standard_price_in_currency, expected, places=2)
+        # esta lectura ademas cachea el valor del template para el chequeo de abajo
+        self.assertAlmostEqual(product.product_tmpl_id.standard_price_in_currency, expected, places=2)
+
+        # si solo se mueve el costo en moneda (ej. un landed cost), el template tiene que seguirlo
+        product.standard_price_in_currency = 5.0
+        self.assertAlmostEqual(product.product_tmpl_id.standard_price_in_currency, 5.0, places=2)

stock_currency_valuation/wizard/stock_valuation_layer_revaluation.py

@@ -26,7 +26,7 @@ class StockValuationLayerRevaluation(models.TransientModel):
     )
     new_value_in_currency_by_qty = fields.Monetary(
         "New value in currency by quantity",
-        compute="_compute_new_value",
+        compute="_compute_new_value_in_currency",
     )
 
     @api.depends("product_id", "company_id")
@@ -69,8 +69,11 @@ def _compute_added_value_in_currency(self):
     def _compute_new_value_in_currency(self):
         for reval in self:
             product_id = reval.product_id.with_company(reval.company_id)
-            reval.new_value_in_currency = product_id.standard_price_in_currency + reval.added_value_in_currency
-            if not float_is_zero(reval.current_quantity_svl, precision_rounding=self.product_id.uom_id.rounding):
+            # standard_price_in_currency es el costo unitario: hay que llevarlo a valor total
+            # antes de sumarle el valor agregado, igual que el nativo con current_value_svl.
+            current_value_in_currency = product_id.standard_price_in_currency * reval.current_quantity_svl
+            reval.new_value_in_currency = current_value_in_currency + reval.added_value_in_currency
+            if not float_is_zero(reval.current_quantity_svl, precision_rounding=reval.product_id.uom_id.rounding):
                 reval.new_value_in_currency_by_qty = reval.new_value_in_currency / reval.current_quantity_svl
             else:
                 reval.new_value_in_currency_by_qty = 0.0
@@ -108,6 +111,12 @@ def action_validate_revaluation(self):
                 product_id.with_context(disable_auto_svl=True).standard_price += (
                     self.added_value / product_id.quantity_svl
                 )
+                # El costo en moneda secundaria no lo actualiza ningun otro camino: el
+                # _update_currency_standard_price del layer solo corre para landed costs
+                # y el layer de revaluacion no tiene, asi que se actualiza aca.
+                product_id.with_context(disable_auto_svl=True).standard_price_in_currency += (
+                    self.added_value_in_currency / product_id.quantity_svl
+                )
                 if self.lot_id:
                     description += _(
                         " lot/serial number cost updated from %(previous)s to %(new_cost)s.",