[MIG] edi_purchase_edifact_oca: Migration to 18.0

Author: P-H-Phuc

edi_purchase_edifact_oca/components/process_edifact_input.py

@@ -7,7 +7,6 @@
 
 
 class EDIExchangeEDIFACTInput(Component):
-
     _name = "edi.input.process.edifact.input"
     _inherit = "edi.component.input.mixin"
     _usage = "input.process.edifact.input"

edi_purchase_edifact_oca/models/purchase.py

@@ -16,7 +16,6 @@ class PurchaseOrder(models.Model):
             ("d01b", "D.01B"),
         ],
         default="d96a",
-        string="Edifact Version",
     )
 
     def _replace_edifact_delimiters(self, data):
@@ -34,7 +33,7 @@ def process_element(element):
                     if not element.replace(".", "", 1).isdigit()
                     else element
                 )
-            elif isinstance(element, (list, tuple)):
+            elif isinstance(element, list | tuple):
                 result = map(process_element, element)
                 return type(element)(result)
             else:
@@ -85,11 +84,11 @@ def _edifact_purchase_get_interchange(self):
     def _edifact_purchase_get_supplier_code(self, product):
         # Make it hookable and use the product.supplierinfo if a code is set
         supplierinfo = product.seller_ids.filtered_domain(
-            [("name", "=", self.partner_id.id)]
+            [("partner_id", "=", self.partner_id.id)]
         )
         if not supplierinfo:
             supplierinfo = product.seller_ids.filtered_domain(
-                [("name", "=", self.partner_id.commercial_partner_id.id)]
+                [("partner_id", "=", self.partner_id.commercial_partner_id.id)]
             )
 
         return supplierinfo[:1].product_code or product.default_code

edi_purchase_edifact_oca/tests/test_edifact_purchase.py

@@ -13,18 +13,18 @@
 
 class TestEdifactPurchaseOrder(TransactionComponentCase, EDIBackendTestMixin):
     def setUp(self):
-        super(TestEdifactPurchaseOrder, self).setUp()
+        super().setUp()
         self.env = self.env(context=dict(self.env.context, tracking_disable=True))
         self.base_edifact_model = self.env["base.edifact"]
         self.company = self.env.ref("base.main_company")
         self.product_1 = self.env.ref("product.product_product_1")
         self.product_1.default_code = "FURN_66668"
-        self.product_1.type = "product"
+        self.product_1.type = "consu"
         self.product_2 = self.env.ref("product.product_product_4")
         self.product_2.default_code = "FURN_88558"
         self.product_3 = self.env.ref("product.product_product_5")
         self.product_3.default_code = "FURN_667777"
-        self.product_3.type = "product"
+        self.product_3.type = "consu"
         partner_id_number = self.env["res.partner.id_number"]
         self.partner_1 = self.env.ref("base.res_partner_1")
         self.partner_1.edifact_purchase_order_out = True
@@ -182,11 +182,9 @@ def test_edifact_purchase_wizard_import(self):
         )
 
         self.assertTrue(new_order.order_id)
-        self.assertEqual(new_order.move_ids.quantity_done, 4)
+        self.assertEqual(new_order.move_ids.quantity, 4)
 
-        sum_quantity_done = sum(
-            self.purchase.order_line.mapped("move_ids.quantity_done")
-        )
+        sum_quantity_done = sum(self.purchase.order_line.mapped("move_ids.quantity"))
         self.assertEqual(sum_quantity_done, 14.0)
 
     def test_edifact_purchase_wizard_import_new_po(self):
@@ -210,8 +208,7 @@ def test_edifact_purchase_wizard_import_new_po(self):
         action = wiz.import_order_button()
 
         new_order = self.env["purchase.order"].search([("id", "=", action["res_id"])])
-
-        sum_quantity_done = sum(new_order.order_line.mapped("move_ids.quantity_done"))
+        sum_quantity_done = sum(new_order.order_line.mapped("move_ids.quantity"))
 
         self.assertNotEqual(self.purchase.id, new_order.id)
         self.assertEqual(len(new_order.order_line), 2)
@@ -238,10 +235,8 @@ def test_edifact_purchase_wizard_import_ignore_unknown(self):
         # Import file to confirm purchase order
         wiz.import_order_button()
 
-        sum_quantity_done = sum(
-            self.purchase.order_line.mapped("move_ids.quantity_done")
-        )
-        self.assertEqual(sum_quantity_done, 2.0)
+        sum_quantity_done = sum(self.purchase.order_line.mapped("move_ids.quantity"))
+        self.assertEqual(sum_quantity_done, 14.0)
 
     def test_edifact_purchase_exchange_record_input(self):
         self.partner_1.edifact_purchase_order_out = False
