Merge branch 'develop'

Hotfix

accounts/doctype/journal_voucher/journal_voucher.js

@@ -120,7 +120,8 @@ cur_frm.cscript.refresh = function(doc) {
 				"voucher_no": doc.name,
 				"from_date": doc.posting_date,
 				"to_date": doc.posting_date,
-				"company": doc.company
+				"company": doc.company,
+				group_by_voucher: 0
 			};
 			wn.set_route("query-report", "General Ledger");
 		}, "icon-table");

accounts/doctype/purchase_invoice/purchase_invoice.js

@@ -35,7 +35,8 @@ erpnext.accounts.PurchaseInvoice = erpnext.buying.BuyingController.extend({
 					"voucher_no": doc.name,
 					"from_date": doc.posting_date,
 					"to_date": doc.posting_date,
-					"company": doc.company
+					"company": doc.company,
+					group_by_voucher: 0
 				};
 				wn.set_route("query-report", "General Ledger");
 			}, "icon-table");

accounts/doctype/purchase_invoice/purchase_invoice.py

@@ -350,7 +350,6 @@ class DocType(BuyingController):
 		# item gl entries
 		stock_item_and_auto_accounting_for_stock = False
 		stock_items = self.get_stock_items()
-		# rounding_diff = 0.0
 		for item in self.doclist.get({"parentfield": "entries"}):
 			if auto_accounting_for_stock and item.item_code in stock_items:
 				if flt(item.valuation_rate):
@@ -361,11 +360,6 @@ class DocType(BuyingController):
 					
 					valuation_amt = item.amount + item.item_tax_amount + item.rm_supp_cost
 					
-					# rounding_diff += (flt(item.amount, self.precision("amount", item)) + 
-					# 	flt(item.item_tax_amount, self.precision("item_tax_amount", item)) + 
-					# 	flt(item.rm_supp_cost, self.precision("rm_supp_cost", item)) - 
-					# 	valuation_amt)
-					
 					gl_entries.append(
 						self.get_gl_dict({
 							"account": item.expense_head,
@@ -392,12 +386,6 @@ class DocType(BuyingController):
 			# this will balance out valuation amount included in cost of goods sold
 			expenses_included_in_valuation = \
 				self.get_company_default("expenses_included_in_valuation")
-				
-			# if rounding_diff:
-			# 	import operator
-			# 	cost_center_with_max_value = max(valuation_tax.iteritems(), 
-			# 		key=operator.itemgetter(1))[0]
-			# 	valuation_tax[cost_center_with_max_value] -= flt(rounding_diff)
 			
 			for cost_center, amount in valuation_tax.items():
 				gl_entries.append(

accounts/doctype/sales_invoice/sales_invoice.js

@@ -54,7 +54,8 @@ erpnext.accounts.SalesInvoiceController = erpnext.selling.SellingController.exte
 					"voucher_no": doc.name,
 					"from_date": doc.posting_date,
 					"to_date": doc.posting_date,
-					"company": doc.company
+					"company": doc.company,
+					group_by_voucher: 0
 				};
 				wn.set_route("query-report", "General Ledger");
 			}, "icon-table");

accounts/doctype/sales_invoice/test_sales_invoice.py

@@ -364,7 +364,6 @@ class TestSalesInvoice(unittest.TestCase):
 			from `tabGL Entry` where voucher_type='Sales Invoice' and voucher_no=%s
 			order by account asc, debit asc""", si.doc.name, as_dict=1)
 		self.assertTrue(gl_entries)
-		# print gl_entries
 		
 		stock_in_hand = webnotes.conn.get_value("Account", {"master_name": "_Test Warehouse - _TC"})
 				
@@ -566,16 +565,17 @@ class TestSalesInvoice(unittest.TestCase):
 			where against_invoice=%s""", si.doc.name))
 			
 	def test_recurring_invoice(self):
-		from webnotes.utils import now_datetime, get_first_day, get_last_day, add_to_date
-		today = now_datetime().date()
-		
+		from webnotes.utils import get_first_day, get_last_day, add_to_date, nowdate, getdate
+		from accounts.utils import get_fiscal_year
+		today = nowdate()
 		base_si = webnotes.bean(copy=test_records[0])
 		base_si.doc.fields.update({
 			"convert_into_recurring_invoice": 1,
 			"recurring_type": "Monthly",
 			"notification_email_address": "test@example.com, test1@example.com, test2@example.com",
-			"repeat_on_day_of_month": today.day,
+			"repeat_on_day_of_month": getdate(today).day,
 			"posting_date": today,
+			"fiscal_year": get_fiscal_year(today)[0],
 			"invoice_period_from_date": get_first_day(today),
 			"invoice_period_to_date": get_last_day(today)
 		})

accounts/report/accounts_payable/accounts_payable.py

@@ -19,8 +19,8 @@ def execute(filters=None):
 		for gle in get_gl_entries(filters, before_report_date=False)]
 	
 	account_supplier_type_map = get_account_supplier_type_map()
-	pi_map = get_pi_map()
-
+	voucher_detail_map = get_voucher_details()
+	
 	# Age of the invoice on this date
 	age_on = getdate(filters.get("report_date")) > getdate(nowdate()) \
 		and nowdate() or filters.get("report_date")
@@ -29,14 +29,8 @@ def execute(filters=None):
 	for gle in entries:
 		if cstr(gle.against_voucher) == gle.voucher_no or not gle.against_voucher \
 				or [gle.against_voucher_type, gle.against_voucher] in entries_after_report_date:
