mirror of
https://gitlab.com/flectra-community/account-financial-reporting.git
synced 2024-12-25 13:31:45 +00:00
965 lines
41 KiB
Python
965 lines
41 KiB
Python
# ?? 2016 Julien Coux (Camptocamp)
|
|
# ?? 2018 Forest and Biomass Romania SA
|
|
# Copyright 2020 ForgeFlow S.L. (https://www.forgeflow.com)
|
|
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
|
|
|
|
|
|
from flectra import _, api, models
|
|
from flectra.tools.float_utils import float_is_zero
|
|
|
|
|
|
class TrialBalanceReport(models.AbstractModel):
|
|
_name = "report.account_financial_report.trial_balance"
|
|
_description = "Trial Balance Report"
|
|
_inherit = "report.account_financial_report.abstract_report"
|
|
|
|
def _get_initial_balances_bs_ml_domain(
|
|
self,
|
|
account_ids,
|
|
journal_ids,
|
|
partner_ids,
|
|
company_id,
|
|
date_from,
|
|
only_posted_moves,
|
|
show_partner_details,
|
|
):
|
|
accounts_domain = [
|
|
("company_id", "=", company_id),
|
|
("include_initial_balance", "=", True),
|
|
]
|
|
if account_ids:
|
|
accounts_domain += [("id", "in", account_ids)]
|
|
domain = [("date", "<", date_from)]
|
|
accounts = self.env["account.account"].search(accounts_domain)
|
|
domain += [("account_id", "in", accounts.ids)]
|
|
if company_id:
|
|
domain += [("company_id", "=", company_id)]
|
|
if journal_ids:
|
|
domain += [("journal_id", "in", journal_ids)]
|
|
if partner_ids:
|
|
domain += [("partner_id", "in", partner_ids)]
|
|
if only_posted_moves:
|
|
domain += [("move_id.state", "=", "posted")]
|
|
else:
|
|
domain += [("move_id.state", "in", ["posted", "draft"])]
|
|
if show_partner_details:
|
|
domain += [
|
|
(
|
|
"account_id.account_type",
|
|
"in",
|
|
["asset_receivable", "liability_payable"],
|
|
)
|
|
]
|
|
return domain
|
|
|
|
def _get_initial_balances_pl_ml_domain(
|
|
self,
|
|
account_ids,
|
|
journal_ids,
|
|
partner_ids,
|
|
company_id,
|
|
date_from,
|
|
only_posted_moves,
|
|
show_partner_details,
|
|
fy_start_date,
|
|
):
|
|
accounts_domain = [
|
|
("company_id", "=", company_id),
|
|
("include_initial_balance", "=", False),
|
|
]
|
|
if account_ids:
|
|
accounts_domain += [("id", "in", account_ids)]
|
|
domain = [("date", "<", date_from), ("date", ">=", fy_start_date)]
|
|
accounts = self.env["account.account"].search(accounts_domain)
|
|
domain += [("account_id", "in", accounts.ids)]
|
|
if company_id:
|
|
domain += [("company_id", "=", company_id)]
|
|
if journal_ids:
|
|
domain += [("journal_id", "in", journal_ids)]
|
|
if partner_ids:
|
|
domain += [("partner_id", "in", partner_ids)]
|
|
if only_posted_moves:
|
|
domain += [("move_id.state", "=", "posted")]
|
|
else:
|
|
domain += [("move_id.state", "in", ["posted", "draft"])]
|
|
if show_partner_details:
|
|
domain += [
|
|
(
|
|
"account_id.account_type",
|
|
"in",
|
|
["asset_receivable", "liability_payable"],
|
|
)
|
|
]
|
|
return domain
|
|
|
|
@api.model
|
|
def _get_period_ml_domain(
|
|
self,
|
|
account_ids,
|
|
journal_ids,
|
|
partner_ids,
|
|
company_id,
|
|
date_to,
|
|
date_from,
|
|
only_posted_moves,
|
|
show_partner_details,
|
|
):
|
|
domain = [
|
|
("display_type", "not in", ["line_note", "line_section"]),
|
|
("date", ">=", date_from),
|
|
("date", "<=", date_to),
|
|
]
|
|
if company_id:
|
|
domain += [("company_id", "=", company_id)]
|
|
if account_ids:
|
|
domain += [("account_id", "in", account_ids)]
|
|
if journal_ids:
|
|
domain += [("journal_id", "in", journal_ids)]
|
|
if partner_ids:
|
|
domain += [("partner_id", "in", partner_ids)]
|
|
if only_posted_moves:
|
|
domain += [("move_id.state", "=", "posted")]
|
|
else:
|
|
domain += [("move_id.state", "in", ["posted", "draft"])]
|
|
if show_partner_details:
|
|
domain += [
|
|
(
|
|
"account_id.account_type",
|
|
"in",
|
|
["asset_receivable", "liability_payable"],
|
|
)
|
|
]
|
|
return domain
|
|
|
|
def _get_initial_balance_fy_pl_ml_domain(
|
|
self,
|
|
account_ids,
|
|
journal_ids,
|
|
partner_ids,
|
|
company_id,
|
|
fy_start_date,
|
|
only_posted_moves,
|
|
show_partner_details,
|
|
):
|
|
accounts_domain = [
|
|
("company_id", "=", company_id),
|
|
("include_initial_balance", "=", False),
|
|
]
|
|
if account_ids:
|
|
accounts_domain += [("id", "in", account_ids)]
|
|
domain = [("date", "<", fy_start_date)]
|
|
accounts = self.env["account.account"].search(accounts_domain)
|
|
domain += [("account_id", "in", accounts.ids)]
|
|
if company_id:
|
|
domain += [("company_id", "=", company_id)]
|
|
if journal_ids:
|
|
domain += [("journal_id", "in", journal_ids)]
|
|
if partner_ids:
|
|
domain += [("partner_id", "in", partner_ids)]
|
|
if only_posted_moves:
|
|
domain += [("move_id.state", "=", "posted")]
|
|
else:
|
|
domain += [("move_id.state", "in", ["posted", "draft"])]
|
|
if show_partner_details:
|
|
domain += [
|
|
(
|
|
"account_id.account_type",
|
|
"in",
|
|
["asset_receivable", "liability_payable"],
|
|
)
|
|
]
|
|
return domain
|
|
|
|
def _get_pl_initial_balance(
|
|
self,
|
|
account_ids,
|
|
journal_ids,
|
|
partner_ids,
|
|
company_id,
|
|
fy_start_date,
|
|
only_posted_moves,
|
|
show_partner_details,
|
|
foreign_currency,
|
|
):
|
|
domain = self._get_initial_balance_fy_pl_ml_domain(
|
|
account_ids,
|
|
journal_ids,
|
|
partner_ids,
|
|
company_id,
|
|
fy_start_date,
|
|
only_posted_moves,
|
|
show_partner_details,
|
|
)
|
|
initial_balances = self.env["account.move.line"].read_group(
|
|
domain=domain,
|
|
fields=["account_id", "balance", "amount_currency:sum"],
|
|
groupby=["account_id"],
|
|
)
|
|
pl_initial_balance = 0.0
|
|
pl_initial_currency_balance = 0.0
|
|
for initial_balance in initial_balances:
|
|
pl_initial_balance += initial_balance["balance"]
|
|
if foreign_currency:
|
|
pl_initial_currency_balance += round(
|
|
initial_balance["amount_currency"], 2
|
|
)
|
|
return pl_initial_balance, pl_initial_currency_balance
|
|
|
|
@api.model
|
|
def _compute_account_amount(
|
|
self, total_amount, tb_initial_acc, tb_period_acc, foreign_currency
|
|
):
|
|
for tb in tb_period_acc:
|
|
acc_id = tb["account_id"][0]
|
|
total_amount[acc_id] = self._prepare_total_amount(tb, foreign_currency)
|
|
total_amount[acc_id]["credit"] = tb["credit"]
|
|
total_amount[acc_id]["debit"] = tb["debit"]
|
|
total_amount[acc_id]["balance"] = tb["balance"]
|
|
total_amount[acc_id]["initial_balance"] = 0.0
|
|
if foreign_currency:
|
|
total_amount[acc_id]["initial_currency_balance"] = 0.0
|
|
if "__context" in tb and "group_by" in tb["__context"]:
|
|
group_by = tb["__context"]["group_by"][0]
|
|
gb_data = {}
|
|
tb_grouped = self.env["account.move.line"].read_group(
|
|
domain=tb["__domain"],
|
|
fields=[
|
|
group_by,
|
|
"debit",
|
|
"credit",
|
|
"balance",
|
|
"amount_currency:sum",
|
|
],
|
|
groupby=[group_by],
|
|
)
|
|
for tb2 in tb_grouped:
|
|
gb_id = tb2[group_by][0] if tb2[group_by] else 0
|
|
gb_data[gb_id] = self._prepare_total_amount(tb2, foreign_currency)
|
|
gb_data[gb_id]["credit"] = tb2["credit"]
|
|
gb_data[gb_id]["debit"] = tb2["debit"]
|
|
gb_data[gb_id]["balance"] = tb2["balance"]
|
|
gb_data[gb_id]["initial_balance"] = 0.0
|
|
if foreign_currency:
|
|
gb_data[gb_id]["initial_currency_balance"] = 0.0
|
|
total_amount[acc_id]["group_by"] = group_by
|
|
total_amount[acc_id]["group_by_data"] = gb_data
|
|
for tb in tb_initial_acc:
|
|
acc_id = tb["account_id"]
|
|
if acc_id not in total_amount.keys():
|
|
total_amount[acc_id] = self._prepare_total_amount(tb, foreign_currency)
|
|
total_amount[acc_id]["group_by_data"] = {}
|
|
total_amount[acc_id]["group_by_data"][0] = self._prepare_total_amount(
|
|
tb, foreign_currency
|
|
)
|
|
else:
|
|
total_amount[acc_id]["initial_balance"] = tb["balance"]
|
|
total_amount[acc_id]["ending_balance"] += tb["balance"]
|
|
if foreign_currency:
|
|
total_amount[acc_id]["initial_currency_balance"] = round(
|
|
tb["amount_currency"], 2
|
|
)
|
|
total_amount[acc_id]["ending_currency_balance"] += round(
|
|
tb["amount_currency"], 2
|
|
)
|
|
if "group_by_data" in tb:
|
|
for gb_key in list(tb["group_by_data"]):
|
|
tb2 = tb["group_by_data"][gb_key]
|
|
if "group_by_data" in total_amount[acc_id]:
|
|
if gb_key not in total_amount[acc_id]["group_by_data"]:
|
|
total_amount[acc_id]["group_by_data"][
|
|
gb_key
|
|
] = self._prepare_total_amount(tb2, foreign_currency)
|
|
else:
|
|
total_amount[acc_id]["group_by_data"][gb_key][
|
|
"initial_balance"
|
|
] = tb2["balance"]
|
|
total_amount[acc_id]["group_by_data"][gb_key][
|
|
"ending_balance"
|
|
] += tb2["balance"]
|
|
if foreign_currency:
|
|
total_amount[acc_id]["group_by_data"][gb_key][
|
|
"initial_currency_balance"
|
|
] = round(tb2["amount_currency"], 2)
|
|
total_amount[acc_id]["group_by_data"][gb_key][
|
|
"ending_currency_balance"
|
|
] += round(tb2["amount_currency"], 2)
|
|
return total_amount
|
|
|
|
@api.model
|
|
def _prepare_total_amount(self, tb, foreign_currency):
|
|
res = {
|
|
"credit": 0.0,
|
|
"debit": 0.0,
|
|
"balance": 0.0,
|
|
"initial_balance": tb["balance"],
|
|
"ending_balance": tb["balance"],
|
|
}
|
|
if foreign_currency:
|
|
res["initial_currency_balance"] = round(tb["amount_currency"], 2)
|
|
res["ending_currency_balance"] = round(tb["amount_currency"], 2)
|
|
return res
|
|
|
|
@api.model
|
|
def _compute_acc_prt_amount(
|
|
self, total_amount, tb, acc_id, prt_id, foreign_currency
|
|
):
|
|
# Add keys to dict if not exists
|
|
if acc_id not in total_amount:
|
|
total_amount[acc_id] = self._prepare_total_amount(tb, foreign_currency)
|
|
if prt_id not in total_amount[acc_id]:
|
|
total_amount[acc_id][prt_id] = self._prepare_total_amount(
|
|
tb, foreign_currency
|
|
)
|
|
else:
|
|
# Increase balance field values
|
|
total_amount[acc_id][prt_id]["initial_balance"] = tb["balance"]
|
|
total_amount[acc_id][prt_id]["ending_balance"] += tb["balance"]
|
|
if foreign_currency:
|
|
total_amount[acc_id][prt_id]["initial_currency_balance"] = round(
|
|
tb["amount_currency"], 2
|
|
)
|
|
total_amount[acc_id][prt_id]["ending_currency_balance"] += round(
|
|
tb["amount_currency"], 2
|
|
)
|
|
total_amount[acc_id][prt_id]["partner_name"] = (
|
|
tb["partner_id"][1] if tb["partner_id"] else _("Missing Partner")
|
|
)
|
|
return total_amount
|
|
|
|
@api.model
|
|
def _compute_partner_amount(
|
|
self, total_amount, tb_initial_prt, tb_period_prt, foreign_currency
|
|
):
|
|
partners_ids = set()
|
|
partners_data = {}
|
|
for tb in tb_period_prt:
|
|
acc_id = tb["account_id"][0]
|
|
prt_id = tb["partner_id"][0] if tb["partner_id"] else 0
|
|
if prt_id not in partners_ids:
|
|
partner_name = (
|
|
tb["partner_id"][1] if tb["partner_id"] else _("Missing Partner")
|
|
)
|
|
partners_data.update({prt_id: {"id": prt_id, "name": partner_name}})
|
|
total_amount[acc_id][prt_id] = self._prepare_total_amount(
|
|
tb, foreign_currency
|
|
)
|
|
total_amount[acc_id][prt_id]["credit"] = tb["credit"]
|
|
total_amount[acc_id][prt_id]["debit"] = tb["debit"]
|
|
total_amount[acc_id][prt_id]["balance"] = tb["balance"]
|
|
total_amount[acc_id][prt_id]["initial_balance"] = 0.0
|
|
total_amount[acc_id][prt_id]["partner_name"] = partners_data[prt_id]["name"]
|
|
partners_ids.add(prt_id)
|
|
for tb in tb_initial_prt:
|
|
acc_id = tb["account_id"][0]
|
|
prt_id = tb["partner_id"][0] if tb["partner_id"] else 0
|
|
if prt_id not in partners_ids:
|
|
partner_name = (
|
|
tb["partner_id"][1] if tb["partner_id"] else _("Missing Partner")
|
|
)
|
|
partners_data.update({prt_id: {"id": prt_id, "name": partner_name}})
|
|
total_amount = self._compute_acc_prt_amount(
|
|
total_amount, tb, acc_id, prt_id, foreign_currency
|
|
)
|
|
# sort on partner_name
|
|
for acc_id, total_data in total_amount.items():
|
|
tmp_list = sorted(
|
|
total_data.items(),
|
|
key=lambda x: isinstance(x[0], int)
|
|
and isinstance(x[1], dict)
|
|
and x[1]["partner_name"]
|
|
or x[0],
|
|
)
|
|
total_amount[acc_id] = {}
|
|
for key, value in tmp_list:
|
|
total_amount[acc_id][key] = value
|
|
return total_amount, partners_data
|
|
|
|
def _remove_accounts_at_cero(self, total_amount, show_partner_details, company):
|
|
def is_removable(d):
|
|
rounding = company.currency_id.rounding
|
|
return (
|
|
float_is_zero(d["initial_balance"], precision_rounding=rounding)
|
|
and float_is_zero(d["credit"], precision_rounding=rounding)
|
|
and float_is_zero(d["debit"], precision_rounding=rounding)
|
|
and float_is_zero(d["ending_balance"], precision_rounding=rounding)
|
|
)
|
|
|
|
accounts_to_remove = []
|
|
for acc_id, ta_data in total_amount.items():
|
|
if is_removable(ta_data):
|
|
accounts_to_remove.append(acc_id)
|
|
elif show_partner_details:
|
|
partner_to_remove = []
|
|
for key, value in ta_data.items():
|
|
# If the show_partner_details option is checked,
|
|
# the partner data is in the same account data dict
|
|
# but with the partner id as the key
|
|
if isinstance(key, int) and is_removable(value):
|
|
partner_to_remove.append(key)
|
|
for partner_id in partner_to_remove:
|
|
del ta_data[partner_id]
|
|
for account_id in accounts_to_remove:
|
|
del total_amount[account_id]
|
|
|
|
# flake8: noqa: C901
|
|
@api.model
|
|
def _get_data(
|
|
self,
|
|
account_ids,
|
|
journal_ids,
|
|
partner_ids,
|
|
company_id,
|
|
date_to,
|
|
date_from,
|
|
foreign_currency,
|
|
only_posted_moves,
|
|
show_partner_details,
|
|
hide_account_at_0,
|
|
unaffected_earnings_account,
|
|
fy_start_date,
|
|
grouped_by,
|
|
):
|
|
accounts_domain = [("company_id", "=", company_id)]
|
|
if account_ids:
|
|
accounts_domain += [("id", "in", account_ids)]
|
|
# If explicit list of accounts is provided,
|
|
# don't include unaffected earnings account
|
|
unaffected_earnings_account = False
|
|
accounts = self.env["account.account"].search(accounts_domain)
|
|
tb_initial_acc = []
|
|
for account in accounts:
|
|
tb_initial_acc.append(
|
|
{"account_id": account.id, "balance": 0.0, "amount_currency": 0.0}
|
|
)
|
|
groupby_fields = ["account_id"]
|
|
if grouped_by:
|
|
groupby_fields.append("analytic_account_ids")
|
|
initial_domain_bs = self._get_initial_balances_bs_ml_domain(
|
|
account_ids,
|
|
journal_ids,
|
|
partner_ids,
|
|
company_id,
|
|
date_from,
|
|
only_posted_moves,
|
|
show_partner_details,
|
|
)
|
|
tb_initial_acc_bs = self.env["account.move.line"].read_group(
|
|
domain=initial_domain_bs,
|
|
fields=["account_id", "balance", "amount_currency:sum"],
|
|
groupby=groupby_fields,
|
|
)
|
|
initial_domain_pl = self._get_initial_balances_pl_ml_domain(
|
|
account_ids,
|
|
journal_ids,
|
|
partner_ids,
|
|
company_id,
|
|
date_from,
|
|
only_posted_moves,
|
|
show_partner_details,
|
|
fy_start_date,
|
|
)
|
|
tb_initial_acc_pl = self.env["account.move.line"].read_group(
|
|
domain=initial_domain_pl,
|
|
fields=["account_id", "balance", "amount_currency:sum"],
|
|
groupby=groupby_fields,
|
|
)
|
|
tb_initial_acc_rg = tb_initial_acc_bs + tb_initial_acc_pl
|
|
for account_rg in tb_initial_acc_rg:
|
|
element = list(
|
|
filter(
|
|
lambda acc_dict: acc_dict["account_id"]
|
|
== account_rg["account_id"][0],
|
|
tb_initial_acc,
|
|
)
|
|
)
|
|
if element:
|
|
element[0]["balance"] += account_rg["balance"]
|
|
element[0]["amount_currency"] += account_rg["amount_currency"]
|
|
if "__context" in account_rg and "group_by" in account_rg["__context"]:
|
|
group_by = account_rg["__context"]["group_by"][0]
|
|
gb_data = {}
|
|
account_rg_grouped = self.env["account.move.line"].read_group(
|
|
domain=account_rg["__domain"],
|
|
fields=[group_by, "balance", "amount_currency:sum"],
|
|
groupby=[group_by],
|
|
)
|
|
for a_rg2 in account_rg_grouped:
|
|
gb_id = a_rg2[group_by][0] if a_rg2[group_by] else 0
|
|
gb_data[gb_id] = {
|
|
"balance": a_rg2["balance"],
|
|
"amount_currency": a_rg2["amount_currency"],
|
|
}
|
|
element[0]["group_by"] = group_by
|
|
element[0]["group_by_data"] = gb_data
|
|
if hide_account_at_0:
|
|
tb_initial_acc = [p for p in tb_initial_acc if p["balance"] != 0]
|
|
|
|
period_domain = self._get_period_ml_domain(
|
|
account_ids,
|
|
journal_ids,
|
|
partner_ids,
|
|
company_id,
|
|
date_to,
|
|
date_from,
|
|
only_posted_moves,
|
|
show_partner_details,
|
|
)
|
|
tb_period_acc = self.env["account.move.line"].read_group(
|
|
domain=period_domain,
|
|
fields=["account_id", "debit", "credit", "balance", "amount_currency:sum"],
|
|
groupby=groupby_fields,
|
|
)
|
|
|
|
if show_partner_details:
|
|
tb_initial_prt_bs = self.env["account.move.line"].read_group(
|
|
domain=initial_domain_bs,
|
|
fields=["account_id", "partner_id", "balance", "amount_currency:sum"],
|
|
groupby=["account_id", "partner_id"],
|
|
lazy=False,
|
|
)
|
|
tb_initial_prt_pl = self.env["account.move.line"].read_group(
|
|
domain=initial_domain_pl,
|
|
fields=["account_id", "partner_id", "balance", "amount_currency:sum"],
|
|
groupby=["account_id", "partner_id"],
|
|
)
|
|
tb_initial_prt = tb_initial_prt_bs + tb_initial_prt_pl
|
|
if hide_account_at_0:
|
|
tb_initial_prt = [p for p in tb_initial_prt if p["balance"] != 0]
|
|
tb_period_prt = self.env["account.move.line"].read_group(
|
|
domain=period_domain,
|
|
fields=[
|
|
"account_id",
|
|
"partner_id",
|
|
"debit",
|
|
"credit",
|
|
"balance",
|
|
"amount_currency:sum",
|
|
],
|
|
groupby=["account_id", "partner_id"],
|
|
lazy=False,
|
|
)
|
|
total_amount = {}
|
|
partners_data = []
|
|
total_amount = self._compute_account_amount(
|
|
total_amount, tb_initial_acc, tb_period_acc, foreign_currency
|
|
)
|
|
if show_partner_details:
|
|
total_amount, partners_data = self._compute_partner_amount(
|
|
total_amount, tb_initial_prt, tb_period_prt, foreign_currency
|
|
)
|
|
# Remove accounts a 0 from collections
|
|
if hide_account_at_0:
|
|
company = self.env["res.company"].browse(company_id)
|
|
self._remove_accounts_at_cero(total_amount, show_partner_details, company)
|
|
|
|
accounts_ids = list(total_amount.keys())
|
|
unaffected_id = unaffected_earnings_account
|
|
if unaffected_id:
|
|
if unaffected_id not in accounts_ids:
|
|
accounts_ids.append(unaffected_id)
|
|
total_amount[unaffected_id] = {}
|
|
total_amount[unaffected_id]["initial_balance"] = 0.0
|
|
total_amount[unaffected_id]["balance"] = 0.0
|
|
total_amount[unaffected_id]["credit"] = 0.0
|
|
total_amount[unaffected_id]["debit"] = 0.0
|
|
total_amount[unaffected_id]["ending_balance"] = 0.0
|
|
if foreign_currency:
|
|
total_amount[unaffected_id]["amount_currency"] = 0
|
|
total_amount[unaffected_id]["initial_currency_balance"] = 0.0
|
|
total_amount[unaffected_id]["ending_currency_balance"] = 0.0
|
|
if grouped_by:
|
|
total_amount[unaffected_id]["group_by"] = grouped_by
|
|
total_amount[unaffected_id]["group_by_data"] = {}
|
|
# Fix to prevent side effects
|
|
if (
|
|
foreign_currency
|
|
and "amount_currency" not in total_amount[unaffected_id]
|
|
):
|
|
total_amount[unaffected_id]["amount_currency"] = 0
|
|
group_by_data_item = self._prepare_total_amount(
|
|
total_amount[unaffected_id], foreign_currency
|
|
)
|
|
total_amount[unaffected_id]["group_by_data"][0] = group_by_data_item
|
|
accounts_data = self._get_accounts_data(accounts_ids)
|
|
(
|
|
pl_initial_balance,
|
|
pl_initial_currency_balance,
|
|
) = self._get_pl_initial_balance(
|
|
account_ids,
|
|
journal_ids,
|
|
partner_ids,
|
|
company_id,
|
|
fy_start_date,
|
|
only_posted_moves,
|
|
show_partner_details,
|
|
foreign_currency,
|
|
)
|
|
if unaffected_id:
|
|
total_amount[unaffected_id]["ending_balance"] += pl_initial_balance
|
|
total_amount[unaffected_id]["initial_balance"] += pl_initial_balance
|
|
if foreign_currency:
|
|
total_amount[unaffected_id][
|
|
"ending_currency_balance"
|
|
] += pl_initial_currency_balance
|
|
total_amount[unaffected_id][
|
|
"initial_currency_balance"
|
|
] += pl_initial_currency_balance
|
|
if grouped_by:
|
|
total_amount[unaffected_id]["group_by_data"][0][
|
|
"ending_balance"
|
|
] = total_amount[unaffected_id]["ending_balance"]
|
|
total_amount[unaffected_id]["group_by_data"][0][
|
|
"initial_balance"
|
|
] = total_amount[unaffected_id]["initial_balance"]
|
|
if foreign_currency:
|
|
total_amount[unaffected_id]["group_by_data"][0][
|
|
"ending_currency_balance"
|
|
] = total_amount[unaffected_id]["ending_currency_balance"]
|
|
total_amount[unaffected_id]["group_by_data"][0][
|
|
"initial_currency_balance"
|
|
] = total_amount[unaffected_id]["initial_currency_balance"]
|
|
return total_amount, accounts_data, partners_data
|
|
|
|
def _get_data_grouped(self, total_amount, accounts_data, foreign_currency):
|
|
"""Get the data grouped by analytical account instead of as used
|
|
"without grouping".
|
|
"""
|
|
trial_balance = {}
|
|
total_amount_grouped = {"type": "total", "name": _("TOTAL")}
|
|
f_names = [
|
|
"credit",
|
|
"debit",
|
|
"balance",
|
|
"initial_balance",
|
|
"ending_balance",
|
|
"initial_currency_balance",
|
|
"ending_currency_balance",
|
|
]
|
|
for f_name in f_names:
|
|
total_amount_grouped[f_name] = 0
|
|
for a_id in list(total_amount.keys()):
|
|
for key in list(total_amount[a_id]["group_by_data"].keys()):
|
|
total_amount_item2 = total_amount[a_id]["group_by_data"][key]
|
|
if key not in trial_balance:
|
|
trial_balance[key] = {}
|
|
for f_name in f_names:
|
|
if f_name in total_amount_item2:
|
|
trial_balance[key][f_name] = 0
|
|
trial_balance[key]["account_data"] = {}
|
|
for f_name in f_names:
|
|
if f_name in total_amount_item2:
|
|
trial_balance[key][f_name] += total_amount_item2[f_name]
|
|
# Prepare data_item
|
|
data_item = total_amount_item2
|
|
data_item["type"] = "account_type"
|
|
data_item["id"] = a_id
|
|
data_item["name"] = accounts_data[a_id]["name"]
|
|
data_item["code"] = accounts_data[a_id]["code"]
|
|
if foreign_currency:
|
|
data_item["currency_id"] = accounts_data[a_id]["currency_id"]
|
|
data_item["currency_name"] = accounts_data[a_id]["currency_name"]
|
|
trial_balance[key]["account_data"][a_id] = data_item
|
|
analytic_account_ids = list(trial_balance.keys())
|
|
aa_data = {}
|
|
aaa_model = self.env["account.analytic.account"].with_context(active_test=False)
|
|
analytic_accounts = aaa_model.search_read(
|
|
domain=[("id", "in", analytic_account_ids)],
|
|
fields=["display_name"],
|
|
)
|
|
for aa in analytic_accounts:
|
|
aa_data[aa["id"]] = aa
|
|
for aa_id in analytic_account_ids:
|
|
trial_balance[aa_id]["id"] = aa_id
|
|
trial_balance[aa_id]["type"] = "analytic_account_type"
|
|
trial_balance[aa_id]["name"] = (
|
|
aa_data[aa_id]["display_name"]
|
|
if aa_id in aa_data
|
|
else _("Without analytic account")
|
|
)
|
|
account_data_item = list(trial_balance[aa_id]["account_data"].values())
|
|
account_data_item = sorted(account_data_item, key=lambda k: k["code"])
|
|
trial_balance[aa_id]["account_data"] = account_data_item
|
|
for f_name in f_names:
|
|
if f_name in trial_balance[aa_id]:
|
|
total_amount_grouped[f_name] += trial_balance[aa_id][f_name]
|
|
trial_balance = list(trial_balance.values())
|
|
trial_balance = sorted(trial_balance, key=lambda k: k["name"])
|
|
return trial_balance, total_amount_grouped
|
|
|
|
def _get_hierarchy_groups(self, group_ids, groups_data, foreign_currency):
|
|
for group_id in group_ids:
|
|
parent_id = groups_data[group_id]["parent_id"]
|
|
while parent_id:
|
|
if parent_id not in groups_data.keys():
|
|
group = self.env["account.group"].browse(parent_id)
|
|
groups_data[group.id] = {
|
|
"id": group.id,
|
|
"code": group.code_prefix_start,
|
|
"name": group.name,
|
|
"parent_id": group.parent_id.id,
|
|
"parent_path": group.parent_path,
|
|
"complete_code": group.complete_code,
|
|
"account_ids": group.compute_account_ids.ids,
|
|
"type": "group_type",
|
|
"initial_balance": 0,
|
|
"debit": 0,
|
|
"credit": 0,
|
|
"balance": 0,
|
|
"ending_balance": 0,
|
|
}
|
|
if foreign_currency:
|
|
groups_data[group.id].update(
|
|
initial_currency_balance=0,
|
|
ending_currency_balance=0,
|
|
)
|
|
acc_keys = ["debit", "credit", "balance"]
|
|
acc_keys += ["initial_balance", "ending_balance"]
|
|
for acc_key in acc_keys:
|
|
groups_data[parent_id][acc_key] += groups_data[group_id][acc_key]
|
|
if foreign_currency:
|
|
groups_data[group_id]["initial_currency_balance"] += groups_data[
|
|
group_id
|
|
]["initial_currency_balance"]
|
|
groups_data[group_id]["ending_currency_balance"] += groups_data[
|
|
group_id
|
|
]["ending_currency_balance"]
|
|
parent_id = groups_data[parent_id]["parent_id"]
|
|
return groups_data
|
|
|
|
def _get_groups_data(self, accounts_data, total_amount, foreign_currency):
|
|
accounts_ids = list(accounts_data.keys())
|
|
accounts = self.env["account.account"].browse(accounts_ids)
|
|
account_group_relation = {}
|
|
for account in accounts:
|
|
accounts_data[account.id]["complete_code"] = (
|
|
account.group_id.complete_code + " / " + account.code
|
|
if account.group_id.id
|
|
else ""
|
|
)
|
|
if account.group_id.id:
|
|
if account.group_id.id not in account_group_relation.keys():
|
|
account_group_relation.update({account.group_id.id: [account.id]})
|
|
else:
|
|
account_group_relation[account.group_id.id].append(account.id)
|
|
groups = self.env["account.group"].browse(account_group_relation.keys())
|
|
groups_data = {}
|
|
for group in groups:
|
|
groups_data.update(
|
|
{
|
|
group.id: {
|
|
"id": group.id,
|
|
"code": group.code_prefix_start,
|
|
"name": group.name,
|
|
"parent_id": group.parent_id.id,
|
|
"parent_path": group.parent_path,
|
|
"type": "group_type",
|
|
"complete_code": group.complete_code,
|
|
"account_ids": group.compute_account_ids.ids,
|
|
"initial_balance": 0.0,
|
|
"credit": 0.0,
|
|
"debit": 0.0,
|
|
"balance": 0.0,
|
|
"ending_balance": 0.0,
|
|
}
|
|
}
|
|
)
|
|
if foreign_currency:
|
|
groups_data[group.id]["initial_currency_balance"] = 0.0
|
|
groups_data[group.id]["ending_currency_balance"] = 0.0
|
|
for group_id in account_group_relation.keys():
|
|
for account_id in account_group_relation[group_id]:
|
|
groups_data[group_id]["initial_balance"] += total_amount[account_id][
|
|
"initial_balance"
|
|
]
|
|
groups_data[group_id]["debit"] += total_amount[account_id]["debit"]
|
|
groups_data[group_id]["credit"] += total_amount[account_id]["credit"]
|
|
groups_data[group_id]["balance"] += total_amount[account_id]["balance"]
|
|
groups_data[group_id]["ending_balance"] += total_amount[account_id][
|
|
"ending_balance"
|
|
]
|
|
if foreign_currency:
|
|
groups_data[group_id]["initial_currency_balance"] += total_amount[
|
|
account_id
|
|
]["initial_currency_balance"]
|
|
groups_data[group_id]["ending_currency_balance"] += total_amount[
|
|
account_id
|
|
]["ending_currency_balance"]
|
|
group_ids = list(groups_data.keys())
|
|
groups_data = self._get_hierarchy_groups(
|
|
group_ids,
|
|
groups_data,
|
|
foreign_currency,
|
|
)
|
|
return groups_data
|
|
|
|
def _get_computed_groups_data(self, accounts_data, total_amount, foreign_currency):
|
|
groups = self.env["account.group"].search([("id", "!=", False)])
|
|
groups_data = {}
|
|
for group in groups:
|
|
len_group_code = len(group.code_prefix_start)
|
|
groups_data.update(
|
|
{
|
|
group.id: {
|
|
"id": group.id,
|
|
"code": group.code_prefix_start,
|
|
"name": group.name,
|
|
"parent_id": group.parent_id.id,
|
|
"parent_path": group.parent_path,
|
|
"type": "group_type",
|
|
"complete_code": group.complete_code,
|
|
"account_ids": group.compute_account_ids.ids,
|
|
"initial_balance": 0.0,
|
|
"credit": 0.0,
|
|
"debit": 0.0,
|
|
"balance": 0.0,
|
|
"ending_balance": 0.0,
|
|
}
|
|
}
|
|
)
|
|
if foreign_currency:
|
|
groups_data[group.id]["initial_currency_balance"] = 0.0
|
|
groups_data[group.id]["ending_currency_balance"] = 0.0
|
|
for account in accounts_data.values():
|
|
if group.code_prefix_start == account["code"][:len_group_code]:
|
|
acc_id = account["id"]
|
|
group_id = group.id
|
|
groups_data[group_id]["initial_balance"] += total_amount[acc_id][
|
|
"initial_balance"
|
|
]
|
|
groups_data[group_id]["debit"] += total_amount[acc_id]["debit"]
|
|
groups_data[group_id]["credit"] += total_amount[acc_id]["credit"]
|
|
groups_data[group_id]["balance"] += total_amount[acc_id]["balance"]
|
|
groups_data[group_id]["ending_balance"] += total_amount[acc_id][
|
|
"ending_balance"
|
|
]
|
|
if foreign_currency:
|
|
groups_data[group_id][
|
|
"initial_currency_balance"
|
|
] += total_amount[acc_id]["initial_currency_balance"]
|
|
groups_data[group_id][
|
|
"ending_currency_balance"
|
|
] += total_amount[acc_id]["ending_currency_balance"]
|
|
return groups_data
|
|
|
|
def _get_report_values(self, docids, data):
|
|
show_partner_details = data["show_partner_details"]
|
|
wizard_id = data["wizard_id"]
|
|
company = self.env["res.company"].browse(data["company_id"])
|
|
company_id = data["company_id"]
|
|
partner_ids = data["partner_ids"]
|
|
journal_ids = data["journal_ids"]
|
|
account_ids = data["account_ids"]
|
|
date_to = data["date_to"]
|
|
date_from = data["date_from"]
|
|
hide_account_at_0 = data["hide_account_at_0"]
|
|
show_hierarchy = data["show_hierarchy"]
|
|
show_hierarchy_level = data["show_hierarchy_level"]
|
|
foreign_currency = data["foreign_currency"]
|
|
only_posted_moves = data["only_posted_moves"]
|
|
unaffected_earnings_account = data["unaffected_earnings_account"]
|
|
fy_start_date = data["fy_start_date"]
|
|
grouped_by = data["grouped_by"]
|
|
total_amount, accounts_data, partners_data = self._get_data(
|
|
account_ids,
|
|
journal_ids,
|
|
partner_ids,
|
|
company_id,
|
|
date_to,
|
|
date_from,
|
|
foreign_currency,
|
|
only_posted_moves,
|
|
show_partner_details,
|
|
hide_account_at_0,
|
|
unaffected_earnings_account,
|
|
fy_start_date,
|
|
grouped_by,
|
|
)
|
|
trial_balance_grouped = False
|
|
total_amount_grouped = False
|
|
if grouped_by:
|
|
trial_balance_grouped, total_amount_grouped = self._get_data_grouped(
|
|
total_amount, accounts_data, foreign_currency
|
|
)
|
|
trial_balance = []
|
|
if not show_partner_details:
|
|
for account_id in accounts_data.keys():
|
|
accounts_data[account_id].update(
|
|
{
|
|
"initial_balance": total_amount[account_id]["initial_balance"],
|
|
"credit": total_amount[account_id]["credit"],
|
|
"debit": total_amount[account_id]["debit"],
|
|
"balance": total_amount[account_id]["balance"],
|
|
"ending_balance": total_amount[account_id]["ending_balance"],
|
|
"group_by": (
|
|
total_amount[account_id]["group_by"]
|
|
if "group_by" in total_amount[account_id]
|
|
else False
|
|
),
|
|
"group_by_data": (
|
|
total_amount[account_id]["group_by_data"]
|
|
if "group_by_data" in total_amount[account_id]
|
|
else False
|
|
),
|
|
"type": "account_type",
|
|
}
|
|
)
|
|
if foreign_currency:
|
|
accounts_data[account_id].update(
|
|
{
|
|
"ending_currency_balance": total_amount[account_id][
|
|
"ending_currency_balance"
|
|
],
|
|
"initial_currency_balance": total_amount[account_id][
|
|
"initial_currency_balance"
|
|
],
|
|
}
|
|
)
|
|
if show_hierarchy:
|
|
groups_data = self._get_groups_data(
|
|
accounts_data, total_amount, foreign_currency
|
|
)
|
|
trial_balance = list(groups_data.values())
|
|
trial_balance += list(accounts_data.values())
|
|
trial_balance = sorted(trial_balance, key=lambda k: k["complete_code"])
|
|
for trial in trial_balance:
|
|
counter = trial["complete_code"].count("/")
|
|
trial["level"] = counter
|
|
else:
|
|
trial_balance = list(accounts_data.values())
|
|
trial_balance = sorted(trial_balance, key=lambda k: k["code"])
|
|
else:
|
|
if foreign_currency:
|
|
for account_id in accounts_data.keys():
|
|
total_amount[account_id]["currency_id"] = accounts_data[account_id][
|
|
"currency_id"
|
|
]
|
|
total_amount[account_id]["currency_name"] = accounts_data[
|
|
account_id
|
|
]["currency_name"]
|
|
return {
|
|
"doc_ids": [wizard_id],
|
|
"doc_model": "trial.balance.report.wizard",
|
|
"docs": self.env["trial.balance.report.wizard"].browse(wizard_id),
|
|
"foreign_currency": data["foreign_currency"],
|
|
"company_name": company.display_name,
|
|
"company_currency": company.currency_id,
|
|
"currency_name": company.currency_id.name,
|
|
"date_from": data["date_from"],
|
|
"date_to": data["date_to"],
|
|
"only_posted_moves": data["only_posted_moves"],
|
|
"hide_account_at_0": data["hide_account_at_0"],
|
|
"show_partner_details": data["show_partner_details"],
|
|
"limit_hierarchy_level": data["limit_hierarchy_level"],
|
|
"show_hierarchy": show_hierarchy,
|
|
"hide_parent_hierarchy_level": data["hide_parent_hierarchy_level"],
|
|
"trial_balance": trial_balance,
|
|
"trial_balance_grouped": trial_balance_grouped,
|
|
"total_amount": total_amount,
|
|
"total_amount_grouped": total_amount_grouped,
|
|
"accounts_data": accounts_data,
|
|
"partners_data": partners_data,
|
|
"show_hierarchy_level": show_hierarchy_level,
|
|
"currency_model": self.env["res.currency"],
|
|
"grouped_by": grouped_by,
|
|
}
|