[MIG] mrp_bom_version: Migration to 16.0

.github/workflows/test.yml

@@ -36,8 +36,17 @@ jobs:
       matrix:
         include:
           - container: ghcr.io/oca/oca-ci/py3.10-odoo16.0:latest
+            include: "mrp_bom_version"
             name: test with Odoo
           - container: ghcr.io/oca/oca-ci/py3.10-ocb16.0:latest
+            include: "mrp_bom_version"
+            name: test with OCB
+            makepot: "true"
+          - container: ghcr.io/oca/oca-ci/py3.10-odoo16.0:latest
+            exclude: "mrp_bom_version"
+            name: test with Odoo
+          - container: ghcr.io/oca/oca-ci/py3.10-ocb16.0:latest
+            exclude: "mrp_bom_version"
             name: test with OCB
             makepot: "true"
     services:
@@ -49,6 +58,9 @@ jobs:
           POSTGRES_DB: odoo
         ports:
           - 5432:5432
+    env:
+      INCLUDE: "${{ matrix.include }}"
+      EXCLUDE: "${{ matrix.exclude }}"
     steps:
       - uses: actions/checkout@v3
         with:

mrp_bom_version/__openerp__.py → mrp_bom_version/__manifest__.py

@@ -5,7 +5,7 @@
 {
     "name": "MRP - BoM version",
     "summary": "BoM versioning",
-    "version": "8.0.1.0.0",
+    "version": "16.0.1.0.0",
     "license": "AGPL-3",
     "author": "OdooMRP team,"
     "AvanzOSC,"

mrp_bom_version/data/mrp_bom_data.xml

@@ -1,11 +1,9 @@
 <?xml version="1.0" encoding="UTF-8" ?>
-<openerp>
-    <data>
-        <record id="mt_active" model="mail.message.subtype">
-            <field name="name">MRP BoM Active</field>
-            <field name="res_model">mrp.bom</field>
-            <field name="default" eval="False" />
-            <field name="description">MRP BoM Active</field>
-        </record>
-    </data>
-</openerp>
+<odoo>
+    <record id="mt_active" model="mail.message.subtype">
+        <field name="name">MRP BoM Active</field>
+        <field name="res_model">mrp.bom</field>
+        <field name="default" eval="False" />
+        <field name="description">MRP BoM Active</field>
+    </record>
+</odoo>

mrp_bom_version/models/mrp_bom.py

@@ -1,28 +1,21 @@
 # (c) 2015 Oihane Crucelaegui - AvanzOSC
 # License AGPL-3 - See http://www.gnu.org/licenses/agpl-3.0.html
 
-from openerp import api, fields, models
-from openerp.tools import config
+from odoo import api, fields, models
+from odoo.tools import config
 
 
 class MrpBom(models.Model):
     _inherit = "mrp.bom"
 
-    _track = {
-        "state": {
-            "mrp_bom_version.mt_active": lambda self, cr, uid, obj, ctx=None: obj.state
-            == "active",
-        },
-    }
-
-    @api.one
-    def _get_old_versions(self):
-        parent = self.parent_bom
-        old_version = self.env["mrp.bom"]
-        while parent:
-            old_version += parent
-            parent = parent.parent_bom
-        self.old_versions = old_version
+    def _compute_old_versions(self):
+        for bom in self:
+            parent = bom.parent_bom
+            old_version = self.env["mrp.bom"]
+            while parent:
+                old_version |= parent
+                parent = parent.parent_bom
+            bom.old_versions = [(6, 0, old_version.ids)]
 
     def _default_active(self):
         """Needed for preserving normal flow when testing other modules."""
@@ -41,14 +34,14 @@ def _default_state(self):
     active = fields.Boolean(
         default=_default_active, readonly=True, states={"draft": [("readonly", False)]}
     )
-    historical_date = fields.Date(string="Historical Date", readonly=True)
+    historical_date = fields.Date(readonly=True, copy=False)
     state = fields.Selection(
         selection=[
             ("draft", "Draft"),
             ("active", "Active"),
             ("historical", "Historical"),
         ],
-        string="State",
+        string="Status",
         index=True,
         readonly=True,
         default=_default_state,
@@ -59,44 +52,48 @@ def _default_state(self):
     )
     product_id = fields.Many2one(readonly=True, states={"draft": [("readonly", False)]})
     product_qty = fields.Float(readonly=True, states={"draft": [("readonly", False)]})
-    name = fields.Char(states={"historical": [("readonly", True)]})
     code = fields.Char(states={"historical": [("readonly", True)]})
     type = fields.Selection(states={"historical": [("readonly", True)]})
     company_id = fields.Many2one(states={"historical": [("readonly", True)]})
-    product_uom = fields.Many2one(states={"historical": [("readonly", True)]})
-    routing_id = fields.Many2one(readonly=True, states={"draft": [("readonly", False)]})
+    product_uom_id = fields.Many2one(states={"historical": [("readonly", True)]})
     bom_line_ids = fields.One2many(
         readonly=True, states={"draft": [("readonly", False)]}
     )
-    position = fields.Char(states={"historical": [("readonly", True)]})
-    date_start = fields.Date(states={"historical": [("readonly", True)]})
-    date_stop = fields.Date(states={"historical": [("readonly", True)]})
-    property_ids = fields.Many2many(states={"historical": [("readonly", True)]})
-    product_rounding = fields.Float(states={"historical": [("readonly", True)]})
-    product_efficiency = fields.Float(states={"historical": [("readonly", True)]})
-    message_follower_ids = fields.Many2many(states={"historical": [("readonly", True)]})
-    message_ids = fields.One2many(states={"historical": [("readonly", True)]})
+    byproduct_ids = fields.One2many(
+        readonly=True, states={"draft": [("readonly", False)]}
+    )
+    sequence = fields.Integer(states={"historical": [("readonly", True)]})
+    operation_ids = fields.One2many(
+        readonly=True, states={"draft": [("readonly", False)]}
+    )
+    ready_to_produce = fields.Selection(states={"historical": [("readonly", True)]})
+    picking_type_id = fields.Many2one(states={"historical": [("readonly", True)]})
+    consumption = fields.Selection(states={"historical": [("readonly", True)]})
     version = fields.Integer(
         states={"historical": [("readonly", True)]}, copy=False, default=1
     )
     parent_bom = fields.Many2one(
         comodel_name="mrp.bom", string="Parent BoM", copy=False
     )
     old_versions = fields.Many2many(
-        comodel_name="mrp.bom", string="Old Versions", compute="_get_old_versions"
+        comodel_name="mrp.bom", compute="_compute_old_versions"
     )
 
-    @api.multi
+    def _track_subtype(self, init_values):
+        if "state" in init_values and self.state == "active":
+            return self.env.ref("mrp_bom_version.mt_active")
+        return super()._track_subtype(init_values)
+
     def button_draft(self):
-        active_draft = self.env["mrp.config.settings"]._get_parameter("active.draft")
+        get_param = self.env["ir.config_parameter"].sudo().get_param
+        active_draft = get_param("mrp_bom_version.active_draft")
         self.write(
             {
-                "active": active_draft and active_draft.value or False,
+                "active": active_draft,
                 "state": "draft",
             }
         )
 
-    @api.multi
     def button_new_version(self):
         self.ensure_one()
         new_bom = self._copy_bom()
@@ -111,21 +108,20 @@ def button_new_version(self):
         }
 
     def _copy_bom(self):