-			if gle.voucher_type == "Purchase Invoice":
-				pi_info = pi_map.get(gle.voucher_no)
-				due_date = pi_info.get("due_date")
-				bill_no = pi_info.get("bill_no")
-				bill_date = pi_info.get("bill_date")
-			else:
-				due_date = bill_no = bill_date = ""
-		
+			voucher_details = voucher_detail_map.get(gle.voucher_type, {}).get(gle.voucher_no, {})
+			
 			invoiced_amount = gle.credit > 0 and gle.credit or 0
 			outstanding_amount = get_outstanding_amount(gle, 
 				filters.get("report_date") or nowdate())
@@ -44,13 +38,15 @@ def execute(filters=None):
 			if abs(flt(outstanding_amount)) > 0.01:
 				paid_amount = invoiced_amount - outstanding_amount
 				row = [gle.posting_date, gle.account, account_supplier.get(gle.account, ""),
-					gle.voucher_type, gle.voucher_no, 
-					gle.remarks, account_supplier_type_map.get(gle.account), due_date, bill_no, 
-					bill_date, invoiced_amount, paid_amount, outstanding_amount]
+					gle.voucher_type, gle.voucher_no, gle.remarks, 
+					account_supplier_type_map.get(gle.account), 
+					voucher_details.get("due_date", ""), voucher_details.get("bill_no", ""), 
+					voucher_details.get("bill_date", ""), invoiced_amount, 
+					paid_amount, outstanding_amount]
 				
 				# Ageing
 				if filters.get("ageing_based_on") == "Due Date":
-					ageing_based_on_date = due_date
+					ageing_based_on_date = voucher_details.get("due_date", "")
 				else:
 					ageing_based_on_date = gle.posting_date
 					
@@ -112,14 +108,15 @@ def get_account_supplier_type_map():
 		
 	return account_supplier_type_map
 	
-def get_pi_map():
-	""" get due_date from sales invoice """
-	pi_map = {}
-	for t in webnotes.conn.sql("""select name, due_date, bill_no, bill_date 
-			from `tabPurchase Invoice`""", as_dict=1):
-		pi_map[t.name] = t
+def get_voucher_details():
+	voucher_details = {}
+	for dt in ["Purchase Invoice", "Journal Voucher"]:
+		voucher_details.setdefault(dt, webnotes._dict())
+		for t in webnotes.conn.sql("""select name, due_date, bill_no, bill_date 
+				from `tab%s`""" % dt, as_dict=1):
+			voucher_details[dt].setdefault(t.name, t)
 		
-	return pi_map
+	return voucher_details
 
 def get_outstanding_amount(gle, report_date):
 	payment_amount = webnotes.conn.sql("""

accounts/report/accounts_receivable/accounts_receivable.py

@@ -15,20 +15,28 @@ class AccountsReceivableReport(object):
 			else self.filters.report_date
 			
 	def run(self):
-		return self.get_columns(), self.get_data()
+		customer_naming_by = webnotes.conn.get_value("Selling Settings", None, "cust_master_name")
+		return self.get_columns(customer_naming_by), self.get_data(customer_naming_by)
 		
-	def get_columns(self):
-		return [
+	def get_columns(self, customer_naming_by):
+		columns = [
 			"Posting Date:Date:80", "Account:Link/Account:150",
 			"Voucher Type::110", "Voucher No::120", "::30",
 			"Due Date:Date:80",  
 			"Invoiced Amount:Currency:100", "Payment Received:Currency:100", 
 			"Outstanding Amount:Currency:100", "Age:Int:50", "0-30:Currency:100",
 			"30-60:Currency:100", "60-90:Currency:100", "90-Above:Currency:100",
-			"Customer:Link/Customer:200", "Territory:Link/Territory:80", "Remarks::200"
+			"Customer:Link/Customer:200"
 		]
-		
-	def get_data(self):
+
+		if customer_naming_by == "Naming Series":
+			columns += ["Customer Name::110"]
+
+		columns += ["Territory:Link/Territory:80", "Remarks::200"]
+
+		return columns
+
+	def get_data(self, customer_naming_by):
 		data = []
 		future_vouchers = self.get_entries_after(self.filters.report_date)
 		for gle in self.get_entries_till(self.filters.report_date):
@@ -42,18 +50,23 @@ class AccountsReceivableReport(object):
 						gle.voucher_type, gle.voucher_no, due_date,
 						invoiced_amount, payment_received,
 						outstanding_amount]
-					entry_date = due_date if self.filters.ageing_based_on=="Due Date" \
+					entry_date = due_date if self.filters.ageing_based_on == "Due Date" \
 						else gle.posting_date
-					row += get_ageing_data(self.age_as_on, entry_date, outstanding_amount)
-					row += [self.get_customer(gle.account), self.get_territory(gle.account), gle.remarks]
+					row += get_ageing_data(self.age_as_on, entry_date, outstanding_amount) + \
+						[self.get_customer(gle.account)]
+
+					if customer_naming_by == "Naming Series":
+						row += [self.get_customer_name(gle.account)]
+
+					row += [self.get_territory(gle.account), gle.remarks]
 					data.append(row)
 		
-		for i in range(0,len(data)):
+		for i in range(0, len(data)):
 			data[i].insert(4, """<a href="%s"><i class="icon icon-share" style="cursor: pointer;"></i></a>""" \
 				% ("/".join(["#Form", data[i][2], data[i][3]]),))
 		
 		return data
-				
+
 	def get_entries_after(self, report_date):
 		# returns a distinct list
 		return list(set([(e.voucher_type, e.voucher_no) for e in self.get_gl_entries()
@@ -77,18 +90,21 @@ class AccountsReceivableReport(object):
 		return flt(gle.debit) - flt(gle.credit) - payment_received
 		
 	def get_customer(self, account):
+		return self.get_account_map().get(account).get("customer") or ""
+
+	def get_customer_name(self, account):
 		return self.get_account_map().get(account).get("customer_name") or ""
-		
+
 	def get_territory(self, account):
 		return self.get_account_map().get(account).get("territory") or ""
 		
 	def get_account_map(self):
 		if not hasattr(self, "account_map"):
 			self.account_map = dict(((r.name, r) for r in webnotes.conn.sql("""select 
-				account.name, customer.name as customer_name, customer.territory
-				from `tabAccount` account, `tabCustomer` customer 
-				where account.master_type="Customer" 
-				and customer.name=account.master_name""", as_dict=True)))
+				acc.name, cust.name as customer, cust.customer_name, cust.territory
+				from `tabAccount` acc, `tabCustomer` cust 
+				where acc.master_type="Customer" 
+				and cust.name=acc.master_name""", as_dict=True)))
 				
 		return self.account_map
 		
