brotherton-erpnext/erpnext/accounts/report/trial_balance/trial_balance.py

273 lines
7.6 KiB
Python
Raw Normal View History

# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
2014-07-22 13:32:11 +00:00
# License: GNU General Public License v3. See license.txt
from __future__ import unicode_literals
import frappe
from frappe import _
from frappe.utils import flt, getdate, formatdate, cstr
from erpnext.accounts.report.financial_statements \
import filter_accounts, set_gl_entries_by_account, filter_out_zero_value_rows
2014-07-22 13:32:11 +00:00
value_fields = ("opening_debit", "opening_credit", "debit", "credit", "closing_debit", "closing_credit")
def execute(filters=None):
2014-07-22 13:32:11 +00:00
validate_filters(filters)
data = get_data(filters)
columns = get_columns()
return columns, data
def validate_filters(filters):
if not filters.fiscal_year:
frappe.throw(_("Fiscal Year {0} is required").format(filters.fiscal_year))
fiscal_year = frappe.db.get_value("Fiscal Year", filters.fiscal_year, ["year_start_date", "year_end_date"], as_dict=True)
if not fiscal_year:
frappe.throw(_("Fiscal Year {0} does not exist").format(filters.fiscal_year))
else:
filters.year_start_date = getdate(fiscal_year.year_start_date)
filters.year_end_date = getdate(fiscal_year.year_end_date)
2014-07-22 13:32:11 +00:00
if not filters.from_date:
filters.from_date = filters.year_start_date
if not filters.to_date:
filters.to_date = filters.year_end_date
filters.from_date = getdate(filters.from_date)
filters.to_date = getdate(filters.to_date)
if filters.from_date > filters.to_date:
frappe.throw(_("From Date cannot be greater than To Date"))
if (filters.from_date < filters.year_start_date) or (filters.from_date > filters.year_end_date):
frappe.msgprint(_("From Date should be within the Fiscal Year. Assuming From Date = {0}")\
.format(formatdate(filters.year_start_date)))
filters.from_date = filters.year_start_date
if (filters.to_date < filters.year_start_date) or (filters.to_date > filters.year_end_date):
frappe.msgprint(_("To Date should be within the Fiscal Year. Assuming To Date = {0}")\
.format(formatdate(filters.year_end_date)))
filters.to_date = filters.year_end_date
def get_data(filters):
2015-12-01 12:47:18 +00:00
accounts = frappe.db.sql("""select name, parent_account, account_name, root_type, report_type, lft, rgt
from `tabAccount` where company=%s order by lft""", filters.company, as_dict=True)
2014-07-22 13:32:11 +00:00
if not accounts:
return None
accounts, accounts_by_name, parent_children_map = filter_accounts(accounts)
2014-07-22 13:32:11 +00:00
min_lft, max_rgt = frappe.db.sql("""select min(lft), max(rgt) from `tabAccount`
where company=%s""", (filters.company,))[0]
2015-12-01 12:47:18 +00:00
gl_entries_by_account = {}
set_gl_entries_by_account(filters.company, filters.from_date,
filters.to_date, min_lft, max_rgt, gl_entries_by_account, ignore_closing_entries=not flt(filters.with_period_closing_entry))
2014-07-22 13:32:11 +00:00
opening_balances = get_opening_balances(filters)
total_row = calculate_values(accounts, gl_entries_by_account, opening_balances, filters)
2014-07-22 13:32:11 +00:00
accumulate_values_into_parents(accounts, accounts_by_name)
data = prepare_data(accounts, filters, total_row, parent_children_map)
data = filter_out_zero_value_rows(data, parent_children_map,
show_zero_values=filters.get("show_zero_values"))
2014-07-22 13:32:11 +00:00
return data
2015-12-01 12:47:18 +00:00
def get_opening_balances(filters):
balance_sheet_opening = get_rootwise_opening_balances(filters, "Balance Sheet")
pl_opening = get_rootwise_opening_balances(filters, "Profit and Loss")
2015-12-01 12:47:18 +00:00
balance_sheet_opening.update(pl_opening)
return balance_sheet_opening
2015-12-01 12:47:18 +00:00
def get_rootwise_opening_balances(filters, report_type):
additional_conditions = " and posting_date >= %(year_start_date)s" \
if report_type == "Profit and Loss" else ""
2015-12-01 12:47:18 +00:00
if not flt(filters.with_period_closing_entry):
additional_conditions += " and ifnull(voucher_type, '')!='Period Closing Voucher'"
2015-12-01 12:47:18 +00:00
gle = frappe.db.sql("""
2015-12-01 12:47:18 +00:00
select
account, sum(debit) as opening_debit, sum(credit) as opening_credit
from `tabGL Entry`
2015-12-01 12:47:18 +00:00
where
company=%(company)s
{additional_conditions}
and (posting_date < %(from_date)s or ifnull(is_opening, 'No') = 'Yes')
and account in (select name from `tabAccount` where report_type=%(report_type)s)
group by account""".format(additional_conditions=additional_conditions),
{
"company": filters.company,
"from_date": filters.from_date,
"report_type": report_type,
"year_start_date": filters.year_start_date
},
as_dict=True)
2015-12-01 12:47:18 +00:00
opening = frappe._dict()
for d in gle:
opening.setdefault(d.account, d)
2015-12-01 12:47:18 +00:00
return opening
def calculate_values(accounts, gl_entries_by_account, opening_balances, filters):
2014-07-22 13:32:11 +00:00
init = {
"opening_debit": 0.0,
"opening_credit": 0.0,
"debit": 0.0,
"credit": 0.0,
"closing_debit": 0.0,
"closing_credit": 0.0
}
total_row = {
"account": None,
"account_name": _("Total"),
"warn_if_negative": True,
"debit": 0.0,
"credit": 0.0
}
for d in accounts:
d.update(init.copy())
# add opening
d["opening_debit"] = opening_balances.get(d.name, {}).get("opening_debit", 0)
d["opening_credit"] = opening_balances.get(d.name, {}).get("opening_credit", 0)
2014-07-22 13:32:11 +00:00
for entry in gl_entries_by_account.get(d.name, []):
2015-06-18 05:02:42 +00:00
if cstr(entry.is_opening) != "Yes":
d["debit"] += flt(entry.debit)
d["credit"] += flt(entry.credit)
2014-07-22 13:32:11 +00:00
total_row["debit"] += d["debit"]
total_row["credit"] += d["credit"]
2015-12-01 12:47:18 +00:00
2014-07-22 13:32:11 +00:00
return total_row
def accumulate_values_into_parents(accounts, accounts_by_name):
for d in reversed(accounts):
if d.parent_account:
for key in value_fields:
accounts_by_name[d.parent_account][key] += d[key]
def prepare_data(accounts, filters, total_row, parent_children_map):
2014-07-22 13:32:11 +00:00
data = []
company_currency = frappe.db.get_value("Company", filters.company, "default_currency")
for d in accounts:
2014-07-22 13:32:11 +00:00
has_value = False
row = {
"account_name": d.account_name,
"account": d.name,
"parent_account": d.parent_account,
"indent": d.indent,
"from_date": filters.from_date,
"to_date": filters.to_date,
"currency": company_currency
2014-07-22 13:32:11 +00:00
}
prepare_opening_and_closing(d)
for key in value_fields:
row[key] = flt(d.get(key, 0.0), 3)
if abs(row[key]) >= 0.005:
# ignore zero values
2014-07-22 13:32:11 +00:00
has_value = True
row["has_value"] = has_value
data.append(row)
2014-07-22 13:32:11 +00:00
data.extend([{},total_row])
return data
def get_columns():
return [
{
"fieldname": "account",
"label": _("Account"),
"fieldtype": "Link",
"options": "Account",
"width": 300
},
{
"fieldname": "opening_debit",
"label": _("Opening (Dr)"),
"fieldtype": "Currency",
"options": "currency",
2014-07-22 13:32:11 +00:00
"width": 120
},
{
"fieldname": "opening_credit",
"label": _("Opening (Cr)"),
"fieldtype": "Currency",
"options": "currency",
2014-07-22 13:32:11 +00:00
"width": 120
},
{
"fieldname": "debit",
"label": _("Debit"),
"fieldtype": "Currency",
"options": "currency",
2014-07-22 13:32:11 +00:00
"width": 120
},
{
"fieldname": "credit",
"label": _("Credit"),
"fieldtype": "Currency",
"options": "currency",
2014-07-22 13:32:11 +00:00
"width": 120
},
{
"fieldname": "closing_debit",
"label": _("Closing (Dr)"),
"fieldtype": "Currency",
"options": "currency",
2014-07-22 13:32:11 +00:00
"width": 120
},
{
"fieldname": "closing_credit",
"label": _("Closing (Cr)"),
"fieldtype": "Currency",
"options": "currency",
2014-07-22 13:32:11 +00:00
"width": 120
},
{
"fieldname": "currency",
"label": _("Currency"),
"fieldtype": "Link",
"options": "Currency",
"hidden": 1
2014-07-22 13:32:11 +00:00
}
]
def prepare_opening_and_closing(d):
d["closing_debit"] = d["opening_debit"] + d["debit"]
d["closing_credit"] = d["opening_credit"] + d["credit"]
if d["closing_debit"] > d["closing_credit"]:
d["closing_debit"] -= d["closing_credit"]
d["closing_credit"] = 0.0
else:
d["closing_credit"] -= d["closing_debit"]
d["closing_debit"] = 0.0
if d["opening_debit"] > d["opening_credit"]:
d["opening_debit"] -= d["opening_credit"]
d["opening_credit"] = 0.0
else:
d["opening_credit"] -= d["opening_debit"]
d["opening_debit"] = 0.0