-        active_draft = self.env["mrp.config.settings"]._get_parameter("active.draft")
+        get_param = self.env["ir.config_parameter"].sudo().get_param
+        active_draft = get_param("mrp_bom_version.active_draft")
         new_bom = self.copy(
             {
                 "version": self.version + 1,
-                "active": active_draft and active_draft.value or False,
+                "active": active_draft,
                 "parent_bom": self.id,
             }
         )
         return new_bom
 
-    @api.multi
     def button_activate(self):
         self.write({"active": True, "state": "active"})
 
-    @api.multi
     def button_historical(self):
         self.write(
             {
@@ -135,39 +131,35 @@ def button_historical(self):
             }
         )
 
-    def search(
-        self, cr, uid, args, offset=0, limit=None, order=None, context=None, count=False
-    ):
+    @api.model
+    def search(self, args, offset=0, limit=None, order=None, count=False):
         """Add search argument for field type if the context says so. This
         should be in old API because context argument is not the last one.
         """
-        if context is None:
-            context = {}
-        search_state = context.get("state", False)
+        search_state = self.env.context.get("state", False)
         if search_state:
             args += [("state", "=", search_state)]
-        return super(MrpBom, self).search(
-            cr,
-            uid,
+        return super().search(
             args,
             offset=offset,
             limit=limit,
             order=order,
-            context=context,
             count=count,
         )
 
     @api.model
-    def _bom_find(self, product_tmpl_id=None, product_id=None, properties=None):
-        """Finds BoM for particular product and product uom.
-        @param product_tmpl_id: Selected product.
-        @param product_uom: Unit of measure of a product.
-        @param properties: List of related properties.
-        @return: False or BoM id.
+    def _bom_find(self, products, picking_type=None, company_id=False, bom_type=False):
+        """Find the first BoM for each products
+
+        :param products: `product.product` recordset
+        :return: One bom (or empty recordset `mrp.bom` if none find)
+                 by product (`product.product` record)
+        :rtype: defaultdict(`lambda: self.env['mrp.bom']`)
         """
         bom_id = super(MrpBom, self.with_context(state="active"))._bom_find(
-            product_tmpl_id=product_tmpl_id,
-            product_id=product_id,
-            properties=properties,
+            products,
+            picking_type=picking_type,
+            company_id=company_id,
+            bom_type=bom_type,
         )
         return bom_id

mrp_bom_version/models/res_config.py

@@ -1,11 +1,11 @@
 # (c) 2015 Oihane Crucelaegui - AvanzOSC
 # License AGPL-3 - See http://www.gnu.org/licenses/agpl-3.0.html
 
-from openerp import api, fields, models
+from odoo import fields, models
 
 
 class MrpConfigSettings(models.TransientModel):
-    _inherit = "mrp.config.settings"
+    _inherit = "res.config.settings"
 
     group_mrp_bom_version = fields.Boolean(
         string="Allow to re-edit BoMs",
@@ -16,34 +16,5 @@ class MrpConfigSettings(models.TransientModel):
         string="Keep re-editing BoM active",
         help="This will allow you to define if those BoM passed back to draft"
         " are still activated or not",
+        config_parameter="mrp_bom_version.active_draft",
     )
-
-    def _get_parameter(self, key, default=False):
-        param_obj = self.env["ir.config_parameter"]
-        rec = param_obj.search([("key", "=", key)])
-        return rec or default
-
-    def _write_or_create_param(self, key, value):
-        param_obj = self.env["ir.config_parameter"]
-        rec = self._get_parameter(key)
-        if rec:
-            if not value:
-                rec.unlink()
-            else:
-                rec.value = value
-        elif value:
-            param_obj.create({"key": key, "value": value})
-
-    @api.multi
-    def get_default_parameters(self):
-        def get_value(key, default=""):
-            rec = self._get_parameter(key)
-            return rec and rec.value or default
-
-        return {
-            "active_draft": get_value("active.draft", False),
-        }
-
-    @api.multi
-    def set_parameters(self):
-        self._write_or_create_param("active.draft", self.active_draft)

mrp_bom_version/security/mrp_bom_version_security.xml

@@ -1,9 +1,7 @@
 <?xml version="1.0" encoding="UTF-8" ?>
-<openerp>
-    <data noupdate="1">
-        <record id="group_mrp_bom_version" model="res.groups">
-            <field name="name">MRP BoM version</field>
-            <field name="category_id" ref="base.module_category_hidden" />
-        </record>
-    </data>
-</openerp>
+<odoo noupdate="1">
+    <record id="group_mrp_bom_version" model="res.groups">
+        <field name="name">MRP BoM version</field>
+        <field name="category_id" ref="base.module_category_hidden" />
+    </record>
+</odoo>

mrp_bom_version/tests/test_mrp_bom_version.py

@@ -1,26 +1,27 @@
 # (c) 2015 Alfredo de la Fuente - AvanzOSC
 # License AGPL-3 - See http://www.gnu.org/licenses/agpl-3.0.html
 
-import openerp.tests.common as common
+import odoo.tests as common
 
 
 class TestMrpBomVersion(common.TransactionCase):
-    def setUp(self):
-        super(TestMrpBomVersion, self).setUp()
-        self.parameter_model = self.env["ir.config_parameter"]
-        self.bom_model = self.env["mrp.bom"].with_context(test_mrp_bom_version=True)
-        self.company = self.env.ref("base.main_company")
+    @classmethod
+    def setUpClass(cls):
+        super(TestMrpBomVersion, cls).setUpClass()
+        cls.parameter_model = cls.env["ir.config_parameter"].sudo()
+        cls.bom_model = cls.env["mrp.bom"].with_context(test_mrp_bom_version=True)
+        cls.company = cls.env.ref("base.main_company")
         vals = {
-            "company_id": self.company.id,
-            "product_tmpl_id": self.env.ref(
+            "company_id": cls.company.id,
+            "product_tmpl_id": cls.env.ref(
                 "product.product_product_11_product_template"
             ).id,
             "bom_line_ids": [
-                (0, 0, {"product_id": self.env.ref("product.product_product_5").id}),
-                (0, 0, {"product_id": self.env.ref("product.product_product_6").id}),
+                (0, 0, {"product_id": cls.env.ref("product.product_product_5").id}),
+                (0, 0, {"product_id": cls.env.ref("product.product_product_6").id}),
             ],
         }
-        self.mrp_bom = self.bom_model.create(vals)
+        cls.mrp_bom = cls.bom_model.create(vals)
 
     def test_mrp_bom(self):
         self.assertEqual(
@@ -49,7 +50,7 @@ def test_mrp_bom_back2draft_default(self):
         self.assertFalse(self.mrp_bom.active, "Check must be False")
 
     def test_mrp_bom_back2draft_active(self):
-        self.parameter_model.create({"key": "active.draft", "value": True})
+        self.parameter_model.set_param("mrp_bom_version.active_draft", True)
         self.mrp_bom.button_activate()
         self.mrp_bom.button_draft()
         self.assertTrue(self.mrp_bom.active, "Check must be True, as set in parameters")
@@ -65,7 +66,11 @@ def test_mrp_bom_versioning(self):
             "historical",
             "Incorrect state, it must have been historified",
         )
-        new_boms = self.bom_model.search([("parent_bom", "=", self.mrp_bom.id)])
+        new_boms = self.bom_model.with_context(active_test=False).search(
+            [
+                ("parent_bom", "=", self.mrp_bom.id),
+            ]
+        )
         for new_bom in new_boms:
             self.assertEqual(
                 new_bom.version,