[IMP] delivery_fee: support refunds and one time fees

MT-13719

Author: chienandalu

delivery_fee/__manifest__.py

@@ -14,6 +14,7 @@
     "data": [
         "views/res_partner_views.xml",
         "views/delivery_carrier_views.xml",
+        "views/res_config_settings.xml",
         "reports/delivery_slip_report.xml",
         "reports/invoice_report.xml",
     ],

delivery_fee/models/__init__.py

@@ -1,4 +1,6 @@
 from . import delivery_carrier
+from . import res_config_settings
+from . import res_company
 from . import res_partner
 from . import sale_order
 from . import stock_picking

delivery_fee/models/delivery_carrier.py

@@ -11,3 +11,8 @@ class DeliveryCarrier(models.Model):
         ondelete="restrict",
         domain="[('type', '=', 'service')]",
     )
+    fee_return_percentage = fields.Float(
+        default=0,
+        help="% of the fee to be returned to the customer in case of full return. "
+        "E.g.: 0% for no return, 100% for full return",
+    )

delivery_fee/models/res_company.py

@@ -0,0 +1,11 @@
+# Copyright 2026 Moduon
+# License LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl).
+from odoo import fields, models
+
+
+class ResCompany(models.Model):
+    _inherit = "res.company"
+
+    one_delivery_fee_by_sale_order = fields.Boolean(
+        help="The delivery fee will be applied just once to the order",
+    )

delivery_fee/models/res_config_settings.py

@@ -0,0 +1,12 @@
+# Copyright 2026 Moduon
+# License LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl).
+from odoo import fields, models
+
+
+class ResConfigSetting(models.TransientModel):
+    _inherit = "res.config.settings"
+
+    one_delivery_fee_by_sale_order = fields.Boolean(
+        related="company_id.one_delivery_fee_by_sale_order",
+        readonly=False,
+    )

delivery_fee/models/sale_order.py

@@ -6,6 +6,22 @@
 class SaleOrder(models.Model):
     _inherit = "sale.order"
 
+    all_fee_pickings_returned = fields.Boolean(
+        compute="_compute_all_fee_pickings_returned"
+    )
+
+    def _compute_all_fee_pickings_returned(self):
+        self.all_fee_pickings_returned = False
+        for order in self:
+            if not order.order_line.filtered("is_delivery_fee"):
+                continue
+            pickings = order.picking_ids.filtered(
+                lambda x: x._is_to_external_location()
+            )
+            order.all_fee_pickings_returned = all(
+                pick._full_returned() for pick in pickings
+            )
+
     def _prepare_delivery_fee_line_vals(self, picking):
         # Based on core `_prepare_delivery_line_vals`
         carrier = picking.carrier_id
@@ -47,6 +63,12 @@ def _create_delivery_fee_line(self, picking):
         values = self._prepare_delivery_fee_line_vals(picking)
         return self.env["sale.order.line"].sudo().create(values)
 
+    def copy(self, default=None):
+        sale_copy = super().copy(default)
+        # Don't copy fees from one order to another
+        sale_copy.order_line.filtered("is_delivery_fee").unlink()
+        return sale_copy
+
 
 class SaleOrderLine(models.Model):
     _inherit = "sale.order.line"

delivery_fee/models/stock_picking.py

@@ -1,21 +1,66 @@
 # Copyright 2026 Moduon
 # License LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl).
 from odoo import models
+from odoo.tools.float_utils import float_compare
 
 
 class StockPicking(models.Model):
     _inherit = "stock.picking"
 
-    def _add_delivery_cost_to_so(self):
-        res = super()._add_delivery_cost_to_so()
-        self._add_delivery_fee_to_order()
+    def _action_done(self):
+        res = super()._action_done()
+        # For returns, we deal with fee reimburse
+        if self.move_ids.origin_returned_move_id:
+            self._update_delivery_fee_on_return()
+        else:
+            self._add_delivery_fee_to_order()
         return res
 
+    def _full_returned(self):
+        full_returned = False
+        for move in self.move_ids:
+            full_returned = not float_compare(
+                move.quantity_done,
+                sum(
+                    move.returned_move_ids.filtered(lambda x: x.state == "done").mapped(
+                        "quantity_done"
+                    )
+                ),
+                precision_rounding=move.product_uom.rounding,
+            )
+            if not full_returned:
+                break
+        return full_returned
+
+    def _update_delivery_fee_on_return(self):
+        """All pickings returned: we can refund the fee"""
+        sale = self.move_ids.origin_returned_move_id.picking_id.sale_id
+        if not sale.all_fee_pickings_returned:
+            return
+        for fee_line in sale.order_line.filtered("is_delivery_fee"):
+            carrier = fee_line.delivery_fee_picking_id.carrier_id
+            # No fee refund for this carrier
+            if not carrier.fee_return_percentage:
+                continue
+            # We change the initial demand so the type of invoicing policy doesn't
+            # affect in order to trigger the refund.
+            fee_line.product_uom_qty = (
+                fee_line.product_uom_qty
+                - (fee_line.product_uom_qty * carrier.fee_return_percentage) / 100
+            )
+
     def _add_delivery_fee_to_order(self):
         if (
-            not self.sale_id
+            self.picking_type_code != "outgoing"
+            or not self.sale_id
             or self.partner_id.delivery_fee_exemption
             or not self.carrier_id.fee_product_id
         ):
             return