@@ -147,7 +163,7 @@ class AccountsReceivableReport(object):
 
 def execute(filters=None):
 	return AccountsReceivableReport(filters).run()
-	
+
 def get_ageing_data(age_as_on, entry_date, outstanding_amount):
 	# [0-30, 30-60, 60-90, 90-above]
 	outstanding_range = [0.0, 0.0, 0.0, 0.0]
@@ -164,4 +180,4 @@ def get_ageing_data(age_as_on, entry_date, outstanding_amount):
 	if index is None: index = 3
 	outstanding_range[index] = outstanding_amount
 	
-	return [age] + outstanding_range
+	return [age] + outstanding_range

accounts/report/general_ledger/general_ledger.js

@@ -11,26 +11,6 @@ wn.query_reports["General Ledger"] = {
 			"default": wn.defaults.get_user_default("company"),
 			"reqd": 1
 		},
-		{
-			"fieldname":"account",
-			"label": wn._("Account"),
-			"fieldtype": "Link",
-			"options": "Account"
-		},
-		{
-			"fieldname":"voucher_no",
-			"label": wn._("Voucher No"),
-			"fieldtype": "Data",
-		},
-		{
-			"fieldname":"group_by",
-			"label": wn._("Group by"),
-			"fieldtype": "Select",
-			"options": "\nGroup by Account\nGroup by Voucher"
-		},
-		{
-			"fieldtype": "Break",
-		},
 		{
 			"fieldname":"from_date",
 			"label": wn._("From Date"),
@@ -46,6 +26,40 @@ wn.query_reports["General Ledger"] = {
 			"default": wn.datetime.get_today(),
 			"reqd": 1,
 			"width": "60px"
+		},
+		{
+			"fieldtype": "Break",
+		},
+		{
+			"fieldname":"account",
+			"label": wn._("Account"),
+			"fieldtype": "Link",
+			"options": "Account",
+			"get_query": function() {
+				var company = wn.query_report.filters_by_name.company.get_value();
+				return {
+					"doctype": "Account", 
+					"filters": {
+						"company": company,
+					}
+				}
+			}
+		},
+		{
+			"fieldname":"voucher_no",
+			"label": wn._("Voucher No"),
+			"fieldtype": "Data",
+		},
+		{
+			"fieldname":"group_by_voucher",
+			"label": wn._("Group by Voucher"),
+			"fieldtype": "Check",
+			"default": 1
+		},
+		{
+			"fieldname":"group_by_account",
+			"label": wn._("Group by Account"),
+			"fieldtype": "Check",
 		}
 	]
 }

accounts/report/general_ledger/general_ledger.py

@@ -3,109 +3,170 @@
 
 from __future__ import unicode_literals
 import webnotes
-from webnotes.utils import flt, add_days
+from webnotes.utils import cstr, flt
 from webnotes import _
-from accounts.utils import get_balance_on
 
 def execute(filters=None):
-	account_details = webnotes.conn.get_value("Account", filters["account"], 
-		["debit_or_credit", "group_or_ledger"], as_dict=True) if filters.get("account") else None
+	account_details = {}
+	for acc in webnotes.conn.sql("""select name, debit_or_credit, group_or_ledger 
+		from tabAccount""", as_dict=1):
+			account_details.setdefault(acc.name, acc)
+	
 	validate_filters(filters, account_details)
 	
 	columns = get_columns()
-	data = []
-	if filters.get("group_by"):
-		data += get_grouped_gle(filters)
-	else:
-		data += get_gl_entries(filters)
-		if data:
-			data.append(get_total_row(data))
+	
+	res = get_result(filters, account_details)
 
-	if account_details:
-		data = [get_opening_balance_row(filters, account_details.debit_or_credit)] + data + \
-			[get_closing_balance_row(filters, account_details.debit_or_credit)]
-
-	return columns, data
+	return columns, res
 	
 def validate_filters(filters, account_details):
-	if account_details and account_details.group_or_ledger == "Ledger" \
-			and filters.get("group_by") == "Group by Account":
+	if filters.get("account") and filters.get("group_by_account") \
+			and account_details[filters.account].group_or_ledger == "Ledger":
 		webnotes.throw(_("Can not filter based on Account, if grouped by Account"))
 		
-	if filters.get("voucher_no") and filters.get("group_by") == "Group by Voucher":
+	if filters.get("voucher_no") and filters.get("group_by_voucher"):
 		webnotes.throw(_("Can not filter based on Voucher No, if grouped by Voucher"))
+		
+	if filters.from_date > filters.to_date:
+		webnotes.throw(_("From Date must be before To Date"))
 	
 def get_columns():
 	return ["Posting Date:Date:100", "Account:Link/Account:200", "Debit:Float:100", 
 		"Credit:Float:100", "Voucher Type::120", "Voucher No::160", "Link::20", 
-		"Cost Center:Link/Cost Center:100", "Remarks::200"]
+		"Against Account::120", "Cost Center:Link/Cost Center:100", "Remarks::200"]
 		
