diff --git a/erpnext/accounts/doctype/journal_voucher/journal_voucher.py b/erpnext/accounts/doctype/journal_voucher/journal_voucher.py
index 0ba0208..f11589b 100644
--- a/erpnext/accounts/doctype/journal_voucher/journal_voucher.py
+++ b/erpnext/accounts/doctype/journal_voucher/journal_voucher.py
@@ -21,22 +21,22 @@
 	def validate(self):
 		if not self.is_opening:
 			self.is_opening='No'
-			
+
 		self.clearance_date = None
-		
+
 		super(JournalVoucher, self).validate_date_with_fiscal_year()
-		
+
 		self.validate_debit_credit()
 		self.validate_cheque_info()
 		self.validate_entries_for_advance()
 		self.validate_against_jv()
-		
+
 		self.set_against_account()
 		self.create_remarks()
 		self.set_aging_date()
 		self.set_print_format_fields()
 
-	
+
 	def on_submit(self):
 		if self.voucher_type in ['Bank Voucher', 'Contra Voucher', 'Journal Entry']:
 			self.check_credit_days()
@@ -46,9 +46,9 @@
 	def on_cancel(self):
 		from erpnext.accounts.utils import remove_against_link_from_jv
 		remove_against_link_from_jv(self.doctype, self.name, "against_jv")
-		
+
 		self.make_gl_entries(1)
-		
+
 	def on_trash(self):
 		pass
 		#if self.amended_from:
@@ -57,7 +57,7 @@
 	def validate_debit_credit(self):
 		for d in self.get('entries'):
 			if d.debit and d.credit:
