You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
870 lines
35 KiB
870 lines
35 KiB
# © 2016 Julien Coux (Camptocamp)
|
|
# Copyright 2020 ForgeFlow S.L. (https://www.forgeflow.com)
|
|
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
|
|
|
|
import calendar
|
|
import datetime
|
|
import operator
|
|
|
|
from odoo import _, api, models
|
|
from odoo.tools import float_is_zero
|
|
|
|
|
|
class GeneralLedgerReport(models.AbstractModel):
|
|
_name = "report.account_financial_report.general_ledger"
|
|
_description = "General Ledger Report"
|
|
|
|
def _get_accounts_data(self, account_ids):
|
|
accounts = self.env["account.account"].browse(account_ids)
|
|
accounts_data = {}
|
|
for account in accounts:
|
|
accounts_data.update(
|
|
{
|
|
account.id: {
|
|
"id": account.id,
|
|
"code": account.code,
|
|
"name": account.name,
|
|
"group_id": account.group_id.id,
|
|
"currency_id": account.currency_id or False,
|
|
"currency_name": account.currency_id.name,
|
|
"centralized": account.centralized,
|
|
}
|
|
}
|
|
)
|
|
return accounts_data
|
|
|
|
def _get_journals_data(self, journals_ids):
|
|
journals = self.env["account.journal"].browse(journals_ids)
|
|
journals_data = {}
|
|
for journal in journals:
|
|
journals_data.update({journal.id: {"id": journal.id, "code": journal.code}})
|
|
return journals_data
|
|
|
|
def _get_tags_data(self, tags_ids):
|
|
tags = self.env["account.analytic.tag"].browse(tags_ids)
|
|
tags_data = {}
|
|
for tag in tags:
|
|
tags_data.update({tag.id: {"name": tag.name}})
|
|
return tags_data
|
|
|
|
def _get_taxes_data(self, taxes_ids):
|
|
taxes = self.env["account.tax"].browse(taxes_ids)
|
|
taxes_data = {}
|
|
for tax in taxes:
|
|
taxes_data.update(
|
|
{
|
|
tax.id: {
|
|
"id": tax.id,
|
|
"amount": tax.amount,
|
|
"amount_type": tax.amount_type,
|
|
"display_name": tax.display_name,
|
|
}
|
|
}
|
|
)
|
|
if tax.amount_type == "percent" or tax.amount_type == "division":
|
|
taxes_data[tax.id]["string"] = "%"
|
|
else:
|
|
taxes_data[tax.id]["string"] = ""
|
|
taxes_data[tax.id]["tax_name"] = (
|
|
tax.display_name
|
|
+ " ("
|
|
+ str(tax.amount)
|
|
+ taxes_data[tax.id]["string"]
|
|
+ ")"
|
|
)
|
|
return taxes_data
|
|
|
|
def _get_acc_prt_accounts_ids(self, company_id):
|
|
accounts_domain = [
|
|
("company_id", "=", company_id),
|
|
("internal_type", "in", ["receivable", "payable"]),
|
|
]
|
|
acc_prt_accounts = self.env["account.account"].search(accounts_domain)
|
|
return acc_prt_accounts.ids
|
|
|
|
def _get_initial_balances_bs_ml_domain(
|
|
self, account_ids, company_id, date_from, base_domain, acc_prt=False
|
|
):
|
|
accounts_domain = [
|
|
("company_id", "=", company_id),
|
|
("user_type_id.include_initial_balance", "=", True),
|
|
]
|
|
if account_ids:
|
|
accounts_domain += [("id", "in", account_ids)]
|
|
domain = []
|
|
domain += base_domain
|
|
domain += [("date", "<", date_from)]
|
|
accounts = self.env["account.account"].search(accounts_domain)
|
|
domain += [("account_id", "in", accounts.ids)]
|
|
if acc_prt:
|
|
domain += [("account_id.internal_type", "in", ["receivable", "payable"])]
|
|
return domain
|
|
|
|
def _get_initial_balances_pl_ml_domain(
|
|
self, account_ids, company_id, date_from, fy_start_date, base_domain
|
|
):
|
|
accounts_domain = [
|
|
("company_id", "=", company_id),
|
|
("user_type_id.include_initial_balance", "=", False),
|
|
]
|
|
if account_ids:
|
|
accounts_domain += [("id", "in", account_ids)]
|
|
domain = []
|
|
domain += base_domain
|
|
domain += [("date", "<", date_from), ("date", ">=", fy_start_date)]
|
|
accounts = self.env["account.account"].search(accounts_domain)
|
|
domain += [("account_id", "in", accounts.ids)]
|
|
return domain
|
|
|
|
def _get_accounts_initial_balance(self, initial_domain_bs, initial_domain_pl):
|
|
gl_initial_acc_bs = self.env["account.move.line"].read_group(
|
|
domain=initial_domain_bs,
|
|
fields=["account_id", "debit", "credit", "balance", "amount_currency"],
|
|
groupby=["account_id"],
|
|
)
|
|
gl_initial_acc_pl = self.env["account.move.line"].read_group(
|
|
domain=initial_domain_pl,
|
|
fields=["account_id", "debit", "credit", "balance", "amount_currency"],
|
|
groupby=["account_id"],
|
|
)
|
|
gl_initial_acc = gl_initial_acc_bs + gl_initial_acc_pl
|
|
return gl_initial_acc
|
|
|
|
def _get_initial_balance_fy_pl_ml_domain(
|
|
self, account_ids, company_id, fy_start_date, base_domain
|
|
):
|
|
accounts_domain = [
|
|
("company_id", "=", company_id),
|
|
("user_type_id.include_initial_balance", "=", False),
|
|
]
|
|
if account_ids:
|
|
accounts_domain += [("id", "in", account_ids)]
|
|
domain = []
|
|
domain += base_domain
|
|
domain += [("date", "<", fy_start_date)]
|
|
accounts = self.env["account.account"].search(accounts_domain)
|
|
domain += [("account_id", "in", accounts.ids)]
|
|
return domain
|
|
|
|
def _get_pl_initial_balance(
|
|
self, account_ids, company_id, fy_start_date, foreign_currency, base_domain
|
|
):
|
|
domain = self._get_initial_balance_fy_pl_ml_domain(
|
|
account_ids, company_id, fy_start_date, base_domain
|
|
)
|
|
initial_balances = self.env["account.move.line"].read_group(
|
|
domain=domain,
|
|
fields=["account_id", "debit", "credit", "balance", "amount_currency"],
|
|
groupby=["account_id"],
|
|
)
|
|
pl_initial_balance = {
|
|
"debit": 0.0,
|
|
"credit": 0.0,
|
|
"balance": 0.0,
|
|
"bal_curr": 0.0,
|
|
}
|
|
for initial_balance in initial_balances:
|
|
pl_initial_balance["debit"] += initial_balance["debit"]
|
|
pl_initial_balance["credit"] += initial_balance["credit"]
|
|
pl_initial_balance["balance"] += initial_balance["balance"]
|
|
pl_initial_balance["bal_curr"] += initial_balance["amount_currency"]
|
|
return pl_initial_balance
|
|
|
|
def _get_initial_balance_data(
|
|
self,
|
|
account_ids,
|
|
partner_ids,
|
|
company_id,
|
|
date_from,
|
|
foreign_currency,
|
|
only_posted_moves,
|
|
unaffected_earnings_account,
|
|
fy_start_date,
|
|
analytic_tag_ids,
|
|
cost_center_ids,
|
|
extra_domain,
|
|
):
|
|
base_domain = []
|
|
if company_id:
|
|
base_domain += [("company_id", "=", company_id)]
|
|
if partner_ids:
|
|
base_domain += [("partner_id", "in", partner_ids)]
|
|
if only_posted_moves:
|
|
base_domain += [("move_id.state", "=", "posted")]
|
|
if analytic_tag_ids:
|
|
base_domain += [("analytic_tag_ids", "in", analytic_tag_ids)]
|
|
if cost_center_ids:
|
|
base_domain += [("analytic_account_id", "in", cost_center_ids)]
|
|
if extra_domain:
|
|
base_domain += extra_domain
|
|
initial_domain_bs = self._get_initial_balances_bs_ml_domain(
|
|
account_ids, company_id, date_from, base_domain
|
|
)
|
|
initial_domain_pl = self._get_initial_balances_pl_ml_domain(
|
|
account_ids, company_id, date_from, fy_start_date, base_domain
|
|
)
|
|
gl_initial_acc = self._get_accounts_initial_balance(
|
|
initial_domain_bs, initial_domain_pl
|
|
)
|
|
initial_domain_acc_prt = self._get_initial_balances_bs_ml_domain(
|
|
account_ids, company_id, date_from, base_domain, acc_prt=True
|
|
)
|
|
gl_initial_acc_prt = self.env["account.move.line"].read_group(
|
|
domain=initial_domain_acc_prt,
|
|
fields=[
|
|
"account_id",
|
|
"partner_id",
|
|
"debit",
|
|
"credit",
|
|
"balance",
|
|
"amount_currency",
|
|
],
|
|
groupby=["account_id", "partner_id"],
|
|
lazy=False,
|
|
)
|
|
gen_ld_data = {}
|
|
for gl in gl_initial_acc:
|
|
acc_id = gl["account_id"][0]
|
|
gen_ld_data[acc_id] = {}
|
|
gen_ld_data[acc_id]["id"] = acc_id
|
|
gen_ld_data[acc_id]["partners"] = False
|
|
gen_ld_data[acc_id]["init_bal"] = {}
|
|
gen_ld_data[acc_id]["init_bal"]["credit"] = gl["credit"]
|
|
gen_ld_data[acc_id]["init_bal"]["debit"] = gl["debit"]
|
|
gen_ld_data[acc_id]["init_bal"]["balance"] = gl["balance"]
|
|
gen_ld_data[acc_id]["fin_bal"] = {}
|
|
gen_ld_data[acc_id]["fin_bal"]["credit"] = gl["credit"]
|
|
gen_ld_data[acc_id]["fin_bal"]["debit"] = gl["debit"]
|
|
gen_ld_data[acc_id]["fin_bal"]["balance"] = gl["balance"]
|
|
gen_ld_data[acc_id]["init_bal"]["bal_curr"] = gl["amount_currency"]
|
|
gen_ld_data[acc_id]["fin_bal"]["bal_curr"] = gl["amount_currency"]
|
|
partners_data = {}
|
|
partners_ids = set()
|
|
if gl_initial_acc_prt:
|
|
for gl in gl_initial_acc_prt:
|
|
if not gl["partner_id"]:
|
|
prt_id = 0
|
|
prt_name = "Missing Partner"
|
|
else:
|
|
prt_id = gl["partner_id"][0]
|
|
prt_name = gl["partner_id"][1]
|
|
prt_name = prt_name._value
|
|
if prt_id not in partners_ids:
|
|
partners_ids.add(prt_id)
|
|
partners_data.update({prt_id: {"id": prt_id, "name": prt_name}})
|
|
acc_id = gl["account_id"][0]
|
|
gen_ld_data[acc_id][prt_id] = {}
|
|
gen_ld_data[acc_id][prt_id]["id"] = prt_id
|
|
gen_ld_data[acc_id]["partners"] = True
|
|
gen_ld_data[acc_id][prt_id]["init_bal"] = {}
|
|
gen_ld_data[acc_id][prt_id]["init_bal"]["credit"] = gl["credit"]
|
|
gen_ld_data[acc_id][prt_id]["init_bal"]["debit"] = gl["debit"]
|
|
gen_ld_data[acc_id][prt_id]["init_bal"]["balance"] = gl["balance"]
|
|
gen_ld_data[acc_id][prt_id]["fin_bal"] = {}
|
|
gen_ld_data[acc_id][prt_id]["fin_bal"]["credit"] = gl["credit"]
|
|
gen_ld_data[acc_id][prt_id]["fin_bal"]["debit"] = gl["debit"]
|
|
gen_ld_data[acc_id][prt_id]["fin_bal"]["balance"] = gl["balance"]
|
|
gen_ld_data[acc_id][prt_id]["init_bal"]["bal_curr"] = gl[
|
|
"amount_currency"
|
|
]
|
|
gen_ld_data[acc_id][prt_id]["fin_bal"]["bal_curr"] = gl[
|
|
"amount_currency"
|
|
]
|
|
accounts_ids = list(gen_ld_data.keys())
|
|
unaffected_id = unaffected_earnings_account
|
|
if unaffected_id not in accounts_ids:
|
|
accounts_ids.append(unaffected_id)
|
|
self._initialize_account(gen_ld_data, unaffected_id, foreign_currency)
|
|
pl_initial_balance = self._get_pl_initial_balance(
|
|
account_ids, company_id, fy_start_date, foreign_currency, base_domain
|
|
)
|
|
gen_ld_data[unaffected_id]["init_bal"]["debit"] += pl_initial_balance["debit"]
|
|
gen_ld_data[unaffected_id]["init_bal"]["credit"] += pl_initial_balance["credit"]
|
|
gen_ld_data[unaffected_id]["init_bal"]["balance"] += pl_initial_balance[
|
|
"balance"
|
|
]
|
|
gen_ld_data[unaffected_id]["fin_bal"]["debit"] += pl_initial_balance["debit"]
|
|
gen_ld_data[unaffected_id]["fin_bal"]["credit"] += pl_initial_balance["credit"]
|
|
gen_ld_data[unaffected_id]["fin_bal"]["balance"] += pl_initial_balance[
|
|
"balance"
|
|
]
|
|
if foreign_currency:
|
|
gen_ld_data[unaffected_id]["init_bal"]["bal_curr"] += pl_initial_balance[
|
|
"bal_curr"
|
|
]
|
|
gen_ld_data[unaffected_id]["fin_bal"]["bal_curr"] += pl_initial_balance[
|
|
"bal_curr"
|
|
]
|
|
return gen_ld_data, partners_data, partner_ids
|
|
|
|
@api.model
|
|
def _get_move_line_data(self, move_line):
|
|
move_line_data = {
|
|
"id": move_line["id"],
|
|
"date": move_line["date"],
|
|
"entry": move_line["move_id"][1],
|
|
"entry_id": move_line["move_id"][0],
|
|
"journal_id": move_line["journal_id"][0],
|
|
"account_id": move_line["account_id"][0],
|
|
"partner_id": move_line["partner_id"][0]
|
|
if move_line["partner_id"]
|
|
else False,
|
|
"partner_name": move_line["partner_id"][1]
|
|
if move_line["partner_id"]
|
|
else "",
|
|
"ref": "" if not move_line["ref"] else move_line["ref"],
|
|
"name": "" if not move_line["name"] else move_line["name"],
|
|
"tax_ids": move_line["tax_ids"],
|
|
"debit": move_line["debit"],
|
|
"credit": move_line["credit"],
|
|
"balance": move_line["balance"],
|
|
"bal_curr": move_line["amount_currency"],
|
|
"rec_id": move_line["full_reconcile_id"][0]
|
|
if move_line["full_reconcile_id"]
|
|
else False,
|
|
"rec_name": move_line["full_reconcile_id"][1]
|
|
if move_line["full_reconcile_id"]
|
|
else "",
|
|
"tag_ids": move_line["analytic_tag_ids"],
|
|
"currency_id": move_line["currency_id"],
|
|
"analytic_account": move_line["analytic_account_id"][1]
|
|
if move_line["analytic_account_id"]
|
|
else "",
|
|
"analytic_account_id": move_line["analytic_account_id"][0]
|
|
if move_line["analytic_account_id"]
|
|
else False,
|
|
}
|
|
if (
|
|
move_line_data["ref"] == move_line_data["name"]
|
|
or move_line_data["ref"] == ""
|
|
):
|
|
ref_label = move_line_data["name"]
|
|
elif move_line_data["name"] == "":
|
|
ref_label = move_line_data["ref"]
|
|
else:
|
|
ref_label = move_line_data["ref"] + str(" - ") + move_line_data["name"]
|
|
move_line_data.update({"ref_label": ref_label})
|
|
return move_line_data
|
|
|
|
@api.model
|
|
def _get_period_domain(
|
|
self,
|
|
account_ids,
|
|
partner_ids,
|
|
company_id,
|
|
only_posted_moves,
|
|
date_to,
|
|
date_from,
|
|
analytic_tag_ids,
|
|
cost_center_ids,
|
|
):
|
|
domain = [
|
|
("display_type", "=", False),
|
|
("date", ">=", date_from),
|
|
("date", "<=", date_to),
|
|
]
|
|
if account_ids:
|
|
domain += [("account_id", "in", account_ids)]
|
|
if company_id:
|
|
domain += [("company_id", "=", company_id)]
|
|
if partner_ids:
|
|
domain += [("partner_id", "in", partner_ids)]
|
|
if only_posted_moves:
|
|
domain += [("move_id.state", "=", "posted")]
|
|
if analytic_tag_ids:
|
|
domain += [("analytic_tag_ids", "in", analytic_tag_ids)]
|
|
if cost_center_ids:
|
|
domain += [("analytic_account_id", "in", cost_center_ids)]
|
|
return domain
|
|
|
|
@api.model
|
|
def _initialize_partner(self, gen_ld_data, acc_id, prt_id, foreign_currency):
|
|
gen_ld_data[acc_id]["partners"] = True
|
|
gen_ld_data[acc_id][prt_id] = {}
|
|
gen_ld_data[acc_id][prt_id]["id"] = prt_id
|
|
gen_ld_data[acc_id][prt_id]["init_bal"] = {}
|
|
gen_ld_data[acc_id][prt_id]["init_bal"]["balance"] = 0.0
|
|
gen_ld_data[acc_id][prt_id]["init_bal"]["credit"] = 0.0
|
|
gen_ld_data[acc_id][prt_id]["init_bal"]["debit"] = 0.0
|
|
gen_ld_data[acc_id][prt_id]["fin_bal"] = {}
|
|
gen_ld_data[acc_id][prt_id]["fin_bal"]["credit"] = 0.0
|
|
gen_ld_data[acc_id][prt_id]["fin_bal"]["debit"] = 0.0
|
|
gen_ld_data[acc_id][prt_id]["fin_bal"]["balance"] = 0.0
|
|
if foreign_currency:
|
|
gen_ld_data[acc_id][prt_id]["init_bal"]["bal_curr"] = 0.0
|
|
gen_ld_data[acc_id][prt_id]["fin_bal"]["bal_curr"] = 0.0
|
|
return gen_ld_data
|
|
|
|
def _initialize_account(self, gen_ld_data, acc_id, foreign_currency):
|
|
gen_ld_data[acc_id] = {}
|
|
gen_ld_data[acc_id]["id"] = acc_id
|
|
gen_ld_data[acc_id]["partners"] = False
|
|
gen_ld_data[acc_id]["init_bal"] = {}
|
|
gen_ld_data[acc_id]["init_bal"]["balance"] = 0.0
|
|
gen_ld_data[acc_id]["init_bal"]["credit"] = 0.0
|
|
gen_ld_data[acc_id]["init_bal"]["debit"] = 0.0
|
|
gen_ld_data[acc_id]["fin_bal"] = {}
|
|
gen_ld_data[acc_id]["fin_bal"]["credit"] = 0.0
|
|
gen_ld_data[acc_id]["fin_bal"]["debit"] = 0.0
|
|
gen_ld_data[acc_id]["fin_bal"]["balance"] = 0.0
|
|
if foreign_currency:
|
|
gen_ld_data[acc_id]["init_bal"]["bal_curr"] = 0.0
|
|
gen_ld_data[acc_id]["fin_bal"]["bal_curr"] = 0.0
|
|
return gen_ld_data
|
|
|
|
def _get_reconciled_after_date_to_ids(self, full_reconcile_ids, date_to):
|
|
full_reconcile_ids = list(full_reconcile_ids)
|
|
domain = [
|
|
("max_date", ">", date_to),
|
|
("full_reconcile_id", "in", full_reconcile_ids),
|
|
]
|
|
fields = ["full_reconcile_id"]
|
|
reconciled_after_date_to = self.env["account.partial.reconcile"].search_read(
|
|
domain=domain, fields=fields
|
|
)
|
|
rec_after_date_to_ids = list(
|
|
map(operator.itemgetter("full_reconcile_id"), reconciled_after_date_to)
|
|
)
|
|
rec_after_date_to_ids = [i[0] for i in rec_after_date_to_ids]
|
|
return rec_after_date_to_ids
|
|
|
|
def _get_period_ml_data(
|
|
self,
|
|
account_ids,
|
|
partner_ids,
|
|
company_id,
|
|
foreign_currency,
|
|
only_posted_moves,
|
|
date_from,
|
|
date_to,
|
|
partners_data,
|
|
gen_ld_data,
|
|
partners_ids,
|
|
analytic_tag_ids,
|
|
cost_center_ids,
|
|
extra_domain,
|
|
):
|
|
domain = self._get_period_domain(
|
|
account_ids,
|
|
partner_ids,
|
|
company_id,
|
|
only_posted_moves,
|
|
date_to,
|
|
date_from,
|
|
analytic_tag_ids,
|
|
cost_center_ids,
|
|
)
|
|
if extra_domain:
|
|
domain += extra_domain
|
|
ml_fields = [
|
|
"id",
|
|
"name",
|
|
"date",
|
|
"move_id",
|
|
"journal_id",
|
|
"account_id",
|
|
"partner_id",
|
|
"debit",
|
|
"credit",
|
|
"balance",
|
|
"currency_id",
|
|
"full_reconcile_id",
|
|
"tax_ids",
|
|
"analytic_tag_ids",
|
|
"amount_currency",
|
|
"ref",
|
|
"name",
|
|
"analytic_account_id",
|
|
]
|
|
move_lines = self.env["account.move.line"].search_read(
|
|
domain=domain, fields=ml_fields
|
|
)
|
|
journal_ids = set()
|
|
full_reconcile_ids = set()
|
|
taxes_ids = set()
|
|
tags_ids = set()
|
|
full_reconcile_data = {}
|
|
acc_prt_account_ids = self._get_acc_prt_accounts_ids(company_id)
|
|
for move_line in move_lines:
|
|
journal_ids.add(move_line["journal_id"][0])
|
|
for tax_id in move_line["tax_ids"]:
|
|
taxes_ids.add(tax_id)
|
|
for analytic_tag_id in move_line["analytic_tag_ids"]:
|
|
tags_ids.add(analytic_tag_id)
|
|
if move_line["full_reconcile_id"]:
|
|
rec_id = move_line["full_reconcile_id"][0]
|
|
if rec_id not in full_reconcile_ids:
|
|
full_reconcile_data.update(
|
|
{
|
|
rec_id: {
|
|
"id": rec_id,
|
|
"name": move_line["full_reconcile_id"][1],
|
|
}
|
|
}
|
|
)
|
|
full_reconcile_ids.add(rec_id)
|
|
acc_id = move_line["account_id"][0]
|
|
ml_id = move_line["id"]
|
|
if move_line["partner_id"]:
|
|
prt_id = move_line["partner_id"][0]
|
|
partner_name = move_line["partner_id"][1]
|
|
if acc_id not in gen_ld_data.keys():
|
|
gen_ld_data = self._initialize_account(
|
|
gen_ld_data, acc_id, foreign_currency
|
|
)
|
|
if acc_id in acc_prt_account_ids:
|
|
if not move_line["partner_id"]:
|
|
prt_id = 0
|
|
partner_name = "Missing Partner"
|
|
partners_ids.append(prt_id)
|
|
partners_data.update({prt_id: {"id": prt_id, "name": partner_name}})
|
|
if prt_id not in gen_ld_data[acc_id]:
|
|
gen_ld_data = self._initialize_partner(
|
|
gen_ld_data, acc_id, prt_id, foreign_currency
|
|
)
|
|
gen_ld_data[acc_id][prt_id][ml_id] = self._get_move_line_data(move_line)
|
|
gen_ld_data[acc_id][prt_id]["fin_bal"]["credit"] += move_line["credit"]
|
|
gen_ld_data[acc_id][prt_id]["fin_bal"]["debit"] += move_line["debit"]
|
|
gen_ld_data[acc_id][prt_id]["fin_bal"]["balance"] += move_line[
|
|
"balance"
|
|
]
|
|
if foreign_currency:
|
|
gen_ld_data[acc_id][prt_id]["fin_bal"]["bal_curr"] += move_line[
|
|
"amount_currency"
|
|
]
|
|
else:
|
|
gen_ld_data[acc_id][ml_id] = self._get_move_line_data(move_line)
|
|
gen_ld_data[acc_id]["fin_bal"]["credit"] += move_line["credit"]
|
|
gen_ld_data[acc_id]["fin_bal"]["debit"] += move_line["debit"]
|
|
gen_ld_data[acc_id]["fin_bal"]["balance"] += move_line["balance"]
|
|
if foreign_currency:
|
|
gen_ld_data[acc_id]["fin_bal"]["bal_curr"] += move_line[
|
|
"amount_currency"
|
|
]
|
|
journals_data = self._get_journals_data(list(journal_ids))
|
|
accounts_data = self._get_accounts_data(gen_ld_data.keys())
|
|
taxes_data = self._get_taxes_data(list(taxes_ids))
|
|
tags_data = self._get_tags_data(list(tags_ids))
|
|
rec_after_date_to_ids = self._get_reconciled_after_date_to_ids(
|
|
full_reconcile_data.keys(), date_to
|
|
)
|
|
return (
|
|
gen_ld_data,
|
|
accounts_data,
|
|
partners_data,
|
|
journals_data,
|
|
full_reconcile_data,
|
|
taxes_data,
|
|
tags_data,
|
|
rec_after_date_to_ids,
|
|
)
|
|
|
|
@api.model
|
|
def _recalculate_cumul_balance(
|
|
self, move_lines, last_cumul_balance, rec_after_date_to_ids
|
|
):
|
|
for move_line in move_lines:
|
|
move_line["balance"] += last_cumul_balance
|
|
last_cumul_balance = move_line["balance"]
|
|
if move_line["rec_id"] in rec_after_date_to_ids:
|
|
move_line["rec_name"] = "(" + _("future") + ") " + move_line["rec_name"]
|
|
return move_lines
|
|
|
|
def _create_account(self, account, acc_id, gen_led_data, rec_after_date_to_ids):
|
|
move_lines = []
|
|
for ml_id in gen_led_data[acc_id].keys():
|
|
if not isinstance(ml_id, int):
|
|
account.update({ml_id: gen_led_data[acc_id][ml_id]})
|
|
else:
|
|
move_lines += [gen_led_data[acc_id][ml_id]]
|
|
move_lines = sorted(move_lines, key=lambda k: (k["date"]))
|
|
move_lines = self._recalculate_cumul_balance(
|
|
move_lines,
|
|
gen_led_data[acc_id]["init_bal"]["balance"],
|
|
rec_after_date_to_ids,
|
|
)
|
|
account.update({"move_lines": move_lines})
|
|
return account
|
|
|
|
def _create_account_not_show_partner(
|
|
self, account, acc_id, gen_led_data, rec_after_date_to_ids
|
|
):
|
|
move_lines = []
|
|
for prt_id in gen_led_data[acc_id].keys():
|
|
if not isinstance(prt_id, int):
|
|
account.update({prt_id: gen_led_data[acc_id][prt_id]})
|
|
else:
|
|
for ml_id in gen_led_data[acc_id][prt_id].keys():
|
|
if isinstance(ml_id, int):
|
|
move_lines += [gen_led_data[acc_id][prt_id][ml_id]]
|
|
move_lines = sorted(move_lines, key=lambda k: (k["date"]))
|
|
move_lines = self._recalculate_cumul_balance(
|
|
move_lines,
|
|
gen_led_data[acc_id]["init_bal"]["balance"],
|
|
rec_after_date_to_ids,
|
|
)
|
|
account.update({"move_lines": move_lines, "partners": False})
|
|
return account
|
|
|
|
def _create_general_ledger(
|
|
self,
|
|
gen_led_data,
|
|
accounts_data,
|
|
show_partner_details,
|
|
rec_after_date_to_ids,
|
|
hide_account_at_0,
|
|
):
|
|
general_ledger = []
|
|
rounding = self.env.user.company_id.currency_id.rounding
|
|
for acc_id in gen_led_data.keys():
|
|
account = {}
|
|
account.update(
|
|
{
|
|
"code": accounts_data[acc_id]["code"],
|
|
"name": accounts_data[acc_id]["name"],
|
|
"type": "account",
|
|
"currency_id": accounts_data[acc_id]["currency_id"],
|
|
"centralized": accounts_data[acc_id]["centralized"],
|
|
}
|
|
)
|
|
if not gen_led_data[acc_id]["partners"]:
|
|
account = self._create_account(
|
|
account, acc_id, gen_led_data, rec_after_date_to_ids
|
|
)
|
|
if (
|
|
hide_account_at_0
|
|
and float_is_zero(
|
|
gen_led_data[acc_id]["init_bal"]["balance"],
|
|
precision_rounding=rounding,
|
|
)
|
|
and account["move_lines"] == []
|
|
):
|
|
continue
|
|
else:
|
|
if show_partner_details:
|
|
list_partner = []
|
|
for prt_id in gen_led_data[acc_id].keys():
|
|
partner = {}
|
|
move_lines = []
|
|
if not isinstance(prt_id, int):
|
|
account.update({prt_id: gen_led_data[acc_id][prt_id]})
|
|
else:
|
|
for ml_id in gen_led_data[acc_id][prt_id].keys():
|
|
if not isinstance(ml_id, int):
|
|
partner.update(
|
|
{ml_id: gen_led_data[acc_id][prt_id][ml_id]}
|
|
)
|
|
else:
|
|
move_lines += [gen_led_data[acc_id][prt_id][ml_id]]
|
|
move_lines = sorted(move_lines, key=lambda k: (k["date"]))
|
|
move_lines = self._recalculate_cumul_balance(
|
|
move_lines,
|
|
gen_led_data[acc_id][prt_id]["init_bal"]["balance"],
|
|
rec_after_date_to_ids,
|
|
)
|
|
partner.update({"move_lines": move_lines})
|
|
if (
|
|
hide_account_at_0
|
|
and float_is_zero(
|
|
gen_led_data[acc_id][prt_id]["init_bal"]["balance"],
|
|
precision_rounding=rounding,
|
|
)
|
|
and partner["move_lines"] == []
|
|
):
|
|
continue
|
|
list_partner += [partner]
|
|
account.update({"list_partner": list_partner})
|
|
if (
|
|
hide_account_at_0
|
|
and float_is_zero(
|
|
gen_led_data[acc_id]["init_bal"]["balance"],
|
|
precision_rounding=rounding,
|
|
)
|
|
and account["list_partner"] == []
|
|
):
|
|
continue
|
|
else:
|
|
account = self._create_account_not_show_partner(
|
|
account, acc_id, gen_led_data, rec_after_date_to_ids
|
|
)
|
|
if (
|
|
hide_account_at_0
|
|
and float_is_zero(
|
|
gen_led_data[acc_id]["init_bal"]["balance"],
|
|
precision_rounding=rounding,
|
|
)
|
|
and account["move_lines"] == []
|
|
):
|
|
continue
|
|
general_ledger += [account]
|
|
return general_ledger
|
|
|
|
@api.model
|
|
def _calculate_centralization(self, centralized_ml, move_line, date_to):
|
|
jnl_id = move_line["journal_id"]
|
|
month = move_line["date"].month
|
|
if jnl_id not in centralized_ml.keys():
|
|
centralized_ml[jnl_id] = {}
|
|
if month not in centralized_ml[jnl_id].keys():
|
|
centralized_ml[jnl_id][month] = {}
|
|
last_day_month = calendar.monthrange(move_line["date"].year, month)
|
|
date = datetime.date(move_line["date"].year, month, last_day_month[1])
|
|
if date > date_to:
|
|
date = date_to
|
|
centralized_ml[jnl_id][month].update(
|
|
{
|
|
"journal_id": jnl_id,
|
|
"ref_label": "Centralized entries",
|
|
"date": date,
|
|
"debit": 0.0,
|
|
"credit": 0.0,
|
|
"balance": 0.0,
|
|
"bal_curr": 0.0,
|
|
"partner_id": False,
|
|
"rec_id": 0,
|
|
"entry_id": False,
|
|
"tax_ids": [],
|
|
"full_reconcile_id": False,
|
|
"id": False,
|
|
"tag_ids": False,
|
|
"currency_id": False,
|
|
"analytic_account_id": False,
|
|
}
|
|
)
|
|
centralized_ml[jnl_id][month]["debit"] += move_line["debit"]
|
|
centralized_ml[jnl_id][month]["credit"] += move_line["credit"]
|
|
centralized_ml[jnl_id][month]["balance"] += (
|
|
move_line["debit"] - move_line["credit"]
|
|
)
|
|
centralized_ml[jnl_id][month]["bal_curr"] += move_line["bal_curr"]
|
|
return centralized_ml
|
|
|
|
@api.model
|
|
def _get_centralized_ml(self, account, date_to):
|
|
centralized_ml = {}
|
|
if isinstance(date_to, str):
|
|
date_to = datetime.datetime.strptime(date_to, "%Y-%m-%d").date()
|
|
if account["partners"]:
|
|
for partner in account["list_partner"]:
|
|
for move_line in partner["move_lines"]:
|
|
centralized_ml = self._calculate_centralization(
|
|
centralized_ml,
|
|
move_line,
|
|
date_to,
|
|
)
|
|
else:
|
|
for move_line in account["move_lines"]:
|
|
centralized_ml = self._calculate_centralization(
|
|
centralized_ml,
|
|
move_line,
|
|
date_to,
|
|
)
|
|
list_centralized_ml = []
|
|
for jnl_id in centralized_ml.keys():
|
|
list_centralized_ml += list(centralized_ml[jnl_id].values())
|
|
return list_centralized_ml
|
|
|
|
def _get_report_values(self, docids, data):
|
|
wizard_id = data["wizard_id"]
|
|
company = self.env["res.company"].browse(data["company_id"])
|
|
company_id = data["company_id"]
|
|
date_to = data["date_to"]
|
|
date_from = data["date_from"]
|
|
partner_ids = data["partner_ids"]
|
|
if not partner_ids:
|
|
filter_partner_ids = False
|
|
else:
|
|
filter_partner_ids = True
|
|
account_ids = data["account_ids"]
|
|
analytic_tag_ids = data["analytic_tag_ids"]
|
|
cost_center_ids = data["cost_center_ids"]
|
|
show_partner_details = data["show_partner_details"]
|
|
hide_account_at_0 = data["hide_account_at_0"]
|
|
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"]
|
|
extra_domain = data["domain"]
|
|
gen_ld_data, partners_data, partners_ids = self._get_initial_balance_data(
|
|
account_ids,
|
|
partner_ids,
|
|
company_id,
|
|
date_from,
|
|
foreign_currency,
|
|
only_posted_moves,
|
|
unaffected_earnings_account,
|
|
fy_start_date,
|
|
analytic_tag_ids,
|
|
cost_center_ids,
|
|
extra_domain,
|
|
)
|
|
centralize = data["centralize"]
|
|
(
|
|
gen_ld_data,
|
|
accounts_data,
|
|
partners_data,
|
|
journals_data,
|
|
full_reconcile_data,
|
|
taxes_data,
|
|
tags_data,
|
|
rec_after_date_to_ids,
|
|
) = self._get_period_ml_data(
|
|
account_ids,
|
|
partner_ids,
|
|
company_id,
|
|
foreign_currency,
|
|
only_posted_moves,
|
|
date_from,
|
|
date_to,
|
|
partners_data,
|
|
gen_ld_data,
|
|
partners_ids,
|
|
analytic_tag_ids,
|
|
cost_center_ids,
|
|
extra_domain,
|
|
)
|
|
general_ledger = self._create_general_ledger(
|
|
gen_ld_data,
|
|
accounts_data,
|
|
show_partner_details,
|
|
rec_after_date_to_ids,
|
|
hide_account_at_0,
|
|
)
|
|
if centralize:
|
|
for account in general_ledger:
|
|
if account["centralized"]:
|
|
centralized_ml = self._get_centralized_ml(account, date_to)
|
|
account["move_lines"] = centralized_ml
|
|
account["move_lines"] = self._recalculate_cumul_balance(
|
|
account["move_lines"],
|
|
gen_ld_data[account["id"]]["init_bal"]["balance"],
|
|
rec_after_date_to_ids,
|
|
)
|
|
if account["partners"]:
|
|
account["partners"] = False
|
|
del account["list_partner"]
|
|
general_ledger = sorted(general_ledger, key=lambda k: k["code"])
|
|
return {
|
|
"doc_ids": [wizard_id],
|
|
"doc_model": "general.ledger.report.wizard",
|
|
"docs": self.env["general.ledger.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_analytic_tags": data["show_analytic_tags"],
|
|
"show_cost_center": data["show_cost_center"],
|
|
"general_ledger": general_ledger,
|
|
"accounts_data": accounts_data,
|
|
"partners_data": partners_data,
|
|
"journals_data": journals_data,
|
|
"full_reconcile_data": full_reconcile_data,
|
|
"taxes_data": taxes_data,
|
|
"centralize": centralize,
|
|
"tags_data": tags_data,
|
|
"filter_partner_ids": filter_partner_ids,
|
|
}
|