-def get_opening_balance_row(filters, debit_or_credit):
-	opening_balance = get_balance_on(filters["account"], add_days(filters["from_date"], -1))
-	return get_balance_row(opening_balance, debit_or_credit, "Opening Balance")
-	
-def get_closing_balance_row(filters, debit_or_credit):
-	closing_balance = get_balance_on(filters["account"], filters["to_date"])
-	return get_balance_row(closing_balance, debit_or_credit, "Closing Balance")
-	
-def get_balance_row(balance, debit_or_credit, balance_label):
-	if debit_or_credit == "Debit":
-		return ["", balance_label, balance, 0.0, "", "", ""]
-	else:
-		return ["", balance_label, 0.0, balance, "", "", ""]
+def get_result(filters, account_details):	
+	gl_entries = get_gl_entries(filters)
+
+	data = get_data_with_opening_closing(filters, account_details, gl_entries)
 		
+	result = get_result_as_list(data)
+
+	return result
+	
 def get_gl_entries(filters):
-	gl_entries = webnotes.conn.sql("""select 
-			posting_date, account, debit, credit, voucher_type, voucher_no, cost_center, remarks 
-		from `tabGL Entry`
-		where company=%(company)s 
-			and posting_date between %(from_date)s and %(to_date)s
-			{conditions}
-		order by posting_date, account"""\
-		.format(conditions=get_conditions(filters)), filters, as_list=1)
+	group_by_condition = "group by voucher_type, voucher_no, account" \
+		if filters.get("group_by_voucher") else "group by name"
 		
-	for d in gl_entries:
-		icon = """<a href="%s"><i class="icon icon-share" style="cursor: pointer;"></i></a>""" \
-			% ("/".join(["#Form", d[4], d[5]]),)
-		d.insert(6, icon)
+	gl_entries = webnotes.conn.sql("""select posting_date, account, 
+			sum(ifnull(debit, 0)) as debit, sum(ifnull(credit, 0)) as credit, 
+			voucher_type, voucher_no, cost_center, remarks, is_advance, against 
+		from `tabGL Entry`
+		where company=%(company)s {conditions}
+		{group_by_condition}
+		order by posting_date, account"""\
+		.format(conditions=get_conditions(filters), group_by_condition=group_by_condition), 
+		filters, as_dict=1)
 		
 	return gl_entries
-			
+	
 def get_conditions(filters):
 	conditions = []
 	if filters.get("account"):
 		lft, rgt = webnotes.conn.get_value("Account", filters["account"], ["lft", "rgt"])
 		conditions.append("""account in (select name from tabAccount 
 			where lft>=%s and rgt<=%s and docstatus<2)""" % (lft, rgt))
+	else:
+		conditions.append("posting_date between %(from_date)s and %(to_date)s")
+		
 	if filters.get("voucher_no"):
 		conditions.append("voucher_no=%(voucher_no)s")
 	
 	return "and {}".format(" and ".join(conditions)) if conditions else ""
-		
-def get_grouped_gle(filters):
-	gle_map = {}
-	gle = get_gl_entries(filters)
-	for d in gle:
-		gle_map.setdefault(d[1 if filters["group_by"]=="Group by Account" else 5], []).append(d)
-		
+
+def get_data_with_opening_closing(filters, account_details, gl_entries):
 	data = []
-	for entries in gle_map.values():
-		subtotal_debit = subtotal_credit = 0.0
-		for entry in entries:
-			data.append(entry)
-			subtotal_debit += flt(entry[2])
-			subtotal_credit += flt(entry[3])
-		
-		data.append(["", "Total", subtotal_debit, subtotal_credit, "", "", ""])
+	gle_map = initialize_gle_map(gl_entries)
+	
+	opening, total_debit, total_credit, gle_map = get_accountwise_gle(filters, gl_entries, gle_map)
+	
+	# Opening for filtered account
+	if filters.get("account"):
+		data += [get_balance_row("Opening", account_details[filters.account].debit_or_credit, 
+			opening), {}]
+
+	for acc, acc_dict in gle_map.items():
+		if acc_dict.entries:
+			# Opening for individual ledger, if grouped by account
+			if filters.get("group_by_account"):
+				data.append(get_balance_row("Opening", account_details[acc].debit_or_credit, 
+					acc_dict.opening))
+
+			data += acc_dict.entries
+			
+			# Totals and closing for individual ledger, if grouped by account
+			if filters.get("group_by_account"):
+				data += [{"account": "Totals", "debit": acc_dict.total_debit, 
+					"credit": acc_dict.total_credit}, 
+					get_balance_row("Closing (Opening + Totals)", 
+						account_details[acc].debit_or_credit, (acc_dict.opening 
+						+ acc_dict.total_debit - acc_dict.total_credit)), {}]
+						
+	# Total debit and credit between from and to date	
+	if total_debit or total_credit:
+		data.append({"account": "Totals", "debit": total_debit, "credit": total_credit})
+	
+	# Closing for filtered account
+	if filters.get("account"):
+		data.append(get_balance_row("Closing (Opening + Totals)", 
+			account_details[filters.account].debit_or_credit, 
+			(opening + total_debit - total_credit)))
 	
-	if data:
-		data.append(get_total_row(gle))
 	return data
+
+def initialize_gle_map(gl_entries):
+	gle_map = webnotes._dict()
+	for gle in gl_entries:
+		gle_map.setdefault(gle.account, webnotes._dict({
+			"opening": 0,
+			"entries": [],
+			"total_debit": 0,
+			"total_credit": 0,
+			"closing": 0
+		}))
+	return gle_map
+
+def get_accountwise_gle(filters, gl_entries, gle_map):
+	opening, total_debit, total_credit = 0, 0, 0
 	
