[IMP] account_internal_transfer: sync amounts and rates for paired payments

Add synchronization logic for paired internal transfer payments:
- Sync counterpart_currency_amount between paired payments for cross-currency transfers
- Sync amounts when counterpart_currency_amount or rate fields change
- Sync journal changes (swapped relationship between payment and paired)
- Preserve exact manual rates by using inverted rate (1/rate) instead of calculating from rounded amounts
- Add comprehensive test suite covering amount sync, rate sync, and edge cases
- Prevent recursion with skip_paired_payment_update context flag

Technical details:
- Enhanced write() method to detect paired payment changes
- Support for payment_pro module fields (counterpart_rate, amount_exact, etc.)
- Use float_compare for rate comparison to handle floating-point precision
- Handle both payment_pro enabled/disabled scenarios

Change note: Se implementó la sincronización automática de montos y tipos de cambio en transferencias internas entre cuentas con diferentes monedas. Cuando se modifica el monto convertido o el tipo de cambio en un pago, el sistema ahora actualiza automáticamente el pago pareado con los valores correspondientes. Además, cuando se establece un tipo de cambio manual (ej. 1500 ARS/USD), ambos movimientos muestran exactamente la misma tasa, evitando valores con decimales generados por redondeo.

Author: cav-adhoc

account_internal_transfer/models/account_payment.py

@@ -1,6 +1,7 @@
 from odoo import _, api, fields, models
 from odoo.exceptions import UserError, ValidationError
 from odoo.fields import Domain
+from odoo.tools import float_compare
 
 
 class AccountPayment(models.Model):
@@ -249,14 +250,65 @@ def write(self, vals):
         if self.env.context.get("skip_paired_payment_update"):
             return res
 
-        # Update paired payment when amount or journal changes
+        # Update paired payment when amount, rate or journal changes
         for payment in self.filtered(lambda p: p.is_internal_transfer and p.paired_internal_transfer_payment_id):
             paired_payment = payment.paired_internal_transfer_payment_id
             updates = {}
 
-            # Sync amount
-            if "amount" in vals and payment.amount != paired_payment.amount:
-                updates["amount"] = payment.amount
+            # Sync amounts: use counterpart_currency_amount for proper cross-currency conversion
+            amount_fields_changed = any(
+                f in vals
+                for f in [
+                    "amount",
+                    "counterpart_currency_amount",
+                    "user_accounting_rate",
+                    "user_counterpart_rate",
+                    "accounting_rate",
+                    "counterpart_rate",
+                ]
+            )
+
+            use_payment_pro = getattr(payment.company_id, "use_payment_pro", False)
+            if amount_fields_changed and use_payment_pro:
+                counterpart_amount = getattr(payment, "counterpart_currency_amount", False)
+                if counterpart_amount:
+                    converted_amount = abs(counterpart_amount)
+                    source_amount = getattr(payment, "amount_exact", False) or payment.amount
+                    if converted_amount != paired_payment.amount:
+                        updates["amount"] = converted_amount
+                        if "amount_exact" in paired_payment._fields:
+                            updates["amount_exact"] = converted_amount
+                    if source_amount != getattr(paired_payment, "counterpart_currency_amount", 0):
+                        updates["counterpart_currency_amount"] = source_amount
+                    # Set rate: use inverted rate if explicitly set, otherwise calculate from amounts
+                    if converted_amount and "counterpart_rate" in paired_payment._fields:
+                        source_rate = getattr(payment, "counterpart_rate", False)
+                        if source_rate:
+                            # Use inverted rate to preserve exact rate value (avoid rounding issues)
+                            updates["counterpart_rate"] = 1.0 / source_rate
+                        else:
+                            # Calculate from amounts when no explicit rate was set
+                            updates["counterpart_rate"] = source_amount / converted_amount
+                elif "amount" in vals:
+                    # Fallback: sync basic amount when counterpart_currency_amount is not available
+                    if payment.amount != paired_payment.amount:
+                        updates["amount"] = payment.amount
+            elif "amount" in vals:
+                if payment.amount != paired_payment.amount:
+                    updates["amount"] = payment.amount
+
+            # Sync rates: invert counterpart_rate because paired payment has swapped currencies
+            rate_fields_changed = any(
+                f in vals
+                for f in ["user_accounting_rate", "user_counterpart_rate", "accounting_rate", "counterpart_rate"]
+            )
+            counterpart_rate = getattr(payment, "counterpart_rate", False)
+            if rate_fields_changed and use_payment_pro and counterpart_rate:
+                inverse_rate = 1.0 / counterpart_rate
+                current_paired_rate = getattr(paired_payment, "counterpart_rate", 0)
+                # Use float_compare with 6 decimal precision to avoid floating-point comparison issues
+                if float_compare(inverse_rate, current_paired_rate, precision_digits=6) != 0:
+                    updates["counterpart_rate"] = inverse_rate
 
             # Sync journals (swapped relationship)
             if "journal_id" in vals and payment.journal_id != paired_payment.destination_journal_id:

