[REF] l10n_it_delivery_note: refactoring invoice generation and preserving sales lines in invoice lines including notes and sections

Co-authored-by: Babbato <abarbato@dinamicheaziendali.it>

Author: Borruso

l10n_it_delivery_note/models/sale_order.py

@@ -129,9 +129,9 @@ def _create_invoices(self, grouped=False, final=False, date=None):
         # - "Create Invoice" button should appear only when new delivery notes exist
         # This would avoid bypassing standard invoicing when delivery notes exist
         # but user wants to invoice directly (e.g., for multi-delivery orders).
-        if self.delivery_note_ids:
+        if any(dn.invoice_status == "to invoice" for dn in self.delivery_note_ids):
             self.delivery_note_ids.action_invoice(
-                invoice_method="service", final=final, sale_orders=self
+                invoice_method="service", final=final, sale_orders=self, grouped=grouped
             )
             # Assign delivery notes to invoices and update statuses
             self._assign_delivery_notes_invoices(self.invoice_ids.ids)

l10n_it_delivery_note/models/stock_delivery_note.py

@@ -5,6 +5,7 @@
 # License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
 
 import datetime
+from itertools import groupby
 
 from odoo import Command, api, fields, models
 from odoo.exceptions import AccessError, UserError
@@ -701,6 +702,80 @@ def _prepare_invoice(self, sale_orders):
         )
         return invoice_vals
 
+    def _build_dn_map(self, sale_orders):
+        """Map delivery note lines by sale_line_id."""
+        dn_map = {}
+        for dn in self.sorted(key=lambda d: (d.date, d.name)):
+            for line in dn.line_ids:
+                if line.sale_line_id and (
+                    not sale_orders or line.sale_line_id.order_id in sale_orders
+                ):
+                    dn_map.setdefault(line.sale_line_id.id, []).append((dn, line))
+        return dn_map
+
+    def _append_dn_linked_lines(self, vals_list, dn_map, sequence, current_dn):
+        """Append product lines coming from delivery notes, grouped by DN."""
+        account_move = self.env["account.move"]
+
+        for dn, dn_line in dn_map:
+            if current_dn != dn:
+                vals_list.append(
+                    Command.create(account_move._prepare_note_dn_value(sequence, dn))
+                )
+                sequence += 1
+                current_dn = dn
+
+            if returned_moves := dn_line.mapped("move_id.returned_move_ids"):
+                return_qty = sum(returned_moves.mapped("quantity"))
+                product_qty = dn_line.product_qty - return_qty
+            else:
+                product_qty = dn_line.product_qty
+
+            vals = dn_line._prepare_invoice_line(
+                sequence=sequence,
+                quantity=product_qty,
+            )
+            vals_list.append(Command.create(vals))
+            sequence += 1
+
+        return sequence, current_dn
+
+    def _append_sale_order_lines(self, vals_list, sale_orders, dn_map, sequence):
+        """Append invoice lines from sale orders preserving SO line order."""
+        current_dn = None
+        for order in sale_orders:
+            so_lines = order.order_line.sorted(key=lambda ln: ln.sequence)
+
+            for line in so_lines:
+                # Add SO lines notes/sections
+                if line.display_type and not line.is_downpayment:
+                    vals = line._prepare_invoice_line(sequence=sequence)
+                    vals_list.append(Command.create(vals))
+                    sequence += 1
+                    continue
+
+                if line.id in dn_map and line.order_id == order:
+                    # Add delivery note lines
+                    sequence, current_dn = self._append_dn_linked_lines(
+                        vals_list=vals_list,
+                        dn_map=dn_map[line.id],
+                        sequence=sequence,
+                        current_dn=current_dn,
+                    )
+                else:
+                    # Add remaining SO lines not in delivery notes
+                    if (
+                        line.product_id.type != "service"
+                        and line.qty_to_invoice > 0
+                        and not line.is_downpayment
+                    ):
+                        vals = line._prepare_invoice_line(sequence=sequence)
+                        vals["sale_line_ids"] = [Command.link(line.id)]
+                        vals_list.append(Command.create(vals))
+                        sequence += 1
+
+        return sequence
+
     def _prepare_invoice_lines(self, sale_orders, invoice_method, final):
         """Creates invoice lines from delivery note lines,
         sorting delivery notes by date and name.
@@ -717,48 +792,16 @@ def _prepare_invoice_lines(self, sale_orders, invoice_method, final):
         Sets the created lines in the invoice values dictionary"""
         vals_list = []
         sequence = 1
-        account_move = self.env["account.move"]
-
-        # Add delivery note lines as sections
-        for dn in self.sorted(key=lambda d: (d.date, d.name)):
-            vals_list.append(
-                Command.create(account_move._prepare_note_dn_value(sequence, dn))
-            )
-            sequence += 1
 
-            # Get delivery note lines, filtered by sale_orders if provided
-            dn_line_ids = dn.line_ids
-            if sale_orders:
-                dn_line_ids = dn_line_ids.filtered(
-                    lambda line: line.sale_line_id
-                    and line.sale_line_id.order_id in sale_orders
-                )
+        dn_map = self._build_dn_map(sale_orders)
 