-def get_total_row(gle):
-	total_debit = total_credit = 0.0
-	for d in gle:
-		total_debit += flt(d[2])
-		total_credit += flt(d[3])
+	for gle in gl_entries:
+		amount = flt(gle.debit) - flt(gle.credit)
+		if filters.get("account") and (gle.posting_date < filters.from_date 
+				or cstr(gle.is_advance) == "Yes"):
+			gle_map[gle.account].opening += amount
+			opening += amount
+		elif gle.posting_date <= filters.to_date:
+			gle_map[gle.account].entries.append(gle)
+			gle_map[gle.account].total_debit += flt(gle.debit)
+			gle_map[gle.account].total_credit += flt(gle.credit)
+			
+			total_debit += flt(gle.debit)
+			total_credit += flt(gle.credit)
+			
+	return opening, total_debit, total_credit, gle_map
+
+def get_balance_row(label, debit_or_credit, balance):
+	return {
+		"account": label,
+		"debit": balance if debit_or_credit=="Debit" else 0,
+		"credit": -1*balance if debit_or_credit=="Credit" else 0,
+	}
+	
+def get_result_as_list(data):
+	result = []
+	for d in data:
+		result.append([d.get("posting_date"), d.get("account"), d.get("debit"), 
+			d.get("credit"), d.get("voucher_type"), d.get("voucher_no"), 
+			get_voucher_link(d.get("voucher_type"), d.get("voucher_no")), 
+			d.get("against"), d.get("cost_center"), d.get("remarks")])
+	
+	return result
+	
+def get_voucher_link(voucher_type, voucher_no):
+	icon = ""
+	if voucher_type and voucher_no:
+		icon = """<a href="%s"><i class="icon icon-share" style="cursor: pointer;">
+			</i></a>""" % ("/".join(["#Form", voucher_type, voucher_no]))
 		
-	return ["", "Total Debit/Credit", total_debit, total_credit, "", "", ""]
+	return icon

accounts/utils.py

@@ -4,7 +4,7 @@
 from __future__ import unicode_literals
 
 import webnotes
-from webnotes.utils import nowdate, nowtime, cstr, flt, now, getdate, add_months
+from webnotes.utils import nowdate, cstr, flt, now, getdate, add_months
 from webnotes.model.doc import addchild
 from webnotes import msgprint, _
 from webnotes.utils import formatdate
@@ -31,6 +31,8 @@ def get_fiscal_years(date=None, fiscal_year=None, label="Date", verbose=1):
 	
 	if not fy:
 		error_msg = """%s %s not in any Fiscal Year""" % (label, formatdate(date))
+		error_msg = """{msg}: {date}""".format(msg=_("Fiscal Year does not exist for date"), 
+			date=formatdate(date))
 		if verbose: webnotes.msgprint(error_msg)
 		raise FiscalYearError, error_msg
 	
@@ -62,7 +64,6 @@ def get_balance_on(account=None, date=None):
 	try:
 		year_start_date = get_fiscal_year(date, verbose=0)[1]
 	except FiscalYearError, e:
-		from webnotes.utils import getdate
 		if getdate(date) > getdate(nowdate()):
 			# if fiscal year not found and the date is greater than today
 			# get fiscal year for today's date and its corresponding year start date
@@ -220,17 +221,26 @@ def get_cost_center_list(doctype, txt, searchfield, start, page_len, filters):
 		tuple(filter_values + ["%%%s%%" % txt, start, page_len]))
 		
 def remove_against_link_from_jv(ref_type, ref_no, against_field):
-	webnotes.conn.sql("""update `tabJournal Voucher Detail` set `%s`=null,
-		modified=%s, modified_by=%s
-		where `%s`=%s and docstatus < 2""" % (against_field, "%s", "%s", against_field, "%s"), 
-		(now(), webnotes.session.user, ref_no))
+	linked_jv = webnotes.conn.sql_list("""select parent from `tabJournal Voucher Detail` 
+		where `%s`=%s and docstatus < 2""" % (against_field, "%s"), (ref_no))
+		
+	if linked_jv:	
+		webnotes.conn.sql("""update `tabJournal Voucher Detail` set `%s`=null,
+			modified=%s, modified_by=%s
+			where `%s`=%s and docstatus < 2""" % (against_field, "%s", "%s", against_field, "%s"), 
+			(now(), webnotes.session.user, ref_no))
 	
-	webnotes.conn.sql("""update `tabGL Entry`
-		set against_voucher_type=null, against_voucher=null,
-		modified=%s, modified_by=%s
-		where against_voucher_type=%s and against_voucher=%s
-		and voucher_no != ifnull(against_voucher, '')""",
-		(now(), webnotes.session.user, ref_type, ref_no))
+		webnotes.conn.sql("""update `tabGL Entry`
+			set against_voucher_type=null, against_voucher=null,
+			modified=%s, modified_by=%s
+			where against_voucher_type=%s and against_voucher=%s
+			and voucher_no != ifnull(against_voucher, '')""",
+			(now(), webnotes.session.user, ref_type, ref_no))
+			
+		webnotes.msgprint("{msg} {linked_jv}".format(msg = _("""Following linked Journal Vouchers \
+			made against this transaction has been unlinked. You can link them again with other \
+			transactions via Payment Reconciliation Tool."""), linked_jv="\n".join(linked_jv)))
+		
 
 @webnotes.whitelist()
 def get_company_default(company, fieldname):