-				msgprint("You cannot credit and debit same account at the same time.", 
+				msgprint("You cannot credit and debit same account at the same time.",
 				 	raise_exception=1)
 
 	def validate_cheque_info(self):
@@ -65,7 +65,7 @@
 			if not self.cheque_no or not self.cheque_date:
 				msgprint("Reference No & Reference Date is required for %s" %
 				self.voucher_type, raise_exception=1)
-				
+
 		if self.cheque_date and not self.cheque_no:
 			msgprint("Reference No is mandatory if you entered Reference Date", raise_exception=1)
 
@@ -85,11 +85,11 @@
 				if d.against_jv == self.name:
 					msgprint("You can not enter current voucher in 'Against JV' column",
 						raise_exception=1)
-				elif not frappe.db.sql("""select name from `tabJournal Voucher Detail` 
-						where account = %s and docstatus = 1 and parent = %s""", 
+				elif not frappe.db.sql("""select name from `tabJournal Voucher Detail`
+						where account = %s and docstatus = 1 and parent = %s""",
 						(d.account, d.against_jv)):
 					msgprint("Against JV: %s is not valid." % d.against_jv, raise_exception=1)
-		
+
 	def set_against_account(self):
 		# Debit = Credit
 		debit, credit = 0.0, 0.0
@@ -104,9 +104,9 @@
 		self.total_credit = credit
 
 		if abs(self.total_debit-self.total_credit) > 0.001:
-			msgprint("Debit must be equal to Credit. The difference is %s" % 
+			msgprint("Debit must be equal to Credit. The difference is %s" %
 			 	(self.total_debit-self.total_credit), raise_exception=1)
-		
+
 		# update against account
 		for d in self.get('entries'):
 			if flt(d.debit) > 0: d.against_account = ', '.join(credit_list)
@@ -114,28 +114,28 @@
 
 	def create_remarks(self):
 		r = []
-		if self.cheque_no :
+		if self.cheque_no:
 			if self.cheque_date:
-				r.append('Via Reference #%s dated %s' % 
+				r.append('Via Reference #%s dated %s' %
 					(self.cheque_no, formatdate(self.cheque_date)))
 			else :
 				msgprint("Please enter Reference date", raise_exception=1)
-		
+
 		for d in self.get('entries'):
 			if d.against_invoice and d.credit:
 				currency = frappe.db.get_value("Sales Invoice", d.against_invoice, "currency")
-				r.append('%s %s against Invoice: %s' % 
+				r.append('%s %s against Invoice: %s' %
 					(cstr(currency), fmt_money(flt(d.credit)), d.against_invoice))
-					
+
 			if d.against_voucher and d.debit:
-				bill_no = frappe.db.sql("""select bill_no, bill_date, currency 
+				bill_no = frappe.db.sql("""select bill_no, bill_date, currency
 					from `tabPurchase Invoice` where name=%s""", d.against_voucher)
 				if bill_no and bill_no[0][0] and bill_no[0][0].lower().strip() \
 						not in ['na', 'not applicable', 'none']:
-					r.append('%s %s against Bill %s dated %s' % 
-						(cstr(bill_no[0][2]), fmt_money(flt(d.debit)), bill_no[0][0], 
+					r.append('%s %s against Bill %s dated %s' %
+						(cstr(bill_no[0][2]), fmt_money(flt(d.debit)), bill_no[0][0],
 						bill_no[0][1] and formatdate(bill_no[0][1].strftime('%Y-%m-%d')) or ''))
-	
+
 		if self.user_remark:
 			r.append("User Remark : %s"%self.user_remark)
 
@@ -157,25 +157,25 @@
 					break
 
 			# If customer/supplier account, aging date is mandatory
-			if exists and not self.aging_date: 
+			if exists and not self.aging_date:
 				msgprint("Aging Date is mandatory for opening entry", raise_exception=1)
 			else:
 				self.aging_date = self.posting_date
 
 	def set_print_format_fields(self):
 		for d in self.get('entries'):
-			account_type, master_type = frappe.db.get_value("Account", d.account, 
+			account_type, master_type = frappe.db.get_value("Account", d.account,
 				["account_type", "master_type"])
-				
+
 			if master_type in ['Supplier', 'Customer']:
 				if not self.pay_to_recd_from:
-					self.pay_to_recd_from = frappe.db.get_value(master_type, 
-						' - '.join(d.account.split(' - ')[:-1]), 
+					self.pay_to_recd_from = frappe.db.get_value(master_type,
+						' - '.join(d.account.split(' - ')[:-1]),
 						master_type == 'Customer' and 'customer_name' or 'supplier_name')
-			
+
 			if account_type in ['Bank', 'Cash']:
 				company_currency = get_company_currency(self.company)
-				amt = flt(d.debit) and d.debit or d.credit	
+				amt = flt(d.debit) and d.debit or d.credit
 				self.total_amount = company_currency + ' ' + cstr(amt)
 				from frappe.utils import money_in_words
 				self.total_amount_in_words = money_in_words(amt, company_currency)
@@ -184,29 +184,29 @@
 		date_diff = 0
 		if self.cheque_date:
 			date_diff = (getdate(self.cheque_date)-getdate(self.posting_date)).days
-		
+
 		if date_diff <= 0: return
-		
+
 		# Get List of Customer Account
-		acc_list = filter(lambda d: frappe.db.get_value("Account", d.account, 
+		acc_list = filter(lambda d: frappe.db.get_value("Account", d.account,
 		 	"master_type")=='Customer', self.get('entries'))
-		
+
 		for d in acc_list:
 			credit_days = self.get_credit_days_for(d.account)
 			# Check credit days
 			if credit_days > 0 and not self.get_authorized_user() and cint(date_diff) > credit_days:
 				msgprint("Credit Not Allowed: Cannot allow a check that is dated \
 					more than %s days after the posting date" % credit_days, raise_exception=1)
-					
+
 	def get_credit_days_for(self, ac):
 		if not self.credit_days_for.has_key(ac):
 			self.credit_days_for[ac] = cint(frappe.db.get_value("Account", ac, "credit_days"))
 
 		if not self.credit_days_for[ac]:
 			if self.credit_days_global==-1:
-				self.credit_days_global = cint(frappe.db.get_value("Company", 
+				self.credit_days_global = cint(frappe.db.get_value("Company",
 					self.company, "credit_days"))
-					
+
 			return self.credit_days_global
 		else:
 			return self.credit_days_for[ac]
@@ -216,33 +216,33 @@
 			self.is_approving_authority = 0
 
 			# Fetch credit controller role
-			approving_authority = frappe.db.get_value("Global Defaults", None, 
+			approving_authority = frappe.db.get_value("Global Defaults", None,
 				"credit_controller")
-			
+
 			# Check logged-in user is authorized
 			if approving_authority in frappe.user.get_roles():
 				self.is_approving_authority = 1
-				
+
 		return self.is_approving_authority
 
 	def check_account_against_entries(self):
 		for d in self.get("entries"):
-			if d.against_invoice and frappe.db.get_value("Sales Invoice", 
+			if d.against_invoice and frappe.db.get_value("Sales Invoice",
 					d.against_invoice, "debit_to") != d.account:
 				frappe.throw(_("Row #") + cstr(d.idx) +  ": " +
 					_("Account is not matching with Debit To account of Sales Invoice"))
-			
-			if d.against_voucher and frappe.db.get_value("Purchase Invoice", 
+
+			if d.against_voucher and frappe.db.get_value("Purchase Invoice",
 					d.against_voucher, "credit_to") != d.account:
 				frappe.throw(_("Row #") + cstr(d.idx) + ": " +
 					_("Account is not matching with Credit To account of Purchase Invoice"))
 
 	def make_gl_entries(self, cancel=0, adv_adj=0):
 		from erpnext.accounts.general_ledger import make_gl_entries
-		
+
 		if not cancel:
 			self.check_account_against_entries()
-		
+
 		gl_map = []
 		for d in self.get("entries"):
 			if d.debit or d.credit:
@@ -252,8 +252,8 @@
 						"against": d.against_account,
 						"debit": d.debit,
 						"credit": d.credit,
-						"against_voucher_type": ((d.against_voucher and "Purchase Invoice") 
-							or (d.against_invoice and "Sales Invoice") 
+						"against_voucher_type": ((d.against_voucher and "Purchase Invoice")
+							or (d.against_invoice and "Sales Invoice")
 							or (d.against_jv and "Journal Voucher")),
 						"against_voucher": d.against_voucher or d.against_invoice or d.against_jv,
 						"remarks": self.remark,
@@ -262,10 +262,10 @@
 				)
 		if gl_map:
 			make_gl_entries(gl_map, cancel=cancel, adv_adj=adv_adj)
-			
+
 	def check_credit_limit(self):
 		for d in self.get("entries"):
-			master_type, master_name = frappe.db.get_value("Account", d.account, 
+			master_type, master_name = frappe.db.get_value("Account", d.account,
 				["master_type", "master_name"])
 			if master_type == "Customer" and master_name:
 				super(JournalVoucher, self).check_credit_limit(d.account)
@@ -276,7 +276,7 @@
 		else:
 			flag, self.total_debit, self.total_credit = 0, 0, 0
 			diff = flt(self.difference, 2)
-			
+
 			# If any row without amount, set the diff on that row
 			for d in self.get('entries'):
 				if not d.credit and not d.debit and diff != 0:
@@ -285,7 +285,7 @@
 					elif diff<0:
 						d.debit = diff
 					flag = 1
-					
+
 			# Set the diff in a new row
 			if flag == 0 and diff != 0:
 				jd = self.append('entries', {})
@@ -293,7 +293,7 @@
 					jd.credit = abs(diff)
 				elif diff<0:
 					jd.debit = abs(diff)
-					
+
 			# Set the total debit, total credit and difference
 			for d in self.get('entries'):
 				self.total_debit += flt(d.debit, 2)
@@ -326,12 +326,12 @@
 		cond = (flt(self.write_off_amount) > 0) and \
 			' and outstanding_amount <= '+ self.write_off_amount or ''
 		if self.write_off_based_on == 'Accounts Receivable':
-			return frappe.db.sql("""select name, debit_to, outstanding_amount 
-				from `tabSales Invoice` where docstatus = 1 and company = %s 
+			return frappe.db.sql("""select name, debit_to, outstanding_amount
+				from `tabSales Invoice` where docstatus = 1 and company = %s
 				and outstanding_amount > 0 %s""" % ('%s', cond), self.company)
 		elif self.write_off_based_on == 'Accounts Payable':
-			return frappe.db.sql("""select name, credit_to, outstanding_amount 
-				from `tabPurchase Invoice` where docstatus = 1 and company = %s 
+			return frappe.db.sql("""select name, credit_to, outstanding_amount
+				from `tabPurchase Invoice` where docstatus = 1 and company = %s
 				and outstanding_amount > 0 %s""" % ('%s', cond), self.company)
 
 @frappe.whitelist()
@@ -344,7 +344,7 @@
 			"account": account,
 			"balance": get_balance_on(account)
 		}
-		
+
 @frappe.whitelist()
 def get_payment_entry_from_sales_invoice(sales_invoice):
 	from erpnext.accounts.utils import get_balance_on
@@ -360,7 +360,7 @@
 
 	# debit bank
 	jv.get("entries")[1].debit = si.outstanding_amount
-	
+
 	return jv.as_dict()
 
 @frappe.whitelist()
@@ -369,7 +369,7 @@
 	pi = frappe.get_doc("Purchase Invoice", purchase_invoice)
 	jv = get_payment_entry(pi)
 	jv.remark = 'Payment against Purchase Invoice {0}. {1}'.format(pi.name, pi.remarks)
-	
+
 	# credit supplier
 	jv.get("entries")[0].account = pi.credit_to
 	jv.get("entries")[0].balance = get_balance_on(pi.credit_to)
@@ -378,12 +378,12 @@
 
 	# credit bank
 	jv.get("entries")[1].credit = pi.outstanding_amount
-	
+
 	return jv.as_dict()
 
 def get_payment_entry(doc):
 	bank_account = get_default_bank_cash_account(doc.company, "Bank Voucher")
-	
+
 	jv = frappe.new_doc('Journal Voucher')
 	jv.voucher_type = 'Bank Voucher'
 
@@ -396,63 +396,63 @@
 	if bank_account:
 		d2.account = bank_account["account"]
 		d2.balance = bank_account["balance"]
-	
+
 	return jv
-	
+
 @frappe.whitelist()
 def get_opening_accounts(company):
 	"""get all balance sheet accounts for opening entry"""
 	from erpnext.accounts.utils import get_balance_on
-	accounts = frappe.db.sql_list("""select name from tabAccount 
+	accounts = frappe.db.sql_list("""select name from tabAccount
 		where group_or_ledger='Ledger' and report_type='Profit and Loss' and company=%s""", company)
-	
+
 	return [{"account": a, "balance": get_balance_on(a)} for a in accounts]
-	
+
 def get_against_purchase_invoice(doctype, txt, searchfield, start, page_len, filters):
-	return frappe.db.sql("""select name, credit_to, outstanding_amount, bill_no, bill_date 
-		from `tabPurchase Invoice` where credit_to = %s and docstatus = 1 
+	return frappe.db.sql("""select name, credit_to, outstanding_amount, bill_no, bill_date
+		from `tabPurchase Invoice` where credit_to = %s and docstatus = 1
 		and outstanding_amount > 0 and %s like %s order by name desc limit %s, %s""" %
-		("%s", searchfield, "%s", "%s", "%s"), 
-		(filters["account"], "%%%s%%" % txt, start, page_len))
-		
-def get_against_sales_invoice(doctype, txt, searchfield, start, page_len, filters):
-	return frappe.db.sql("""select name, debit_to, outstanding_amount 
-		from `tabSales Invoice` where debit_to = %s and docstatus = 1 
-		and outstanding_amount > 0 and `%s` like %s order by name desc limit %s, %s""" %
-		("%s", searchfield, "%s", "%s", "%s"), 
-		(filters["account"], "%%%s%%" % txt, start, page_len))
-		
-def get_against_jv(doctype, txt, searchfield, start, page_len, filters):
-	return frappe.db.sql("""select jv.name, jv.posting_date, jv.user_remark 
-		from `tabJournal Voucher` jv, `tabJournal Voucher Detail` jv_detail 
-		where jv_detail.parent = jv.name and jv_detail.account = %s and jv.docstatus = 1 
-		and jv.%s like %s order by jv.name desc limit %s, %s""" % 
-		("%s", searchfield, "%s", "%s", "%s"), 
+		("%s", searchfield, "%s", "%s", "%s"),
 		(filters["account"], "%%%s%%" % txt, start, page_len))
 
-@frappe.whitelist()		
+def get_against_sales_invoice(doctype, txt, searchfield, start, page_len, filters):
+	return frappe.db.sql("""select name, debit_to, outstanding_amount
+		from `tabSales Invoice` where debit_to = %s and docstatus = 1
+		and outstanding_amount > 0 and `%s` like %s order by name desc limit %s, %s""" %
+		("%s", searchfield, "%s", "%s", "%s"),
+		(filters["account"], "%%%s%%" % txt, start, page_len))
+
+def get_against_jv(doctype, txt, searchfield, start, page_len, filters):
+	return frappe.db.sql("""select jv.name, jv.posting_date, jv.user_remark
+		from `tabJournal Voucher` jv, `tabJournal Voucher Detail` jv_detail
+		where jv_detail.parent = jv.name and jv_detail.account = %s and jv.docstatus = 1
+		and jv.%s like %s order by jv.name desc limit %s, %s""" %
+		("%s", searchfield, "%s", "%s", "%s"),
+		(filters["account"], "%%%s%%" % txt, start, page_len))
+
+@frappe.whitelist()
 def get_outstanding(args):
 	args = eval(args)
 	if args.get("doctype") == "Journal Voucher" and args.get("account"):
 		against_jv_amount = frappe.db.sql("""
-			select sum(ifnull(debit, 0)) - sum(ifnull(credit, 0)) 
-			from `tabJournal Voucher Detail` where parent=%s and account=%s 
+			select sum(ifnull(debit, 0)) - sum(ifnull(credit, 0))
+			from `tabJournal Voucher Detail` where parent=%s and account=%s
 			and ifnull(against_invoice, '')='' and ifnull(against_voucher, '')=''
 			and ifnull(against_jv, '')=''""", (args['docname'], args['account']))
-			
+
 		against_jv_amount = flt(against_jv_amount[0][0]) if against_jv_amount else 0
 		if against_jv_amount > 0:
 			return {"credit": against_jv_amount}
 		else:
 			return {"debit": -1* against_jv_amount}
-		
+
 	elif args.get("doctype") == "Sales Invoice":
 		return {
-			"credit": flt(frappe.db.get_value("Sales Invoice", args["docname"], 
+			"credit": flt(frappe.db.get_value("Sales Invoice", args["docname"],
 				"outstanding_amount"))
 		}
 	elif args.get("doctype") == "Purchase Invoice":
 		return {
-			"debit": flt(frappe.db.get_value("Purchase Invoice", args["docname"], 
+			"debit": flt(frappe.db.get_value("Purchase Invoice", args["docname"],
 				"outstanding_amount"))
 		}
diff --git a/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py b/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py
index 88df6bd..e178d03 100644
--- a/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py
+++ b/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py
@@ -28,13 +28,13 @@
 		'source_field': 'amount',
 		'percent_join_field': 'purchase_order',
 	}]
-		
+
 	def validate(self):
 		if not self.is_opening:
 			self.is_opening = 'No'
-			
+
 		super(PurchaseInvoice, self).validate()
-		
+
 		self.po_required()
 		self.pr_required()
 		self.check_active_purchase_items()
@@ -51,22 +51,22 @@
 		self.validate_write_off_account()
 		self.update_raw_material_cost()
 		self.update_valuation_rate("entries")
-		self.validate_multiple_billing("Purchase Receipt", "pr_detail", "amount", 
+		self.validate_multiple_billing("Purchase Receipt", "pr_detail", "amount",
 			"purchase_receipt_details")
-	
+
 	def set_missing_values(self, for_validate=False):
 		if not self.credit_to:
 			self.credit_to = get_party_account(self.company, self.supplier, "Supplier")
 		if not self.due_date:
 			self.due_date = get_due_date(self.posting_date, self.supplier, "Supplier",
 				self.credit_to, self.company)
-		
+
 		super(PurchaseInvoice, self).set_missing_values(for_validate)
-	
+
 	def get_advances(self):
-		super(PurchaseInvoice, self).get_advances(self.credit_to, 
+		super(PurchaseInvoice, self).get_advances(self.credit_to,
 			"Purchase Invoice Advance", "advance_allocation_details", "debit")
-		
+
 	def check_active_purchase_items(self):
 		for d in self.get('entries'):
 			if d.item_code:		# extra condn coz item_code is not mandatory in PV
@@ -77,29 +77,29 @@
 				if not valid_item[0][1] == 'Yes':
 					msgprint("Item : '%s' is not Purchase Item"%(d.item_code))
 					raise Exception
-						
+
 	def check_conversion_rate(self):
-		default_currency = get_company_currency(self.company)		
+		default_currency = get_company_currency(self.company)
 		if not default_currency:
 			msgprint('Message: Please enter default currency in Company Master')
 			raise Exception
 		if (self.currency == default_currency and flt(self.conversion_rate) != 1.00) or not self.conversion_rate or (self.currency != default_currency and flt(self.conversion_rate) == 1.00):
 			msgprint("Message: Please Enter Appropriate Conversion Rate.")
-			raise Exception				
-			
+			raise Exception
+
 	def validate_bill_no(self):
 		if self.bill_no and self.bill_no.lower().strip() \
 				not in ['na', 'not applicable', 'none']:
-			b_no = frappe.db.sql("""select bill_no, name, ifnull(is_opening,'') from `tabPurchase Invoice` 
-				where bill_no = %s and credit_to = %s and docstatus = 1 and name != %s""", 
+			b_no = frappe.db.sql("""select bill_no, name, ifnull(is_opening,'') from `tabPurchase Invoice`
+				where bill_no = %s and credit_to = %s and docstatus = 1 and name != %s""",
 				(self.bill_no, self.credit_to, self.name))
 			if b_no and cstr(b_no[0][2]) == cstr(self.is_opening):
 				msgprint("Please check you have already booked expense against Bill No. %s \
-					in Purchase Invoice %s" % (cstr(b_no[0][0]), cstr(b_no[0][1])), 
+					in Purchase Invoice %s" % (cstr(b_no[0][0]), cstr(b_no[0][1])),
 					raise_exception=1)
-					
+
 			if not self.remarks and self.bill_date:
-				self.remarks = (self.remarks or '') + "\n" + ("Against Bill %s dated %s" 
+				self.remarks = (self.remarks or '') + "\n" + ("Against Bill %s dated %s"
 					% (self.bill_no, formatdate(self.bill_date)))
 
 		if not self.remarks:
@@ -108,28 +108,28 @@
 	def validate_credit_acc(self):
 		if frappe.db.get_value("Account", self.credit_to, "report_type") != "Balance Sheet":
 			frappe.throw(_("Account must be a balance sheet account"))
-	
+
 	# Validate Acc Head of Supplier and Credit To Account entered
 	# ------------------------------------------------------------
-	def check_for_acc_head_of_supplier(self): 
+	def check_for_acc_head_of_supplier(self):
 		if self.supplier and self.credit_to:
 			acc_head = frappe.db.sql("select master_name from `tabAccount` where name = %s", self.credit_to)
-			
+
 			if (acc_head and cstr(acc_head[0][0]) != cstr(self.supplier)) or (not acc_head and (self.credit_to != cstr(self.supplier) + " - " + self.company_abbr)):
 				msgprint("Credit To: %s do not match with Supplier: %s for Company: %s.\n If both correctly entered, please select Master Type and Master Name in account master." %(self.credit_to,self.supplier,self.company), raise_exception=1)
-				
+
 	# Check for Stopped PO
 	# ---------------------
 	def check_for_stopped_status(self):
 		check_list = []
 		for d in self.get('entries'):
 			if d.purchase_order and not d.purchase_order in check_list and not d.purchase_receipt:
-				check_list.append(d.purhcase_order)
+				check_list.append(d.purchase_order)
 				stopped = frappe.db.sql("select name from `tabPurchase Order` where status = 'Stopped' and name = %s", d.purchase_order)
 				if stopped:
 					msgprint("One cannot do any transaction against 'Purchase Order' : %s, it's status is 'Stopped'" % (d.purhcase_order))
 					raise Exception
-		
+
 	def validate_with_previous_doc(self):
 		super(PurchaseInvoice, self).validate_with_previous_doc(self.tname, {
 			"Purchase Order": {
@@ -152,7 +152,7 @@
 				"is_child_table": True
 			}
 		})
-		
+
 		if cint(frappe.defaults.get_global_default('maintain_same_rate')):
 			super(PurchaseInvoice, self).validate_with_previous_doc(self.tname, {
 				"Purchase Order Item": {
@@ -167,21 +167,21 @@
 					"is_child_table": True
 				}
 			})
-			
-					
+
+
 	def set_aging_date(self):
 		if self.is_opening != 'Yes':
 			self.aging_date = self.posting_date
 		elif not self.aging_date:
 			msgprint("Aging Date is mandatory for opening entry")
 			raise Exception
-			
+
 	def set_against_expense_account(self):
 		auto_accounting_for_stock = cint(frappe.defaults.get_global_default("auto_accounting_for_stock"))
 
 		if auto_accounting_for_stock:
 			stock_not_billed_account = self.get_company_default("stock_received_but_not_billed")
-		
+
 		against_accounts = []
 		stock_items = self.get_stock_items()
 		for item in self.get("entries"):
@@ -191,18 +191,18 @@
 				# Stock Received But Not Billed for a stock item
 				item.expense_account = stock_not_billed_account
 				item.cost_center = None
-				
+
 				if stock_not_billed_account not in against_accounts:
 					against_accounts.append(stock_not_billed_account)
-			
+
 			elif not item.expense_account:
-				msgprint(_("Expense account is mandatory for item") + ": " + 
+				msgprint(_("Expense account is mandatory for item") + ": " +
 					(item.item_code or item.item_name), raise_exception=1)
-			
+
 			elif item.expense_account not in against_accounts:
 				# if no auto_accounting_for_stock or not a stock item
 				against_accounts.append(item.expense_account)
-				
+
 		self.against_expense_account = ",".join(against_accounts)
 
 	def po_required(self):
@@ -233,8 +233,8 @@
 				submitted = frappe.db.sql("select name from `tabPurchase Receipt` where docstatus = 1 and name = %s", d.purchase_receipt)
 				if not submitted:
 					frappe.throw("Purchase Receipt : "+ cstr(d.purchase_receipt) +" is not submitted")
-					
-					
+
+
 	def update_against_document_in_jv(self):
 		"""
 			Links invoice and advance voucher:
@@ -242,33 +242,33 @@
 				2. split into multiple rows if partially adjusted, assign against voucher
 				3. submit advance voucher
 		"""
-		
+
 		lst = []
 		for d in self.get('advance_allocation_details'):
 			if flt(d.allocated_amount) > 0:
 				args = {
-					'voucher_no' : d.journal_voucher, 
-					'voucher_detail_no' : d.jv_detail_no, 
-					'against_voucher_type' : 'Purchase Invoice', 
+					'voucher_no' : d.journal_voucher,
+					'voucher_detail_no' : d.jv_detail_no,
+					'against_voucher_type' : 'Purchase Invoice',
 					'against_voucher'  : self.name,
-					'account' : self.credit_to, 
-					'is_advance' : 'Yes', 
-					'dr_or_cr' : 'debit', 
+					'account' : self.credit_to,
+					'is_advance' : 'Yes',
+					'dr_or_cr' : 'debit',
 					'unadjusted_amt' : flt(d.advance_amount),
 					'allocated_amt' : flt(d.allocated_amount)
 				}
 				lst.append(args)
-		
+
 		if lst:
 			from erpnext.accounts.utils import reconcile_against_document
 			reconcile_against_document(lst)
 
 	def on_submit(self):
 		self.check_prev_docstatus()
-		
-		frappe.get_doc('Authorization Control').validate_approving_authority(self.doctype, 
+
+		frappe.get_doc('Authorization Control').validate_approving_authority(self.doctype,
 			self.company, self.grand_total)
-		
+
 		# this sequence because outstanding may get -negative
 		self.make_gl_entries()
 		self.update_against_document_in_jv()
@@ -278,9 +278,9 @@
 	def make_gl_entries(self):
 		auto_accounting_for_stock = \
 			cint(frappe.defaults.get_global_default("auto_accounting_for_stock"))
-		
+
 		gl_entries = []
-		
+
 		# parent's gl entry
 		if self.grand_total:
 			gl_entries.append(
@@ -293,7 +293,7 @@
 					"against_voucher_type": self.doctype,
 				})
 			)
-	
+
 		# tax table gl entries
 		valuation_tax = {}
 		for tax in self.get("other_charges"):
@@ -308,31 +308,31 @@
 						"cost_center": tax.cost_center
 					})
 				)
-			
+
 			# accumulate valuation tax
 			if tax.category in ("Valuation", "Valuation and Total") and flt(tax.tax_amount):
 				if auto_accounting_for_stock and not tax.cost_center:
 					frappe.throw(_("Row %(row)s: Cost Center is mandatory \
-						if tax/charges category is Valuation or Valuation and Total" % 
+						if tax/charges category is Valuation or Valuation and Total" %
 						{"row": tax.idx}))
 				valuation_tax.setdefault(tax.cost_center, 0)
 				valuation_tax[tax.cost_center] += \
 					(tax.add_deduct_tax == "Add" and 1 or -1) * flt(tax.tax_amount)
-					
+
 		# item gl entries
 		stock_item_and_auto_accounting_for_stock = False
 		stock_items = self.get_stock_items()
 		for item in self.get("entries"):
 			if auto_accounting_for_stock and item.item_code in stock_items:
 				if flt(item.valuation_rate):
-					# if auto inventory accounting enabled and stock item, 
+					# if auto inventory accounting enabled and stock item,
 					# then do stock related gl entries
 					# expense will be booked in sales invoice
 					stock_item_and_auto_accounting_for_stock = True
-					
-					valuation_amt = flt(item.base_amount + item.item_tax_amount + item.rm_supp_cost, 
+
+					valuation_amt = flt(item.base_amount + item.item_tax_amount + item.rm_supp_cost,
 						self.precision("base_amount", item))
-					
+
 					gl_entries.append(
 						self.get_gl_dict({
 							"account": item.expense_account,
@@ -341,7 +341,7 @@
 							"remarks": self.remarks or "Accounting Entry for Stock"
 						})
 					)
-			
+
 			elif flt(item.base_amount):
 				# if not a stock item or auto inventory accounting disabled, book the expense
 				gl_entries.append(
@@ -353,13 +353,13 @@
 						"cost_center": item.cost_center
 					})
 				)
-				
+
 		if stock_item_and_auto_accounting_for_stock and valuation_tax:
 			# credit valuation tax amount in "Expenses Included In Valuation"
 			# this will balance out valuation amount included in cost of goods sold
 			expenses_included_in_valuation = \
 				self.get_company_default("expenses_included_in_valuation")
-			
+
 			for cost_center, amount in valuation_tax.items():
 				gl_entries.append(
 					self.get_gl_dict({
@@ -370,8 +370,8 @@
 						"remarks": self.remarks or "Accounting Entry for Stock"
 					})
 				)
-		
-		# writeoff account includes petty difference in the invoice amount 
+
+		# writeoff account includes petty difference in the invoice amount
 		# and the amount that is paid
 		if self.write_off_account and flt(self.write_off_amount):
 			gl_entries.append(
@@ -383,7 +383,7 @@
 					"cost_center": self.write_off_cost_center
 				})
 			)
-		
+
 		if gl_entries:
 			from erpnext.accounts.general_ledger import make_gl_entries
 			make_gl_entries(gl_entries, cancel=(self.docstatus == 2))
@@ -391,43 +391,43 @@
 	def on_cancel(self):
 		from erpnext.accounts.utils import remove_against_link_from_jv
 		remove_against_link_from_jv(self.doctype, self.name, "against_voucher")
-		
+
 		self.update_prevdoc_status()
 		self.update_billing_status_for_zero_amount_refdoc("Purchase Order")
 		self.make_cancel_gl_entries()
-		
+
 	def on_update(self):
 		pass
-		
+
 	def update_raw_material_cost(self):
 		if self.sub_contracted_items:
 			for d in self.get("entries"):
-				rm_cost = frappe.db.sql("""select raw_material_cost / quantity 
-					from `tabBOM` where item = %s and is_default = 1 and docstatus = 1 
+				rm_cost = frappe.db.sql("""select raw_material_cost / quantity
+					from `tabBOM` where item = %s and is_default = 1 and docstatus = 1
 					and is_active = 1 """, (d.item_code,))
 				rm_cost = rm_cost and flt(rm_cost[0][0]) or 0
-				
+
 				d.conversion_factor = d.conversion_factor or flt(frappe.db.get_value(
-					"UOM Conversion Detail", {"parent": d.item_code, "uom": d.uom}, 
+					"UOM Conversion Detail", {"parent": d.item_code, "uom": d.uom},
 					"conversion_factor")) or 1
-		
+
 				d.rm_supp_cost = rm_cost * flt(d.qty) * flt(d.conversion_factor)
-				
+
 @frappe.whitelist()
 def get_expense_account(doctype, txt, searchfield, start, page_len, filters):
 	from erpnext.controllers.queries import get_match_cond
-	
-	# expense account can be any Debit account, 
-	# but can also be a Liability account with account_type='Expense Account' in special circumstances. 
+
+	# expense account can be any Debit account,
+	# but can also be a Liability account with account_type='Expense Account' in special circumstances.
 	# Hence the first condition is an "OR"
-	return frappe.db.sql("""select tabAccount.name from `tabAccount` 
+	return frappe.db.sql("""select tabAccount.name from `tabAccount`
 			where (tabAccount.report_type = "Profit and Loss"
 					or tabAccount.account_type = "Expense Account")
-				and tabAccount.group_or_ledger="Ledger" 
-				and tabAccount.docstatus!=2 
+				and tabAccount.group_or_ledger="Ledger"
+				and tabAccount.docstatus!=2
 				and ifnull(tabAccount.master_type, "")=""
 				and ifnull(tabAccount.master_name, "")=""
-				and tabAccount.company = '%(company)s' 
+				and tabAccount.company = '%(company)s'
 				and tabAccount.%(key)s LIKE '%(txt)s'
-				%(mcond)s""" % {'company': filters['company'], 'key': searchfield, 
+				%(mcond)s""" % {'company': filters['company'], 'key': searchfield,
 			'txt': "%%%s%%" % txt, 'mcond':get_match_cond(doctype)})
diff --git a/erpnext/controllers/stock_controller.py b/erpnext/controllers/stock_controller.py
index e5ad8c6..6aeb940 100644
--- a/erpnext/controllers/stock_controller.py
+++ b/erpnext/controllers/stock_controller.py
@@ -14,29 +14,29 @@
 	def make_gl_entries(self, repost_future_gle=True):
 		if self.docstatus == 2:
 			delete_gl_entries(voucher_type=self.doctype, voucher_no=self.name)
-			
+
 		if cint(frappe.defaults.get_global_default("auto_accounting_for_stock")):
 			warehouse_account = self.get_warehouse_account()
-		
+
 			if self.docstatus==1:
 				gl_entries = self.get_gl_entries(warehouse_account)
 				make_gl_entries(gl_entries)
 
 			if repost_future_gle:
 				items, warehouse_account = self.get_items_and_warehouse_accounts(warehouse_account)
-				update_gl_entries_after(self.posting_date, self.posting_time, 
+				update_gl_entries_after(self.posting_date, self.posting_time,
 					warehouse_account, items)
-	
+
 	def get_gl_entries(self, warehouse_account=None, default_expense_account=None,
 			default_cost_center=None):
 		from erpnext.accounts.general_ledger import process_gl_map
 		if not warehouse_account:
 			warehouse_account = get_warehouse_account()
-		
+
 		stock_ledger = self.get_stock_ledger_details()
-		voucher_details = self.get_voucher_details(stock_ledger, default_expense_account, 
+		voucher_details = self.get_voucher_details(stock_ledger, default_expense_account,
 			default_cost_center)
-		
+
 		gl_list = []
 		warehouse_with_no_account = []
 		for detail in voucher_details:
@@ -63,13 +63,13 @@
 						}))
 					elif sle.warehouse not in warehouse_with_no_account:
 						warehouse_with_no_account.append(sle.warehouse)
-						
-		if warehouse_with_no_account:				
-			msgprint(_("No accounting entries for following warehouses") + ": \n" + 
+
+		if warehouse_with_no_account:
+			msgprint(_("No accounting entries for following warehouses") + ": \n" +
 				"\n".join(warehouse_with_no_account))
-		
+
 		return process_gl_map(gl_list)
-			
+
 	def get_voucher_details(self, stock_ledger, default_expense_account, default_cost_center):
 		if not default_expense_account:
 			details = self.get(self.fname)
@@ -77,18 +77,18 @@
 				self.check_expense_account(d)
 		else:
 			details = [frappe._dict({
-				"name":d, 
-				"expense_account": default_expense_account, 
+				"name":d,
+				"expense_account": default_expense_account,
 				"cost_center": default_cost_center
 			}) for d in stock_ledger.keys()]
-			
+
 		return details
-		
+
 	def get_items_and_warehouse_accounts(self, warehouse_account=None):
 		items, warehouses = [], []
 		if not warehouse_account:
 			warehouse_account = get_warehouse_account()
-		
+
 		if hasattr(self, "fname"):
 			item_doclist = self.get(self.fname)
 		elif self.doctype == "Stock Reconciliation":
@@ -98,26 +98,26 @@
 			for row in data[data.index(self.head_row)+1:]:
 				d = frappe._dict(zip(["item_code", "warehouse", "qty", "valuation_rate"], row))
 				item_doclist.append(d)
-			
+
 		if item_doclist:
 			for d in item_doclist:
 				if d.item_code and d.item_code not in items:
 					items.append(d.item_code)
-				
+
 				if d.get("warehouse") and d.warehouse not in warehouses:
 					warehouses.append(d.warehouse)
-				
+
 				if self.doctype == "Stock Entry":
 					if d.get("s_warehouse") and d.s_warehouse not in warehouses:
 						warehouses.append(d.s_warehouse)
 					if d.get("t_warehouse") and d.t_warehouse not in warehouses:
 						warehouses.append(d.t_warehouse)
 
-			warehouse_account = {wh: warehouse_account[wh] for wh in warehouses 
+			warehouse_account = {wh: warehouse_account[wh] for wh in warehouses
 				if warehouse_account.get(wh)}
-	
+
 		return items, warehouse_account
-		
+
 	def get_stock_ledger_details(self):
 		stock_ledger = {}
 		for sle in frappe.db.sql("""select warehouse, stock_value_difference, voucher_detail_no
@@ -125,12 +125,12 @@
 			(self.doctype, self.name), as_dict=True):
 				stock_ledger.setdefault(sle.voucher_detail_no, []).append(sle)
 		return stock_ledger
-		
+
 	def get_warehouse_account(self):
-		warehouse_account = dict(frappe.db.sql("""select master_name, name from tabAccount 
+		warehouse_account = dict(frappe.db.sql("""select master_name, name from tabAccount
 			where account_type = 'Warehouse' and ifnull(master_name, '') != ''"""))
 		return warehouse_account
-		
+
 	def update_gl_entries_after(self, warehouse_account=None):
 		future_stock_vouchers = self.get_future_stock_vouchers()
 		gle = self.get_voucherwise_gl_entries(future_stock_vouchers)
@@ -153,53 +153,53 @@
 										break
 				else:
 					matched = False
-									
+
 				if not matched:
 					self.delete_gl_entries(voucher_type, voucher_no)
 					voucher_obj.make_gl_entries(repost_future_gle=False)
 			else:
 				self.delete_gl_entries(voucher_type, voucher_no)
-				
-		
+
+
 	def get_future_stock_vouchers(self):
 		future_stock_vouchers = []
-		
+
 		if hasattr(self, "fname"):
 			item_list = [d.item_code for d in self.get(self.fname)]
 			condition = ''.join(['and item_code in (\'', '\', \''.join(item_list) ,'\')'])
 		else:
 			condition = ""
-		
-		for d in frappe.db.sql("""select distinct sle.voucher_type, sle.voucher_no 
+
+		for d in frappe.db.sql("""select distinct sle.voucher_type, sle.voucher_no
 			from `tabStock Ledger Entry` sle
 			where timestamp(sle.posting_date, sle.posting_time) >= timestamp(%s, %s) %s
-			order by timestamp(sle.posting_date, sle.posting_time) asc, name asc""" % 
-			('%s', '%s', condition), (self.posting_date, self.posting_time), 
+			order by timestamp(sle.posting_date, sle.posting_time) asc, name asc""" %
+			('%s', '%s', condition), (self.posting_date, self.posting_time),
 			as_dict=True):
 				future_stock_vouchers.append([d.voucher_type, d.voucher_no])
-		
+
 		return future_stock_vouchers
-				
+
 	def get_voucherwise_gl_entries(self, future_stock_vouchers):
 		gl_entries = {}
 		if future_stock_vouchers:
-			for d in frappe.db.sql("""select * from `tabGL Entry` 
-				where posting_date >= %s and voucher_no in (%s)""" % 
-				('%s', ', '.join(['%s']*len(future_stock_vouchers))), 
+			for d in frappe.db.sql("""select * from `tabGL Entry`
+				where posting_date >= %s and voucher_no in (%s)""" %
+				('%s', ', '.join(['%s']*len(future_stock_vouchers))),
 				tuple([self.posting_date] + [d[1] for d in future_stock_vouchers]), as_dict=1):
 					gl_entries.setdefault((d.voucher_type, d.voucher_no), []).append(d)
-		
+
 		return gl_entries
-		
+
 	def delete_gl_entries(self, voucher_type, voucher_no):
-		frappe.db.sql("""delete from `tabGL Entry` 
+		frappe.db.sql("""delete from `tabGL Entry`
 			where voucher_type=%s and voucher_no=%s""", (voucher_type, voucher_no))
-					
+
 	def make_adjustment_entry(self, expected_gle, voucher_obj):
 		from erpnext.accounts.utils import get_stock_and_account_difference
 		account_list = [d.account for d in expected_gle]
 		acc_diff = get_stock_and_account_difference(account_list, expected_gle[0].posting_date)
-		
+
 		cost_center = self.get_company_default("cost_center")
 		stock_adjustment_account = self.get_company_default("stock_adjustment_account")
 
@@ -214,7 +214,7 @@
 						"debit": diff,
 						"remarks": "Adjustment Accounting Entry for Stock",
 					}),
-				
+
 					# account against stock in hand
 					voucher_obj.get_gl_dict({
 						"account": stock_adjustment_account,
@@ -224,21 +224,21 @@
 						"remarks": "Adjustment Accounting Entry for Stock",
 					}),
 				])
-				
+
 		if gl_entries:
 			from erpnext.accounts.general_ledger import make_gl_entries
 			make_gl_entries(gl_entries)
-			
+
 	def check_expense_account(self, item):
 		if item.meta.get_field("expense_account") and not item.expense_account:
-			msgprint(_("""Expense/Difference account is mandatory for item: """) + item.item_code, 
+			msgprint(_("""Expense/Difference account is mandatory for item: """) + item.item_code,
 				raise_exception=1)
-				
+
 		if item.meta.get_field("expense_account") and not item.cost_center:
-			msgprint(_("""Cost Center is mandatory for item: """) + item.item_code, 
+			msgprint(_("""Cost Center is mandatory for item: """) + item.item_code,
 				raise_exception=1)
-				
-	def get_sl_entries(self, d, args):		
+
+	def get_sl_entries(self, d, args):
 		sl_dict = {
 			"item_code": d.item_code,
 			"warehouse": d.get("warehouse", None),
@@ -257,27 +257,27 @@
 			"project": d.get("project_name"),
 			"is_cancelled": self.docstatus==2 and "Yes" or "No"
 		}
-		
+
 		sl_dict.update(args)
 		return sl_dict
-		
+
 	def make_sl_entries(self, sl_entries, is_amended=None):
 		from erpnext.stock.stock_ledger import make_sl_entries
 		make_sl_entries(sl_entries, is_amended)
-		
+
 	def make_cancel_gl_entries(self):
-		if frappe.db.sql("""select name from `tabGL Entry` where voucher_type=%s 
+		if frappe.db.sql("""select name from `tabGL Entry` where voucher_type=%s
 			and voucher_no=%s""", (self.doctype, self.name)):
 				self.make_gl_entries()
-				
+
 def update_gl_entries_after(posting_date, posting_time, warehouse_account=None, for_items=None):
 	def _delete_gl_entries(voucher_type, voucher_no):
-		frappe.db.sql("""delete from `tabGL Entry` 
+		frappe.db.sql("""delete from `tabGL Entry`
 			where voucher_type=%s and voucher_no=%s""", (voucher_type, voucher_no))
-	
+
 	if not warehouse_account:
 		warehouse_account = get_warehouse_account()
-	future_stock_vouchers = get_future_stock_vouchers(posting_date, posting_time, 
+	future_stock_vouchers = get_future_stock_vouchers(posting_date, posting_time,
 		warehouse_account, for_items)
 	gle = get_voucherwise_gl_entries(future_stock_vouchers, posting_date)
 
@@ -286,13 +286,13 @@
 		voucher_obj = frappe.get_doc(voucher_type, voucher_no)
 		expected_gle = voucher_obj.get_gl_entries(warehouse_account)
 		if expected_gle:
-			if not existing_gle or not compare_existing_and_expected_gle(existing_gle, 
+			if not existing_gle or not compare_existing_and_expected_gle(existing_gle,
 				expected_gle):
 					_delete_gl_entries(voucher_type, voucher_no)
 					voucher_obj.make_gl_entries(repost_future_gle=False)
 		else:
 			_delete_gl_entries(voucher_type, voucher_no)
-			
+
 def compare_existing_and_expected_gle(existing_gle, expected_gle):
 	matched = True
 	for entry in expected_gle:
@@ -306,36 +306,36 @@
 
 def get_future_stock_vouchers(posting_date, posting_time, warehouse_account=None, for_items=None):
 	future_stock_vouchers = []
-	
+
 	condition = ""
 	if for_items:
 		condition = ''.join([' and item_code in (\'', '\', \''.join(for_items) ,'\')'])
-	
+
 	if warehouse_account:
 		condition += ''.join([' and warehouse in (\'', '\', \''.join(warehouse_account.keys()) ,'\')'])
-	
-	for d in frappe.db.sql("""select distinct sle.voucher_type, sle.voucher_no 
+
+	for d in frappe.db.sql("""select distinct sle.voucher_type, sle.voucher_no
 		from `tabStock Ledger Entry` sle
 		where timestamp(sle.posting_date, sle.posting_time) >= timestamp(%s, %s) %s
-		order by timestamp(sle.posting_date, sle.posting_time) asc, name asc""" % 
-		('%s', '%s', condition), (posting_date, posting_time), 
+		order by timestamp(sle.posting_date, sle.posting_time) asc, name asc""" %
+		('%s', '%s', condition), (posting_date, posting_time),
 		as_dict=True):
 			future_stock_vouchers.append([d.voucher_type, d.voucher_no])
-	
+
 	return future_stock_vouchers
-			
+
 def get_voucherwise_gl_entries(future_stock_vouchers, posting_date):
 	gl_entries = {}
 	if future_stock_vouchers:
-		for d in frappe.db.sql("""select * from `tabGL Entry` 
-			where posting_date >= %s and voucher_no in (%s)""" % 
-			('%s', ', '.join(['%s']*len(future_stock_vouchers))), 
+		for d in frappe.db.sql("""select * from `tabGL Entry`
+			where posting_date >= %s and voucher_no in (%s)""" %
+			('%s', ', '.join(['%s']*len(future_stock_vouchers))),
 			tuple([posting_date] + [d[1] for d in future_stock_vouchers]), as_dict=1):
 				gl_entries.setdefault((d.voucher_type, d.voucher_no), []).append(d)
-	
+
 	return gl_entries
 
 def get_warehouse_account():
-	warehouse_account = dict(frappe.db.sql("""select master_name, name from tabAccount 
+	warehouse_account = dict(frappe.db.sql("""select master_name, name from tabAccount
 		where account_type = 'Warehouse' and ifnull(master_name, '') != ''"""))
 	return warehouse_account
diff --git a/erpnext/stock/doctype/stock_entry/stock_entry.py b/erpnext/stock/doctype/stock_entry/stock_entry.py
index b5d46a2..9a28033 100644
--- a/erpnext/stock/doctype/stock_entry/stock_entry.py
+++ b/erpnext/stock/doctype/stock_entry/stock_entry.py
@@ -19,12 +19,12 @@
 class IncorrectValuationRateError(frappe.ValidationError): pass
 class DuplicateEntryForProductionOrderError(frappe.ValidationError): pass
 class StockOverProductionError(frappe.ValidationError): pass
-	
+
 from erpnext.controllers.stock_controller import StockController
 
 class StockEntry(StockController):
-	fname = 'mtn_details' 
-		
+	fname = 'mtn_details'
+
 	def validate(self):
 		self.validate_posting_time()
 		self.validate_purpose()
@@ -44,7 +44,7 @@
 		self.validate_with_material_request()
 		self.validate_fiscal_year()
 		self.set_total_amount()
-		
+
 	def on_submit(self):
 		self.update_stock_ledger()
 
@@ -57,32 +57,32 @@
 		self.update_stock_ledger()
 		self.update_production_order()
 		self.make_cancel_gl_entries()
-		
+
 	def validate_fiscal_year(self):
 		from erpnext.accounts.utils import validate_fiscal_year
 		validate_fiscal_year(self.posting_date, self.fiscal_year,
 			self.meta.get_label("posting_date"))
-		
+
 	def validate_purpose(self):
-		valid_purposes = ["Material Issue", "Material Receipt", "Material Transfer", 
+		valid_purposes = ["Material Issue", "Material Receipt", "Material Transfer",
 			"Manufacture/Repack", "Subcontract", "Sales Return", "Purchase Return"]
 		if self.purpose not in valid_purposes:
 			msgprint(_("Purpose must be one of ") + comma_or(valid_purposes),
 				raise_exception=True)
-		
+
 	def validate_item(self):
 		stock_items = self.get_stock_items()
 		for item in self.get("mtn_details"):
 			if item.item_code not in stock_items:
 				msgprint(_("""Only Stock Items are allowed for Stock Entry"""),
 					raise_exception=True)
-		
+
 	def validate_warehouse(self, pro_obj):
 		"""perform various (sometimes conditional) validations on warehouse"""
-		
+
 		source_mandatory = ["Material Issue", "Material Transfer", "Purchase Return"]
 		target_mandatory = ["Material Receipt", "Material Transfer", "Sales Return"]
-		
+
 		validate_for_manufacture_repack = any([d.bom_no for d in self.get("mtn_details")])
 
 		if self.purpose in source_mandatory and self.purpose not in target_mandatory:
@@ -101,11 +101,11 @@
 
 			if not (d.s_warehouse or d.t_warehouse):
 				msgprint(_("Atleast one warehouse is mandatory"), raise_exception=1)
-			
+
 			if self.purpose in source_mandatory and not d.s_warehouse:
 				msgprint(_("Row # ") + "%s: " % cint(d.idx)
 					+ _("Source Warehouse") + _(" is mandatory"), raise_exception=1)
-				
+
 			if self.purpose in target_mandatory and not d.t_warehouse:
 				msgprint(_("Row # ") + "%s: " % cint(d.idx)
 					+ _("Target Warehouse") + _(" is mandatory"), raise_exception=1)
@@ -114,39 +114,39 @@
 				if validate_for_manufacture_repack:
 					if d.bom_no:
 						d.s_warehouse = None
-						
+
 						if not d.t_warehouse:
 							msgprint(_("Row # ") + "%s: " % cint(d.idx)
 								+ _("Target Warehouse") + _(" is mandatory"), raise_exception=1)
-						
+
 						elif pro_obj and cstr(d.t_warehouse) != pro_obj.fg_warehouse:
 							msgprint(_("Row # ") + "%s: " % cint(d.idx)
 								+ _("Target Warehouse") + _(" should be same as that in ")
 								+ _("Production Order"), raise_exception=1)
-					
+
 					else:
 						d.t_warehouse = None
 						if not d.s_warehouse:
 							msgprint(_("Row # ") + "%s: " % cint(d.idx)
 								+ _("Source Warehouse") + _(" is mandatory"), raise_exception=1)
-			
+
 			if cstr(d.s_warehouse) == cstr(d.t_warehouse):
-				msgprint(_("Source and Target Warehouse cannot be same"), 
+				msgprint(_("Source and Target Warehouse cannot be same"),
 					raise_exception=1)
-				
+
 	def validate_production_order(self, pro_obj=None):
 		if not pro_obj:
 			if self.production_order:
 				pro_obj = frappe.get_doc('Production Order', self.production_order)
 			else:
 				return
-		
+
 		if self.purpose == "Manufacture/Repack":
 			# check for double entry
 			self.check_duplicate_entry_for_production_order()
 		elif self.purpose != "Material Transfer":
 			self.production_order = None
-	
+
 	def check_duplicate_entry_for_production_order(self):
 		other_ste = [t[0] for t in frappe.db.get_values("Stock Entry",  {
 			"production_order": self.production_order,
@@ -154,24 +154,24 @@
 			"docstatus": ["!=", 2],
 			"name": ["!=", self.name]
 		}, "name")]
-		
+
 		if other_ste:
-			production_item, qty = frappe.db.get_value("Production Order", 
+			production_item, qty = frappe.db.get_value("Production Order",
 				self.production_order, ["production_item", "qty"])
 			args = other_ste + [production_item]
 			fg_qty_already_entered = frappe.db.sql("""select sum(actual_qty)
-				from `tabStock Entry Detail` 
-				where parent in (%s) 
-					and item_code = %s 
+				from `tabStock Entry Detail`
+				where parent in (%s)
+					and item_code = %s
 					and ifnull(s_warehouse,'')='' """ % (", ".join(["%s" * len(other_ste)]), "%s"), args)[0][0]
-			
+
 			if fg_qty_already_entered >= qty:
-				frappe.throw(_("Stock Entries already created for Production Order ") 
+				frappe.throw(_("Stock Entries already created for Production Order ")
 					+ self.production_order + ":" + ", ".join(other_ste), DuplicateEntryForProductionOrderError)
 
 	def set_total_amount(self):
 		self.total_amount = sum([flt(item.amount) for item in self.get("mtn_details")])
-			
+
 	def get_stock_and_rate(self):
 		"""get stock and incoming rate on posting date"""
 		for d in self.get('mtn_details'):
@@ -186,21 +186,21 @@
 			})
 			# get actual stock at source warehouse
 			d.actual_qty = get_previous_sle(args).get("qty_after_transaction") or 0
-			
+
 			# get incoming rate
 			if not flt(d.incoming_rate):
 				d.incoming_rate = self.get_incoming_rate(args)
-				
+
 			d.amount = flt(d.transfer_qty) * flt(d.incoming_rate)
-			
+
 	def get_incoming_rate(self, args):
 		incoming_rate = 0
 		if self.purpose == "Sales Return" and \
 				(self.delivery_note_no or self.sales_invoice_no):
-			sle = frappe.db.sql("""select name, posting_date, posting_time, 
-				actual_qty, stock_value, warehouse from `tabStock Ledger Entry` 
-				where voucher_type = %s and voucher_no = %s and 
-				item_code = %s limit 1""", 
+			sle = frappe.db.sql("""select name, posting_date, posting_time,
+				actual_qty, stock_value, warehouse from `tabStock Ledger Entry`
+				where voucher_type = %s and voucher_no = %s and
+				item_code = %s limit 1""",
 				((self.delivery_note_no and "Delivery Note" or "Sales Invoice"),
 				self.delivery_note_no or self.sales_invoice_no, args.item_code), as_dict=1)
 			if sle:
@@ -215,14 +215,14 @@
 					flt(sle[0].actual_qty)
 		else:
 			incoming_rate = get_incoming_rate(args)
-			
+
 		return incoming_rate
-		
+
 	def validate_incoming_rate(self):
 		for d in self.get('mtn_details'):
 			if d.t_warehouse:
 				self.validate_value("incoming_rate", ">", 0, d, raise_exception=IncorrectValuationRateError)
-					
+
 	def validate_bom(self):
 		for d in self.get('mtn_details'):
 			if d.bom_no and not frappe.db.sql("""select name from `tabBOM`
@@ -231,72 +231,72 @@
 				msgprint(_("Item") + " %s: " % cstr(d.item_code)
 					+ _("does not belong to BOM: ") + cstr(d.bom_no)
 					+ _(" or the BOM is cancelled or inactive"), raise_exception=1)
-					
+
 	def validate_finished_goods(self):
 		"""validation: finished good quantity should be same as manufacturing quantity"""
 		for d in self.get('mtn_details'):
 			if d.bom_no and flt(d.transfer_qty) != flt(self.fg_completed_qty):
-				msgprint(_("Row #") + " %s: " % d.idx 
+				msgprint(_("Row #") + " %s: " % d.idx
 					+ _("Quantity should be equal to Manufacturing Quantity. To fetch items again, click on 'Get Items' button or update the Quantity manually."), raise_exception=1)
-						
+
 	def validate_return_reference_doc(self):
 		"""validate item with reference doc"""
 		ref = get_return_doc_and_details(self)
-		
+
 		if ref.doc:
 			# validate docstatus
 			if ref.doc.docstatus != 1:
-				frappe.msgprint(_(ref.doc.doctype) + ' "' + ref.doc.name + '": ' 
+				frappe.msgprint(_(ref.doc.doctype) + ' "' + ref.doc.name + '": '
 					+ _("Status should be Submitted"), raise_exception=frappe.InvalidStatusError)
-			
+
 			# update stock check
 			if ref.doc.doctype == "Sales Invoice" and cint(ref.doc.update_stock) != 1:
-				frappe.msgprint(_(ref.doc.doctype) + ' "' + ref.doc.name + '": ' 
-					+ _("Update Stock should be checked."), 
+				frappe.msgprint(_(ref.doc.doctype) + ' "' + ref.doc.name + '": '
+					+ _("Update Stock should be checked."),
 					raise_exception=NotUpdateStockError)
-			
+
 			# posting date check
-			ref_posting_datetime = "%s %s" % (cstr(ref.doc.posting_date), 
+			ref_posting_datetime = "%s %s" % (cstr(ref.doc.posting_date),
 				cstr(ref.doc.posting_time) or "00:00:00")
-			this_posting_datetime = "%s %s" % (cstr(self.posting_date), 
+			this_posting_datetime = "%s %s" % (cstr(self.posting_date),
 				cstr(self.posting_time))
 			if this_posting_datetime < ref_posting_datetime:
 				from frappe.utils.dateutils import datetime_in_user_format
 				frappe.msgprint(_("Posting Date Time cannot be before")
 					+ ": " + datetime_in_user_format(ref_posting_datetime),
 					raise_exception=True)
-			
+
 			stock_items = get_stock_items_for_return(ref.doc, ref.parentfields)
 			already_returned_item_qty = self.get_already_returned_item_qty(ref.fieldname)
-			
+
 			for item in self.get("mtn_details"):
 				# validate if item exists in the ref doc and that it is a stock item
 				if item.item_code not in stock_items:
 					msgprint(_("Item") + ': "' + item.item_code + _("\" does not exist in ") +
-						ref.doc.doctype + ": " + ref.doc.name, 
+						ref.doc.doctype + ": " + ref.doc.name,
 						raise_exception=frappe.DoesNotExistError)
-				
+
 				# validate quantity <= ref item's qty - qty already returned
 				ref_item = ref.doc.getone({"item_code": item.item_code})
 				returnable_qty = ref_item.qty - flt(already_returned_item_qty.get(item.item_code))
 				if not returnable_qty:
 					frappe.throw("{item}: {item_code} {returned}".format(
-						item=_("Item"), item_code=item.item_code, 
-						returned=_("already returned though some other documents")), 
+						item=_("Item"), item_code=item.item_code,
+						returned=_("already returned though some other documents")),
 						StockOverReturnError)
 				elif item.transfer_qty > returnable_qty:
 					frappe.throw("{item}: {item_code}, {returned}: {qty}".format(
 						item=_("Item"), item_code=item.item_code,
 						returned=_("Max Returnable Qty"), qty=returnable_qty), StockOverReturnError)
-						
+
 	def get_already_returned_item_qty(self, ref_fieldname):
 		return dict(frappe.db.sql("""select item_code, sum(transfer_qty) as qty
 			from `tabStock Entry Detail` where parent in (
 				select name from `tabStock Entry` where `%s`=%s and docstatus=1)
 			group by item_code""" % (ref_fieldname, "%s"), (self.get(ref_fieldname),)))
-						
+
 	def update_stock_ledger(self):
-		sl_entries = []			
+		sl_entries = []
 		for d in self.get('mtn_details'):
 			if cstr(d.s_warehouse) and self.docstatus == 1:
 				sl_entries.append(self.get_sl_entries(d, {
@@ -304,57 +304,57 @@
 					"actual_qty": -flt(d.transfer_qty),
 					"incoming_rate": 0
 				}))
-				
+
 			if cstr(d.t_warehouse):
 				sl_entries.append(self.get_sl_entries(d, {
 					"warehouse": cstr(d.t_warehouse),
 					"actual_qty": flt(d.transfer_qty),
 					"incoming_rate": flt(d.incoming_rate)
 				}))
-			
-			# On cancellation, make stock ledger entry for 
+
+			# On cancellation, make stock ledger entry for
 			# target warehouse first, to update serial no values properly
-			
+
 			if cstr(d.s_warehouse) and self.docstatus == 2:
 				sl_entries.append(self.get_sl_entries(d, {
 					"warehouse": cstr(d.s_warehouse),
 					"actual_qty": -flt(d.transfer_qty),
 					"incoming_rate": 0
 				}))
-				
+
 		self.make_sl_entries(sl_entries, self.amended_from and 'Yes' or 'No')
 
 	def update_production_order(self):
 		def _validate_production_order(pro_doc):
 			if flt(pro_doc.docstatus) != 1:
-				frappe.throw(_("Production Order must be submitted") + ": " + 
+				frappe.throw(_("Production Order must be submitted") + ": " +
 					self.production_order)
-					
+
 			if pro_doc.status == 'Stopped':
-				msgprint(_("Transaction not allowed against stopped Production Order") + ": " + 
+				msgprint(_("Transaction not allowed against stopped Production Order") + ": " +
 					self.production_order)
-		
+
 		if self.production_order:
 			pro_doc = frappe.get_doc("Production Order", self.production_order)
 			_validate_production_order(pro_doc)
 			self.update_produced_qty(pro_doc)
 			if self.purpose == "Manufacture/Repack":
 				self.update_planned_qty(pro_doc)
-			
+
 	def update_produced_qty(self, pro_doc):
 		if self.purpose == "Manufacture/Repack":
 			produced_qty = flt(pro_doc.produced_qty) + \
 				(self.docstatus==1 and 1 or -1 ) * flt(self.fg_completed_qty)
-				
+
 			if produced_qty > flt(pro_doc.qty):
 				frappe.throw(_("Production Order") + ": " + self.production_order + "\n" +
-					_("Total Manufactured Qty can not be greater than Planned qty to manufacture") 
+					_("Total Manufactured Qty can not be greater than Planned qty to manufacture")
 					+ "(%s/%s)" % (produced_qty, flt(pro_doc.qty)), StockOverProductionError)
-					
+
 			status = 'Completed' if flt(produced_qty) >= flt(pro_doc.qty) else 'In Process'
-			frappe.db.sql("""update `tabProduction Order` set status=%s, produced_qty=%s 
+			frappe.db.sql("""update `tabProduction Order` set status=%s, produced_qty=%s
 				where name=%s""", (status, produced_qty, self.production_order))
-			
+
 	def update_planned_qty(self, pro_doc):
 		from erpnext.stock.utils import update_bin
 		update_bin({
@@ -363,16 +363,16 @@
 			"posting_date": self.posting_date,
 			"planned_qty": (self.docstatus==1 and -1 or 1 ) * flt(self.fg_completed_qty)
 		})
-					
+
 	def get_item_details(self, arg):
 		arg = json.loads(arg)
-		item = frappe.db.sql("""select stock_uom, description, item_name, 
-			expense_account, buying_cost_center from `tabItem` 
-			where name = %s and (ifnull(end_of_life,'')='' or end_of_life ='0000-00-00' 
+		item = frappe.db.sql("""select stock_uom, description, item_name,
+			expense_account, buying_cost_center from `tabItem`
+			where name = %s and (ifnull(end_of_life,'')='' or end_of_life ='0000-00-00'
 			or end_of_life > now())""", (arg.get('item_code')), as_dict = 1)
-		if not item: 
+		if not item:
 			msgprint("Item is not active", raise_exception=1)
-						
+
 		ret = {
 			'uom'			      	: item and item[0]['stock_uom'] or '',
 			'stock_uom'			  	: item and item[0]['stock_uom'] or '',
@@ -394,7 +394,7 @@
 
 	def get_uom_details(self, arg = ''):
 		arg, ret = eval(arg), {}
-		uom = frappe.db.sql("""select conversion_factor from `tabUOM Conversion Detail` 
+		uom = frappe.db.sql("""select conversion_factor from `tabUOM Conversion Detail`
 			where parent = %s and uom = %s""", (arg['item_code'], arg['uom']), as_dict = 1)
 		if not uom or not flt(uom[0].conversion_factor):
 			msgprint("There is no Conversion Factor for UOM '%s' in Item '%s'" % (arg['uom'],
@@ -406,7 +406,7 @@
 				'transfer_qty'			: flt(arg['qty']) * flt(uom[0]['conversion_factor']),
 			}
 		return ret
-		
+
 	def get_warehouse_details(self, args):
 		args = json.loads(args)
 		ret = {}
@@ -416,14 +416,14 @@
 				"posting_time": self.posting_time,
 			})
 			args = frappe._dict(args)
-		
+
 			ret = {
 				"actual_qty" : get_previous_sle(args).get("qty_after_transaction") or 0,
 				"incoming_rate" : self.get_incoming_rate(args)
 			}
 		return ret
-		
-	def get_items(self):		
+
+	def get_items(self):
 		pro_obj = None
 		if self.production_order:
 			# common validations
@@ -434,7 +434,7 @@
 			else:
 				# invalid production order
 				self.production_order = None
-		
+
 		if self.bom_no:
 			if self.purpose in ["Material Issue", "Material Transfer", "Manufacture/Repack",
 					"Subcontract"]:
@@ -451,10 +451,10 @@
 
 				# add raw materials to Stock Entry Detail table
 				idx = self.add_to_stock_entry_detail(item_dict)
-					
+
 			# add finished good item to Stock Entry Detail table -- along with bom_no
 			if self.production_order and self.purpose == "Manufacture/Repack":
-				item = frappe.db.get_value("Item", pro_obj.production_item, ["item_name", 
+				item = frappe.db.get_value("Item", pro_obj.production_item, ["item_name",
 					"description", "stock_uom", "expense_account", "buying_cost_center"], as_dict=1)
 				self.add_to_stock_entry_detail({
 					cstr(pro_obj.production_item): {
@@ -468,14 +468,14 @@
 						"cost_center": item.buying_cost_center,
 					}
 				}, bom_no=pro_obj.bom_no, idx=idx)
-								
+
 			elif self.purpose in ["Material Receipt", "Manufacture/Repack"]:
 				if self.purpose=="Material Receipt":
 					self.from_warehouse = ""
-					
-				item = frappe.db.sql("""select name, item_name, description, 
-					stock_uom, expense_account, buying_cost_center from `tabItem` 
-					where name=(select item from tabBOM where name=%s)""", 
+
+				item = frappe.db.sql("""select name, item_name, description,
+					stock_uom, expense_account, buying_cost_center from `tabItem`
+					where name=(select item from tabBOM where name=%s)""",
 					self.bom_no, as_dict=1)
 				self.add_to_stock_entry_detail({
 					item[0]["name"] : {
@@ -488,20 +488,20 @@
 						"cost_center": item[0].buying_cost_center,
 					}
 				}, bom_no=self.bom_no, idx=idx)
-		
+
 		self.get_stock_and_rate()
-	
+
 	def get_bom_raw_materials(self, qty):
 		from erpnext.manufacturing.doctype.bom.bom import get_bom_items_as_dict
-		
+
 		# item dict = { item_code: {qty, description, stock_uom} }
 		item_dict = get_bom_items_as_dict(self.bom_no, qty=qty, fetch_exploded = self.use_multi_level_bom)
-		
+
 		for item in item_dict.values():
 			item.from_warehouse = item.default_warehouse
-			
+
 		return item_dict
-			
+
 	def get_pending_raw_materials(self, pro_obj):
 		"""
 			issue (item quantity) that is pending to issue or desire to transfer,
@@ -509,10 +509,10 @@
 		"""
 		item_dict = self.get_bom_raw_materials(1)
 		issued_item_qty = self.get_issued_qty()
-		
+
 		max_qty = flt(pro_obj.qty)
 		only_pending_fetched = []
-		
+
 		for item in item_dict:
 			pending_to_issue = (max_qty * item_dict[item]["qty"]) - issued_item_qty.get(item, 0)
 			desire_to_transfer = flt(self.fg_completed_qty) * item_dict[item]["qty"]
@@ -522,17 +522,17 @@
 				item_dict[item]["qty"] = pending_to_issue
 				if pending_to_issue:
 					only_pending_fetched.append(item)
-		
+
 		# delete items with 0 qty
 		for item in item_dict.keys():
 			if not item_dict[item]["qty"]:
 				del item_dict[item]
-		
+
 		# show some message
 		if not len(item_dict):
 			frappe.msgprint(_("""All items have already been transferred \
 				for this Production Order."""))
-			
+
 		elif only_pending_fetched:
 			frappe.msgprint(_("""Only quantities pending to be transferred \
 				were fetched for the following items:\n""" + "\n".join(only_pending_fetched)))
@@ -548,7 +548,7 @@
 			group by t1.item_code""", self.production_order)
 		for t in result:
 			issued_item_qty[t[0]] = flt(t[1])
-		
+
 		return issued_item_qty
 
 	def add_to_stock_entry_detail(self, item_dict, bom_no=None, idx=None):
@@ -569,79 +569,79 @@
 			se_child.qty = flt(item_dict[d]["qty"])
 			se_child.expense_account = item_dict[d]["expense_account"] or expense_account
 			se_child.cost_center = item_dict[d]["cost_center"] or cost_center
-			
+
 			# in stock uom
 			se_child.transfer_qty = flt(item_dict[d]["qty"])
 			se_child.conversion_factor = 1.00
-			
+
 			# to be assigned for finished item
 			se_child.bom_no = bom_no
 
 			# increment idx by 1
 			idx += 1
 		return idx
-		
+
 	def validate_with_material_request(self):
 		for item in self.get("mtn_details"):
 			if item.material_request:
-				mreq_item = frappe.db.get_value("Material Request Item", 
+				mreq_item = frappe.db.get_value("Material Request Item",
 					{"name": item.material_request_item, "parent": item.material_request},
 					["item_code", "warehouse", "idx"], as_dict=True)
 				if mreq_item.item_code != item.item_code or mreq_item.warehouse != item.t_warehouse:
 					msgprint(_("Row #") + (" %d: " % item.idx) + _("does not match")
 						+ " " + _("Row #") + (" %d %s " % (mreq_item.idx, _("of")))
-						+ _("Material Request") + (" - %s" % item.material_request), 
+						+ _("Material Request") + (" - %s" % item.material_request),
 						raise_exception=frappe.MappingMismatchError)
-	
-@frappe.whitelist()					
+
+@frappe.whitelist()
 def get_party_details(ref_dt, ref_dn):
 	if ref_dt in ["Delivery Note", "Sales Invoice"]:
-		res = frappe.db.get_value(ref_dt, ref_dn, 
+		res = frappe.db.get_value(ref_dt, ref_dn,
 			["customer", "customer_name", "address_display as customer_address"], as_dict=1)
 	else:
-		res = frappe.db.get_value(ref_dt, ref_dn, 
+		res = frappe.db.get_value(ref_dt, ref_dn,
 			["supplier", "supplier_name", "address_display as supplier_address"], as_dict=1)
 	return res or {}
-	
+
 @frappe.whitelist()
 def get_production_order_details(production_order):
-	result = frappe.db.sql("""select bom_no, 
-		ifnull(qty, 0) - ifnull(produced_qty, 0) as fg_completed_qty, use_multi_level_bom, 
+	result = frappe.db.sql("""select bom_no,
+		ifnull(qty, 0) - ifnull(produced_qty, 0) as fg_completed_qty, use_multi_level_bom,
 		wip_warehouse from `tabProduction Order` where name = %s""", production_order, as_dict=1)
 	return result and result[0] or {}
-	
+
 def query_sales_return_doc(doctype, txt, searchfield, start, page_len, filters):
 	conditions = ""
 	if doctype == "Sales Invoice":
 		conditions = "and update_stock=1"
-	
+
 	return frappe.db.sql("""select name, customer, customer_name
 		from `tab%s` where docstatus = 1
-			and (`%s` like %%(txt)s 
+			and (`%s` like %%(txt)s
 				or `customer` like %%(txt)s) %s %s
 		order by name, customer, customer_name
-		limit %s""" % (doctype, searchfield, conditions, 
-		get_match_cond(doctype), "%(start)s, %(page_len)s"), 
-		{"txt": "%%%s%%" % txt, "start": start, "page_len": page_len}, 
+		limit %s""" % (doctype, searchfield, conditions,
+		get_match_cond(doctype), "%(start)s, %(page_len)s"),
+		{"txt": "%%%s%%" % txt, "start": start, "page_len": page_len},
 		as_list=True)
-	
+
 def query_purchase_return_doc(doctype, txt, searchfield, start, page_len, filters):
 	return frappe.db.sql("""select name, supplier, supplier_name
 		from `tab%s` where docstatus = 1
-			and (`%s` like %%(txt)s 
+			and (`%s` like %%(txt)s
 				or `supplier` like %%(txt)s) %s
 		order by name, supplier, supplier_name
-		limit %s""" % (doctype, searchfield, get_match_cond(doctype), 
-		"%(start)s, %(page_len)s"),	{"txt": "%%%s%%" % txt, "start": 
+		limit %s""" % (doctype, searchfield, get_match_cond(doctype),
+		"%(start)s, %(page_len)s"),	{"txt": "%%%s%%" % txt, "start":
 		start, "page_len": page_len}, as_list=True)
-		
+
 def query_return_item(doctype, txt, searchfield, start, page_len, filters):
 	txt = txt.replace("%", "")
 
 	ref = get_return_doc_and_details(filters)
-			
+
 	stock_items = get_stock_items_for_return(ref.doc, ref.parentfields)
-	
+
 	result = []
 	for item in ref.doc.get_all_children():
 		if getattr(item, "item_code", None) in stock_items:
@@ -649,8 +649,8 @@
 			item.description = cstr(item.description)
 			if (txt in item.item_code) or (txt in item.item_name) or (txt in item.description):
 				val = [
-					item.item_code, 
-					(len(item.item_name) > 40) and (item.item_name[:40] + "...") or item.item_name, 
+					item.item_code,
+					(len(item.item_name) > 40) and (item.item_name[:40] + "...") or item.item_name,
 					(len(item.description) > 40) and (item.description[:40] + "...") or \
 						item.description
 				]
@@ -662,45 +662,45 @@
 def get_batch_no(doctype, txt, searchfield, start, page_len, filters):
 	if not filters.get("posting_date"):
 		filters["posting_date"] = nowdate()
-		
+
 	batch_nos = None
 	args = {
-		'item_code': filters['item_code'], 
-		's_warehouse': filters['s_warehouse'], 
-		'posting_date': filters['posting_date'], 
-		'txt': "%%%s%%" % txt, 
-		'mcond':get_match_cond(doctype), 
-		"start": start, 
+		'item_code': filters['item_code'],
+		's_warehouse': filters['s_warehouse'],
+		'posting_date': filters['posting_date'],
+		'txt': "%%%s%%" % txt,
+		'mcond':get_match_cond(doctype),
+		"start": start,
 		"page_len": page_len
 	}
-	
+
 	if filters.get("s_warehouse"):
-		batch_nos = frappe.db.sql("""select batch_no 
-			from `tabStock Ledger Entry` sle 
-			where item_code = '%(item_code)s' 
+		batch_nos = frappe.db.sql("""select batch_no
+			from `tabStock Ledger Entry` sle
+			where item_code = '%(item_code)s'
 				and warehouse = '%(s_warehouse)s'
-				and batch_no like '%(txt)s' 
-				and exists(select * from `tabBatch` 
-					where name = sle.batch_no 
-					and (ifnull(expiry_date, '2099-12-31') >= %(posting_date)s 
+				and batch_no like '%(txt)s'
+				and exists(select * from `tabBatch`
+					where name = sle.batch_no
+					and (ifnull(expiry_date, '2099-12-31') >= %(posting_date)s
 						or expiry_date = '')
-					and docstatus != 2) 
+					and docstatus != 2)
 			%(mcond)s
-			group by batch_no having sum(actual_qty) > 0 
-			order by batch_no desc 
-			limit %(start)s, %(page_len)s """ 
+			group by batch_no having sum(actual_qty) > 0
+			order by batch_no desc
+			limit %(start)s, %(page_len)s """
 			% args)
-	
+
 	if batch_nos:
 		return batch_nos
 	else:
-		return frappe.db.sql("""select name from `tabBatch` 
+		return frappe.db.sql("""select name from `tabBatch`
 			where item = '%(item_code)s'
 			and docstatus < 2
-			and (ifnull(expiry_date, '2099-12-31') >= %(posting_date)s 
+			and (ifnull(expiry_date, '2099-12-31') >= %(posting_date)s
 				or expiry_date = '' or expiry_date = "0000-00-00")
 			%(mcond)s
-			order by name desc 
+			order by name desc
 			limit %(start)s, %(page_len)s
 		""" % args)
 
@@ -708,19 +708,19 @@
 	"""return item codes filtered from doc, which are stock items"""
 	if isinstance(parentfields, basestring):
 		parentfields = [parentfields]
-	
-	all_items = list(set([d.item_code for d in 
+
+	all_items = list(set([d.item_code for d in
 		ref_doc.get_all_children() if d.get("item_code")]))
 	stock_items = frappe.db.sql_list("""select name from `tabItem`
 		where is_stock_item='Yes' and name in (%s)""" % (", ".join(["%s"] * len(all_items))),
 		tuple(all_items))
 
 	return stock_items
-	
+
 def get_return_doc_and_details(args):
 	ref = frappe._dict()
-	
-	# get ref_doc	
+
+	# get ref_doc
 	if args.get("purpose") in return_map:
 		for fieldname, val in return_map[args.get("purpose")].items():
 			if args.get(fieldname):
@@ -728,9 +728,9 @@
 				ref.doc = frappe.get_doc(val[0], args.get(fieldname))
 				ref.parentfields = val[1]
 				break
-				
+
 	return ref
-	
+
 return_map = {
 	"Sales Return": {
 		# [Ref DocType, [Item tables' parentfields]]
@@ -747,29 +747,28 @@
 	se = frappe.get_doc("Stock Entry", stock_entry)
 	if not se.purpose in ["Sales Return", "Purchase Return"]:
 		return
-	
+
 	ref = get_return_doc_and_details(se)
-	
+
 	if ref.doc.doctype == "Delivery Note":
 		result = make_return_jv_from_delivery_note(se, ref)
 	elif ref.doc.doctype == "Sales Invoice":
 		result = make_return_jv_from_sales_invoice(se, ref)
 	elif ref.doc.doctype == "Purchase Receipt":
 		result = make_return_jv_from_purchase_receipt(se, ref)
-	
+
 	# create jv doc and fetch balance for each unique row item
-	jv_list = [{
-		"__islocal": 1,
-		"doctype": "Journal Voucher",
+	jv = frappe.new_doc("Journal Voucher")
+	jv.update({
 		"posting_date": se.posting_date,
 		"voucher_type": se.purpose == "Sales Return" and "Credit Note" or "Debit Note",
 		"fiscal_year": se.fiscal_year,
 		"company": se.company
-	}]
-	
+	})
+
 	from erpnext.accounts.utils import get_balance_on
 	for r in result:
-		jv_list.append({
+		jv.append("entries", {
 			"__islocal": 1,
 			"doctype": "Journal Voucher Detail",
 			"parentfield": "entries",
@@ -779,139 +778,140 @@
 			"balance": get_balance_on(r.get("account"), se.posting_date) \
 				if r.get("account") else 0
 		})
-		
-	return jv_list
-	
+
+	return jv
+
 def make_return_jv_from_sales_invoice(se, ref):
 	# customer account entry
 	parent = {
 		"account": ref.doc.debit_to,
 		"against_invoice": ref.doc.name,
 	}
-	
+
 	# income account entries
 	children = []
 	for se_item in se.get("mtn_details"):
 		# find item in ref.doc
 		ref_item = ref.doc.get({"item_code": se_item.item_code})[0]
-		
+
 		account = get_sales_account_from_item(ref.doc, ref_item)
-		
+
 		if account not in children:
 			children.append(account)
-			
+
 	return [parent] + [{"account": account} for account in children]
-	
+
 def get_sales_account_from_item(doc, ref_item):
 	account = None
-	if not ref_item.income_account:
+	if not getattr(ref_item, "income_account", None):
 		if ref_item.parent_item:
-			parent_item = doc.get({"item_code": ref_item.parent_item})[0]
+			parent_item = doc.get(doc.fname, {"item_code": ref_item.parent_item})[0]
 			account = parent_item.income_account
 	else:
 		account = ref_item.income_account
-	
+
 	return account
-	
+
 def make_return_jv_from_delivery_note(se, ref):
 	invoices_against_delivery = get_invoice_list("Sales Invoice Item", "delivery_note",
 		ref.doc.name)
-	
+
 	if not invoices_against_delivery:
-		sales_orders_against_delivery = [d.against_sales_order for d in ref.doc.get_all_children() if d.against_sales_order]
-		
+		sales_orders_against_delivery = [d.against_sales_order for d in ref.doc.get_all_children() if getattr(d, "against_sales_order", None)]
+
 		if sales_orders_against_delivery:
 			invoices_against_delivery = get_invoice_list("Sales Invoice Item", "sales_order",
 				sales_orders_against_delivery)
-			
+
 	if not invoices_against_delivery:
 		return []
-		
+
 	packing_item_parent_map = dict([[d.item_code, d.parent_item] for d in ref.doc.get(ref.parentfields[1])])
-	
+
 	parent = {}
 	children = []
-	
+
 	for se_item in se.get("mtn_details"):
 		for sales_invoice in invoices_against_delivery:
 			si = frappe.get_doc("Sales Invoice", sales_invoice)
-			
+
 			if se_item.item_code in packing_item_parent_map:
 				ref_item = si.get({"item_code": packing_item_parent_map[se_item.item_code]})
 			else:
 				ref_item = si.get({"item_code": se_item.item_code})
-			
+
 			if not ref_item:
 				continue
-				
+
 			ref_item = ref_item[0]
-			
+
 			account = get_sales_account_from_item(si, ref_item)
-			
+
 			if account not in children:
 				children.append(account)
-			
+
 			if not parent:
 				parent = {"account": si.debit_to}
 
 			break
-			
+
 	if len(invoices_against_delivery) == 1:
 		parent["against_invoice"] = invoices_against_delivery[0]
-	
+
 	result = [parent] + [{"account": account} for account in children]
-	
+
 	return result
-	
+
 def get_invoice_list(doctype, link_field, value):
 	if isinstance(value, basestring):
 		value = [value]
-	
+
 	return frappe.db.sql_list("""select distinct parent from `tab%s`
 		where docstatus = 1 and `%s` in (%s)""" % (doctype, link_field,
 			", ".join(["%s"]*len(value))), tuple(value))
-			
+
 def make_return_jv_from_purchase_receipt(se, ref):
 	invoice_against_receipt = get_invoice_list("Purchase Invoice Item", "purchase_receipt",
 		ref.doc.name)
-	
+
 	if not invoice_against_receipt:
-		purchase_orders_against_receipt = [d.prevdoc_docname for d in 
-			ref.get({"prevdoc_doctype": "Purchase Order"}) if d.prevdoc_docname]
-		
+		purchase_orders_against_receipt = [d.prevdoc_docname for d in
+			ref.doc.get(ref.doc.fname, {"prevdoc_doctype": "Purchase Order"})
+			if getattr(d, "prevdoc_docname", None)]
+
 		if purchase_orders_against_receipt:
 			invoice_against_receipt = get_invoice_list("Purchase Invoice Item", "purchase_order",
 				purchase_orders_against_receipt)
-			
+
 	if not invoice_against_receipt:
 		return []
-	
+
 	parent = {}
 	children = []
-	
+
 	for se_item in se.get("mtn_details"):
 		for purchase_invoice in invoice_against_receipt:
 			pi = frappe.get_doc("Purchase Invoice", purchase_invoice)
 			ref_item = pi.get({"item_code": se_item.item_code})
-			
+
 			if not ref_item:
 				continue
-				
+
 			ref_item = ref_item[0]
-			
+
 			account = ref_item.expense_account
-			
+
 			if account not in children:
 				children.append(account)
-			
+
 			if not parent:
 				parent = {"account": pi.credit_to}
 
 			break
-			
+
 	if len(invoice_against_receipt) == 1:
 		parent["against_voucher"] = invoice_against_receipt[0]
-	
+
 	result = [parent] + [{"account": account} for account in children]
-	
-	return result
\ No newline at end of file
+
+	return result
diff --git a/erpnext/stock/doctype/stock_entry/test_stock_entry.py b/erpnext/stock/doctype/stock_entry/test_stock_entry.py
index 0aa0433..f8cdeb7 100644
--- a/erpnext/stock/doctype/stock_entry/test_stock_entry.py
+++ b/erpnext/stock/doctype/stock_entry/test_stock_entry.py
@@ -3,6 +3,7 @@
 
 from __future__ import unicode_literals
 import frappe, unittest
+import frappe.defaults
 from frappe.utils import flt, getdate
 from erpnext.stock.doctype.serial_no.serial_no import *
 from erpnext.stock.doctype.purchase_receipt.test_purchase_receipt import set_perpetual_inventory
@@ -31,7 +32,6 @@
 		st2.submit()
 
 		from erpnext.stock.utils import reorder_item
-
 		reorder_item()
 
 		mr_name = frappe.db.sql("""select parent from `tabMaterial Request Item`
@@ -39,8 +39,6 @@
 
 		self.assertTrue(mr_name)
 
-		frappe.db.set_default("company", self.old_default_company)
-
 	def test_material_receipt_gl_entry(self):
 		self._clear_stock_account_balance()
 		set_perpetual_inventory()
@@ -367,14 +365,14 @@
 
 	def _test_sales_return_jv(self, se):
 		from erpnext.stock.doctype.stock_entry.stock_entry import make_return_jv
-		jv_list = make_return_jv(se.name)
+		jv = make_return_jv(se.name)
 
-		self.assertEqual(len(jv_list), 3)
-		self.assertEqual(jv_list[0].get("voucher_type"), "Credit Note")
-		self.assertEqual(jv_list[0].get("posting_date"), se.posting_date)
-		self.assertEqual(jv_list[1].get("account"), "_Test Customer - _TC")
-		self.assertEqual(jv_list[2].get("account"), "Sales - _TC")
-		self.assertTrue(jv_list[1].get("against_invoice"))
+		self.assertEqual(len(jv.get("entries")), 2)
+		self.assertEqual(jv.get("voucher_type"), "Credit Note")
+		self.assertEqual(jv.get("posting_date"), se.posting_date)
+		self.assertEqual(jv.get("entries")[0].get("account"), "_Test Customer - _TC")
+		self.assertEqual(jv.get("entries")[1].get("account"), "Sales - _TC")
+		self.assertTrue(jv.get("entries")[0].get("against_invoice"))
 
 	def test_make_return_jv_for_sales_invoice_non_packing_item(self):
 		self._clear_stock_account_balance()
@@ -527,14 +525,14 @@
 
 	def _test_purchase_return_jv(self, se):
 		from erpnext.stock.doctype.stock_entry.stock_entry import make_return_jv
-		jv_list = make_return_jv(se.name)
+		jv = make_return_jv(se.name)
 
-		self.assertEqual(len(jv_list), 3)
-		self.assertEqual(jv_list[0].get("voucher_type"), "Debit Note")
-		self.assertEqual(jv_list[0].get("posting_date"), se.posting_date)
-		self.assertEqual(jv_list[1].get("account"), "_Test Supplier - _TC")
-		self.assertEqual(jv_list[2].get("account"), "_Test Account Cost for Goods Sold - _TC")
-		self.assertTrue(jv_list[1].get("against_voucher"))
+		self.assertEqual(len(jv.get("entries")), 2)
+		self.assertEqual(jv.get("voucher_type"), "Debit Note")
+		self.assertEqual(jv.get("posting_date"), se.posting_date)
+		self.assertEqual(jv.get("entries")[0].get("account"), "_Test Supplier - _TC")
+		self.assertEqual(jv.get("entries")[1].get("account"), "_Test Account Cost for Goods Sold - _TC")
+		self.assertTrue(jv.get("entries")[0].get("against_voucher"))
 
 	def test_make_return_jv_for_purchase_receipt(self):
 		self._clear_stock_account_balance()
@@ -774,10 +772,9 @@
 
 	# permission tests
 	def test_warehouse_user(self):
-		import frappe.defaults
 		set_perpetual_inventory(0)
 
-		frappe.defaults.add_default("Warehouse", "_Test Warehouse 1 - _TC1", "test@example.com", "Restriction")
+		frappe.defaults.add_default("Warehouse", "_Test Warehouse 1 - _TC", "test@example.com", "Restriction")
 		frappe.defaults.add_default("Warehouse", "_Test Warehouse 2 - _TC1", "test2@example.com", "Restriction")
 		frappe.get_doc("User", "test@example.com")\
 			.add_roles("Sales User", "Sales Manager", "Material User", "Material Manager")
@@ -797,15 +794,17 @@
 		st1.insert()
 		st1.submit()
 
-		frappe.defaults.clear_default("Warehouse", "_Test Warehouse 1 - _TC1", "test@example.com", parenttype="Restriction")
-		frappe.defaults.clear_default("Warehouse", "_Test Warehouse 2 - _TC1", "test2@example.com", parenttype="Restriction")
+		frappe.defaults.clear_default("Warehouse", "_Test Warehouse 1 - _TC",
+			"test@example.com", parenttype="Restriction")
+		frappe.defaults.clear_default("Warehouse", "_Test Warehouse 2 - _TC1",
+			"test2@example.com", parenttype="Restriction")
 
 	def test_freeze_stocks (self):
 		self._clear_stock_account_balance()
 		frappe.db.set_value('Stock Settings', None,'stock_auth_role', '')
 
 		# test freeze_stocks_upto
-		date_newer_than_test_records = add_days(getdate(test_records[0][0]['posting_date']), 5)
+		date_newer_than_test_records = add_days(getdate(test_records[0]['posting_date']), 5)
 		frappe.db.set_value("Stock Settings", None, "stock_frozen_upto", date_newer_than_test_records)
 		se = frappe.copy_doc(test_records[0]).insert()
 		self.assertRaises (StockFreezeError, se.submit)
diff --git a/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py b/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py
index 17d4282..17d683f 100644
--- a/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py
+++ b/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py
@@ -19,15 +19,15 @@
 		self.validate_item()
 		validate_warehouse_company(self.warehouse, self.company)
 		self.scrub_posting_time()
-		
+
 		from erpnext.accounts.utils import validate_fiscal_year
-		validate_fiscal_year(self.posting_date, self.fiscal_year, 
+		validate_fiscal_year(self.posting_date, self.fiscal_year,
 			self.meta.get_label("posting_date"))
 
 	def on_submit(self):
 		self.check_stock_frozen_date()
 		self.actual_amt_check()
-		
+
 		from erpnext.stock.doctype.serial_no.serial_no import process_serial_no
 		process_serial_no(self)
 
@@ -58,7 +58,7 @@
 				msgprint("Stock Ledger Entry: '%s' is mandatory" % k, raise_exception = 1)
 			elif k == 'warehouse':
 				if not frappe.db.exists("Warehouse", self.get(k)):
-					msgprint("Warehouse: '%s' does not exist in the system. Please check." % 
+					msgprint("Warehouse: '%s' does not exist in the system. Please check." %
 						self.get(k), raise_exception = 1)
 
 	def validate_item(self):
@@ -76,9 +76,9 @@
 				frappe.throw("Batch number is mandatory for Item '%s'" % self.item_code)
 
 			# check if batch belongs to item
-			if not frappe.db.get_value("Batch", 
+			if not frappe.db.get_value("Batch",
 					{"item": self.item_code, "name": self.batch_no}):
-				frappe.throw("'%s' is not a valid Batch Number for Item '%s'" % 
+				frappe.throw("'%s' is not a valid Batch Number for Item '%s'" %
 					(self.batch_no, self.item_code))
 
 		if not self.stock_uom:
@@ -108,4 +108,4 @@
 		where Key_name="posting_sort_index" """):
 		frappe.db.commit()
 		frappe.db.sql("""alter table `tabStock Ledger Entry`
-			add index posting_sort_index(posting_date, posting_time, name)""")
\ No newline at end of file
+			add index posting_sort_index(posting_date, posting_time, name)""")
diff --git a/erpnext/stock/doctype/warehouse/test_records.json b/erpnext/stock/doctype/warehouse/test_records.json
index 05d30d6..e0941af 100644
--- a/erpnext/stock/doctype/warehouse/test_records.json
+++ b/erpnext/stock/doctype/warehouse/test_records.json
@@ -1,25 +1,25 @@
 [
  {
-  "company": "_Test Company", 
-  "create_account_under": "Stock Assets - _TC", 
-  "doctype": "Warehouse", 
+  "company": "_Test Company",
+  "create_account_under": "Stock Assets - _TC",
+  "doctype": "Warehouse",
   "warehouse_name": "_Test Warehouse"
- }, 
+ },
  {
-  "company": "_Test Company", 
-  "create_account_under": "Fixed Assets - _TC", 
-  "doctype": "Warehouse", 
+  "company": "_Test Company",
+  "create_account_under": "Fixed Assets - _TC",
+  "doctype": "Warehouse",
   "warehouse_name": "_Test Warehouse 1"
- }, 
+ },
  {
-  "company": "_Test Company 1", 
-  "create_account_under": "Stock Assets - _TC", 
-  "doctype": "Warehouse", 
+  "company": "_Test Company 1",
+  "create_account_under": "Stock Assets - _TC",
+  "doctype": "Warehouse",
   "warehouse_name": "_Test Warehouse 2"
- }, 
+ },
  {
-  "company": "_Test Company", 
-  "doctype": "Warehouse", 
+  "company": "_Test Company",
+  "doctype": "Warehouse",
   "warehouse_name": "_Test Warehouse No Account"
  }
-]
\ No newline at end of file
+]
diff --git a/erpnext/stock/stock_ledger.py b/erpnext/stock/stock_ledger.py
index 8a19bb1..34558fb 100644
--- a/erpnext/stock/stock_ledger.py
+++ b/erpnext/stock/stock_ledger.py
@@ -169,9 +169,13 @@
 def get_sle_after_datetime(args, for_update=False):
 	"""get Stock Ledger Entries after a particular datetime, for reposting"""
 	# NOTE: using for update of
-	return get_stock_ledger_entries(args,
-		["timestamp(posting_date, posting_time) > timestamp(%(posting_date)s, %(posting_time)s)"],
-		"asc", for_update=for_update)
+	conditions = ["timestamp(posting_date, posting_time) > timestamp(%(posting_date)s, %(posting_time)s)"]
+
+	# Excluding name: Workaround for MariaDB timestamp() floating microsecond issue
+	if args.get("name"):
+		conditions.append("name!=%(name)s")
+
+	return get_stock_ledger_entries(args, conditions, "asc", for_update=for_update)
 
 def get_stock_ledger_entries(args, conditions=None, order="desc", limit=None, for_update=False):
 	"""get stock ledger entries filtered by specific posting datetime conditions"""
@@ -180,7 +184,7 @@
 	if not args.get("posting_time"):
 		args["posting_time"] = "00:00"
 
-	return frappe.db.sql("""select * from `tabStock Ledger Entry`
+	return frappe.db.sql("""select *, timestamp(posting_date, posting_time) as "timestamp" from `tabStock Ledger Entry`
 		where item_code = %%(item_code)s
 		and warehouse = %%(warehouse)s
 		and ifnull(is_cancelled, 'No')='No'
diff --git a/erpnext/stock/utils.py b/erpnext/stock/utils.py
index 0345a7e..bce94f3 100644
--- a/erpnext/stock/utils.py
+++ b/erpnext/stock/utils.py
@@ -9,34 +9,34 @@
 from frappe.utils.email_lib import sendmail
 
 class InvalidWarehouseCompany(frappe.ValidationError): pass
-	
+
 def get_stock_balance_on(warehouse, posting_date=None):
 	if not posting_date: posting_date = nowdate()
-	
+
 	stock_ledger_entries = frappe.db.sql("""
-		SELECT 
+		SELECT
 			item_code, stock_value
-		FROM 
+		FROM
 			`tabStock Ledger Entry`
-		WHERE 
+		WHERE
 			warehouse=%s AND posting_date <= %s
 		ORDER BY timestamp(posting_date, posting_time) DESC, name DESC
 	""", (warehouse, posting_date), as_dict=1)
-	 
+
 	sle_map = {}
 	for sle in stock_ledger_entries:
 		sle_map.setdefault(sle.item_code, flt(sle.stock_value))
-		
+
 	return sum(sle_map.values())
-	
+
 def get_latest_stock_balance():
 	bin_map = {}
-	for d in frappe.db.sql("""SELECT item_code, warehouse, stock_value as stock_value 
+	for d in frappe.db.sql("""SELECT item_code, warehouse, stock_value as stock_value
 		FROM tabBin""", as_dict=1):
 			bin_map.setdefault(d.warehouse, {}).setdefault(d.item_code, flt(d.stock_value))
-			
+
 	return bin_map
-	
+
 def get_bin(item_code, warehouse):
 	bin = frappe.db.get_value("Bin", {"item_code": item_code, "warehouse": warehouse})
 	if not bin:
@@ -58,18 +58,18 @@
 		bin.update_stock(args)
 		return bin
 	else:
-		msgprint("[Stock Update] Ignored %s since it is not a stock item" 
+		msgprint("[Stock Update] Ignored %s since it is not a stock item"
 			% args.get("item_code"))
 
 def get_incoming_rate(args):
 	"""Get Incoming Rate based on valuation method"""
 	from erpnext.stock.stock_ledger import get_previous_sle
-		
+
 	in_rate = 0
 	if args.get("serial_no"):
 		in_rate = get_avg_purchase_rate(args.get("serial_no"))
 	elif args.get("bom_no"):
-		result = frappe.db.sql("""select ifnull(total_cost, 0) / ifnull(quantity, 1) 
+		result = frappe.db.sql("""select ifnull(total_cost, 0) / ifnull(quantity, 1)
 			from `tabBOM` where name = %s and docstatus=1 and is_active=1""", args.get("bom_no"))
 		in_rate = result and flt(result[0][0]) or 0
 	else:
@@ -84,12 +84,12 @@
 		elif valuation_method == 'Moving Average':
 			in_rate = previous_sle.get('valuation_rate') or 0
 	return in_rate
-	
+
 def get_avg_purchase_rate(serial_nos):
 	"""get average value of serial numbers"""
-	
+
 	serial_nos = get_valid_serial_nos(serial_nos)
-	return flt(frappe.db.sql("""select avg(ifnull(purchase_rate, 0)) from `tabSerial No` 
+	return flt(frappe.db.sql("""select avg(ifnull(purchase_rate, 0)) from `tabSerial No`
 		where name in (%s)""" % ", ".join(["%s"] * len(serial_nos)),
 		tuple(serial_nos))[0][0])
 
@@ -99,11 +99,11 @@
 	if not val_method:
 		val_method = get_global_default('valuation_method') or "FIFO"
 	return val_method
-		
+
 def get_fifo_rate(previous_stock_queue, qty):
 	"""get FIFO (average) Rate from Queue"""
 	if qty >= 0:
-		total = sum(f[0] for f in previous_stock_queue)	
+		total = sum(f[0] for f in previous_stock_queue)
 		return total and sum(f[0] * f[1] for f in previous_stock_queue) / flt(total) or 0.0
 	else:
 		outgoing_cost = 0
@@ -123,12 +123,12 @@
 				qty_to_pop = 0
 		# if queue gets blank and qty_to_pop remaining, get average rate of full queue
 		return outgoing_cost / abs(qty) - qty_to_pop
-	
+
 def get_valid_serial_nos(sr_nos, qty=0, item_code=''):
 	"""split serial nos, validate and return list of valid serial nos"""
 	# TODO: remove duplicates in client side
 	serial_nos = cstr(sr_nos).strip().replace(',', '\n').split('\n')
-	
+
 	valid_serial_nos = []
 	for val in serial_nos:
 		if val:
@@ -137,12 +137,12 @@
 				msgprint("You have entered duplicate serial no: '%s'" % val, raise_exception=1)
 			else:
 				valid_serial_nos.append(val)
-	
+
 	if qty and len(valid_serial_nos) != abs(qty):
 		msgprint("Please enter serial nos for "
 			+ cstr(abs(qty)) + " quantity against item code: " + item_code,
 			raise_exception=1)
-		
+
 	return valid_serial_nos
 
 def validate_warehouse_company(warehouse, company):
@@ -151,48 +151,48 @@
 		frappe.msgprint(_("Warehouse does not belong to company.") + " (" + \
 			warehouse + ", " + company +")", raise_exception=InvalidWarehouseCompany)
 
-def get_sales_bom_buying_amount(item_code, warehouse, voucher_type, voucher_no, voucher_detail_no, 
+def get_sales_bom_buying_amount(item_code, warehouse, voucher_type, voucher_no, voucher_detail_no,
 		stock_ledger_entries, item_sales_bom):
 	# sales bom item
 	buying_amount = 0.0
 	for bom_item in item_sales_bom[item_code]:
 		if bom_item.get("parent_detail_docname")==voucher_detail_no:
-			buying_amount += get_buying_amount(voucher_type, voucher_no, voucher_detail_no, 
+			buying_amount += get_buying_amount(voucher_type, voucher_no, voucher_detail_no,
 				stock_ledger_entries.get((bom_item.item_code, warehouse), []))
 
 	return buying_amount
-		
+
 def get_buying_amount(voucher_type, voucher_no, item_row, stock_ledger_entries):
 	# IMP NOTE
-	# stock_ledger_entries should already be filtered by item_code and warehouse and 
+	# stock_ledger_entries should already be filtered by item_code and warehouse and
 	# sorted by posting_date desc, posting_time desc
 	for i, sle in enumerate(stock_ledger_entries):
 		if sle.voucher_type == voucher_type and sle.voucher_no == voucher_no and \
 			sle.voucher_detail_no == item_row:
 				previous_stock_value = len(stock_ledger_entries) > i+1 and \
 					flt(stock_ledger_entries[i+1].stock_value) or 0.0
-				buying_amount =  previous_stock_value - flt(sle.stock_value)						
-				
+				buying_amount =  previous_stock_value - flt(sle.stock_value)
+
 				return buying_amount
 	return 0.0
-	
+
 
 def reorder_item():
 	""" Reorder item if stock reaches reorder level"""
 	if getattr(frappe.local, "auto_indent", None) is None:
 		frappe.local.auto_indent = cint(frappe.db.get_value('Stock Settings', None, 'auto_indent'))
-	
+
 	if frappe.local.auto_indent:
 		material_requests = {}
 		bin_list = frappe.db.sql("""select item_code, warehouse, projected_qty
 			from tabBin where ifnull(item_code, '') != '' and ifnull(warehouse, '') != ''
-			and exists (select name from `tabItem` 
-				where `tabItem`.name = `tabBin`.item_code and 
+			and exists (select name from `tabItem`
+				where `tabItem`.name = `tabBin`.item_code and
 				is_stock_item='Yes' and (is_purchase_item='Yes' or is_sub_contracted_item='Yes') and
-				(ifnull(end_of_life, '')='' or end_of_life > now()))""", as_dict=True)
+				(ifnull(end_of_life, '')='' or end_of_life > curdate()))""", as_dict=True)
 		for bin in bin_list:
 			#check if re-order is required
-			item_reorder = frappe.db.get("Item Reorder", 
+			item_reorder = frappe.db.get("Item Reorder",
 				{"parent": bin.item_code, "warehouse": bin.warehouse})
 			if item_reorder:
 				reorder_level = item_reorder.warehouse_reorder_level
@@ -202,15 +202,15 @@
 				reorder_level, reorder_qty = frappe.db.get_value("Item", bin.item_code,
 					["re_order_level", "re_order_qty"])
 				material_request_type = "Purchase"
-		
+
 			if flt(reorder_level) and flt(bin.projected_qty) < flt(reorder_level):
 				if flt(reorder_level) - flt(bin.projected_qty) > flt(reorder_qty):
 					reorder_qty = flt(reorder_level) - flt(bin.projected_qty)
-					
+
 				company = frappe.db.get_value("Warehouse", bin.warehouse, "company") or \
 					frappe.defaults.get_defaults()["company"] or \
 					frappe.db.sql("""select name from tabCompany limit 1""")[0][0]
-					
+
 				material_requests.setdefault(material_request_type, frappe._dict()).setdefault(
 					company, []).append(frappe._dict({
 						"item_code": bin.item_code,
@@ -218,7 +218,7 @@
 						"reorder_qty": reorder_qty
 					})
 				)
-		
+
 		create_material_request(material_requests)
 
 def create_material_request(material_requests):
@@ -234,21 +234,19 @@
 				items = material_requests[request_type][company]
 				if not items:
 					continue
-					
-				mr = [{
-					"doctype": "Material Request",
+
+				mr = frappe.new_doc("Material Request")
+				mr.update({
 					"company": company,
 					"fiscal_year": current_fiscal_year,
 					"transaction_date": nowdate(),
 					"material_request_type": request_type
-				}]
-			
+				})
+
 				for d in items:
 					item = frappe.get_doc("Item", d.item_code)
-					mr.append({
+					mr.append("indent_details", {
 						"doctype": "Material Request Item",
-						"parenttype": "Material Request",
-						"parentfield": "indent_details",
 						"item_code": d.item_code,
 						"schedule_date": add_days(nowdate(),cint(item.lead_time_days)),
 						"uom":	item.stock_uom,
@@ -259,11 +257,10 @@
 						"qty": d.reorder_qty,
 						"brand": item.brand,
 					})
-			
-				mr_doc = frappe.get_doc(mr)
-				mr_doc.insert()
-				mr_doc.submit()
-				mr_list.append(mr_doc)
+
+				mr.insert()
+				mr.submit()
+				mr_list.append(mr)
 
 			except:
 				if frappe.local.message_log:
@@ -274,24 +271,24 @@
 
 	if mr_list:
 		if getattr(frappe.local, "reorder_email_notify", None) is None:
-			frappe.local.reorder_email_notify = cint(frappe.db.get_value('Stock Settings', None, 
+			frappe.local.reorder_email_notify = cint(frappe.db.get_value('Stock Settings', None,
 				'reorder_email_notify'))
-			
+
 		if(frappe.local.reorder_email_notify):
 			send_email_notification(mr_list)
 
 	if exceptions_list:
 		notify_errors(exceptions_list)
-		
+
 def send_email_notification(mr_list):
 	""" Notify user about auto creation of indent"""
-	
-	email_list = frappe.db.sql_list("""select distinct r.parent 
+
+	email_list = frappe.db.sql_list("""select distinct r.parent
 		from tabUserRole r, tabUser p
 		where p.name = r.parent and p.enabled = 1 and p.docstatus < 2
-		and r.role in ('Purchase Manager','Material Manager') 
+		and r.role in ('Purchase Manager','Material Manager')
 		and p.name not in ('Administrator', 'All', 'Guest')""")
-	
+
 	msg="""<h3>Following Material Requests has been raised automatically \
 		based on item reorder level:</h3>"""
 	for mr in mr_list:
@@ -302,13 +299,13 @@
 				cstr(item.qty) + "</td><td>" + cstr(item.uom) + "</td></tr>"
 		msg += "</table>"
 	sendmail(email_list, subject='Auto Material Request Generation Notification', msg = msg)
-	
+
 def notify_errors(exceptions_list):
 	subject = "[Important] [ERPNext] Error(s) while creating Material Requests based on Re-order Levels"
 	msg = """Dear System Manager,
 
 		An error occured for certain Items while creating Material Requests based on Re-order level.
-		
+
 		Please rectify these issues:
 		---