2
0
account-financial-tools/account_loan/models/account_loan_line.py

482 lines
17 KiB
Python
Raw Normal View History

2018-02-26 12:17:24 +01:00
# Copyright 2018 Creu Blanca
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
import logging
2023-09-15 10:04:47 +02:00
from odoo import Command, _, api, fields, models
from odoo.exceptions import UserError
2018-02-26 12:17:24 +01:00
_logger = logging.getLogger(__name__)
try:
import numpy_financial
2018-02-26 12:17:24 +01:00
except (ImportError, IOError) as err:
_logger.error(err)
class AccountLoanLine(models.Model):
_name = "account.loan.line"
_description = "Annuity"
_order = "sequence asc"
2018-02-26 12:17:24 +01:00
name = fields.Char(compute="_compute_name")
2018-02-26 12:17:24 +01:00
loan_id = fields.Many2one(
2022-01-10 15:07:49 +01:00
"account.loan",
required=True,
readonly=True,
ondelete="cascade",
)
company_id = fields.Many2one(
"res.company", readonly=True, related="loan_id.company_id"
)
partner_id = fields.Many2one(
"res.partner", readonly=True, related="loan_id.partner_id"
)
2022-01-10 15:07:49 +01:00
is_leasing = fields.Boolean(
related="loan_id.is_leasing",
readonly=True,
)
journal_id = fields.Many2one(
"account.journal",
readonly=True,
related="loan_id.journal_id",
)
short_term_loan_account_id = fields.Many2one(
"account.account",
readonly=True,
related="loan_id.short_term_loan_account_id",
)
interest_expenses_account_id = fields.Many2one(
"account.account",
readonly=True,
related="loan_id.interest_expenses_account_id",
)
loan_type = fields.Selection(
related="loan_id.loan_type",
2018-02-26 12:17:24 +01:00
readonly=True,
)
loan_state = fields.Selection(
related="loan_id.state",
readonly=True,
store=True,
2018-02-26 12:17:24 +01:00
)
sequence = fields.Integer(required=True, readonly=True)
date = fields.Date(
2022-01-10 15:07:49 +01:00
required=True,
readonly=True,
help="Date when the payment will be accounted",
2018-02-26 12:17:24 +01:00
)
long_term_loan_account_id = fields.Many2one(
2022-01-10 15:07:49 +01:00
"account.account",
readonly=True,
related="loan_id.long_term_loan_account_id",
)
currency_id = fields.Many2one(
"res.currency",
related="loan_id.currency_id",
)
rate = fields.Float(
required=True,
readonly=True,
digits=(8, 6),
2018-02-26 12:17:24 +01:00
)
pending_principal_amount = fields.Monetary(
currency_field="currency_id",
2018-02-26 12:17:24 +01:00
readonly=True,
help="Pending amount of the loan before the payment",
2018-02-26 12:17:24 +01:00
)
long_term_pending_principal_amount = fields.Monetary(
currency_field="currency_id",
2018-02-26 12:17:24 +01:00
readonly=True,
help="Pending amount of the loan before the payment that will not be "
"payed in, at least, 12 months",
2018-02-26 12:17:24 +01:00
)
payment_amount = fields.Monetary(
currency_field="currency_id",
2018-02-26 12:17:24 +01:00
readonly=True,
help="Total amount that will be payed (Annuity)",
2018-02-26 12:17:24 +01:00
)
interests_amount = fields.Monetary(
currency_field="currency_id",
2018-02-26 12:17:24 +01:00
readonly=True,
help="Amount of the payment that will be assigned to interests",
2018-02-26 12:17:24 +01:00
)
principal_amount = fields.Monetary(
currency_field="currency_id",
compute="_compute_amounts",
help="Amount of the payment that will reduce the pending loan amount",
2018-02-26 12:17:24 +01:00
)
long_term_principal_amount = fields.Monetary(
currency_field="currency_id",
2018-02-26 12:17:24 +01:00
readonly=True,
help="Amount that will reduce the pending loan amount on long term",
2018-02-26 12:17:24 +01:00
)
final_pending_principal_amount = fields.Monetary(
currency_field="currency_id",
compute="_compute_amounts",
help="Pending amount of the loan after the payment",
2018-02-26 12:17:24 +01:00
)
2022-01-10 15:07:49 +01:00
move_ids = fields.One2many(
"account.move",
inverse_name="loan_line_id",
)
has_moves = fields.Boolean(compute="_compute_has_moves")
has_invoices = fields.Boolean(compute="_compute_has_invoices")
2018-02-26 12:17:24 +01:00
_sql_constraints = [
(
"sequence_loan",
"unique(loan_id, sequence)",
"Sequence must be unique in a loan",
)
2018-02-26 12:17:24 +01:00
]
@api.depends("move_ids")
2018-02-26 12:17:24 +01:00
def _compute_has_moves(self):
for record in self:
record.has_moves = bool(record.move_ids)
@api.depends("move_ids")
2018-02-26 12:17:24 +01:00
def _compute_has_invoices(self):
for record in self:
record.has_invoices = bool(record.move_ids)
2018-02-26 12:17:24 +01:00
@api.depends("loan_id.name", "sequence")
2018-02-26 12:17:24 +01:00
def _compute_name(self):
for record in self:
record.name = "%s-%d" % (record.loan_id.name, record.sequence)
2018-02-26 12:17:24 +01:00
@api.depends("payment_amount", "interests_amount", "pending_principal_amount")
2018-02-26 12:17:24 +01:00
def _compute_amounts(self):
for rec in self:
rec.final_pending_principal_amount = (
rec.pending_principal_amount - rec.payment_amount + rec.interests_amount
2018-02-26 12:17:24 +01:00
)
rec.principal_amount = rec.payment_amount - rec.interests_amount
2023-09-15 10:04:47 +02:00
def _compute_amount(self):
2018-02-26 12:17:24 +01:00
"""
Computes the payment amount
:return: Amount to be payed on the annuity
"""
if self.sequence == self.loan_id.periods:
return (
self.pending_principal_amount
+ self.interests_amount
- self.loan_id.residual_amount
)
if self.loan_type == "fixed-principal" and self.loan_id.round_on_end:
return self.loan_id.fixed_amount + self.interests_amount
if self.loan_type == "fixed-principal":
return (self.pending_principal_amount - self.loan_id.residual_amount) / (
2018-02-26 12:17:24 +01:00
self.loan_id.periods - self.sequence + 1
) + self.interests_amount
if self.loan_type == "interest":
2018-02-26 12:17:24 +01:00
return self.interests_amount
if self.loan_type == "fixed-annuity" and self.loan_id.round_on_end:
2018-02-26 12:17:24 +01:00
return self.loan_id.fixed_amount
if self.loan_type == "fixed-annuity":
return self.currency_id.round(
-numpy_financial.pmt(
2023-09-15 10:04:47 +02:00
self.loan_id._loan_rate() / 100,
self.loan_id.periods - self.sequence + 1,
self.pending_principal_amount,
-self.loan_id.residual_amount,
)
)
if self.loan_type == "fixed-annuity-begin" and self.loan_id.round_on_end:
return self.loan_id.fixed_amount
if self.loan_type == "fixed-annuity-begin":
return self.currency_id.round(
-numpy_financial.pmt(
2023-09-15 10:04:47 +02:00
self.loan_id._loan_rate() / 100,
self.loan_id.periods - self.sequence + 1,
self.pending_principal_amount,
-self.loan_id.residual_amount,
when="begin",
)
)
2018-02-26 12:17:24 +01:00
2023-09-15 10:04:47 +02:00
def _check_amount(self):
2018-02-26 12:17:24 +01:00
"""Recompute amounts if the annuity has not been processed"""
if self.move_ids:
raise UserError(
_("Amount cannot be recomputed if moves or invoices exists " "already")
)
if (
self.sequence == self.loan_id.periods
and self.loan_id.round_on_end
and self.loan_type in ["fixed-annuity", "fixed-annuity-begin"]
):
2018-02-26 12:17:24 +01:00
self.interests_amount = self.currency_id.round(
self.loan_id.fixed_amount
- self.pending_principal_amount
+ self.loan_id.residual_amount
)
2023-09-15 10:04:47 +02:00
self.payment_amount = self.currency_id.round(self._compute_amount())
elif not self.loan_id.round_on_end:
2023-09-15 10:04:47 +02:00
self.interests_amount = self.currency_id.round(self._compute_interest())
self.payment_amount = self.currency_id.round(self._compute_amount())
2018-02-26 12:17:24 +01:00
else:
2023-09-15 10:04:47 +02:00
self.interests_amount = self._compute_interest()
self.payment_amount = self._compute_amount()
2018-02-26 12:17:24 +01:00
2023-09-15 10:04:47 +02:00
def _compute_interest(self):
if self.loan_type == "fixed-annuity-begin":
return -numpy_financial.ipmt(
2023-09-15 10:04:47 +02:00
self.loan_id._loan_rate() / 100,
2,
self.loan_id.periods - self.sequence + 1,
self.pending_principal_amount,
-self.loan_id.residual_amount,
when="begin",
)
2023-09-15 10:04:47 +02:00
return self.pending_principal_amount * self.loan_id._loan_rate() / 100
2023-09-15 10:04:47 +02:00
def _check_move_amount(self):
2018-02-26 12:17:24 +01:00
"""
Changes the amounts of the annuity once the move is posted
:return:
"""
self.ensure_one()
interests_moves = self.move_ids.mapped("line_ids").filtered(
2018-02-26 12:17:24 +01:00
lambda r: r.account_id == self.loan_id.interest_expenses_account_id
)
short_term_moves = self.move_ids.mapped("line_ids").filtered(
2018-02-26 12:17:24 +01:00
lambda r: r.account_id == self.loan_id.short_term_loan_account_id
)
long_term_moves = self.move_ids.mapped("line_ids").filtered(
2018-02-26 12:17:24 +01:00
lambda r: r.account_id == self.loan_id.long_term_loan_account_id
)
self.interests_amount = sum(interests_moves.mapped("debit")) - sum(
interests_moves.mapped("credit")
2018-02-26 12:17:24 +01:00
)
self.long_term_principal_amount = sum(long_term_moves.mapped("debit")) - sum(
long_term_moves.mapped("credit")
2018-02-26 12:17:24 +01:00
)
self.payment_amount = (
sum(short_term_moves.mapped("debit"))
- sum(short_term_moves.mapped("credit"))
+ self.long_term_principal_amount
+ self.interests_amount
2018-02-26 12:17:24 +01:00
)
def _move_vals(self, journal=False, account=False):
2018-02-26 12:17:24 +01:00
return {
"loan_line_id": self.id,
"loan_id": self.loan_id.id,
"date": self.date,
"ref": self.name,
"journal_id": (journal and journal.id) or self.loan_id.journal_id.id,
"line_ids": [
Command.create(vals) for vals in self._move_line_vals(account=account)
],
2018-02-26 12:17:24 +01:00
}
def _move_line_vals(self, account=False):
2018-02-26 12:17:24 +01:00
vals = []
2022-01-10 15:07:49 +01:00
partner = self.loan_id.partner_id.with_company(self.loan_id.company_id)
vals.append(
{
"account_id": (account and account.id)
or partner.property_account_payable_id.id,
"partner_id": partner.id,
"credit": self.payment_amount,
"debit": 0,
}
)
if self.interests_amount:
vals.append(
{
"account_id": self.loan_id.interest_expenses_account_id.id,
"credit": 0,
"debit": self.interests_amount,
}
)
vals.append(
{
"account_id": self.loan_id.short_term_loan_account_id.id,
"credit": 0,
"debit": self.payment_amount - self.interests_amount,
}
)
2018-02-26 12:17:24 +01:00
if self.long_term_loan_account_id and self.long_term_principal_amount:
vals.append(
{
"account_id": self.loan_id.short_term_loan_account_id.id,
"credit": self.long_term_principal_amount,
"debit": 0,
}
)
vals.append(
{
"account_id": self.long_term_loan_account_id.id,
"credit": 0,
"debit": self.long_term_principal_amount,
}
)
2018-02-26 12:17:24 +01:00
return vals
2023-09-15 10:04:47 +02:00
def _invoice_vals(self):
2018-02-26 12:17:24 +01:00
return {
"loan_line_id": self.id,
"loan_id": self.loan_id.id,
2022-01-10 15:07:49 +01:00
"move_type": "in_invoice",
"partner_id": self.loan_id.partner_id.id,
"invoice_date": self.date,
"journal_id": self.loan_id.journal_id.id,
"company_id": self.loan_id.company_id.id,
2023-09-15 10:04:47 +02:00
"invoice_line_ids": [
Command.create(vals) for vals in self._invoice_line_vals()
],
2018-02-26 12:17:24 +01:00
}
2023-09-15 10:04:47 +02:00
def _invoice_line_vals(self):
2018-02-26 12:17:24 +01:00
vals = list()
vals.append(
{
"product_id": self.loan_id.product_id.id,
"name": self.loan_id.product_id.name,
"quantity": 1,
"price_unit": self.principal_amount,
"account_id": self.loan_id.short_term_loan_account_id.id,
}
)
vals.append(
{
"product_id": self.loan_id.interests_product_id.id,
"name": self.loan_id.interests_product_id.name,
"quantity": 1,
"price_unit": self.interests_amount,
"account_id": self.loan_id.interest_expenses_account_id.id,
}
)
2018-02-26 12:17:24 +01:00
return vals
def _generate_move(self, journal=False, account=False):
2018-02-26 12:17:24 +01:00
"""
Computes and post the moves of loans
:return: list of account.move generated
"""
res = []
for record in self:
if not record.move_ids:
if record.loan_id.line_ids.filtered(
lambda r: r.date < record.date and not r.move_ids
2018-02-26 12:17:24 +01:00
):
raise UserError(_("Some moves must be created first"))
move = self.env["account.move"].create(
record._move_vals(journal=journal, account=account)
)
move.action_post()
2018-02-26 12:17:24 +01:00
res.append(move.id)
return res
2023-09-15 10:04:47 +02:00
def _long_term_move_vals(self):
return {
"loan_line_id": self.id,
"loan_id": self.loan_id.id,
"date": self.date,
"ref": self.name,
"journal_id": self.loan_id.journal_id.id,
"line_ids": [
Command.create(vals) for vals in self._get_long_term_move_line_vals()
],
}
def _generate_invoice(self):
2018-02-26 12:17:24 +01:00
"""
Computes invoices of leases
:return: list of account.move generated
2018-02-26 12:17:24 +01:00
"""
res = []
for record in self:
if not record.move_ids:
2018-02-26 12:17:24 +01:00
if record.loan_id.line_ids.filtered(
lambda r: r.date < record.date and not r.move_ids
2018-02-26 12:17:24 +01:00
):
raise UserError(_("Some invoices must be created first"))
2023-09-15 10:04:47 +02:00
invoice = self.env["account.move"].create(record._invoice_vals())
2018-02-26 12:17:24 +01:00
res.append(invoice.id)
for line in invoice.invoice_line_ids:
line.tax_ids = line._get_computed_taxes()
2023-09-15 10:04:47 +02:00
invoice.flush_recordset()
invoice.filtered(
lambda m: m.currency_id.round(m.amount_total) < 0
).action_switch_invoice_into_refund_credit_note()
2023-09-15 10:04:47 +02:00
if record.loan_id.post_invoice:
invoice.action_post()
if (
record.long_term_loan_account_id
and record.long_term_principal_amount != 0
):
2023-09-15 10:04:47 +02:00
move = self.env["account.move"].create(
record._long_term_move_vals()
)
if record.loan_id.post_invoice:
move.action_post()
res.append(move.id)
2018-02-26 12:17:24 +01:00
return res
def _get_long_term_move_line_vals(self):
return [
2023-09-15 10:04:47 +02:00
{
"account_id": self.loan_id.short_term_loan_account_id.id,
"credit": self.long_term_principal_amount,
"debit": 0,
},
{
"account_id": self.long_term_loan_account_id.id,
"credit": 0,
"debit": self.long_term_principal_amount,
},
]
2018-02-26 12:17:24 +01:00
def view_account_values(self):
"""Shows the invoice if it is a leasing or the move if it is a loan"""
self.ensure_one()
if self.is_leasing:
return self.view_account_invoices()
return self.view_account_moves()
def view_process_values(self):
"""Computes the annuity and returns the result"""
self.ensure_one()
if self.is_leasing:
2023-09-15 10:04:47 +02:00
self._generate_invoice()
2018-02-26 12:17:24 +01:00
else:
2023-09-15 10:04:47 +02:00
self._generate_move()
2018-02-26 12:17:24 +01:00
return self.view_account_values()
def view_account_moves(self):
self.ensure_one()
result = self.env["ir.actions.act_window"]._for_xml_id(
"account.action_move_line_form"
)
result["context"] = {
"default_loan_line_id": self.id,
"default_loan_id": self.loan_id.id,
2018-02-26 12:17:24 +01:00
}
result["domain"] = [("loan_line_id", "=", self.id)]
2018-02-26 12:17:24 +01:00
if len(self.move_ids) == 1:
2023-09-15 10:04:47 +02:00
res = self.env.ref("account.view_move_form", False)
result["views"] = [(res and res.id or False, "form")]
result["res_id"] = self.move_ids.id
2018-02-26 12:17:24 +01:00
return result
def view_account_invoices(self):
self.ensure_one()
result = self.env["ir.actions.act_window"]._for_xml_id(
"account.action_move_out_invoice_type"
)
result["context"] = {
"default_loan_line_id": self.id,
"default_loan_id": self.loan_id.id,
2018-02-26 12:17:24 +01:00
}
2022-01-10 15:07:49 +01:00
result["domain"] = [
("loan_line_id", "=", self.id),
]
if len(self.move_ids) == 1:
res = self.env.ref("account.view_move_form", False)
result["views"] = [(res and res.id or False, "form")]
result["res_id"] = self.move_ids.id
2018-02-26 12:17:24 +01:00
return result