add account_invoice_send_on_reconcile (#219)

Author: jans23

account_invoice_send_on_reconcile/README.md

@@ -0,0 +1,31 @@
+# Account Invoice Send on Reconcile
+
+## Overview
+
+This Odoo 15.0 module automatically sends customer invoice emails when bank payments are
+reconciled with invoices from bank statements.
+
+## Features
+
+- **Automatic Invoice Sending**: When reconciling bank statement lines with customer
+  invoices, the module automatically sends the invoice email to the customer
+- **Duplicate Prevention**: Uses the `is_move_sent` flag to prevent sending duplicate
+  emails
+- **Smart Filtering**: Only sends for:
+  - Posted customer invoices
+  - Fully paid invoices
+  - Invoices not already marked as sent
+- **Error Handling**: Email sending errors are logged but don't break the reconciliation
+  process
+
+## Configuration
+
+No configuration required. The module works automatically once installed.
+
+## Usage
+
+1. Navigate to Accounting > Dashboard > Bank
+2. Import or create bank statement lines
+3. Reconcile statement lines with customer invoices
+4. The module automatically sends invoice emails for reconciled, fully-paid invoices
+5. Check the invoice's "Sent" status to confirm

account_invoice_send_on_reconcile/__init__.py

@@ -0,0 +1,3 @@
+# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
+
+from . import models

account_invoice_send_on_reconcile/__manifest__.py

@@ -0,0 +1,16 @@
+{
+    "name": "Account Invoice Send on Reconcile",
+    "version": "15.0.1.0.0",
+    "category": "Accounting",
+    "author": "Nitrokey GmbH",
+    "license": "AGPL-3",
+    "website": "https://github.com/OCA/server-tools",
+    "summary": "Automatically send invoice emails when reconciling bank payments",
+    "depends": [
+        "account",
+        "payment",
+    ],
+    "data": [],
+    "installable": True,
+    "auto_install": False,
+}

account_invoice_send_on_reconcile/models/__init__.py

@@ -0,0 +1,3 @@
+# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
+
+from . import account_move_line

account_invoice_send_on_reconcile/models/account_move_line.py

@@ -0,0 +1,90 @@
+# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
+
+import logging
+
+from odoo import models
+
+_logger = logging.getLogger(__name__)
+
+
+class AccountMoveLine(models.Model):
+    _inherit = "account.move.line"
+
+    def reconcile(self):
+        """Override to automatically send invoice emails after reconciliation.
+
+        This method is called when move lines are reconciled, including
+        bank statement reconciliation and payment register.
+        """
+        # Call parent method to perform standard reconciliation
+        res = super().reconcile()
+
+        # Get all invoices from the reconciled move lines
+        invoices = self.mapped("move_id").filtered(
+            lambda m: m.is_invoice(include_receipts=True)
+        )
+
+        for invoice in invoices:
+            # Skip if not a valid invoice for sending
+            if not self._should_send_invoice_after_reconciliation(invoice):
+                continue
+
+            # Send invoice email with error handling
+            try:
+                _logger.info(
+                    "Sending invoice email for %s after reconciliation",
+                    invoice.name,
+                )
+
+                # Get email context from action_invoice_sent
+                action_dict = invoice.action_invoice_sent()
+                if action_dict and action_dict.get("context"):
+                    email_ctx = action_dict["context"]
+                    invoice.with_context(**email_ctx).message_post_with_template(
+                        email_ctx.get("default_template_id")
+                    )
+
+                # Mark invoice as sent
+                invoice.write({"is_move_sent": True})
+
+                _logger.info("Successfully sent invoice email for %s", invoice.name)
+            except Exception as e:
+                # Log error but don't break reconciliation process
+                _logger.error(
+                    "Failed to send invoice email for %s: %s",
+                    invoice.name,
+                    str(e),
+                    exc_info=True,
+                )
+
+        return res
+
+    def _should_send_invoice_after_reconciliation(self, invoice):
+        """Determine if invoice should be sent after bank statement reconciliation.
+
+        Checks multiple conditions:
+        - Invoice must be posted
+        - Must be customer invoice (out_invoice only)
+        - Must be fully paid
+        - Must not already be sent
+
+        Args:
+            invoice: account.move record
+
+        Returns:
+            bool: True if invoice should be sent, False otherwise
+        """
+        # Check basic invoice conditions
+        if invoice.state != "posted":
+            return False
+
+        if invoice.move_type != "out_invoice":
+            return False
+
+        if invoice.payment_state != "paid":
+            return False
+
+        if invoice.is_move_sent:
+            return False
+
+        return True

account_invoice_send_on_reconcile/tests/__init__.py

@@ -0,0 +1,3 @@
+# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
+
+from . import test_invoice_send_on_reconcile

account_invoice_send_on_reconcile/tests/common.py

@@ -0,0 +1,156 @@
+# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
+
+import logging
+
+from odoo.tests.common import TransactionCase
+
+_logger = logging.getLogger(__name__)
+
+
+class TestCommon(TransactionCase):
+    """Base test class with tracking disabled."""
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.env = cls.env(context=dict(cls.env.context, tracking_disable=True))
+
+
+class TestInvoiceSendOnReconcileMixin:
+    """Mixin with helper methods for invoice send on reconcile tests."""
+
+    def create_partner(self, name="Test Partner", email="[email protected]"):
+        """Create a test partner with email."""
+        return self.env["res.partner"].create(
+            {
+                "name": name,
+                "email": email,
+            }
+        )
+
+    def create_product(self, name="Test Product", price=100.0):
+        """Create a test product."""
+        return self.env["product.product"].create(
+            {
+                "name": name,
+                "list_price": price,
+                "type": "service",
+            }
+        )
+
+    def create_invoice(self, partner, product, amount=100.0, move_type="out_invoice"):
+        """Create a customer invoice.
+
+        Args:
+            partner: res.partner record
+            product: product.product record
+            amount: invoice amount
+            move_type: 'out_invoice', 'out_refund', 'in_invoice', etc.
+
+        Returns:
+            account.move record
+        """
+        invoice = self.env["account.move"].create(
+            {
+                "partner_id": partner.id,
+                "move_type": move_type,
+                "invoice_line_ids": [
+                    (
+                        0,
+                        0,
+                        {
+                            "product_id": product.id,
+                            "name": product.name,
+                            "quantity": 1,
+                            "price_unit": amount,
+                        },
+                    )
+                ],
+            }
+        )
+        return invoice
+
+    def create_bank_journal(self, name="Bank", code="BNK1"):
+        """Create a bank journal for payments."""
+        return self.env["account.journal"].create(
+            {
+                "name": name,
+                "code": code,
+                "type": "bank",
+            }
+        )
+
+    def reconcile_invoice_with_payment(self, invoice, journal=None):
+        """Reconcile invoice with a payment using account.payment.register wizard.
+
+        Args:
+            invoice: account.move record (must be posted)
+            journal: account.journal record (optional, uses first bank journal if not provided)
+
+        Returns:
+            dict: Result from _reconcile_payments
+        """
+        if journal is None:
+            journal = self.env["account.journal"].search(
+                [("type", "=", "bank")], limit=1
+            )
+            if not journal:
+                journal = self.create_bank_journal()
+
+        # Create payment register wizard
+        ctx = {
+            "active_model": "account.move",
+            "active_ids": invoice.ids,
+        }
+
+        payment_register = (
+            self.env["account.payment.register"]
+            .with_context(**ctx)
+            .create(
+                {
+                    "journal_id": journal.id,
+                }
+            )
+        )
+
+        # Process the payment (this calls _reconcile_payments internally)
+        result = payment_register.action_create_payments()
+
+        return result
+
+    def get_sent_mail_count(self, invoice):
+        """Get count of sent mails for an invoice.
+
+        Args:
+            invoice: account.move record
+
+        Returns:
+            int: Number of mail.mail records for this invoice
+        """
+        return self.env["mail.mail"].search_count(
+            [
+                ("model", "=", "account.move"),
+                ("res_id", "=", invoice.id),
+            ]
+        )
+
+    def create_payment_acquirer(self, provider="paypal"):
+        """Create a payment acquirer for testing online payments.
+
+        Args:
+            provider: Provider name (paypal, stripe, etc.)
+
+        Returns:
+            payment.acquirer record
+        """
+        vals = {
+            "name": f"Test {provider.title()}",
+            "provider": provider,
+            "state": "test",
+        }
+
+        # Add provider-specific required fields
+        if provider == "paypal":
+            vals["paypal_email_account"] = "[email protected]"
+
+        return self.env["payment.acquirer"].create(vals)