odoo-addon-account-reconcile-oca 17.0.1.5.3__py3-none-any.whl → 17.0.1.5.5__py3-none-any.whl

odoo/addons/account_reconcile_oca/models/account_bank_statement_line.py

@@ -8,7 +8,8 @@ from dateutil.relativedelta import relativedelta
 
 from odoo import Command, _, api, fields, models, tools
 from odoo.exceptions import UserError
-from odoo.tools import float_is_zero
+from odoo.fields import first
+from odoo.tools import float_compare, float_is_zero
 
 
 class AccountBankStatementLine(models.Model):
@@ -178,41 +179,63 @@ class AccountBankStatementLine(models.Model):
             )._default_reconcile_data()
         self.can_reconcile = self.reconcile_data_info.get("can_reconcile", False)
 
+    def _get_amount_currency(self, line, dest_curr):
+        if line["line_currency_id"] == dest_curr.id:
+            amount = line["currency_amount"]
+        else:
+            amount = self.company_id.currency_id._convert(
+                line["amount"],
+                dest_curr,
+                self.company_id,
+                self.date,
+            )
+        return amount
+
     @api.onchange("add_account_move_line_id")
     def _onchange_add_account_move_line_id(self):
         if self.add_account_move_line_id:
-            data = self.reconcile_data_info["data"]
-            new_data = []
-            is_new_line = True
-            pending_amount = 0.0
-            for line in data:
-                if line["kind"] != "suspense":
-                    pending_amount += line["amount"]
-                if self.add_account_move_line_id.id in line.get(
-                    "counterpart_line_ids", []
-                ):
-                    is_new_line = False
-                else:
+            self._add_account_move_line(self.add_account_move_line_id)
+            self.add_account_move_line_id = False
+
+    def _add_account_move_line(self, move_line, keep_current=False):
+        data = self.reconcile_data_info["data"]
+        new_data = []
+        is_new_line = True
+        pending_amount = 0.0
+        currency = self._get_reconcile_currency()
+        for line in data:
+            if line["kind"] != "suspense":
+                pending_amount += self._get_amount_currency(line, currency)
+            if move_line.id in line.get("counterpart_line_ids", []):
+                is_new_line = False
+                if keep_current:
                     new_data.append(line)
-            if is_new_line:
-                reconcile_auxiliary_id, lines = self._get_reconcile_line(
-                    self.add_account_move_line_id, "other", True, pending_amount
-                )
-                new_data += lines
-            self.reconcile_data_info = self._recompute_suspense_line(
-                new_data,
-                self.reconcile_data_info["reconcile_auxiliary_id"],
-                self.manual_reference,
+            else:
+                new_data.append(line)
+        if is_new_line:
+            reconcile_auxiliary_id, lines = self._get_reconcile_line(
+                move_line,
+                "other",
+                is_counterpart=True,
+                max_amount=currency.round(pending_amount),
+                move=True,
             )
-            self.can_reconcile = self.reconcile_data_info.get("can_reconcile", False)
-            self.add_account_move_line_id = False
+            new_data += lines
+        self.reconcile_data_info = self._recompute_suspense_line(
+            new_data,
+            self.reconcile_data_info["reconcile_auxiliary_id"],
+            self.manual_reference,
+        )
+        self.can_reconcile = self.reconcile_data_info.get("can_reconcile", False)
 
     def _recompute_suspense_line(self, data, reconcile_auxiliary_id, manual_reference):
         can_reconcile = True
         total_amount = 0
+        currency_amount = 0
         new_data = []
         suspense_line = False
         counterparts = []
+        suspense_currency = self.foreign_currency_id or self.currency_id
         for line in data:
             if line.get("counterpart_line_ids"):
                 counterparts += line["counterpart_line_ids"]
@@ -224,10 +247,29 @@ class AccountBankStatementLine(models.Model):
             if line["kind"] != "suspense":
                 new_data.append(line)
                 total_amount += line["amount"]
+                if not line.get("is_exchange_counterpart"):
+                    # case of statement line with foreign_currency
+                    if (
+                        line["kind"] == "liquidity"
+                        and line["line_currency_id"] != suspense_currency.id
+                    ):
+                        currency_amount += self.amount_currency
+                    elif (
+                        line.get("currency_amount")
+                        and line.get("line_currency_id") == suspense_currency.id
+                    ):
+                        currency_amount += line.get("currency_amount")
+                    else:
+                        currency_amount += self.company_id.currency_id._convert(
+                            line["amount"],
+                            suspense_currency,
+                            self.company_id,
+                            self.date,
+                        )
             else:
                 suspense_line = line
         if not float_is_zero(
-            total_amount, precision_digits=self.currency_id.decimal_places
+            total_amount, precision_digits=self.company_id.currency_id.decimal_places
         ):
             can_reconcile = False
             if suspense_line:
@@ -236,6 +278,7 @@ class AccountBankStatementLine(models.Model):
                         "amount": -total_amount,
                         "credit": total_amount if total_amount > 0 else 0.0,
                         "debit": -total_amount if total_amount < 0 else 0.0,
+                        "currency_amount": -currency_amount,
                     }
                 )
             else:
