Merge pull request #1955 from anandpdoshi/financial-statements

Balance Sheet and Profit and Loss Statement

erpnext/accounts/doctype/fiscal_year/fiscal_year.json

@@ -55,7 +55,7 @@
  ], 
  "icon": "icon-calendar", 
  "idx": 1, 
- "modified": "2014-05-27 03:49:10.942338", 
+ "modified": "2014-07-14 05:30:56.843180", 
  "modified_by": "Administrator", 
  "module": "Accounts", 
  "name": "Fiscal Year", 
@@ -82,5 +82,7 @@
    "read": 1, 
    "role": "All"
   }
- ]
+ ], 
+ "sort_field": "name", 
+ "sort_order": "DESC"
 }

erpnext/accounts/report/balance_sheet/balance_sheet.html

@@ -0,0 +1 @@
+{% include "accounts/report/financial_statements.html" %}

erpnext/accounts/report/balance_sheet/balance_sheet.js

@@ -0,0 +1,6 @@
+// Copyright (c) 2013, Web Notes Technologies Pvt. Ltd. and Contributors
+// License: GNU General Public License v3. See license.txt
+
+frappe.require("assets/erpnext/js/financial_statements.js");
+
+frappe.query_reports["Balance Sheet"] = erpnext.financial_statements;

erpnext/accounts/report/balance_sheet/balance_sheet.json

@@ -0,0 +1,15 @@
+{
+ "apply_user_permissions": 1, 
+ "creation": "2014-07-14 05:24:20.385279", 
+ "docstatus": 0, 
+ "doctype": "Report", 
+ "is_standard": "Yes", 
+ "modified": "2014-07-14 05:24:20.385279", 
+ "modified_by": "Administrator", 
+ "module": "Accounts", 
+ "name": "Balance Sheet", 
+ "owner": "Administrator", 
+ "ref_doctype": "GL Entry", 
+ "report_name": "Balance Sheet", 
+ "report_type": "Script Report"
+}

erpnext/accounts/report/balance_sheet/balance_sheet.py

@@ -0,0 +1,53 @@
+# Copyright (c) 2013, Web Notes Technologies Pvt. Ltd. and Contributors
+# License: GNU General Public License v3. See license.txt
+
+from __future__ import unicode_literals
+import frappe
+from frappe import _
+from frappe.utils import flt
+from erpnext.accounts.report.financial_statements import (process_filters, get_period_list, get_columns, get_data)
+
+def execute(filters=None):
+	process_filters(filters)
+	period_list = get_period_list(filters.fiscal_year, filters.periodicity, from_beginning=True)
+
+	asset = get_data(filters.company, "Asset", "Debit", period_list, filters.depth)
+	liability = get_data(filters.company, "Liability", "Credit", period_list, filters.depth)
+	equity = get_data(filters.company, "Equity", "Credit", period_list, filters.depth)
+	provisional_profit_loss = get_provisional_profit_loss(asset, liability, equity, period_list)
+
+	data = []
+	data.extend(asset or [])
+	data.extend(liability or [])
+	data.extend(equity or [])
+	if provisional_profit_loss:
+		data.append(provisional_profit_loss)
+
+	columns = get_columns(period_list)
+
+	return columns, data
+
+def get_provisional_profit_loss(asset, liability, equity, period_list):
+	if asset and (liability or equity):
+		provisional_profit_loss = {
+			"account_name": _("Provisional Profit / Loss (Credit)"),
+			"account": None,
+			"is_profit_loss": True
+		}
+
+		has_value = False
+
+		for period in period_list:
+			effective_liability = 0.0
+			if liability:
+				effective_liability += flt(liability[-2][period.key])
+			if equity:
+				effective_liability += flt(equity[-2][period.key])
+
+			provisional_profit_loss[period.key] = flt(asset[-2][period.key]) - effective_liability
+
+			if provisional_profit_loss[period.key]:
+				has_value = True
+
+		if has_value:
+			return provisional_profit_loss

erpnext/accounts/report/financial_statements.html

