[16.0][MIG] delivery_schenker

delivery_schenker/README.rst

@@ -23,7 +23,7 @@ Delivery Schenker
     :target: https://runboat.odoo-community.org/webui/builds.html?repo=OCA/delivery-carrier&target_branch=14.0
     :alt: Try me on Runboat
 
-|badge1| |badge2| |badge3| |badge4| |badge5| 
+|badge1| |badge2| |badge3| |badge4| |badge5|
 
 This module links the `DB Schenker <https://www.dbschenker.com>`_ booking and tracking
 APIs with Odoo delivery system.
@@ -156,6 +156,7 @@ Contributors
 * `Studio73 <https://www.studio73.es>`_:
 
   * Ethan Hildick
+  * Ferran Mora
 
 * Michael Tietz (MT Software) <mtietz@mt-software.de>
 

delivery_schenker/__manifest__.py

@@ -1,10 +1,11 @@
 # Copyright 2021 Tecnativa - David Vidal
 # Copyright 2021 Studio73 - Ethan Hildick <ethan@studio73.es>
+# Copyright 2023 Studio73 - Ferran Mora <ferran@studio73.es>
 # License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
 {
     "name": "Delivery Schenker",
     "summary": "Delivery Carrier implementation for DB Schenker API",
-    "version": "14.0.1.0.1",
+    "version": "16.0.1.0.0",
     "category": "Stock",
     "website": "https://github.com/OCA/delivery-carrier",
     "author": "Tecnativa, Studio73, Odoo Community Association (OCA)",

delivery_schenker/data/delivery_schenker_data.xml

@@ -1,117 +1,117 @@
 <?xml version="1.0" encoding="utf-8" ?>
 <odoo noupdate="1">
     <!-- Schenker Product Packagings. It'd be nice to have proper measures -->
-    <record id="schenker_packaging_01" model="product.packaging">
+    <record id="schenker_package_type_01" model="stock.package.type">
         <field name="shipper_package_code">CI</field>
         <field name="name">(Schenker) Canister</field>
         <field name="package_carrier_type">schenker</field>
     </record>
-    <record id="schenker_packaging_02" model="product.packaging">
+    <record id="schenker_package_type_02" model="stock.package.type">
         <field name="shipper_package_code">CT</field>
         <field name="name">(Schenker) Carton</field>
         <field name="package_carrier_type">schenker</field>
     </record>
-    <record id="schenker_packaging_03" model="product.packaging">
+    <record id="schenker_package_type_03" model="stock.package.type">
         <field name="shipper_package_code">CS</field>
         <field name="name">(Schenker) Case</field>
         <field name="package_carrier_type">schenker</field>
     </record>
-    <record id="schenker_packaging_04" model="product.packaging">
+    <record id="schenker_package_type_04" model="stock.package.type">
         <field name="shipper_package_code">CO</field>
         <field name="name">(Schenker) Colli</field>
         <field name="package_carrier_type">schenker</field>
     </record>
-    <record id="schenker_packaging_05" model="product.packaging">
+    <record id="schenker_package_type_05" model="stock.package.type">
         <field name="shipper_package_code">CH</field>
         <field name="name">(Schenker) Crate</field>
         <field name="package_carrier_type">schenker</field>
     </record>
-    <record id="schenker_packaging_06" model="product.packaging">
+    <record id="schenker_package_type_06" model="stock.package.type">
         <field name="shipper_package_code">GP</field>
         <field name="name">(Schenker) Skeleton box pallet</field>
         <field name="package_carrier_type">schenker</field>
     </record>
-    <record id="schenker_packaging_07" model="product.packaging">
+    <record id="schenker_package_type_07" model="stock.package.type">
         <field name="shipper_package_code">NE</field>
         <field name="name">(Schenker) Unpacked Skid</field>
         <field name="package_carrier_type">schenker</field>
     </record>
-    <record id="schenker_packaging_08" model="product.packaging">
+    <record id="schenker_package_type_08" model="stock.package.type">
         <field name="shipper_package_code">BG</field>
         <field name="name">(Schenker) Bag</field>
         <field name="package_carrier_type">schenker</field>
     </record>
-    <record id="schenker_packaging_09" model="product.packaging">
+    <record id="schenker_package_type_09" model="stock.package.type">
         <field name="shipper_package_code">BL</field>
         <field name="name">(Schenker) Bale</field>
         <field name="package_carrier_type">schenker</field>
     </record>
-    <record id="schenker_packaging_10" model="product.packaging">
+    <record id="schenker_package_type_10" model="stock.package.type">
         <field name="shipper_package_code">DR</field>
         <field name="name">(Schenker) Barrel</field>
         <field name="package_carrier_type">schenker</field>
     </record>
-    <record id="schenker_packaging_11" model="product.packaging">
+    <record id="schenker_package_type_11" model="stock.package.type">
         <field name="shipper_package_code">BX</field>
         <field name="name">(Schenker) Box</field>
         <field name="package_carrier_type">schenker</field>
     </record>
-    <record id="schenker_packaging_12" model="product.packaging">
+    <record id="schenker_package_type_12" model="stock.package.type">
         <field name="shipper_package_code">BY</field>
         <field name="name">(Schenker) Bundle</field>
         <field name="package_carrier_type">schenker</field>
     </record>
-    <record id="schenker_packaging_13" model="product.packaging">
+    <record id="schenker_package_type_13" model="stock.package.type">
         <field name="shipper_package_code">TR</field>
         <field name="name">(Schenker) Drum</field>
         <field name="package_carrier_type">schenker</field>
     </record>
-    <record id="schenker_packaging_14" model="product.packaging">
+    <record id="schenker_package_type_14" model="stock.package.type">
         <field name="shipper_package_code">EP</field>
         <field name="name">(Schenker) Europallet</field>
         <field name="package_carrier_type">schenker</field>
     </record>
-    <record id="schenker_packaging_15" model="product.packaging">
+    <record id="schenker_package_type_15" model="stock.package.type">
         <field name="shipper_package_code">FR</field>
         <field name="name">(Schenker) Frame</field>
         <field name="package_carrier_type">schenker</field>
     </record>
-    <record id="schenker_packaging_16" model="product.packaging">
+    <record id="schenker_package_type_16" model="stock.package.type">
         <field name="shipper_package_code">HO</field>
         <field name="name">(Schenker) Hobbock</field>
         <field name="package_carrier_type">schenker</field>
     </record>
-    <record id="schenker_packaging_17" model="product.packaging">
+    <record id="schenker_package_type_17" model="stock.package.type">
         <field name="shipper_package_code">OP</field>
         <field name="name">(Schenker) One-way pallet</field>
         <field name="package_carrier_type">schenker</field>
     </record>
-    <record id="schenker_packaging_18" model="product.packaging">
+    <record id="schenker_package_type_18" model="stock.package.type">
         <field name="shipper_package_code">PK</field>
         <field name="name">(Schenker) Package</field>
         <field name="package_carrier_type">schenker</field>
     </record>
-    <record id="schenker_packaging_19" model="product.packaging">
+    <record id="schenker_package_type_19" model="stock.package.type">
         <field name="shipper_package_code">XP</field>
         <field name="name">(Schenker) Pallet</field>
         <field name="package_carrier_type">schenker</field>
     </record>
-    <record id="schenker_packaging_20" model="product.packaging">
+    <record id="schenker_package_type_20" model="stock.package.type">
         <field name="shipper_package_code">PZ</field>
         <field name="name">(Schenker) Pipe</field>
         <field name="package_carrier_type">schenker</field>
     </record>
-    <record id="schenker_packaging_21" model="product.packaging">
+    <record id="schenker_package_type_21" model="stock.package.type">
         <field name="shipper_package_code">RO</field>
         <field name="name">(Schenker) Roll</field>
         <field name="package_carrier_type">schenker</field>
     </record>
-    <record id="schenker_packaging_22" model="product.packaging">
+    <record id="schenker_package_type_22" model="stock.package.type">
         <field name="shipper_package_code">SK</field>
         <field name="name">(Schenker) Sack</field>
         <field name="package_carrier_type">schenker</field>
     </record>
-    <record id="schenker_packaging_23" model="product.packaging">
+    <record id="schenker_package_type_23" model="stock.package.type">
         <field name="shipper_package_code">ZZ</field>
         <field name="name">(Schenker) Other</field>
         <field name="package_carrier_type">schenker</field>

delivery_schenker/migrations/16.0.1.0.0/post-migration.py

@@ -0,0 +1,23 @@
+# Copyright 2023 Studio73 - Ferran Mora
+# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
+
+from openupgradelib import openupgrade
+
+
+@openupgrade.migrate()
+def migrate(env, version):
+    for i in range(1, 23):
+        xml_id = "delivery_schenker.schenker_packaging_{}".format(str(i).zfill(2))
+        pack = env.ref(xml_id, raise_if_not_found=False)
+        if pack:
+            xml_id = "delivery_schenker.schenker_package_type_{}".format(
+                str(i).zfill(2)
+            )
+            package_type = env.ref(xml_id, raise_if_not_found=False)
+            if package_type:
+                env.cr.execute(
+                    "SELECT schenker_stackable FROM product_packaging WHERE id=%s",
+                    (pack.id,),
+                )
+                schenker_stackable = env.cr.fetchone()
+                package_type.write({"schenker_stackable": schenker_stackable})

delivery_schenker/models/__init__.py

@@ -1,4 +1,4 @@
 from . import delivery_carrier
-from . import product_packaging
 from . import schenker_request
+from . import stock_package_type
 from . import stock_picking

delivery_schenker/models/delivery_carrier.py

@@ -158,66 +158,66 @@
         ],
         default="VOLUME",
     )