-            # Add delivery note lines
-            for line in dn_line_ids:
-                if line.mapped("move_id.returned_move_ids"):
-                    return_qty = sum(line.mapped("move_id.returned_move_ids.quantity"))
-                    product_qty = line.product_qty - return_qty
-                else:
-                    product_qty = line.product_qty
-                vals = line._prepare_invoice_line(
-                    sequence=sequence, quantity=product_qty
-                )
-                vals_list.append(Command.create(vals))
-                sequence += 1
-
-        # Add remaining SO lines not in delivery notes
         if sale_orders:
-            sale_lines = sale_orders.mapped("order_line").filtered(
-                lambda ol: not ol.delivery_note_line_ids
-                and ol.product_id.type != "service"
-                and ol.qty_to_invoice > 0
+            sequence = self._append_sale_order_lines(
+                vals_list=vals_list,
+                sale_orders=sale_orders,
+                dn_map=dn_map,
+                sequence=sequence,
             )
-            for line in sale_lines:
-                vals = line._prepare_invoice_line(sequence=sequence)
-                vals["sale_line_ids"] = [(4, line.id)]
-                vals_list.append(Command.create(vals))
-                sequence += 1
 
         # Add service lines if requested
         if invoice_method == "service":
@@ -769,7 +812,7 @@ def _prepare_invoice_lines(self, sale_orders, invoice_method, final):
             )
             for line in service_lines:
                 vals = line._prepare_invoice_line(sequence=sequence)
-                vals["sale_line_ids"] = [(4, line.id)]
+                vals["sale_line_ids"] = [Command.link(line.id)]
                 vals_list.append(Command.create(vals))
                 sequence += 1
 
@@ -799,7 +842,7 @@ def _prepare_invoice_lines(self, sale_orders, invoice_method, final):
 
         return vals_list
 