+        # In the case we want to apply the fee just once
+        if (
+            self.company_id.one_delivery_fee_by_sale_order
+            and self.sale_id.order_line.filtered("is_delivery_fee")
+        ):
+            return
         self.sale_id._create_delivery_fee_line(self)

delivery_fee/reports/delivery_slip_report.xml

@@ -5,9 +5,13 @@
         inherit_id="delivery.report_delivery_document2"
     >
         <xpath expr="//div[hasclass('page')]" position="inside">
-            <t t-set="fee_product" t-value="o.carrier_id.fee_product_id" />
+            <t
+                t-set="fee_line"
+                t-value="o.sale_id.order_line.filtered(lambda x: x.is_delivery_fee and x.delivery_fee_picking_id == o)"
+            />
+            <t t-set="fee_product" t-value="fee_line and fee_line.product_id" />
             <div
-                t-if="o.sale_id and fee_product.description_sale and not o.partner_id.delivery_fee_exemption"
+                t-if="fee_product and fee_product.description_sale and not o.partner_id.delivery_fee_exemption"
             >
                 <p class="mt-5 fw-bolder fst-italic">
                     <img

delivery_fee/tests/test_delivery_fee.py

@@ -31,6 +31,7 @@ def setUpClass(cls):
                 "product_id": cls.delivery_product.id,
                 "fixed_price": 5.0,
                 "fee_product_id": cls.fee_product.id,
+                "fee_return_percentage": 75,
             }
         )
         cls.carrier_without_fee = cls.env["delivery.carrier"].create(
@@ -69,30 +70,153 @@ def setUpClass(cls):
                 ],
             }
         )
+        # Defaults to `False`, but it's useful to declare it explicitly for local tests
+        cls.env.company.one_delivery_fee_by_sale_order = False
 
-    def test_delivery_fee_added_on_picking_validation(self):
-        """Test that delivery fee is added when picking is validated"""
+    def _validate_picking(self, picking):
+        picking.action_set_quantities_to_reservation()
+        picking._action_done()
+
+    def _picking_return(self, picking, qty=None):
+        stock_return_picking_form = Form(
+            self.env["stock.return.picking"].with_context(
+                active_ids=picking.ids,
+                active_id=picking.id,
+                active_model="stock.picking",
+            )
+        )
+        stock_return_picking = stock_return_picking_form.save()
+        if qty:
+            stock_return_picking.product_return_moves.quantity = qty
+        stock_return_picking_action = stock_return_picking.create_returns()
+        return_pick = self.env["stock.picking"].browse(
+            stock_return_picking_action["res_id"]
+        )
+        self._validate_picking(return_pick)
+        return return_pick
+
+    def _add_line_to_sale_order(self, sale):
+        so_form = Form(self.sale_order)
+        with so_form.order_line.new() as line:
+            line.product_id = self.product
+        so_form.save()
+
+    def _test_regex_in_report(self, report, res_ids, expression, expected_in_html=True):
+        """Helper method to test whether or not a regular expression should be
+        expected in the report resulting rendering"""
+        html, _ = self.env["ir.actions.report"]._render_qweb_html(report, res_ids)
+        assertion = self.assertRegex if expected_in_html else self.assertNotRegex
+        assertion(str(html), expression)
+
+    def _common_test_delivery_fee_added_on_picking_validation(self):
         self.sale_order.carrier_id = self.carrier_with_fee
         self.sale_order.action_confirm()
         picking = self.sale_order.picking_ids
-        picking.action_set_quantities_to_reservation()
-        picking._action_done()
+        self._validate_picking(picking)
         fee_lines = self.sale_order.order_line.filtered("is_delivery_fee")
         self.assertEqual(len(fee_lines), 1)
         self.assertEqual(fee_lines.price_unit, 2.0)
-        # TODO: test render
-        # TODO: test invoice
-        # TODO: test multiple fees
+        # The fee text is printed
+        self._test_regex_in_report(
+            "stock.report_deliveryslip",
+            picking.ids,
+            r"Delivery fee charged per shipment.+2",
+        )
+
+    def _common_fee_added_on_picking_validation_refund(self):
+        """"""
+        picking_2, picking_1 = self.sale_order.picking_ids
+        return_pick_1 = self._picking_return(picking_1)
+        # The fee shouldn't show up in returns
+        self._test_regex_in_report(
+            "stock.report_deliveryslip",
+            return_pick_1.ids,
+            r"Delivery fee charged per shipment",
+            expected_in_html=False,
+        )
+        self.assertFalse(self.sale_order.all_fee_pickings_returned)
+        picking_1_fee = self.sale_order.order_line.filtered(
+            lambda x, pick=picking_1: x.is_delivery_fee
+            and x.delivery_fee_picking_id == pick
+        )
+        self.assertAlmostEqual(picking_1_fee.price_subtotal, 2)
+        self.assertAlmostEqual(picking_1_fee.product_uom_qty, 1)
+        return_pick_2 = self._picking_return(picking_2)
+        self._test_regex_in_report(
+            "stock.report_deliveryslip",
+            return_pick_2.ids,
+            r"Delivery fee charged per shipment",
+            expected_in_html=False,
+        )
+        self.assertTrue(self.sale_order.all_fee_pickings_returned)
+        self.assertAlmostEqual(picking_1_fee.price_subtotal, 0.50)
+        self.assertAlmostEqual(picking_1_fee.product_uom_qty, 0.25)
+
+    def test_delivery_fee_added_on_picking_validation(self):
+        """Test that delivery fee is added when picking is validated"""
+        self._common_test_delivery_fee_added_on_picking_validation()
+        existing_picking = self.sale_order.picking_ids
+        # Let's add a new picking
+        self._add_line_to_sale_order(self.sale_order)
+        new_picking = self.sale_order.picking_ids - existing_picking
+        self._validate_picking(new_picking)
+        fee_lines = self.sale_order.order_line.filtered("is_delivery_fee")
+        self.assertEqual(len(fee_lines), 2)
+        self._test_regex_in_report(
+            "stock.report_deliveryslip",
+            new_picking.ids,
+            r"Delivery fee charged per shipment.+2",
+        )
+        # The fee is printed in the invoice report as well
+        invoice = self.sale_order._create_invoices()
+        self._test_regex_in_report(
+            "account.report_invoice",
+            invoice.ids,
+            r"Delivery fee charged per shipment.+2",
+        )
+        self._common_fee_added_on_picking_validation_refund()
+
+    def test_delivery_fee_added_on_picking_validation_one_fee_per_order(self):
+        """Same tests as before, but now only one fee is added when the first
+        picking is validated"""
+        self.env.company.one_delivery_fee_by_sale_order = True
+        self._common_test_delivery_fee_added_on_picking_validation()
+        existing_picking = self.sale_order.picking_ids
+        # Let's add a new picking
+        self._add_line_to_sale_order(self.sale_order)
+        new_picking = self.sale_order.picking_ids - existing_picking
+        self._validate_picking(new_picking)
+        fee_lines = self.sale_order.order_line.filtered("is_delivery_fee")
+        self.assertEqual(len(fee_lines), 1, "The fee should be added just once!")
+        self._test_regex_in_report(
+            "stock.report_deliveryslip",
+            new_picking.ids,
+            r"Delivery fee charged per shipment",
+            expected_in_html=False,
+        )
+        # The fee is printed in the invoice report as well
+        invoice = self.sale_order._create_invoices()
+        self._test_regex_in_report(
+            "account.report_invoice",
+            invoice.ids,
+            r"Delivery fee charged per shipment.+2",
+        )
+        self._common_fee_added_on_picking_validation_refund()
 
     def test_no_fee_for_carrier_without_fee_product(self):
         """Test that no fee is added if carrier has no fee product"""
         self.sale_order.carrier_id = self.carrier_without_fee
         self.sale_order.action_confirm()
         picking = self.sale_order.picking_ids
-        picking.move_ids.quantity_done = 1
-        picking._action_done()
+        self._validate_picking(picking)
         fee_lines = self.sale_order.order_line.filtered("is_delivery_fee")
         self.assertEqual(len(fee_lines), 0)
+        self._test_regex_in_report(
+            "stock.report_deliveryslip",
+            picking.ids,
+            r"Delivery fee charged per shipment",
+            expected_in_html=False,
+        )
 
     def test_exempt_customer_no_fee(self):
         """Test that exempt customers don't get charged delivery fees"""
@@ -102,7 +226,12 @@ def test_exempt_customer_no_fee(self):
         self.sale_order.carrier_id = self.carrier_with_fee
         self.sale_order.action_confirm()
         picking = self.sale_order.picking_ids
-        picking.move_ids.quantity_done = 1
-        picking._action_done()
+        self._validate_picking(picking)
         fee_lines = self.sale_order.order_line.filtered("is_delivery_fee")
         self.assertEqual(len(fee_lines), 0)
+        self._test_regex_in_report(
+            "stock.report_deliveryslip",
+            picking.ids,
+            r"Delivery fee charged per shipment",
+            expected_in_html=False,
+        )

delivery_fee/views/delivery_carrier_views.xml

@@ -9,6 +9,10 @@
                     name="fee_product_id"
                     context="{'default_detailed_type': 'service', 'default_sale_ok': False, 'default_purchase_ok': False, 'default_invoice_policy': 'order'}"
                 />
+                <field
+                    name="fee_return_percentage"
+                    attrs="{'invisible': [('fee_product_id', '=', False)]}"
+                />
             </xpath>
         </field>
     </record>