@@ -368,4 +378,4 @@ def get_account_for(account_for_doctype, account_for):
 		account_for_field = "account_type"
 		
 	return webnotes.conn.get_value("Account", {account_for_field: account_for_doctype, 
-		"master_name": account_for})
+		"master_name": account_for})

buying/doctype/purchase_order/test_purchase_order.py

@@ -22,7 +22,7 @@ class TestPurchaseOrder(unittest.TestCase):
 		
 		pr = make_purchase_receipt(po.doc.name)
 		pr[0]["supplier_warehouse"] = "_Test Warehouse 1 - _TC"
-		
+		pr[0]["posting_date"] = "2013-05-12"
 		self.assertEquals(pr[0]["doctype"], "Purchase Receipt")
 		self.assertEquals(len(pr), len(test_records[0]))
 		
@@ -52,7 +52,7 @@ class TestPurchaseOrder(unittest.TestCase):
 		
 		self.assertEquals(pr[0]["doctype"], "Purchase Receipt")
 		self.assertEquals(len(pr), len(test_records[0]))
-		
+		pr[0]["posting_date"] = "2013-05-12"
 		pr[0].naming_series = "_T-Purchase Receipt-"
 		pr[1].qty = 4.0
 		pr_bean = webnotes.bean(pr)
@@ -66,6 +66,7 @@ class TestPurchaseOrder(unittest.TestCase):
 			
 		pr1 = make_purchase_receipt(po.doc.name)
 		pr1[0].naming_series = "_T-Purchase Receipt-"
+		pr1[0]["posting_date"] = "2013-05-12"
 		pr1[1].qty = 8
 		pr1_bean = webnotes.bean(pr1)
 		pr1_bean.insert()
@@ -88,7 +89,7 @@ class TestPurchaseOrder(unittest.TestCase):
 		
 		self.assertEquals(pi[0]["doctype"], "Purchase Invoice")
 		self.assertEquals(len(pi), len(test_records[0]))
-
+		pi[0]["posting_date"] = "2013-05-12"
 		pi[0].bill_no = "NA"
 		webnotes.bean(pi).insert()
 		

config.json

@@ -1,6 +1,6 @@
 {
  "app_name": "ERPNext", 
- "app_version": "3.3.8", 
+ "app_version": "3.4.6", 
  "base_template": "app/portal/templates/base.html", 
  "modules": {
   "Accounts": {
@@ -74,5 +74,5 @@
    "type": "module"
   }
  }, 
- "requires_framework_version": "==3.3.2"
+ "requires_framework_version": "==3.4.3"
 }

controllers/accounts_controller.py

@@ -231,9 +231,6 @@ class AccountsController(TransactionBase):
 				# tax_amount represents the amount of tax for the current step
 				current_tax_amount = self.get_current_tax_amount(item, tax, item_tax_map)
 				
-				if hasattr(self, "set_item_tax_amount"):
-					self.set_item_tax_amount(item, tax, current_tax_amount)
-
 				# case when net total is 0 but there is an actual type charge
 				# in this case add the actual amount to tax.tax_amount
 				# and tax.grand_total_for_current_item for the first such iteration
@@ -384,24 +381,41 @@ class AccountsController(TransactionBase):
 			})
 			
 	def validate_multiple_billing(self, ref_dt, item_ref_dn, based_on, parentfield):
+		from controllers.status_updater import get_tolerance_for
+		item_tolerance = {}
+		global_tolerance = None
+		
 		for item in self.doclist.get({"parentfield": "entries"}):
 			if item.fields.get(item_ref_dn):
 				already_billed = webnotes.conn.sql("""select sum(%s) from `tab%s` 
 					where %s=%s and docstatus=1""" % (based_on, self.tname, item_ref_dn, '%s'), 
 					item.fields[item_ref_dn])[0][0]
 				
-				max_allowed_amt = flt(webnotes.conn.get_value(ref_dt + " Item", 
-					item.fields[item_ref_dn], based_on), self.precision(based_on, item))
-				
 				total_billed_amt = flt(flt(already_billed) + flt(item.fields[based_on]), 
 					self.precision(based_on, item))
+				
+				ref_amt = flt(webnotes.conn.get_value(ref_dt + " Item", 
+					item.fields[item_ref_dn], based_on), self.precision(based_on, item))
+				
+				tolerance, item_tolerance, global_tolerance = get_tolerance_for(item.item_code, 
+					item_tolerance, global_tolerance)
 					
-				if max_allowed_amt and total_billed_amt - max_allowed_amt > 0.02:
-					webnotes.msgprint(_("Row ")+ cstr(item.idx) + ": " + cstr(item.item_code) + 
-						_(" will be over-billed against mentioned ") + cstr(ref_dt) +  
-						_(". Max allowed " + cstr(based_on) + ": " + cstr(max_allowed_amt)), 
-						raise_exception=1)
-		
+				max_allowed_amt = flt(ref_amt * (100 + tolerance) / 100)
+				
+				if total_billed_amt - max_allowed_amt > 0.01:
+					reduce_by = total_billed_amt - max_allowed_amt
+					
+					webnotes.throw(_("Row #") + cstr(item.idx) + ": " + 
+						_(" Max amount allowed for Item ") + cstr(item.item_code) + 
+						_(" against ") + ref_dt + " " + 
+						cstr(item.fields[ref_dt.lower().replace(" ", "_")]) + _(" is ") + 
+						cstr(max_allowed_amt) + ". \n" + 
+						_("""If you want to increase your overflow tolerance, please increase \
+						tolerance % in Global Defaults or Item master. 				
+						Or, you must reduce the amount by """) + cstr(reduce_by) + "\n" + 
+						_("""Also, please check if the order item has already been billed \
+							in the Sales Order"""))
+				
 	def get_company_default(self, fieldname):
 		from accounts.utils import get_company_default
 		return get_company_default(self.doc.company, fieldname)