@@ -0,0 +1,53 @@
+{%
+	if (report.columns.length > 6) {
+		frappe.throw(__("Too many columns. Export the report and print it using a spreadsheet application."));
+	}
+%}
+
+<style>
+	.financial-statements-important td {
+		font-weight: bold;
+	}
+
+	.financial-statements-blank-row td {
+		height: 37px;
+	}
+</style>
+
+<h2 class="text-center">{%= __(report.report_name) %}</h2>
+<h4 class="text-center">{%= filters.company %}</h3>
+<h4 class="text-center">{%= filters.fiscal_year %}</h3>
+<hr>
+<table class="table table-bordered">
+	<thead>
+		<tr>
+			<th style="width: {%= 100 - (report.columns.length - 2) * 15 %}%"></th>
+			{% for(var i=2, l=report.columns.length; i<l; i++) { %}
+				<th class="text-right">{%= report.columns[i].label %}</th>
+			{% } %}
+		</tr>
+	</thead>
+	<tbody>
+		{% for(var j=0, k=data.length; j<k; j++) { %}
+			{%
+				var row = data[j];
+				var row_class = data[j].parent_account ? "" : "financial-statements-important";
+				row_class += data[j].account_name ? "" : " financial-statements-blank-row";
+			%}
+			<tr class="{%= row_class %}">
+				<td>
+					<span style="padding-left: {%= cint(data[j].indent) * 2 %}em">{%= row.account_name %}</span>
+				</td>
+				{% for(var i=2, l=report.columns.length; i<l; i++) { %}
+					<td class="text-right">
+						{% var fieldname = report.columns[i].field; %}
+						{% if (!is_null(row[fieldname])) { %}
+							{%= format_currency(row[fieldname]) %}
+						{% } %}
+					</td>
+				{% } %}
+			</tr>
+		{% } %}
+	</tbody>
+</table>
+<p class="text-right text-muted">Printed On {%= dateutil.str_to_user(dateutil.get_datetime_as_string()) %}</p>

erpnext/accounts/report/financial_statements.py

