2
0
account-financial-tools/account_loan/model/account_loan_line.py
2023-09-15 11:24:50 +02:00

445 lines
16 KiB
Python

# Copyright 2018 Creu Blanca
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
import logging
from odoo import _, api, fields, models
from odoo.exceptions import UserError
_logger = logging.getLogger(__name__)
try:
import numpy_financial
except (ImportError, IOError) as err:
_logger.error(err)
class AccountLoanLine(models.Model):
_name = "account.loan.line"
_description = "Annuity"
_order = "sequence asc"
name = fields.Char(compute="_compute_name")
loan_id = fields.Many2one(
"account.loan",
required=True,
readonly=True,
ondelete="cascade",
)
is_leasing = fields.Boolean(
related="loan_id.is_leasing",
readonly=True,
)
loan_type = fields.Selection(
related="loan_id.loan_type",
readonly=True,
)
loan_state = fields.Selection(
related="loan_id.state",
readonly=True,
store=True,
)
sequence = fields.Integer(required=True, readonly=True)
date = fields.Date(
required=True,
readonly=True,
help="Date when the payment will be accounted",
)
long_term_loan_account_id = fields.Many2one(
"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),
)
pending_principal_amount = fields.Monetary(
currency_field="currency_id",
readonly=True,
help="Pending amount of the loan before the payment",
)
long_term_pending_principal_amount = fields.Monetary(
currency_field="currency_id",
readonly=True,
help="Pending amount of the loan before the payment that will not be "
"payed in, at least, 12 months",
)
payment_amount = fields.Monetary(
currency_field="currency_id",
readonly=True,
help="Total amount that will be payed (Annuity)",
)
interests_amount = fields.Monetary(
currency_field="currency_id",
readonly=True,
help="Amount of the payment that will be assigned to interests",
)
principal_amount = fields.Monetary(
currency_field="currency_id",
compute="_compute_amounts",
help="Amount of the payment that will reduce the pending loan amount",
)
long_term_principal_amount = fields.Monetary(
currency_field="currency_id",
readonly=True,
help="Amount that will reduce the pending loan amount on long term",
)
final_pending_principal_amount = fields.Monetary(
currency_field="currency_id",
compute="_compute_amounts",
help="Pending amount of the loan after the payment",
)
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")
_sql_constraints = [
(
"sequence_loan",
"unique(loan_id, sequence)",
"Sequence must be unique in a loan",
)
]
@api.depends("move_ids")
def _compute_has_moves(self):
for record in self:
record.has_moves = bool(record.move_ids)
@api.depends("move_ids")
def _compute_has_invoices(self):
for record in self:
record.has_invoices = bool(record.move_ids)
@api.depends("loan_id.name", "sequence")
def _compute_name(self):
for record in self:
record.name = "%s-%d" % (record.loan_id.name, record.sequence)
@api.depends("payment_amount", "interests_amount", "pending_principal_amount")
def _compute_amounts(self):
for rec in self:
rec.final_pending_principal_amount = (
rec.pending_principal_amount - rec.payment_amount + rec.interests_amount
)
rec.principal_amount = rec.payment_amount - rec.interests_amount
def compute_amount(self):
"""
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) / (
self.loan_id.periods - self.sequence + 1
) + self.interests_amount
if self.loan_type == "interest":
return self.interests_amount
if self.loan_type == "fixed-annuity" and self.loan_id.round_on_end:
return self.loan_id.fixed_amount
if self.loan_type == "fixed-annuity":
return self.currency_id.round(
-numpy_financial.pmt(
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(
self.loan_id.loan_rate() / 100,
self.loan_id.periods - self.sequence + 1,
self.pending_principal_amount,
-self.loan_id.residual_amount,
when="begin",
)
)
def check_amount(self):
"""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"]
):
self.interests_amount = self.currency_id.round(
self.loan_id.fixed_amount
- self.pending_principal_amount
+ self.loan_id.residual_amount
)
self.payment_amount = self.currency_id.round(self.compute_amount())
elif not self.loan_id.round_on_end:
self.interests_amount = self.currency_id.round(self.compute_interest())
self.payment_amount = self.currency_id.round(self.compute_amount())
else:
self.interests_amount = self.compute_interest()
self.payment_amount = self.compute_amount()
def compute_interest(self):
if self.loan_type == "fixed-annuity-begin":
return -numpy_financial.ipmt(
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",
)
return self.pending_principal_amount * self.loan_id.loan_rate() / 100
def check_move_amount(self):
"""
Changes the amounts of the annuity once the move is posted
:return:
"""
self.ensure_one()
interests_moves = self.move_ids.mapped("line_ids").filtered(
lambda r: r.account_id == self.loan_id.interest_expenses_account_id
)
short_term_moves = self.move_ids.mapped("line_ids").filtered(
lambda r: r.account_id == self.loan_id.short_term_loan_account_id
)
long_term_moves = self.move_ids.mapped("line_ids").filtered(
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")
)
self.long_term_principal_amount = sum(long_term_moves.mapped("debit")) - sum(
long_term_moves.mapped("credit")
)
self.payment_amount = (
sum(short_term_moves.mapped("debit"))
- sum(short_term_moves.mapped("credit"))
+ self.long_term_principal_amount
+ self.interests_amount
)
def 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": [(0, 0, vals) for vals in self.move_line_vals()],
}
def move_line_vals(self):
vals = []
partner = self.loan_id.partner_id.with_company(self.loan_id.company_id)
vals.append(
{
"account_id": partner.property_account_payable_id.id,
"partner_id": partner.id,
"credit": self.payment_amount,
"debit": 0,
}
)
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,
}
)
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,
}
)
return vals
def invoice_vals(self):
return {
"loan_line_id": self.id,
"loan_id": self.loan_id.id,
"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,
"invoice_line_ids": [(0, 0, vals) for vals in self.invoice_line_vals()],
}
def invoice_line_vals(self):
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,
}
)
return vals
def generate_move(self):
"""
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
):
raise UserError(_("Some moves must be created first"))
move = self.env["account.move"].create(record.move_vals())
move.post()
res.append(move.id)
return res
def generate_invoice(self):
"""
Computes invoices of leases
: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
):
raise UserError(_("Some invoices must be created first"))
invoice = self.env["account.move"].create(record.invoice_vals())
res.append(invoice.id)
for line in invoice.invoice_line_ids:
line.tax_ids = line._get_computed_taxes()
invoice.with_context(
check_move_validity=False
)._recompute_dynamic_lines(recompute_all_taxes=True)
invoice._check_balanced()
if (
record.long_term_loan_account_id
and record.long_term_principal_amount != 0
):
invoice.write({"line_ids": record._get_long_term_move_line_vals()})
if record.loan_id.post_invoice:
invoice.post()
return res
def _get_long_term_move_line_vals(self):
return [
(
0,
0,
{
"account_id": self.loan_id.short_term_loan_account_id.id,
"credit": self.long_term_principal_amount,
"debit": 0,
"exclude_from_invoice_tab": True,
},
),
(
0,
0,
{
"account_id": self.long_term_loan_account_id.id,
"credit": 0,
"debit": self.long_term_principal_amount,
"exclude_from_invoice_tab": True,
},
),
]
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:
self.generate_invoice()
else:
self.generate_move()
return self.view_account_values()
def view_account_moves(self):
self.ensure_one()
action = self.env.ref("account.action_move_line_form")
result = action.read()[0]
result["context"] = {
"default_loan_line_id": self.id,
"default_loan_id": self.loan_id.id,
}
result["domain"] = [("loan_line_id", "=", self.id)]
if len(self.move_ids) == 1:
res = self.env.ref("account.move.form", False)
result["views"] = [(res and res.id or False, "form")]
result["res_id"] = self.move_ids.id
return result
def view_account_invoices(self):
self.ensure_one()
action = self.env.ref("account.action_move_out_invoice_type")
result = action.read()[0]
result["context"] = {
"default_loan_line_id": self.id,
"default_loan_id": self.loan_id.id,
}
result["domain"] = [
("loan_line_id", "=", self.id),
("move_type", "=", "in_invoice"),
]
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
return result