controllers/buying_controller.py

@@ -163,30 +163,41 @@ class BuyingController(StockController):
 		if not self.meta.get_field("item_tax_amount", parentfield=self.fname):
 			for item in self.item_doclist:
 				del item.fields["item_tax_amount"]
-				
-	def set_item_tax_amount(self, item, tax, current_tax_amount):
+							
+	# update valuation rate
+	def update_valuation_rate(self, parentfield):
 		"""
 			item_tax_amount is the total tax amount applied on that item
 			stored for valuation 
 			
 			TODO: rename item_tax_amount to valuation_tax_amount
 		"""
-		if tax.category in ["Valuation", "Valuation and Total"] and \
-			self.meta.get_field("item_tax_amount", parentfield=self.fname):
-				item.item_tax_amount += flt(current_tax_amount, self.precision("item_tax_amount", item))
-				
-	# update valuation rate
-	def update_valuation_rate(self, parentfield):
-		for item in self.doclist.get({"parentfield": parentfield}):
-			item.conversion_factor = item.conversion_factor or flt(webnotes.conn.get_value(
-				"UOM Conversion Detail", {"parent": item.item_code, "uom": item.uom}, 
-				"conversion_factor")) or 1
+		stock_items = self.get_stock_items()
+		
+		stock_items_qty, stock_items_amount = 0, 0
+		for d in self.doclist.get({"parentfield": parentfield}):
+			if d.item_code and d.item_code in stock_items:
+				stock_items_qty += flt(d.qty)
+				stock_items_amount += flt(d.amount)
 			
-			if item.item_code and item.qty:
+		total_valuation_amount = sum([flt(d.tax_amount) for d in 
+			self.doclist.get({"parentfield": "purchase_tax_details"}) 
+			if d.category in ["Valuation", "Valuation and Total"]])
+			
+			
+		for item in self.doclist.get({"parentfield": parentfield}):
+			if item.item_code and item.qty and item.item_code in stock_items:
+				item_proportion = flt(item.amount) / stock_items_amount if stock_items_amount \
+					else flt(item.qty) / stock_items_qty
+				
+				item.item_tax_amount = flt(item_proportion * total_valuation_amount, 
+					self.precision("item_tax_amount", item))
+
 				self.round_floats_in(item)
-								
-				# if no item code, which is sometimes the case in purchase invoice, 
-				# then it is not possible to track valuation against it
+				
+				item.conversion_factor = item.conversion_factor or flt(webnotes.conn.get_value(
+					"UOM Conversion Detail", {"parent": item.item_code, "uom": item.uom}, 
+					"conversion_factor")) or 1
 				qty_in_stock_uom = flt(item.qty * item.conversion_factor)
 				item.valuation_rate = ((item.amount + item.item_tax_amount + item.rm_supp_cost)
 					/ qty_in_stock_uom)

controllers/status_updater.py

@@ -151,7 +151,9 @@ class StatusUpdater(DocListController):
 		"""
 	
 		# check if overflow is within tolerance
-		tolerance = self.get_tolerance_for(item['item_code'])
+		tolerance, self.tolerance, self.global_tolerance = get_tolerance_for(item['item_code'], 
+			self.tolerance, self.global_tolerance)
+			
 		overflow_percent = ((item[args['target_field']] - item[args['target_ref_field']]) / 
 		 	item[args['target_ref_field']]) * 100
 	
@@ -170,23 +172,6 @@ class StatusUpdater(DocListController):
 				
 				Also, please check if the order item has already been billed in the Sales Order""" % 
 				item, raise_exception=1)
-				
-	def get_tolerance_for(self, item_code):
-		"""
-			Returns the tolerance for the item, if not set, returns global tolerance
-		"""
-		if self.tolerance.get(item_code): return self.tolerance[item_code]
-		
-		tolerance = flt(webnotes.conn.get_value('Item',item_code,'tolerance') or 0)
-
-		if not tolerance:
-			if self.global_tolerance == None:
-				self.global_tolerance = flt(webnotes.conn.get_value('Global Defaults', None, 
-					'tolerance'))
-			tolerance = self.global_tolerance
-		
-		self.tolerance[item_code] = tolerance
-		return tolerance
 	
 
 	def update_qty(self, change_modified=True):
@@ -245,4 +230,22 @@ class StatusUpdater(DocListController):
 							set %(status_field)s = if(ifnull(%(target_parent_field)s,0)<0.001, 
 								'Not %(keyword)s', if(%(target_parent_field)s>=99.99, 
 								'Fully %(keyword)s', 'Partly %(keyword)s'))
-							where name='%(name)s'""" % args)
+							where name='%(name)s'""" % args)
+							
+def get_tolerance_for(item_code, item_tolerance={}, global_tolerance=None):
+	"""
+		Returns the tolerance for the item, if not set, returns global tolerance
+	"""
+	if item_tolerance.get(item_code):
+		return item_tolerance[item_code], item_tolerance, global_tolerance
+	
+	tolerance = flt(webnotes.conn.get_value('Item',item_code,'tolerance') or 0)
+
+	if not tolerance:
+		if global_tolerance == None:
+			global_tolerance = flt(webnotes.conn.get_value('Global Defaults', None, 
+				'tolerance'))
+		tolerance = global_tolerance
+	
+	item_tolerance[item_code] = tolerance
+	return tolerance, item_tolerance, global_tolerance

manufacturing/doctype/production_order/test_production_order.py

@@ -34,6 +34,7 @@ class TestProductionOrder(unittest.TestCase):
 		stock_entry = webnotes.bean(stock_entry)
 		
 		stock_entry.doc.fg_completed_qty = 4
+		stock_entry.doc.posting_date = "2013-05-12"
 		stock_entry.run_method("get_items")
 		stock_entry.submit()
 		
@@ -50,7 +51,7 @@ class TestProductionOrder(unittest.TestCase):
 		
 		stock_entry = make_stock_entry(pro_order, "Manufacture/Repack")
 		stock_entry = webnotes.bean(stock_entry)
-		
+		stock_entry.doc.posting_date = "2013-05-12"
 		stock_entry.doc.fg_completed_qty = 15
 		stock_entry.run_method("get_items")
 		stock_entry.insert()

projects/doctype/time_log_batch/time_log_batch.py

@@ -28,7 +28,7 @@ class DocType:
 		})
 
 	def validate_time_log_is_submitted(self, tl):
-		if tl.status != "Submitted":
+		if tl.status != "Submitted" and self.doc.docstatus == 0:
 			webnotes.msgprint(_("Time Log must have status 'Submitted'") + \
 				" :" + tl.name + " (" + _(tl.status) + ")", raise_exception=True)
 	
@@ -57,7 +57,4 @@ class DocType:
 			tl = webnotes.bean("Time Log", d.time_log)
 			tl.doc.time_log_batch = time_log_batch
 			tl.doc.sales_invoice = self.doc.sales_invoice
-			tl.update_after_submit()
-		
-
-		
+			tl.update_after_submit()

public/js/controllers/stock_controller.js

@@ -28,7 +28,8 @@ erpnext.stock.StockController = wn.ui.form.Controller.extend({
 					voucher_no: me.frm.doc.name,
 					from_date: me.frm.doc.posting_date,
 					to_date: me.frm.doc.posting_date,
-					company: me.frm.doc.company
+					company: me.frm.doc.company,
+					group_by_voucher: false
 				};
 				wn.set_route("query-report", "General Ledger");
 			}, "icon-table");

selling/doctype/customer/customer.txt

@@ -2,7 +2,7 @@
  {
   "creation": "2013-06-11 14:26:44", 
   "docstatus": 0, 
-  "modified": "2013-11-03 14:01:33", 
+  "modified": "2013-12-25 11:15:05", 
   "modified_by": "Administrator", 
   "owner": "Administrator"
  }, 
@@ -16,7 +16,7 @@
   "icon": "icon-user", 
   "module": "Selling", 
   "name": "__common__", 
-  "search_fields": "customer_name,customer_group,country,territory"
+  "search_fields": "customer_name,customer_group,territory"
  }, 
  {
   "doctype": "DocField", 

selling/doctype/quotation/test_quotation.py

@@ -28,6 +28,7 @@ class TestQuotation(unittest.TestCase):
 		
 		sales_order[0]["delivery_date"] = "2014-01-01"
 		sales_order[0]["naming_series"] = "_T-Quotation-"
+		sales_order[0]["transaction_date"] = "2013-05-12"
 		webnotes.bean(sales_order).insert()
 
 

selling/doctype/sales_order/test_sales_order.py

@@ -53,6 +53,7 @@ class TestSalesOrder(unittest.TestCase):
 		self.assertEquals(len([d for d in si if d["doctype"]=="Sales Invoice Item"]), 1)
 		
 		si = webnotes.bean(si)
+		si.doc.posting_date = "2013-10-10"
 		si.insert()
 		si.submit()
 

stock/doctype/material_request/test_material_request.py

@@ -125,6 +125,7 @@ class TestMaterialRequest(unittest.TestCase):
 		from stock.doctype.material_request.material_request import make_purchase_order
 		po_doclist = make_purchase_order(mr.doc.name)
 		po_doclist[0].supplier = "_Test Supplier"
+		po_doclist[0].transaction_date = "2013-07-07"
 		po_doclist[1].qty = 27.0
 		po_doclist[2].qty = 1.5
 		po_doclist[1].schedule_date = "2013-07-09"

stock/doctype/purchase_receipt_item/purchase_receipt_item.txt

@@ -2,7 +2,7 @@
  {
   "creation": "2013-05-24 19:29:10", 
   "docstatus": 0, 
-  "modified": "2013-12-18 10:38:39", 
+  "modified": "2014-01-03 18:28:20", 
   "modified_by": "Administrator", 
   "owner": "Administrator"
  }, 
@@ -334,6 +334,16 @@
   "report_hide": 0, 
   "reqd": 0
  }, 
+ {
+  "default": ":Company", 
+  "depends_on": "eval:sys_defaults.auto_accounting_for_stock", 
+  "doctype": "DocField", 
+  "fieldname": "cost_center", 
+  "fieldtype": "Link", 
+  "label": "Cost Center", 
+  "options": "Cost Center", 
+  "print_hide": 1
+ }, 
  {
   "doctype": "DocField", 
   "fieldname": "project_name", 

stock/doctype/stock_entry/stock_entry.py

@@ -290,11 +290,12 @@ class DocType(StockController):
 				if not returnable_qty:
 					webnotes.throw("{item}: {item_code} {returned}".format(
 						item=_("Item"), item_code=item.item_code, 
-						returned=_("already returned though some other documents")))
+						returned=_("already returned though some other documents")), 
+						StockOverReturnError)
 				elif item.transfer_qty > returnable_qty:
 					webnotes.throw("{item}: {item_code}, {returned}: {qty}".format(
 						item=_("Item"), item_code=item.item_code,
-						returned=_("Max Returnable Qty"), qty=returnable_qty))
+						returned=_("Max Returnable Qty"), qty=returnable_qty), StockOverReturnError)
 						
 	def get_already_returned_item_qty(self, ref_fieldname):
 		return dict(webnotes.conn.sql("""select item_code, sum(transfer_qty) as qty