-    schenker_default_packaging_id = fields.Many2one(
-        comodel_name="product.packaging",
+    schenker_default_package_type_id = fields.Many2one(
+        comodel_name="stock.package.type",
         string="Default Package Type",
         domain=[("package_carrier_type", "=", "schenker")],
         help="If not delivery package or the package doesn't have defined the packaging"
-        "it will default to this type",
+        " it will default to this type",
     )
 
     def _get_schenker_credentials(self):
         """Access key is mandatory for every request while group and user are
         optional"""
         credentials = {
             "prod": self.prod_environment,
             "access_key": self.schenker_access_key,
         }
         if self.schenker_group_id:
             credentials["group_id"] = self.schenker_group_id
         if self.schenker_user:
             credentials["user"] = self.schenker_user
         return credentials
 
     @api.model
     def _schenker_log_request(self, schenker_request, picking):
         """Helper to write raw request/response to the current picking. If debug
         is active in the carrier, those will be logged in the ir.logging as well"""
         schenker_last_request = schenker_last_response = False
         try:
             schenker_last_request = etree.tostring(
                 schenker_request.history.last_sent["envelope"],
                 encoding="UTF-8",
                 pretty_print=True,
             )
             schenker_last_response = etree.tostring(
                 schenker_request.history.last_received["envelope"],
                 encoding="UTF-8",
                 pretty_print=True,
             )
         # Don't fail hard on this. Sometimes zeep could not be able to keep history
         except Exception:
             return
         # Debug must be active in the carrier
         self.log_xml(schenker_last_request, "schenker_request")
         self.log_xml(schenker_last_response, "schenker_response")
 
     def _prepare_schenker_barcode(self):
         """Always request the barcode label when generating the booking. We can choose
         between two formats: A6 and A4, where an starting position can be set"""
         vals = {"barcodeRequest": self.schenker_barcode_format}
         if self.schenker_barcode_mail:
             vals["barcodeRequestEmail"] = self.schenker_barcode_mail
         if self.schenker_barcode_format == "A6":
             return vals
         # This options only can be informed when the label format is A4
         vals.update(
             {
                 "start_pos": self.schenker_barcode_a4_start_pos,
                 "separated": self.schenker_barcode_a4_separated,
             }
         )
         return vals
 
     def _prepare_schenker_address(
         self,
@@ -233,7 +233,7 @@
         :param res.partner record
         :returns dicts with shipping address formated for Scheneket API
         """
         vals = {
             "type": address_type,
             "name1": partner.name,
             "locationType": location_type,  # POSTAL or PHYSICAL
@@ -248,14 +248,14 @@
         }
         # Optional stuff. The API doesn't like falsy or empty request fields
         if partner.email:
             vals["email"] = partner.email
         if partner.mobile:
             vals["mobilePhone"] = partner.mobile
         if partner.phone:
             vals["phone"] = partner.phone
         if partner.street2:
             vals["street2"] = partner.street2
         return vals
 
     def _schenker_shipping_address(self, picking):
         """Each booking should have at least 2 addresses of types: SHIPPER and CONSIGNEE
@@ -264,12 +264,12 @@
         :param picking record
         :returns list of dicts with shipping addresses formated for Scheneket API
         """
         shipper_address = (
             picking.picking_type_id.warehouse_id.partner_id
             or picking.company_id.partner_id
         )
         consignee_address = picking.partner_id
         return [
             self._prepare_schenker_address(shipper_address, "SHIPPER"),
             self._prepare_schenker_address(consignee_address),
         ]
@@ -278,21 +278,21 @@
         """Gets the proper shipping product according to the shipping type
         :returns string with shipping product code
         """
         type_mapping = {
             "air": self.schenker_service_air,
             "land": self.schenker_service_land,
             "ocean_fcl": "fcl",
             "ocean_lcl": "lcl",
         }
         return type_mapping[self.schenker_booking_type]
 
     def _schenker_metric_system(self):
         """
         :returns string with schenker metric system (METRIC or IMPERIAL)
         """
         get_param = self.env["ir.config_parameter"].sudo().get_param
         product_weight_in_lbs_param = get_param("product.weight_in_lbs", "0")
         return "IMPERIAL" if product_weight_in_lbs_param == "1" else "METRIC"
 
     def _schenker_pickup_dates(self, picking):
         """Convert picking dates for schenker api. We're taking the whole delivery
@@ -300,22 +300,22 @@
         :param picking record with picking to send
         :returns dict values with the picking dates in iso format
         """
         date_from = fields.Datetime.context_timestamp(
             self, picking.date_done.replace(hour=0, minute=0, second=0)
         ).isoformat()
         date_to = fields.Datetime.context_timestamp(
             self, picking.date_done.replace(hour=23, minute=59, second=59)
         ).isoformat()
         return {"pickUpDateFrom": date_from, "pickUpDateTo": date_to}
 
     def _schenker_shipping_information_package(self, picking, package):
         weight = package.shipping_weight or package.weight
         # Volume calculations can be unfolded with stock_quant_package_dimension
         if hasattr(package, "volume"):
             volume = round(package.volume, 2)
         else:
             volume = sum([q.quantity * q.product_id.volume for q in package.quant_ids])
         return {
             # Dangerous goods is not supported
             "dgr": False,
             "cargoDesc": picking.name + " / " + package.name,
@@ -323,12 +323,12 @@
             # Default to 1 if no volume informed
             "volume": volume or 0.01,
             "packageType": (
-                package.packaging_id.shipper_package_code
-                or self.schenker_default_packaging_id.shipper_package_code
+                package.package_type_id.shipper_package_code
+                or self.schenker_default_package_type_id.shipper_package_code
             ),
             "stackable": (
-                package.packaging_id.schenker_stackable
-                or self.schenker_default_packaging_id.schenker_stackable
+                package.package_type_id.schenker_stackable
+                or self.schenker_default_package_type_id.schenker_stackable
             ),
             "pieces": 1,
         }
@@ -344,7 +344,7 @@
                 self._schenker_shipping_information_package(picking, package)
                 for package in picking.package_ids
             ]
         weight = picking.shipping_weight or picking.weight
         # Obviously products should be well configured. This parameter is mandatory.
         volume = sum(
             [
@@ -353,7 +353,7 @@
                 for ml in picking.move_line_ids
             ]
         )
         return [
             {
                 # Dangerous goods is not supported
                 "dgr": False,
@@ -361,8 +361,8 @@
                 # For a more complex solution use packaging properly
                 "grossWeight": round(weight / picking.number_of_packages, 2),
                 "volume": round(volume, 2) or 0.01,
-                "packageType": self.schenker_default_packaging_id.shipper_package_code,
-                "stackable": self.schenker_default_packaging_id.schenker_stackable,
+                "packageType": self.schenker_default_package_type_id.shipper_package_code,
+                "stackable": self.schenker_default_package_type_id.schenker_stackable,
                 "pieces": picking.number_of_packages,
             }
         ]
@@ -375,22 +375,22 @@
         :returns dict values for the proper unit key and value
         """
         if self.schenker_measure_unit == "VOLUME":
             return {"measureUnitVolume": vals["shippingInformation"]["volume"]}
         return {}
 
     def _prepare_schenker_shipping(self, picking):
         """Convert picking values for schenker api
         :param picking record with picking to send
         :returns dict values for the connector
         """
         self.ensure_one()
         # We'll compose the request via some diferenced parts, like label settings,
         # address options, incoterms and so. There are lots of thing to take into
         # account to acomplish a properly formed request.
         vals = {}
         vals.update(self._prepare_schenker_barcode())
         shipping_information = self._schenker_shipping_information(picking)
         vals.update(
             {
                 "address": self._schenker_shipping_address(picking),
                 "incoterm": (
@@ -404,7 +404,7 @@
                 "shippingInformation": {
                     "shipmentPosition": shipping_information,
                     "grossWeight": round(picking.shipping_weight, 2),
-                    "volume": shipping_information["volume"],
+                    "volume": shipping_information[0]["volume"],
                 },
                 "measureUnit": self.schenker_measure_unit,
                 # Customs Clearance not supported for now as it needs a full customs
@@ -427,8 +427,8 @@
                 "pharmaceuticals": self.schenker_pharmaceuticals,
             }
         )
         vals.update(self._schenker_measures(picking, vals))
         return vals
 
     def schenker_send_shipping(self, pickings):
         """Send booking request to Schenker
@@ -438,83 +438,83 @@
         to this design, we have to inject vals in the context to be able to
         add them to the message.
         """
         schenker_request = SchenkerRequest(**self._get_schenker_credentials())
         result = []
         for picking in pickings:
             vals = self._prepare_schenker_shipping(picking)
             vals.update({"tracking_number": False, "exact_price": 0})
             try:
                 response = schenker_request._send_shipping(
                     vals, self.schenker_booking_type
                 )
             except Exception as e:
                 raise (e)
             finally:
                 self._schenker_log_request(schenker_request, picking)
             if not response:
                 result.append(vals)
                 continue
             vals["tracking_number"] = response.get("booking_id")
             # We post an extra message in the chatter with the barcode and the
             # label because there's clean way to override the one sent by core.
             body = _("Schenker Shipping barcode document")
             attachment = []
             if response.get("barcode"):
                 attachment = [
                     (
                         "schenker_label_{}.pdf".format(response.get("booking_id")),
                         response.get("barcode"),
                     )
                 ]
             picking.message_post(body=body, attachments=attachment)
             result.append(vals)
         return result
 
     def schenker_cancel_shipment(self, pickings):
         """Cancel the expedition
         :param pickings - stock.picking recordset
         :returns pdf file
         """
         schenker_request = SchenkerRequest(**self._get_schenker_credentials())
         for picking in pickings.filtered("carrier_tracking_ref"):
             try:
                 schenker_request._cancel_shipment(picking.carrier_tracking_ref)
             except Exception as e:
                 raise (e)
             finally:
                 self._schenker_log_request(schenker_request, picking)
         return True
 
     def schenker_get_label(self, reference):
         """Generate label for picking
         :param picking - stock.picking record
         :returns pdf file
         """
         self.ensure_one()
         if not reference:
             return False
         schenker_request = SchenkerRequest(**self._get_schenker_credentials())
         format_vals = self.schenker_barcode_format
         if format_vals == "A4":
             format_vals = {
                 "start_pos": self.schenker_barcode_a4_start_pos,
                 "_value_1": self.schenker_barcode_format,
             }
         label = schenker_request._shipping_label([reference], format_vals)
         if not label:
             return False
         return label
 
     def schenker_get_tracking_link(self, picking):
         """Provide tracking link for the customer"""
         return (
             "https://eschenker.dbschenker.com/app/tracking-public/?refNumber=%s"
             % picking.carrier_tracking_ref
         )
 
     def _prepare_schenker_tracking(self, picking):
         self.ensure_one()
         return {
             "reference": picking.carrier_tracking_ref,
             "reference_type": "cu",
             "booking_type": self.schenker_booking_type,
@@ -522,20 +522,20 @@
 
     def schenker_tracking_state_update(self, picking):
         """Tracking state update"""
         self.ensure_one()
         if not picking.carrier_tracking_ref:
             return
         schenker_request = SchenkerRequest(
             **self._get_schenker_credentials(), service="tracking"
         )
         response = schenker_request._get_tracking_states(
             **self._prepare_schenker_tracking(picking)
         )
         if response.get("shipment"):
             shipment = response.get("shipment")[0]
             info = shipment.ShipmentInfo.ShipmentBasicInfo
             status_event_list = info.StatusEventList.StatusEvent
             last_event = SCHENKER_STATUS_CODES.get(info.LastEvent, ("",))
             picking.write(
                 {
                     "tracking_state_history": (
@@ -558,11 +558,11 @@
                     "delivery_state": last_event[1],
                 }
             )
         return
 
     def schenker_rate_shipment(self, order):
         """There's no public API so another price method should be used."""
         return {
             "success": True,
             "price": self.product_id.lst_price,
             "error_message": _(
@@ -585,7 +585,7 @@
         the future, this can be removed as long as those method have the proper
         support"""
         if self.schenker_booking_type != "land":
             raise UserError(_("Only land shipping is currently supported"))
 
     @api.onchange("schenker_measure_unit")
     def onchange_schenker_measure_unit(self):
@@ -593,4 +593,4 @@
         calculation structure should be provided to use the other API options. A hook
         method is provided though."""
         if self.schenker_measure_unit != "VOLUME":
             raise UserError(_("Only volume is currently supported"))

delivery_schenker/models/schenker_request.py

@@ -34,14 +34,14 @@
     def __init__(
         self, access_key=None, group_id=None, user=None, prod=False, service="booking"
     ):
         self.access_key = access_key or ""
         self.group_id = group_id or ""
         self.user = user or ""
         self.service = service
         api_env = "prod" if prod else "test"
         self.history = HistoryPlugin(maxlen=10)
         settings = Settings(strict=False, xml_huge_tree=True)
         self.client = Client(
             wsdl=SCHENKER_API_URL[api_env] + SCHENKER_API_SERVICE[service],
             settings=settings,
             plugins=[self.history],
@@ -51,37 +51,42 @@
         """Schenker API returns error petitions as server exceptions wich makes zeep to
         raise a Fault exception as well. To catch the error info we need to make a
         raw_response request and the extract the error codes from the response."""
         try:
             if not send_as_kw:
                 response = service(vals)
             else:
                 response = service(**vals)
         except Fault as e:
             with self.client.settings(raw_response=True):
                 if not send_as_kw:
                     response = service(vals)
                 else:
                     response = service(**vals)
                 try:
                     root = ET.fromstring(response.text)
                     error_text = next(root.iter("faultstring")).text
                     error_message = next(root.iter("message")).text
                     error_code = next(root.iter("code")).text
                     raise ValidationError(
                         _(
                             "Error in the request to the Schenker API. This is the "
                             "thrown message:\n\n"
-                            "[%s]\n"
-                            "%s - %s" % (error_text, error_code, error_message)
+                            "[%(error_text)s]\n"
+                            "%(error_code)s - %(error_message)s"
                         )
+                        % {
+                            "error_text": error_text,
+                            "error_code": error_code,
+                            "error_message": error_message,
+                        }
                     ) from e
                 except ValidationError:
                     raise
                 # If we can't get the proper exception, fallback to the first
                 # exception error traceback
                 except Exception as exc:
                     raise Fault(e) from exc
         return response
 
     # Booking API methods
 
@@ -91,101 +96,101 @@
         :params string with shipping method
         :returns string with the mapped key value for the proper method
         """
         method_map = {
             "land": "getBookingRequestLand",
             "air": "getBookingRequestAir",
             "ocean_fcl": "getBookingRequestOceanFCL",
             "ocean_lcl": "getBookingRequestOceanLCL",
         }
         return method_map.get("method", "getBookingRequestLand")
 
     def _shipping_api_credentials(self):
         """Each API has a different credentials SOAP declaration"""
         credentials = {"applicationArea": {"accessKey": self.access_key}}
         if self.user:
             credentials["applicationArea"]["userId"] = self.user
         if self.group_id:
             credentials["applicationArea"]["groupId"] = self.group_id
         return credentials
 
     def _scheneker_shipping_api_wrapper(self, method=False):
         """Aside from a different API method, each one has its own wrapper"""
         booking_wrapper_map = {
             "land": "bookingLand",
             "air": "bookingAir",
             "ocean_fcl": "bookingOceanFCL",
             "ocean_lcl": "bookingOceanLCL",
         }
         return booking_wrapper_map.get(method, "land")
 
     def _send_shipping(self, picking_vals, method=False):
         """Create new shipment
         :params vals dict of needed values
         :returns dict with Schenker response containing the shipping code and label
         """
         vals = self._shipping_api_credentials()
         method_wrapper = self._scheneker_shipping_api_wrapper(method)
         vals[method_wrapper] = picking_vals
         # From the Schenker docs:
         # Defines if booking shall be submitted. If false, the booking can be edited
         # in the frontend and MUST be submitted manually.
         vals[method_wrapper].update({"submitBooking": True})
         response = self._process_reply(
             self.client.service[self._shipping_type_method(method)], vals
         )
         return {"booking_id": response.bookingId, "barcode": response.barcodeDocument}
 
     def _shipping_label(self, reference_list=None, label_format="A6"):
         """Get shipping label for the given ref
         :param list reference -- shipping reference list
         :returns: base64 with pdf labels
         """
         reference_list = reference_list or []
         vals = dict(
             **self._shipping_api_credentials(),
             **{"barcodeRequest": {"format": label_format}}
         )
         vals["barcodeRequest"].update({"bookingId": ref for ref in reference_list})
         label = self._process_reply(
             self.client.service.getBookingBarcodeRequest, vals
         ).document
         return label
 
     def _cancel_shipment(self, reference=False):
         """Cancel de expedition for the given ref
         :param str reference -- booking reference string
         :returns: bool True if success
         """
         vals = self._shipping_api_credentials()
         vals.update({"cancelRequest": {"bookingId": reference}})
         response = self._process_reply(
             self.client.service.getBookingCancelRequest, vals
         )
         # TODO: Inspect typical response as we don't want to return a zeep  object.
         # Anyway, it's going to fail if the booking can't be cancelled. So either we
         # receive an exception error or the booking is cancelled.
         return bool(response)
 
     # Tracking API methods
 
     def _tracking_api_credentials(self):
         """Each API has a different credentials SOAP declaration"""
         return {"AccessKey": self.access_key, "in": {}}
 
     def _get_tracking_states(
         self, reference=False, reference_type="cu", booking_type="land"
     ):
         if not reference:
             return {}
         vals = self._tracking_api_credentials()
         vals["in"].update(
             {
                 "referenceNumber": reference,
                 "referenceType": reference_type,
                 "transportNature": "exp" if booking_type == "land" else "int",
             }
         )
         response = self._process_reply(
             self.client.service.getPublicShipmentDetails, vals, send_as_kw=True
         )
         return {"shipment": response.Shipment}

delivery_schenker/models/product_packaging.py → delivery_schenker/models/stock_package_type.py

@@ -1,10 +1,11 @@
 # Copyright 2021 Tecnativa - David Vidal
+# Copyright 2023 Studio73 - Ferran Mora
 # License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
 from odoo import fields, models
 
 
-class ProductPackaging(models.Model):
-    _inherit = "product.packaging"
+class StockPackageType(models.Model):
+    _inherit = "stock.package.type"
 
     package_carrier_type = fields.Selection(selection_add=[("schenker", "DB Schenker")])
     schenker_stackable = fields.Boolean(

delivery_schenker/views/delivery_schenker_view.xml

@@ -62,7 +62,7 @@
                         </group>
                         <group string="Logistics">
                             <field
-                                name="schenker_default_packaging_id"
+                                name="schenker_default_package_type_id"
                                 attrs="{'required': [('delivery_type', '=', 'schenker')]}"
                             />
                             <field

delivery_schenker/views/stock_picking_views.xml

@@ -3,13 +3,13 @@
     <record id="view_picking_withcarrier_out_form" model="ir.ui.view">
         <field name="model">stock.picking</field>
         <field name="inherit_id" ref="delivery.view_picking_withcarrier_out_form" />
-        <field name="groups_id" eval="[(4, ref('base.group_no_one'))]" />
         <field name="arch" type="xml">
             <xpath expr="//header" position='inside'>
                 <button
                     name="schenker_get_label"
                     string="Schenker Label"
                     type="object"
+                    groups="base.group_no_one"
                     attrs="{
                         'invisible':[
                             '|',