@@ -0,0 +1,255 @@
+# Copyright (c) 2013, Web Notes Technologies Pvt. Ltd. and Contributors
+# License: GNU General Public License v3. See license.txt
+
+from __future__ import unicode_literals
+import frappe
+from frappe import _, _dict
+from frappe.utils import (flt, cint, getdate, get_first_day, get_last_day,
+	add_months, add_days, formatdate)
+
+def process_filters(filters):
+	filters.depth = cint(filters.depth) or 3
+	if not filters.periodicity:
+		filters.periodicity = "Yearly"
+
+def get_period_list(fiscal_year, periodicity, from_beginning=False):
+	"""Get a list of dict {"to_date": to_date, "key": key, "label": label}
+		Periodicity can be (Yearly, Quarterly, Monthly)"""
+
+	start_date, end_date = frappe.db.get_value("Fiscal Year", fiscal_year, ["year_start_date", "year_end_date"])
+	start_date = getdate(start_date)
+	end_date = getdate(end_date)
+
+	if periodicity == "Yearly":
+		period_list = [_dict({"to_date": end_date, "key": fiscal_year, "label": fiscal_year})]
+	else:
+		months_to_add = {
+			"Half-yearly": 6,
+			"Quarterly": 3,
+			"Monthly": 1
+		}[periodicity]
+
+		period_list = []
+
+		# start with first day, so as to avoid year to_dates like 2-April if ever they occur
+		to_date = get_first_day(start_date)
+
+		for i in xrange(12 / months_to_add):
+			to_date = add_months(to_date, months_to_add)
+
+			if to_date == get_first_day(to_date):
+				# if to_date is the first day, get the last day of previous month
+				to_date = add_days(to_date, -1)
+			else:
+				# to_date should be the last day of the new to_date's month
+				to_date = get_last_day(to_date)
+
+			if to_date <= end_date:
+				# the normal case
+				period_list.append(_dict({ "to_date": to_date }))
+
+				# if it ends before a full year
+				if to_date == end_date:
+					break
+
+			else:
+				# if a fiscal year ends before a 12 month period
+				period_list.append(_dict({ "to_date": end_date }))
+				break
+
+	# common processing
+	for opts in period_list:
+		key = opts["to_date"].strftime("%b_%Y").lower()
+		label = formatdate(opts["to_date"], "MMM YYYY")
+		opts.update({
+			"key": key.replace(" ", "_").replace("-", "_"),
+			"label": label,
+			"year_start_date": start_date,
+			"year_end_date": end_date
+		})
+
+		if from_beginning:
+			# set start date as None for all fiscal periods, used in case of Balance Sheet
+			opts["from_date"] = None
+		else:
+			opts["from_date"] = start_date
+
+	return period_list
+
+def get_data(company, root_type, balance_must_be, period_list, depth, ignore_closing_entries=False):
+	accounts = get_accounts(company, root_type)
+	if not accounts:
+		return None
+
+	accounts, accounts_by_name = filter_accounts(accounts, depth)
+	gl_entries_by_account = get_gl_entries(company, root_type, period_list[0]["from_date"], period_list[-1]["to_date"],
+		accounts[0].lft, accounts[0].rgt, ignore_closing_entries=ignore_closing_entries)
+
+	calculate_values(accounts, gl_entries_by_account, period_list)
+	accumulate_values_into_parents(accounts, accounts_by_name, period_list)
+	out = prepare_data(accounts, balance_must_be, period_list)
+
+	if out:
+		add_total_row(out, balance_must_be, period_list)
+
+	return out
+
+def calculate_values(accounts, gl_entries_by_account, period_list):
+	for d in accounts:
+		for name in ([d.name] + (d.collapsed_children or [])):
+			for entry in gl_entries_by_account.get(name, []):
+				for period in period_list:
+					entry.posting_date = getdate(entry.posting_date)
+
+					# check if posting date is within the period
+					if entry.posting_date <= period.to_date:
+						d[period.key] = d.get(period.key, 0.0) + flt(entry.debit) - flt(entry.credit)
+
+
+def accumulate_values_into_parents(accounts, accounts_by_name, period_list):
+	"""accumulate children's values in parent accounts"""
+	for d in reversed(accounts):
+		if d.parent_account:
+			for period in period_list:
+				accounts_by_name[d.parent_account][period.key] = accounts_by_name[d.parent_account].get(period.key, 0.0) + \
+					d.get(period.key, 0.0)
+
+def prepare_data(accounts, balance_must_be, period_list):
+	out = []
+	year_start_date = period_list[0]["year_start_date"].strftime("%Y-%m-%d")
+	year_end_date = period_list[-1]["year_end_date"].strftime("%Y-%m-%d")
+
+	for d in accounts:
+		# add to output
+		has_value = False
+		row = {
+			"account_name": d.account_name,
+			"account": d.name,
+			"parent_account": d.parent_account,
+			"indent": flt(d.indent),
+			"year_start_date": year_start_date,
+			"year_end_date": year_end_date
+		}
+		for period in period_list:
+			if d.get(period.key):
+				# change sign based on Debit or Credit, since calculation is done using (debit - credit)
+				d[period.key] *= (1 if balance_must_be=="Debit" else -1)
+
+			row[period.key] = flt(d.get(period.key, 0.0), 3)
+
+			if abs(row[period.key]) >= 0.005:
+				# ignore zero values
+				has_value = True
+
+		if has_value:
+			out.append(row)
+
+	return out
+
+def add_total_row(out, balance_must_be, period_list):
+	row = {
+		"account_name": _("Total ({0})").format(balance_must_be),
+		"account": None
+	}
+	for period in period_list:
+		row[period.key] = out[0].get(period.key, 0.0)
+		out[0][period.key] = ""
+
+	out.append(row)
+
+	# blank row after Total
+	out.append({})
+
+def get_accounts(company, root_type):
+	# root lft, rgt
+	root_account = frappe.db.sql("""select lft, rgt from `tabAccount`
+		where company=%s and root_type=%s order by lft limit 1""",
+		(company, root_type), as_dict=True)
+
+	if not root_account:
+		return None
+
+	lft, rgt = root_account[0].lft, root_account[0].rgt
+
+	accounts = frappe.db.sql("""select * from `tabAccount`
+		where company=%(company)s and lft >= %(lft)s and rgt <= %(rgt)s order by lft""",
+		{ "company": company, "lft": lft, "rgt": rgt }, as_dict=True)
+
+	return accounts
+
+def filter_accounts(accounts, depth):
+	parent_children_map = {}
+	accounts_by_name = {}
+	for d in accounts:
+		accounts_by_name[d.name] = d
+		parent_children_map.setdefault(d.parent_account or None, []).append(d)
+
+	filtered_accounts = []
+	def add_to_list(parent, level):
+		if level < depth:
+			for child in (parent_children_map.get(parent) or []):
+				child.indent = level
+				filtered_accounts.append(child)
+				add_to_list(child.name, level + 1)
+
+		else:
+			# include all children at level lower than the depth
+			parent_account = accounts_by_name[parent]
+			parent_account["collapsed_children"] = []
+			for d in accounts:
+				if d.lft > parent_account.lft and d.rgt < parent_account.rgt:
+					parent_account["collapsed_children"].append(d.name)
+
+	add_to_list(None, 0)
+
+	return filtered_accounts, accounts_by_name
+
+def get_gl_entries(company, root_type, from_date, to_date, root_lft, root_rgt, ignore_closing_entries=False):
+	"""Returns a dict like { "account": [gl entries], ... }"""
+	additional_conditions = []
+
+	if ignore_closing_entries:
+		additional_conditions.append("and ifnull(voucher_type, '')!='Period Closing Voucher'")
+
+	if from_date:
+		additional_conditions.append("and posting_date >= %(from_date)s")
+
+	gl_entries = frappe.db.sql("""select * from `tabGL Entry`
+		where company=%(company)s
+		{additional_conditions}
+		and posting_date <= %(to_date)s
+		and account in (select name from `tabAccount`
+			where lft >= %(lft)s and rgt <= %(rgt)s)
+		order by account, posting_date""".format(additional_conditions="\n".join(additional_conditions)),
+		{
+			"company": company,
+			"from_date": from_date,
+			"to_date": to_date,
+			"lft": root_lft,
+			"rgt": root_rgt
+		},
+		as_dict=True)
+
+	gl_entries_by_account = {}
+	for entry in gl_entries:
+		gl_entries_by_account.setdefault(entry.account, []).append(entry)
+
+	return gl_entries_by_account
+
+def get_columns(period_list):
+	columns = [{
+		"fieldname": "account",
+		"label": _("Account"),
+		"fieldtype": "Link",
+		"options": "Account",
+		"width": 300
+	}]
+	for period in period_list:
+		columns.append({
+			"fieldname": period.key,
+			"label": period.label,
+			"fieldtype": "Currency",
+			"width": 150
+		})
+
+	return columns

erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.html

@@ -0,0 +1 @@
+{% include "accounts/report/financial_statements.html" %}

erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.js

@@ -0,0 +1,6 @@
+// Copyright (c) 2013, Web Notes Technologies Pvt. Ltd. and Contributors
+// License: GNU General Public License v3. See license.txt
+
+frappe.require("assets/erpnext/js/financial_statements.js");
+
+frappe.query_reports["Profit and Loss Statement"] = erpnext.financial_statements;

erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.json

@@ -0,0 +1,17 @@
+{
+ "add_total_row": 0, 
+ "apply_user_permissions": 1, 
+ "creation": "2014-07-18 11:43:33.173207", 
+ "disabled": 0, 
+ "docstatus": 0, 
+ "doctype": "Report", 
+ "is_standard": "Yes", 
+ "modified": "2014-07-18 11:43:33.173207", 
+ "modified_by": "Administrator", 
+ "module": "Accounts", 
+ "name": "Profit and Loss Statement", 
+ "owner": "Administrator", 
+ "ref_doctype": "GL Entry", 
+ "report_name": "Profit and Loss Statement", 
+ "report_type": "Script Report"
+}

erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py

@@ -0,0 +1,39 @@
+# Copyright (c) 2013, Web Notes Technologies Pvt. Ltd. and Contributors
+# License: GNU General Public License v3. See license.txt
+
+from __future__ import unicode_literals
+import frappe
+from frappe import _
+from frappe.utils import flt
+from erpnext.accounts.report.financial_statements import (process_filters, get_period_list, get_columns, get_data)
+
+def execute(filters=None):
+	process_filters(filters)
+	period_list = get_period_list(filters.fiscal_year, filters.periodicity)
+
+	income = get_data(filters.company, "Income", "Credit", period_list, filters.depth, ignore_closing_entries=True)
+	expense = get_data(filters.company, "Expense", "Debit", period_list, filters.depth, ignore_closing_entries=True)
+	net_profit_loss = get_net_profit_loss(income, expense, period_list)
+
+	data = []
+	data.extend(income or [])
+	data.extend(expense or [])
+	if net_profit_loss:
+		data.append(net_profit_loss)
+
+	columns = get_columns(period_list)
+
+	return columns, data
+
+def get_net_profit_loss(income, expense, period_list):
+	if income and expense:
+		net_profit_loss = {
+			"account_name": _("Net Profit / Loss"),
+			"account": None,
+			"is_profit_loss": True
+		}
+
+		for period in period_list:
+			net_profit_loss[period.key] = flt(income[-2][period.key] - expense[-2][period.key], 3)
+
+		return net_profit_loss