-    def _update_invoice_statuses(self, invoice, sale_orders):
+    def _update_invoice_statuses(self, invoices, sale_orders):
         """Update invoice statuses after invoice creation"""
         # Get all delivery note lines with sale orders
         delivery_note_lines = self.mapped("line_ids").filtered(
@@ -817,20 +860,92 @@ def _update_invoice_statuses(self, invoice, sale_orders):
 
         # Link invoice to delivery notes
         for delivery_note in self:
-            delivery_note.write({"invoice_ids": [(4, invoice.id)]})
+            delivery_note.write(
+                {"invoice_ids": [Command.link(invoice.id) for invoice in invoices]}
+            )
 
         # Recompute overall invoice status
         self._compute_invoice_status()
 
-    def action_invoice(self, invoice_method=False, final=False, sale_orders=None):
+    def _build_invoice_vals_list(
+        self, sale_orders, delivery_notes, invoice_method=False, final=False
+    ):
+        invoice_vals_list = []
+
+        orders = delivery_notes.sale_ids & sale_orders
+        invoice_vals = delivery_notes._prepare_invoice(orders)
+        invoice_vals["invoice_line_ids"] = delivery_notes._prepare_invoice_lines(
+            orders, invoice_method, final
+        )
+        invoice_vals_list.append(invoice_vals)
+
+        return invoice_vals_list
+
+    def _group_invoice_vals(self, invoice_vals_list, sale_orders):
+        new_invoice_vals_list = []
+        invoice_grouping_keys = sale_orders._get_invoice_grouping_keys()
+
+        invoice_vals_list = sorted(
+            invoice_vals_list,
+            key=lambda vals: [vals.get(k) for k in invoice_grouping_keys],
+        )
+
+        for _keys, invoices in groupby(
+            invoice_vals_list,
+            key=lambda vals: [vals.get(k) for k in invoice_grouping_keys],
+        ):
+            grouped_vals = None
+            origins = set()
+            payment_refs = set()
+            refs = set()
+
+            for invoice_vals in invoices:
+                if not grouped_vals:
+                    grouped_vals = invoice_vals
+                else:
+                    grouped_vals["invoice_line_ids"] += invoice_vals["invoice_line_ids"]
+
+                if invoice_vals.get("invoice_origin"):
+                    origins.add(invoice_vals["invoice_origin"])
+                if invoice_vals.get("payment_reference"):
+                    payment_refs.add(invoice_vals["payment_reference"])
+                if invoice_vals.get("ref"):
+                    refs.add(invoice_vals["ref"])
+
+            grouped_vals.update(
+                {
+                    "ref": ", ".join(refs)[:2000],
+                    "invoice_origin": ", ".join(origins),
+                    "payment_reference": payment_refs.pop()
+                    if len(payment_refs) == 1
+                    else False,
+                }
+            )
+            new_invoice_vals_list.append(grouped_vals)
+
+        return new_invoice_vals_list
+
+    def action_invoice(
+        self, invoice_method=False, final=False, sale_orders=None, grouped=False
+    ):
         delivery_note_ids = self.filtered(
             lambda dn: dn.state == "confirm" and dn.invoice_status == "to invoice"
         )
         delivery_note_ids._check_delivery_notes_before_invoicing()
 
         # If not passed explicitly, get all sale orders from delivery notes
-        if sale_orders is None:
-            sale_orders = delivery_note_ids.sale_ids
+        sale_orders = sale_orders or delivery_note_ids.sale_ids
+        if not sale_orders:
+            return self.env["account.move"]
+
+        # Check if the user has access rights to create invoices
+        if not self.env["account.move"].check_access("create"):
+            try:
+                self.check_access("write")
+            except AccessError:
+                return self.env["account.move"]
+
+        moves = self.env["account.move"]
 
         # Group by payment term (include empty payment term)
         payment_terms = sale_orders.payment_term_id or [False]
@@ -850,13 +965,6 @@ def action_invoice(self, invoice_method=False, final=False, sale_orders=None):
             if not filtered_sales:
                 continue
 
-            # Check if the user has access rights to create invoices
-            if not self.env["account.move"].check_access("create"):
-                try:
-                    self.check_access("write")
-                except AccessError:
-                    return self.env["account.move"]
-
             # Filter delivery notes related to the sale orders
             filter_delivery_notes = delivery_note_ids.filtered(
                 lambda dn, so=filtered_sales: all(
@@ -865,36 +973,58 @@ def action_invoice(self, invoice_method=False, final=False, sale_orders=None):
                 or all(so_id in dn.sale_ids.ids for so_id in so.ids)
             )
 
-            # Prepare invoice
-            invoice_vals = filter_delivery_notes._prepare_invoice(filtered_sales)
-
-            # Prepare invoice lines
-            vals_list = filter_delivery_notes._prepare_invoice_lines(
-                filtered_sales, invoice_method, final
+            # prepare invoice lines for every SO
+            invoice_vals_list = self._build_invoice_vals_list(
+                filtered_sales, filter_delivery_notes, invoice_method, final
             )
+            if not invoice_vals_list:
+                continue
 
-            # invoice creation
-            invoice_vals["invoice_line_ids"] = vals_list
-            invoice_id = (
-                self.env["account.move"]
-                .sudo()
-                .with_context(default_move_type="out_invoice")
-                .create(invoice_vals)
-            )
+            #  GROUPING
+            if not grouped:
+                invoice_vals_list = self._group_invoice_vals(
+                    invoice_vals_list, sale_orders
+                )
+
+            for invoice_vals in invoice_vals_list:
+                sequence = 1
+                for line in invoice_vals.get("invoice_line_ids", []):
+                    if len(line) >= 3 and isinstance(line[2], dict):
+                        line[2]["sequence"] = self.env[
+                            "sale.order.line"
+                        ]._get_invoice_line_sequence(
+                            new=sequence,
+                            old=line[2].get("sequence"),
+                        )
+                        sequence += 1
 
-            # Update statuses
-            filter_delivery_notes._update_invoice_statuses(invoice_id, filtered_sales)
+            # CREATE invoices
+            moves = self.env["account.move"]
+
+            for invoice_vals in invoice_vals_list:
+                move = (
+                    self.env["account.move"]
+                    .sudo()
+                    .with_context(default_move_type="out_invoice")
+                    .create(invoice_vals)
+                )
+                moves |= move
+
+            # update delivery notes status
+            filter_delivery_notes._update_invoice_statuses(moves, sale_orders)
 
             # Some moves might actually be refunds: convert them if the total amount is
             # negative.
             # We do this after the moves have been created since we need taxes, etc.
             # to know if the total is actually negative or not
             if final and (
-                move_to_switch := invoice_id.sudo().filtered(lambda m: m.amount_total < 0)
+                moves_to_switch := moves.sudo().filtered(lambda m: m.amount_total < 0)
             ):
-                with self.env.protecting([invoice_id._fields["team_id"]], move_to_switch):
-                    move_to_switch.action_switch_move_type()
-                    invoice_id._set_reversed_entry(move_to_switch)
+                with self.env.protecting([moves._fields["team_id"]], moves_to_switch):
+                    moves_to_switch.action_switch_move_type()
+                    sale_orders.invoice_ids._set_reversed_entry(moves_to_switch)
+
+        return moves
 
     def action_done(self):
         self.write({"state": DOMAIN_DELIVERY_NOTE_STATES[3]})
@@ -972,7 +1102,7 @@ def _create_detail_lines(self, move_ids):
         moves = self.env["stock.move"].browse(move_ids)
         lines_vals = self.env["stock.delivery.note.line"]._prepare_detail_lines(moves)
 
-        self.write({"line_ids": [(0, False, vals) for vals in lines_vals]})
+        self.write({"line_ids": [Command.create(vals) for vals in lines_vals]})
 
     def _delete_detail_lines(self, move_ids):
         if not move_ids:
@@ -982,7 +1112,7 @@ def _delete_detail_lines(self, move_ids):
             [("move_id", "in", move_ids)]
         )
 
-        self.write({"line_ids": [(2, line.id, False) for line in lines]})
+        self.write({"line_ids": [Command.delete(line.id) for line in lines]})
 
     def update_detail_lines(self):
         for note in self: