[FIX] account: unreconcile payment

- Create a SO for a customer of 100 $
- Create Invoice for the Sales Order and Register the payment
- Create a Refund Invoice, Validate it and keep it in "Open" state
- Create a second SO for 5 $
- Create an invoice for this order and validate it
- It will show you outstanding payments
- Apply the credit and the invoice will be fulfilled => Now you have a
  credit left for 95 $
- Create a third Sales order for the same customer for 5 $
- Create an Invoice for it
- It will show you outstanding credit (95 $)
- Apply the credits
- Now 90 $ are left
- In the same invoice, the credit which you applied, Unreconcile it
- It should have shown you 95 $, but it shows you 100 $ which means it
  removed the credit which we applied to second SO

The unreconcile process does not filter the partial reconciliations of
the selected invoice. All partial reconciliations on the AML are
removed instead.

opw-1819602

addons/account/models/account_move.py

@@ -1062,6 +1062,11 @@ class AccountMoveLine(models.Model):
                     account_move_line.payment_id.write({'invoice_ids': [(3, invoice.id, None)]})
             rec_move_ids += account_move_line.matched_debit_ids
             rec_move_ids += account_move_line.matched_credit_ids
+        if self.env.context.get('invoice_id'):
+            current_invoice = self.env['account.invoice'].browse(self.env.context['invoice_id'])
+            rec_move_ids = rec_move_ids.filtered(
+                lambda r: (r.debit_move_id + r.credit_move_id) & current_invoice.move_id.line_ids
+            )
         return rec_move_ids.unlink()
 
     ####################################################

addons/account/tests/test_reconciliation.py

@@ -620,3 +620,39 @@ class TestReconciliation(AccountingTestCase):
         # Checking if the direction of the move is correct
         full_rec_payable = full_rec_move.line_ids.filtered(lambda l: l.account_id == self.account_rsa)
         self.assertEqual(full_rec_payable.balance, 18.75)
+
+    def test_unreconcile(self):
+        # Use case:
+        # 2 invoices paid with a single payment. Unreconcile the payment with one invoice, the
+        # other invoice should remain reconciled.
+        inv1 = self.create_invoice(invoice_amount=10, currency_id=self.currency_usd_id)
+        inv2 = self.create_invoice(invoice_amount=20, currency_id=self.currency_usd_id)
+        payment = self.env['account.payment'].create({
+            'payment_type': 'inbound',
+            'payment_method_id': self.env.ref('account.account_payment_method_manual_in').id,
+            'partner_type': 'customer',
+            'partner_id': self.partner_agrolait_id,
+            'amount': 100,
+            'currency_id': self.currency_usd_id,
+            'journal_id': self.bank_journal_usd.id,
+        })
+        payment.post()
+        credit_aml = payment.move_line_ids.filtered('credit')
+
+        # Check residual before assignation
+        self.assertAlmostEquals(inv1.residual, 10)
+        self.assertAlmostEquals(inv2.residual, 20)
+
+        # Assign credit and residual
+        inv1.assign_outstanding_credit(credit_aml.id)
+        inv2.assign_outstanding_credit(credit_aml.id)
+        self.assertAlmostEquals(inv1.residual, 0)
+        self.assertAlmostEquals(inv2.residual, 0)
+
+        # Unreconcile one invoice at a time and check residual
+        credit_aml.with_context(invoice_id=inv1.id).remove_move_reconcile()
+        self.assertAlmostEquals(inv1.residual, 10)
+        self.assertAlmostEquals(inv2.residual, 0)
+        credit_aml.with_context(invoice_id=inv2.id).remove_move_reconcile()
+        self.assertAlmostEquals(inv1.residual, 10)
+        self.assertAlmostEquals(inv2.residual, 20)