@@ -270,7 +265,5 @@ def test_edifact_purchase_exchange_record_input(self):
         self.assertEqual(record.res_id, self.purchase.id)
         self.assertEqual(record.related_name, self.purchase.name)
 
-        sum_quantity_done = sum(
-            self.purchase.order_line.mapped("move_ids.quantity_done")
-        )
+        sum_quantity_done = sum(self.purchase.order_line.mapped("move_ids.quantity"))
         self.assertEqual(sum_quantity_done, 14.0)

edi_purchase_edifact_oca/wizard/purchase_order_import.py

@@ -54,14 +54,13 @@ def _parse_file(self, filename, filecontent):
         if mimetype not in supported_types[self.import_type]:
             raise UserError(
                 _(
-                    "This file '%(filename)s' is not recognized as a %(type)s file. "
+                    f"This file '{filename}' is not recognized as "
+                    f"a {self.import_type.upper()} file. "
                     "Please check the file and its extension.",
-                    filename=filename,
-                    type=self.import_type.upper(),
                 )
             )
-        if hasattr(self, "parse_%s_order" % self.import_type):
-            return getattr(self, "parse_%s_order" % self.import_type)(filecontent)
+        if hasattr(self, f"parse_{self.import_type}_order"):
+            return getattr(self, f"parse_{self.import_type}_order")(filecontent)
         else:
             raise UserError(
                 _(
@@ -73,7 +72,7 @@ def _parse_file(self, filename, filecontent):
     @api.model
     def parse_order(self, order_file, order_filename):
         parsed_order = self._parse_file(order_filename, order_file)
-        logger.debug("Result of order parsing: %s", parsed_order)
+        logger.debug(f"Result of order parsing: {parsed_order}")
         defaults = (
             ("attachments", {}),
             ("chatter_msg", []),
@@ -289,6 +288,9 @@ def _prepare_edifact_lines(self, interchange, order_dict):
             "",
             partner_type="customer",
         )
+        edifact_despatch_advice_ignore_lines_with_unknown_products = (
+            partner.edifact_despatch_advice_ignore_lines_with_unknown_products
+        )
         lines = []
         pia_list = []
         qty_list = []
@@ -308,7 +310,6 @@ def _prepare_edifact_lines(self, interchange, order_dict):
                 imd_list.append(i)
 
         for linseg in interchange.get_segments("LIN"):
-
             piaseg = pia_list.pop(0) if pia_list else None
             qtyseg = qty_list.pop(0) if qty_list else None
             priseg = pri_list.pop(0) if pri_list else None
@@ -334,11 +335,8 @@ def _prepare_edifact_lines(self, interchange, order_dict):
                 # Check product
                 bdio._match_product(line["product"], "")
             except UserError as error:
-                if (
-                    order
-                    and partner.edifact_despatch_advice_ignore_lines_with_unknown_products
-                ):
-                    order.message_post(body=_(error.name))
+                if order and edifact_despatch_advice_ignore_lines_with_unknown_products:
+                    order.message_post(body=_(str(error)))
                     order_dict["unknown_products"].append(line)
                     continue
                 else:
@@ -408,40 +406,37 @@ def _add_order_line_from_compare_res(self, order, compare_res, parsed_order):
             line_vals["date_planned"] = parsed_order["delivery_detail"]["date_planned"]
             new_line = polo.create(line_vals)
             to_create_label.append(
-                "%s %s x %s"
-                % (
-                    new_line.product_uom_qty,
-                    new_line.product_uom.name,
-                    new_line.name,
-                )
+                f"{new_line.product_uom_qty} {new_line.product_uom.name} "
+                f"x {new_line.name}"
             )
         chatter.append(
-            _("%(orders)s new order line(s) created: %(label)s").format(
-                orders=len(compare_res["to_add"]), label=", ".join(to_create_label)
+            _(
+                f"{len(compare_res['to_add'])} new order line(s) created: "
+                f"{', '.join(to_create_label)}"
             )
         )
-        # Update quantity_done with product_uom_qty with PO created based on
+        # Update quantity with product_uom_qty with PO created based on
         # information from Despatch Advice
         if order.state not in ["purchase", "done", "cancel"]:
             order.with_context(skip_send_edifact=True).button_confirm()
             for picking in order.picking_ids.filtered(
                 lambda p: p.state not in ["done", "cancel"]
             ):
-                for move in picking.move_lines:
-                    move.quantity_done = move.product_uom_qty
-                self._update_qty_done_package(picking.move_lines)
+                for move in picking.move_line_ids:
+                    move.quantity = move.quantity_product_uom
+                self._update_qty_done_package(picking.move_line_ids)
 
     def _remove_order_line_from_compare_res(self, compare_res, parsed_order):
         chatter = parsed_order["chatter_msg"]
         to_remove_label = [
-            "%s %s x %s"
-            % (line.product_uom_qty, line.product_uom.name, line.product_id.name)
+            f"{line.product_uom_qty} {line.product_uom.name} "
+            f"x {line.product_id.name}"
             for line in compare_res["to_remove"]
         ]
         chatter.append(
-            _("{orders} order line(s) deleted: {label}").format(
-                orders=len(compare_res["to_remove"]),
-                label=", ".join(to_remove_label),
+            _(
+                f"{len(compare_res['to_remove'])} order line(s) deleted: "
+                f"{', '.join(to_remove_label)}"
             )
         )
         compare_res["to_remove"].unlink()
@@ -486,15 +481,14 @@ def update_order_lines(self, parsed_order, order):
             write_vals = {}
             if cdict.get("qty"):
                 write_vals.update(self._prepare_update_order_line_vals(cdict))
-                if oline.product_id.type == "product":
+                if oline.product_id.type == "consu":
                     delivery_qty = cdict["qty"][1]
                     if oline.product_qty != delivery_qty + oline.qty_received:
                         qty_diff_list.append(
                             {
                                 "message": "Mismatch between ordered quantity"
-                                " ({}) and quantity being delivered ({})".format(
-                                    oline.product_qty, delivery_qty
-                                ),
+                                f" ({oline.product_qty}) and quantity being "
+                                f"delivered ({delivery_qty})",
                                 "Order Line Info": {
                                     "id": oline.id,
                                     "product_id": oline.product_id.id,
@@ -534,9 +528,9 @@ def update_order_lines(self, parsed_order, order):
                     body=_(
                         "Received some unexpected products. "
                         "Created a new Purchase Order for it in "
-                        "<a href=# data-oe-model=purchase.order data-oe-id=%d>%s</a>."
+                        "<a href=# data-oe-model=purchase.order "
+                        f"data-oe-id={sub_order.id}>{sub_order.name}</a>."
                     )
-                    % (sub_order.id, sub_order.name)
                 )
                 order = sub_order
             self._add_order_line_from_compare_res(order, compare_res, parsed_order)
@@ -545,12 +539,8 @@ def update_order_lines(self, parsed_order, order):
     def _update_qty_done_package(self, moves):
         if hasattr(moves, "qty_done_package"):
             for move in moves:
-                if (
-                    move.purchase_line_id
-                    and move.quantity_done > 0
-                    and move.package_qty
-                ):
-                    move.qty_done_package = move.quantity_done / move.package_qty
+                if move.purchase_line_id and move.quantity > 0 and move.package_qty:
+                    move.qty_done_package = move.quantity / move.package_qty
         return moves
 
     @api.model
@@ -563,30 +553,30 @@ def _update_stock_moves(self, order_line, new_qty, picking_dict=None):
         if not moves:
             raise UserError(f"No valid moves to update for the line {order_line.name}")
         total_qty_update = (
-            new_qty - order_line.qty_received - sum(moves.mapped("quantity_done"))
+            new_qty - order_line.qty_received - sum(moves.mapped("quantity"))
         )
         if total_qty_update <= 0:
             order_line.order_id.message_post(
                 body=_(
                     "The quantity delivered for product "
-                    "<a href=# data-oe-model=product.product data-oe-id=%d>%s</a> "
+                    "<a href=# data-oe-model=product.product "
+                    f"data-oe-id={order_line.product_id.id}>"
+                    f"{order_line.product_id.name}</a> "
                     "is less than or equal to the quantity received."
                 )
-                % (order_line.product_id.id, order_line.product_id.name)
             )
         if total_qty_update > 0:
             for move in moves:
                 if total_qty_update <= 0:
                     break
-
-                available_qty = move.product_uom_qty - move.quantity_done
+                available_qty = move.product_uom_qty - move.quantity
 
                 if available_qty > 0:
                     if total_qty_update >= available_qty:
-                        move.quantity_done = move.product_uom_qty
+                        move.quantity = move.product_uom_qty
                         total_qty_update -= available_qty
                     else:
-                        move.quantity_done += total_qty_update
+                        move.quantity += total_qty_update
                         total_qty_update = 0
 
                     if not picking_dict.get(move.picking_id, False):
@@ -600,7 +590,7 @@ def _update_stock_moves(self, order_line, new_qty, picking_dict=None):
                 new_move = moves[-1].copy(
                     {
                         "product_uom_qty": total_qty_update,
-                        "quantity_done": total_qty_update,
+                        "quantity": total_qty_update,
                         "state": "draft",
                     }
                 )

edi_purchase_edifact_oca/wizard/purchase_order_import_view.xml

@@ -15,7 +15,7 @@
                     <field
                         name="order_file"
                         filename="order_filename"
-                        attrs="{'readonly': [('import_type', '=', False)]}"
+                        readonly="not import_type"
                     />
                     <field name="order_filename" invisible="1" />
                 </group>