account_internal_transfer/tests/__init__.py

@@ -0,0 +1 @@
+from . import test_account_payment

account_internal_transfer/tests/test_account_payment.py

@@ -0,0 +1,223 @@
+from odoo.tests import TransactionCase, tagged
+
+
+@tagged("post_install", "-at_install")
+class TestAccountPaymentInternalTransfer(TransactionCase):
+    """Test internal transfer payment synchronization for amounts and rates"""
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+
+        # Use existing currency and journals to minimize data creation
+        cls.company = cls.env.company
+        cls.usd = cls.env.ref("base.USD")
+        cls.eur = cls.env.ref("base.EUR")
+
+        # Check if payment_pro is available
+        cls.has_payment_pro = "use_payment_pro" in cls.env["res.company"]._fields
+
+        # Get or create minimal journals
+        cls.journal_usd = cls.env["account.journal"].search(
+            [
+                ("type", "in", ["bank", "cash"]),
+                ("company_id", "=", cls.company.id),
+            ],
+            limit=1,
+        )
+
+        cls.journal_eur = cls.env["account.journal"].search(
+            [
+                ("type", "in", ["bank", "cash"]),
+                ("company_id", "=", cls.company.id),
+                ("id", "!=", cls.journal_usd.id),
+            ],
+            limit=1,
+        )
+
+        # Create second journal only if needed
+        if not cls.journal_eur:
+            cls.journal_eur = cls.env["account.journal"].create(
+                {
+                    "name": "Test Bank 2",
+                    "type": "bank",
+                    "code": "TB2",
+                }
+            )
+
+    def _create_paired_payments(self, amount=1000.0):
+        """Helper to create paired payments for testing"""
+        payment = self.env["account.payment"].create(
+            {
+                "payment_type": "outbound",
+                "amount": amount,
+                "journal_id": self.journal_usd.id,
+                "is_internal_transfer": True,
+                "destination_journal_id": self.journal_eur.id,
+            }
+        )
+
+        paired_payment = self.env["account.payment"].create(
+            {
+                "payment_type": "inbound",
+                "amount": amount,
+                "journal_id": self.journal_eur.id,
+                "is_internal_transfer": True,
+                "destination_journal_id": self.journal_usd.id,
+                "paired_internal_transfer_payment_id": payment.id,
+            }
+        )
+        payment.paired_internal_transfer_payment_id = paired_payment
+
+        return payment, paired_payment
+
+    def test_amount_sync_basic(self):
+        """Test basic amount synchronization (works with or without payment_pro)"""
+        payment, paired_payment = self._create_paired_payments()
+
+        # Update amount on source payment
+        payment.write({"amount": 1500.0})
+
+        # Verify paired payment amount was synced
+        self.assertEqual(paired_payment.amount, 1500.0, "Paired payment amount should sync with source payment amount")
+
+    def test_amount_sync_with_counterpart_currency(self):
+        """Test amount synchronization with counterpart_currency_amount (payment_pro)"""
+        if not self.has_payment_pro:
+            self.skipTest("account_payment_pro module is not installed")
+
+        if "counterpart_currency_amount" not in self.env["account.payment"]._fields:
+            self.skipTest("counterpart_currency_amount field not available")
+
+        # Enable payment_pro
+        self.company.use_payment_pro = True
+
+        payment, paired_payment = self._create_paired_payments()
+
+        # Update with counterpart_currency_amount (cross-currency transfer)
+        payment.write(
+            {
+                "counterpart_currency_amount": 850.0,
+            }
+        )
+
+        # Verify paired payment received the converted amount
+        self.assertEqual(paired_payment.amount, 850.0, "Paired payment amount should match counterpart_currency_amount")
+
+        # Verify reverse sync
+        self.assertEqual(
+            paired_payment.counterpart_currency_amount,
+            1000.0,
+            "Paired payment counterpart_currency_amount should be source payment amount",
+        )
+
+    def test_rate_sync_with_inverted_counterpart_rate(self):
+        """Test rate synchronization with inverted counterpart_rate (payment_pro)"""
+        if not self.has_payment_pro:
+            self.skipTest("account_payment_pro module is not installed")
+
+        if "counterpart_rate" not in self.env["account.payment"]._fields:
+            self.skipTest("counterpart_rate field not available")
+
+        # Enable payment_pro
+        self.company.use_payment_pro = True
+
+        payment, paired_payment = self._create_paired_payments()
+
+        # Set a counterpart_rate on the source payment
+        payment.write(
+            {
+                "counterpart_rate": 1.2,
+            }
+        )
+
+        # Verify paired payment has inverted rate (1/1.2)
+        expected_inverse_rate = 1.0 / 1.2
+        self.assertAlmostEqual(
+            paired_payment.counterpart_rate,
+            expected_inverse_rate,
+            places=4,
+            msg="Paired payment counterpart_rate should be inverted (1/rate)",
+        )
+
+    def test_journal_sync_swapped_relationship(self):
+        """Test journal synchronization maintains swapped relationship"""
+        payment, paired_payment = self._create_paired_payments()
+
+        # Create minimal third journal for testing
+        new_journal = self.env["account.journal"].create(
+            {
+                "name": "Test Bank 3",
+                "type": "bank",
+                "code": "TB3",
+            }
+        )
+
+        # Change destination_journal on source payment
+        payment.write(
+            {
+                "destination_journal_id": new_journal.id,
+            }
+        )
+
+        # Verify paired payment's journal_id was updated (swapped relationship)
+        self.assertEqual(
+            paired_payment.journal_id.id,
+            new_journal.id,
+            "Paired payment journal_id should sync with source destination_journal_id",
+        )
+
+    def test_no_recursion_with_context(self):
+        """Test that skip_paired_payment_update context prevents recursion"""
+        payment, paired_payment = self._create_paired_payments()
+
+        # Store original amount
+        original_amount = paired_payment.amount
+
+        # Update payment with skip context
+        payment.with_context(skip_paired_payment_update=True).write(
+            {
+                "amount": 2000.0,
+            }
+        )
+
+        # Verify paired payment was NOT updated
+        self.assertEqual(
+            paired_payment.amount,
+            original_amount,
+            "Paired payment should not be updated when skip_paired_payment_update context is set",
+        )
+
+    def test_rate_fields_trigger_sync(self):
+        """Test that rate fields trigger synchronization (payment_pro)"""
+        if not self.has_payment_pro:
+            self.skipTest("account_payment_pro module is not installed")
+
+        if "counterpart_rate" not in self.env["account.payment"]._fields:
+            self.skipTest("counterpart_rate field not available")
+
+        # Enable payment_pro
+        self.company.use_payment_pro = True
+
+        payment, paired_payment = self._create_paired_payments()
+
+        # Set initial counterpart_rate
+        payment.write({"counterpart_rate": 2.0})
+
+        # Verify inverse rate was set on paired payment
+        self.assertAlmostEqual(
+            paired_payment.counterpart_rate,
+            0.5,  # 1/2.0
+            places=4,
+            msg="Counterpart rate should be inverted on paired payment",
+        )
+
+        # Update rate and verify sync continues to work
+        payment.write({"counterpart_rate": 1.5})
+
+        self.assertAlmostEqual(
+            paired_payment.counterpart_rate,
+            1.0 / 1.5,
+            places=4,
+            msg="Changing counterpart_rate should trigger sync with inverted rate",
+        )