erpnext/config/accounts.py

@@ -195,6 +195,18 @@ def get_data():
 					"doctype": "Purchase Invoice",
 					"is_query_report": True
 				},
+				{
+					"type": "report",
+					"name": "Balance Sheet",
+					"doctype": "GL Entry",
+					"is_query_report": True
+				},
+				{
+					"type": "report",
+					"name": "Profit and Loss Statement",
+					"doctype": "GL Entry",
+					"is_query_report": True
+				},
 				{
 					"type": "page",
 					"name": "financial-analytics",

erpnext/public/js/financial_statements.js

@@ -0,0 +1,75 @@
+frappe.provide("erpnext.financial_statements");
+
+erpnext.financial_statements = {
+	"filters": [
+		{
+			"fieldname":"company",
+			"label": __("Company"),
+			"fieldtype": "Link",
+			"options": "Company",
+			"default": frappe.defaults.get_user_default("company"),
+			"reqd": 1
+		},
+		{
+			"fieldname":"fiscal_year",
+			"label": __("Fiscal Year"),
+			"fieldtype": "Link",
+			"options": "Fiscal Year",
+			"default": frappe.defaults.get_user_default("fiscal_year"),
+			"reqd": 1
+		},
+		{
+			"fieldname": "periodicity",
+			"label": __("Periodicity"),
+			"fieldtype": "Select",
+			"options": "Yearly\nHalf-yearly\nQuarterly\nMonthly",
+			"default": "Yearly",
+			"reqd": 1
+		},
+		{
+			"fieldname": "depth",
+			"label": __("Depth"),
+			"fieldtype": "Select",
+			"options": "3\n4\n5",
+			"default": "3"
+		}
+	],
+	"formatter": function(row, cell, value, columnDef, dataContext) {
+		if (columnDef.df.fieldname=="account") {
+			var link = $("<a></a>")
+				.text(dataContext.account_name)
+				.attr("onclick", "erpnext.financial_statements.open_general_ledger(" + JSON.stringify(dataContext) + ")");
+
+			var span = $("<span></span>")
+				.css("padding-left", (cint(dataContext.indent) * 21) + "px")
+				.append(link);
+
+			value = span.wrap("<p></p>").parent().html();
+
+		} else {
+			value = erpnext.financial_statements.default_formatter(row, cell, value, columnDef, dataContext);
+		}
+
+		if (!dataContext.parent_account) {
+			var $value = $(value).css("font-weight", "bold");
+			if (dataContext.is_profit_loss && dataContext[columnDef.df.fieldname] < 0) {
+				$value.addClass("text-danger");
+			}
+
+			value = $value.wrap("<p></p>").parent().html();
+		}
+
+		return value;
+	},
+	"open_general_ledger": function(data) {
+		if (!data.account) return;
+
+		frappe.route_options = {
+			"account": data.account,
+			"company": frappe.query_report.filters_by_name.company.get_value(),
+			"from_date": data.year_start_date,
+			"to_date": data.year_end_date
+		};
+		frappe.set_route("query-report", "General Ledger");
+	}
+};