@@ -261,8 +304,8 @@ class AccountBankStatementLine(models.Model):
                     "debit": -total_amount if total_amount < 0 else 0.0,
                     "kind": "suspense",
                     "currency_id": self.company_id.currency_id.id,
-                    "line_currency_id": self.company_id.currency_id.id,
-                    "currency_amount": -total_amount,
+                    "line_currency_id": suspense_currency.id,
+                    "currency_amount": -currency_amount,
                 }
                 reconcile_auxiliary_id += 1
             new_data.append(suspense_line)
@@ -282,11 +325,37 @@ class AccountBankStatementLine(models.Model):
             )
             or self.manual_account_id.id != line["account_id"][0]
             or self.manual_name != line["name"]
-            or (self.manual_partner_id and self.manual_partner_id.display_name or False)
+            or (
+                self.manual_partner_id
+                and [self.manual_partner_id.id, self.manual_partner_id.display_name]
+                or [False, False]
+            )
             != line.get("partner_id")
             or self.analytic_distribution != line.get("analytic_distribution", False)
         )
 
+    def _check_reconcile_data_changed(self):
+        self.ensure_one()
+        data = self.reconcile_data_info.get("data", [])
+        liquidity_lines, _suspense_lines, _other_lines = self._seek_for_lines()
+        move_amount_cur = sum(liquidity_lines.mapped("amount_currency"))
+        move_credit = sum(liquidity_lines.mapped("credit"))
+        move_debit = sum(liquidity_lines.mapped("debit"))
+        stmt_amount_curr = stmt_debit = stmt_credit = 0.0
+        for line_data in data:
+            if line_data["kind"] != "liquidity":
+                continue
+            stmt_amount_curr += line_data["currency_amount"]
+            stmt_debit += line_data["debit"]
+            stmt_credit += line_data["credit"]
+        prec = self.currency_id.rounding
+        return (
+            float_compare(move_amount_cur, move_amount_cur, precision_rounding=prec)
+            != 0
+            or float_compare(move_credit, stmt_credit, precision_rounding=prec) != 0
+            or float_compare(move_debit, stmt_debit, precision_rounding=prec) != 0
+        )
+
     def _get_manual_delete_vals(self):
         return {
             "manual_reference": False,
@@ -362,7 +431,11 @@ class AccountBankStatementLine(models.Model):
 
     @api.onchange("manual_amount_in_currency")
     def _onchange_manual_amount_in_currency(self):
-        if self.manual_line_id.exists() and self.manual_line_id:
+        if (
+            self.manual_line_id.exists()
+            and self.manual_line_id
+            and self.manual_kind != "liquidity"
+        ):
             self.manual_amount = self.manual_in_currency_id._convert(
                 self.manual_amount_in_currency,
                 self.company_id.currency_id,
@@ -372,7 +445,7 @@ class AccountBankStatementLine(models.Model):
         self._onchange_manual_reconcile_vals()
 
     def _get_manual_reconcile_vals(self):
-        return {
+        vals = {
             "name": self.manual_name,
             "partner_id": (
                 self.manual_partner_id
@@ -390,6 +463,19 @@ class AccountBankStatementLine(models.Model):
             "debit": self.manual_amount if self.manual_amount > 0 else 0.0,
             "analytic_distribution": self.analytic_distribution,
         }
+        liquidity_lines, _suspense_lines, _other_lines = self._seek_for_lines()
+        if self.manual_line_id and self.manual_line_id.id not in liquidity_lines.ids:
+            vals.update(
+                {
+                    "currency_amount": self.manual_currency_id._convert(
+                        self.manual_amount,
+                        self.manual_in_currency_id,
+                        self.company_id,
+                        self.manual_line_id.date,
+                    ),
+                }
+            )
+        return vals
 
     @api.onchange(
         "manual_account_id",
@@ -472,6 +558,8 @@ class AccountBankStatementLine(models.Model):
     def _reconcile_data_by_model(self, data, reconcile_model, reconcile_auxiliary_id):
         new_data = []
         liquidity_amount = 0.0
+        currency = self._get_reconcile_currency()
+        currency_amount = False
         for line_data in data:
             if line_data["kind"] == "suspense":
                 continue
@@ -484,8 +572,18 @@ class AccountBankStatementLine(models.Model):
             new_line = line.copy()
             amount = line.get("balance")
             if self.foreign_currency_id:
-                amount = self.foreign_currency_id.compute(
-                    amount, self.journal_id.currency_id or self.company_currency_id
+                amount = self.foreign_currency_id._convert(
+                    amount,
+                    self.journal_id.currency_id or self.company_currency_id,
+                    self.company_id,
+                    self.date,
+                )
+            if currency != self.company_id.currency_id:
+                currency_amount = self.company_id.currency_id._convert(
+                    amount,
+                    currency,
+                    self.company_id,
+                    self.date,
                 )
             new_line.update(
                 {
@@ -502,9 +600,9 @@ class AccountBankStatementLine(models.Model):
                         .display_name,
                     ],
                     "date": fields.Date.to_string(self.date),
-                    "line_currency_id": self.company_id.currency_id.id,
+                    "line_currency_id": currency.id,
                     "currency_id": self.company_id.currency_id.id,
-                    "currency_amount": amount,
+                    "currency_amount": currency_amount or amount,
                     "name": line.get("name") or self.payment_ref,
                 }
             )
@@ -525,7 +623,10 @@ class AccountBankStatementLine(models.Model):
         reconcile_auxiliary_id = 1
         for line in liquidity_lines:
             reconcile_auxiliary_id, lines = self._get_reconcile_line(
-                line, "liquidity", reconcile_auxiliary_id=reconcile_auxiliary_id
+                line,
+                "liquidity",
+                reconcile_auxiliary_id=reconcile_auxiliary_id,
+                move=True,
             )
             data += lines
         if not from_unreconcile:
@@ -551,6 +652,7 @@ class AccountBankStatementLine(models.Model):
                     self.manual_reference,
                 )
             elif res and res.get("amls"):
+                # TODO should be signed in currency get_reconcile_currency
                 amount = self.amount_total_signed
                 for line in res.get("amls", []):
                     reconcile_auxiliary_id, line_data = self._get_reconcile_line(
@@ -570,16 +672,89 @@ class AccountBankStatementLine(models.Model):
                     self.manual_reference,
                 )
         for line in other_lines:
-            reconcile_auxiliary_id, lines = self._get_reconcile_line(
-                line, "other", from_unreconcile=from_unreconcile
-            )
-            data += lines
+            partial_lines = self._all_partials_lines(line) if from_unreconcile else []
+            if partial_lines:
+                for reconciled_line in (
+                    partial_lines.debit_move_id + partial_lines.credit_move_id - line
+                ):
+                    if (
+                        reconciled_line.move_id.journal_id
+                        == self.company_id.currency_exchange_journal_id
+                    ):
+                        reconcile_auxiliary_id, lines = self._get_reconcile_line(
+                            reconciled_line.move_id.line_ids - reconciled_line,
+                            "other",
+                            from_unreconcile=False,
+                            move=True,
+                        )
+                        data += lines
+                        continue
+                    partial = partial_lines.filtered(
+                        lambda r, line=reconciled_line: r.debit_move_id == line
+                        or r.credit_move_id == line
+                    )
+                    partial_amount = sum(
+                        partial.filtered(
+                            lambda r, line=reconciled_line: r.credit_move_id == line
+                        ).mapped("amount")
+                    ) - sum(
+                        partial.filtered(
+                            lambda r, line=reconciled_line: r.debit_move_id == line
+                        ).mapped("amount")
+                    )
+                    reconcile_auxiliary_id, lines = self._get_reconcile_line(
+                        reconciled_line,
+                        "other",
+                        from_unreconcile={
+                            "amount": partial_amount,
+                            "credit": partial_amount > 0 and partial_amount,
+                            "debit": partial_amount < 0 and -partial_amount,
+                            "currency_amount": sum(
+                                partial.filtered(
+                                    lambda r, line=reconciled_line: r.credit_move_id
+                                    == line
+                                ).mapped("credit_amount_currency")
+                            )
+                            - sum(
+                                partial.filtered(
+                                    lambda r, line=reconciled_line: r.debit_move_id
+                                    == line
+                                ).mapped("debit_amount_currency")
+                            ),
+                        },
+                        move=True,
+                    )
+                    data += lines
+            else:
+                reconcile_auxiliary_id, lines = self._get_reconcile_line(
+                    line, "other", from_unreconcile=False
+                )
+                data += lines
+
         return self._recompute_suspense_line(
             data,
             reconcile_auxiliary_id,
             self.manual_reference,
         )
 
+    def _all_partials_lines(self, lines):
+        reconciliation_lines = lines.filtered(
+            lambda x: x.account_id.reconcile
+            or x.account_id.account_type in ("asset_cash", "liability_credit_card")
+        )
+        current_lines = reconciliation_lines
+        current_partials = self.env["account.partial.reconcile"]
+        partials = self.env["account.partial.reconcile"]
+        while current_lines:
+            current_partials = (
+                current_lines.matched_debit_ids + current_lines.matched_credit_ids
+            ) - current_partials
+            current_lines = (
+                current_partials.debit_move_id + current_partials.credit_move_id
+            ) - current_lines
+            partials += current_partials
+        return partials
+
     def clean_reconcile(self):
         self.reconcile_data_info = self._default_reconcile_data()
         self.can_reconcile = self.reconcile_data_info.get("can_reconcile", False)
@@ -734,12 +909,13 @@ class AccountBankStatementLine(models.Model):
             to_reverse._reverse_moves(default_values_list, cancel=True)
 
     def _reconcile_move_line_vals(self, line, move_id=False):
-        return {
+        vals = {
             "move_id": move_id or self.move_id.id,
             "account_id": line["account_id"][0],
             "partner_id": line.get("partner_id") and line["partner_id"][0],
             "credit": line["credit"],
             "debit": line["debit"],
+            "currency_id": line.get("line_currency_id", self.company_id.currency_id.id),
             "tax_ids": line.get("tax_ids", []),
             "tax_tag_ids": line.get("tax_tag_ids", []),
             "group_tax_id": line.get("group_tax_id"),
@@ -748,6 +924,11 @@ class AccountBankStatementLine(models.Model):
             "name": line.get("name"),
             "reconcile_model_id": line.get("reconcile_model_id"),
         }
+        if line.get("line_currency_id") and line["currency_id"] != line.get(
+            "line_currency_id"
+        ):
+            vals["amount_currency"] = line["currency_amount"]
+        return vals
 
     @api.model_create_multi
     def create(self, mvals):
@@ -771,7 +952,9 @@ class AccountBankStatementLine(models.Model):
             data = []
             for line in liquidity_lines:
                 reconcile_auxiliary_id, lines = record._get_reconcile_line(
-                    line, "liquidity"
+                    line,
+                    "liquidity",
+                    move=True,
                 )
                 data += lines
             reconcile_auxiliary_id = 1
@@ -783,10 +966,10 @@ class AccountBankStatementLine(models.Model):
                     self.manual_reference,
                 )
             elif res.get("amls"):
-                amount = self.amount
+                amount = self.amount_currency or self.amount
                 for line in res.get("amls", []):
                     reconcile_auxiliary_id, line_datas = record._get_reconcile_line(
-                        line, "other", is_counterpart=True, max_amount=amount
+                        line, "other", is_counterpart=True, max_amount=amount, move=True
                     )
                     amount -= sum(line_data.get("amount") for line_data in line_datas)
                     data += line_datas
@@ -802,6 +985,67 @@ class AccountBankStatementLine(models.Model):
             )(self._prepare_reconcile_line_data(data["data"]))
         return result
 
+    def _synchronize_to_moves(self, changed_fields):
+        """We want to avoid to change stuff (mainly amounts ) in accounting entries
+        when some changes happen in the reconciliation widget. The only change
+        (among the fields triggering the synchronization) possible from the
+        reconciliation widget is the partner_id field.
+
+        So, in case of change on partner_id field we do not call super but make
+        only the required change (relative to partner) on accounting entries.
+
+        And if something else changes, we then re-define reconcile_data_info to
+        make the data consistent (for example, if debit/credit has changed by
+        applying a different rate or even if there was a correction on statement
+        line amount).
+        """
+        if self._context.get("skip_account_move_synchronization"):
+            return
+        if "partner_id" in changed_fields and not any(
+            field_name in changed_fields
+            for field_name in (
+                "payment_ref",
+                "amount",
+                "amount_currency",
+                "foreign_currency_id",
+                "currency_id",
+            )
+        ):
+            for st_line in self.with_context(skip_account_move_synchronization=True):
+                (
+                    liquidity_lines,
+                    suspense_lines,
+                    _other_lines,
+                ) = st_line._seek_for_lines()
+                line_vals = {"partner_id": st_line.partner_id}
+                line_ids_commands = [(1, liquidity_lines.id, line_vals)]
+                if suspense_lines:
+                    line_ids_commands.append((1, suspense_lines.id, line_vals))
+                st_line_vals = {"line_ids": line_ids_commands}
+                if st_line.move_id.partner_id != st_line.partner_id:
+                    st_line_vals["partner_id"] = st_line.partner_id.id
+                st_line.move_id.write(st_line_vals)
+        else:
+            super()._synchronize_to_moves(changed_fields=changed_fields)
+
+        if not any(
+            field_name in changed_fields
+            for field_name in (
+                "payment_ref",
+                "amount",
+                "amount_currency",
+                "foreign_currency_id",
+                "currency_id",
+                "partner_id",
+            )
+        ):
+            return
+        # reset reconcile_data_info if amounts are not consistent anymore with the
+        # amounts of the accounting entries
+        for st_line in self:
+            if st_line._check_reconcile_data_changed():
+                st_line.reconcile_data_info = st_line._default_reconcile_data()
+
     def _prepare_reconcile_line_data(self, lines):
         new_lines = []
         reverse_lines = {}
@@ -848,6 +1092,7 @@ class AccountBankStatementLine(models.Model):
                     is_counterpart=True,
                     reconcile_auxiliary_id=reconcile_auxiliary_id,
                     max_amount=original_amount,
+                    move=True,
                 )
                 new_data += lines
                 new_data.append(
@@ -895,6 +1140,7 @@ class AccountBankStatementLine(models.Model):
         max_amount=False,
         from_unreconcile=False,
         reconcile_auxiliary_id=False,
+        move=False,
     ):
         new_vals = super()._get_reconcile_line(
             line,
@@ -902,29 +1148,48 @@ class AccountBankStatementLine(models.Model):
             is_counterpart=is_counterpart,
             max_amount=max_amount,
             from_unreconcile=from_unreconcile,
+            move=move,
         )
         rates = []
         for vals in new_vals:
+            rate = False
             if vals["partner_id"] is False:
                 vals["partner_id"] = (False, self.partner_name)
-            reconcile_auxiliary_id, rate = self._compute_exchange_rate(
-                vals, line, reconcile_auxiliary_id
-            )
+            if vals.get("kind") not in ("suspense", "liquidity"):
+                reconcile_auxiliary_id, rate = self._compute_exchange_rate(
+                    vals, line, reconcile_auxiliary_id
+                )
             if rate:
                 rates.append(rate)
         new_vals += rates
         return reconcile_auxiliary_id, new_vals
 
     def _get_exchange_rate_amount(self, amount, currency_amount, currency, line):
-        return (
-            currency._convert(
+        if self.foreign_currency_id == currency:
+            # take real rate of statement line to compute the exchange rate gain/loss
+            real_rate = self.amount / self.amount_currency
+            to_amount_journal_currency = currency_amount * real_rate
+            to_amount_company_currency = self.currency_id._convert(
+                to_amount_journal_currency,
+                self.company_id.currency_id,
+                self.company_id,
+                self.date,
+            )
+            to_amount = self.company_id.currency_id.round(to_amount_company_currency)
+        elif self.currency_id == currency and not self.foreign_currency_id:
+            liquidity_lines, _suspense_lines, _other_lines = self._seek_for_lines()
+            real_rate = (
+                first(liquidity_lines).balance / first(liquidity_lines).amount_currency
+            )
+            to_amount = self.company_id.currency_id.round(currency_amount * real_rate)
+        else:
+            to_amount = currency._convert(
                 currency_amount,
                 self.company_id.currency_id,
                 self.company_id,
                 self.date,
             )
-            - amount
-        )
+        return self.company_id.currency_id.round(to_amount - amount)
 
     def _compute_exchange_rate(
         self,
@@ -963,8 +1228,8 @@ class AccountBankStatementLine(models.Model):
             "debit": amount if amount > 0 else 0.0,
             "kind": "other",
             "currency_id": self.company_id.currency_id.id,
-            "line_currency_id": self.company_id.currency_id.id,
-            "currency_amount": amount,
+            "line_currency_id": currency.id,
+            "currency_amount": 0,
         }
         reconcile_auxiliary_id += 1
         return reconcile_auxiliary_id, data
@@ -991,3 +1256,17 @@ class AccountBankStatementLine(models.Model):
             "split_line_id": self.id,
         }
         return action
+
+    def _get_reconcile_currency(self):
+        return (
+            self.foreign_currency_id
+            or self.journal_id.currency_id
+            or self.company_id.currency_id
+        )
+
+    def add_multiple_lines(self, domain):
+        res = super().add_multiple_lines(domain)
+        lines = self.env["account.move.line"].search(domain)
+        for line in lines:
+            self._add_account_move_line(line, keep_current=True)
+        return res