Merged with 4.0-wip

erpnext/controllers/accounts_controller.py

@@ -3,7 +3,7 @@
 
 from __future__ import unicode_literals
 import webnotes
-from webnotes import _, msgprint
+from webnotes import _, throw
 from webnotes.utils import flt, cint, today, cstr
 from webnotes.model.code import get_obj
 from erpnext.setup.utils import get_company_currency
@@ -44,14 +44,13 @@ class AccountsController(TransactionBase):
 	def validate_for_freezed_account(self):
 		for fieldname in ["customer", "supplier"]:
 			if self.meta.get_field(fieldname) and self.doc.fields.get(fieldname):
-				accounts = webnotes.conn.get_values("Account", {"master_type": fieldname.title(), 
-					"master_name": self.doc.fields[fieldname], "company": self.doc.company}, 
-					"freeze_account", as_dict=1)
-				
+				accounts = webnotes.conn.get_values("Account", 
+					{"master_type": fieldname.title(), "master_name": self.doc.fields[fieldname], 
+					"company": self.doc.company}, "name")
 				if accounts:
-					if not filter(lambda x: cstr(x.freeze_account) in ["", "No"], accounts):
-						msgprint(_("Account for this ") + fieldname + _(" has been freezed. ") + 
-							self.doc.doctype + _(" can not be made."), raise_exception=1)
+					from erpnext.accounts.doctype.gl_entry.gl_entry import validate_frozen_account
+					for account in accounts:						
+						validate_frozen_account(account[0])
 			
 	def set_price_list_currency(self, buying_or_selling):
 		if self.meta.get_field("currency"):
@@ -133,6 +132,13 @@ class AccountsController(TransactionBase):
 				self.doclist.append(tax)
 					
 	def calculate_taxes_and_totals(self):
+		self.discount_amount_applied = False
+		self._calculate_taxes_and_totals()
+		
+		if self.meta.get_field("discount_amount"):
+			self.apply_discount_amount()
+
+	def _calculate_taxes_and_totals(self):
 		# validate conversion rate
 		company_currency = get_company_currency(self.doc.company)
 		if not self.doc.currency or self.doc.currency == company_currency:
@@ -141,7 +147,7 @@ class AccountsController(TransactionBase):
 		else:
 			validate_conversion_rate(self.doc.currency, self.doc.conversion_rate,
 				self.meta.get_label("conversion_rate"), self.doc.company)
-		
+
 		self.doc.conversion_rate = flt(self.doc.conversion_rate)
 		self.item_doclist = self.doclist.get({"parentfield": self.fname})
 		self.tax_doclist = self.doclist.get({"parentfield": self.other_fname})
@@ -157,17 +163,19 @@ class AccountsController(TransactionBase):
 		self.calculate_totals()
 		self._cleanup()
 		
-		# TODO
-		# print format: show net_total_export instead of net_total
-		
 	def initialize_taxes(self):
 		for tax in self.tax_doclist:
 			tax.item_wise_tax_detail = {}
-			for fieldname in ["tax_amount", "total", 
-				"tax_amount_for_current_item", "grand_total_for_current_item",
-				"tax_fraction_for_current_item", "grand_total_fraction_for_current_item"]:
-					tax.fields[fieldname] = 0.0
-			
+			tax_fields = ["total", "tax_amount_after_discount_amount", 
+				"tax_amount_for_current_item", "grand_total_for_current_item", 
+				"tax_fraction_for_current_item", "grand_total_fraction_for_current_item"]
+
+			if not self.discount_amount_applied:
+				tax_fields.append("tax_amount")
+
+			for fieldname in tax_fields:
+				tax.fields[fieldname] = 0.0
+
 			self.validate_on_previous_row(tax)
 			self.validate_inclusive_tax(tax)
 			self.round_floats_in(tax)
@@ -179,17 +187,17 @@ class AccountsController(TransactionBase):
 		"""
 		if tax.charge_type in ["On Previous Row Amount", "On Previous Row Total"] and \
 				(not tax.row_id or cint(tax.row_id) >= tax.idx):
-			msgprint((_("Row") + " # %(idx)s [%(taxes_doctype)s]: " + \
+			throw((_("Row") + " # %(idx)s [%(taxes_doctype)s]: " + \
 				_("Please specify a valid") + " %(row_id_label)s") % {
 					"idx": tax.idx,
 					"taxes_doctype": tax.doctype,
 					"row_id_label": self.meta.get_label("row_id",
 						parentfield=self.other_fname)
-				}, raise_exception=True)
+				})
 				
 	def validate_inclusive_tax(self, tax):
 		def _on_previous_row_error(row_range):
-			msgprint((_("Row") + " # %(idx)s [%(doctype)s]: " +
+			throw((_("Row") + " # %(idx)s [%(doctype)s]: " +
 				_("to be included in Item's rate, it is required that: ") +
 				" [" + _("Row") + " # %(row_range)s] " + _("also be included in Item's rate")) % {
 					"idx": tax.idx,
@@ -200,12 +208,12 @@ class AccountsController(TransactionBase):
 						parentfield=self.other_fname),
 					"charge_type": tax.charge_type,
 					"row_range": row_range
-				}, raise_exception=True)
+				})
 		
 		if cint(tax.included_in_print_rate):
 			if tax.charge_type == "Actual":
 				# inclusive tax cannot be of type Actual
-				msgprint((_("Row") 
+				throw((_("Row") 
 					+ " # %(idx)s [%(doctype)s]: %(charge_type_label)s = \"%(charge_type)s\" " 
 					+ "cannot be included in Item's rate") % {
 						"idx": tax.idx,
@@ -213,46 +221,49 @@ class AccountsController(TransactionBase):
 						"charge_type_label": self.meta.get_label("charge_type",
 							parentfield=self.other_fname),
 						"charge_type": tax.charge_type,
-					}, raise_exception=True)
+					})
 			elif tax.charge_type == "On Previous Row Amount" and \
-					not cint(self.tax_doclist[tax.row_id - 1].included_in_print_rate):
+					not cint(self.tax_doclist[cint(tax.row_id) - 1].included_in_print_rate):
 				# referred row should also be inclusive
 				_on_previous_row_error(tax.row_id)
 			elif tax.charge_type == "On Previous Row Total" and \
-					not all([cint(t.included_in_print_rate) for t in self.tax_doclist[:tax.row_id - 1]]):
+					not all([cint(t.included_in_print_rate) for t in self.tax_doclist[:cint(tax.row_id) - 1]]):
 				# all rows about the reffered tax should be inclusive
 				_on_previous_row_error("1 - %d" % (tax.row_id,))
 				
 	def calculate_taxes(self):
-		for item in self.item_doclist:
+		# maintain actual tax rate based on idx
+		actual_tax_dict = dict([[tax.idx, tax.rate] for tax in self.tax_doclist 
+			if tax.charge_type == "Actual"])
+
+		for n, item in enumerate(self.item_doclist):
 			item_tax_map = self._load_item_tax_rate(item.item_tax_rate)
 
 			for i, tax in enumerate(self.tax_doclist):
 				# tax_amount represents the amount of tax for the current step
 				current_tax_amount = self.get_current_tax_amount(item, tax, item_tax_map)
-				
-				if hasattr(self, "set_item_tax_amount"):
-					self.set_item_tax_amount(item, tax, current_tax_amount)
 
-				# case when net total is 0 but there is an actual type charge
-				# in this case add the actual amount to tax.tax_amount
-				# and tax.grand_total_for_current_item for the first such iteration
-				if tax.charge_type=="Actual" and \
-						not (current_tax_amount or self.doc.net_total or tax.tax_amount):
-					zero_net_total_adjustment = flt(tax.rate, self.precision("tax_amount", tax))
-					current_tax_amount += zero_net_total_adjustment
+				# Adjust divisional loss to the last item
+				if tax.charge_type == "Actual":
+					actual_tax_dict[tax.idx] -= current_tax_amount
+					if n == len(self.item_doclist) - 1:
+						current_tax_amount += actual_tax_dict[tax.idx]
 
 				# store tax_amount for current item as it will be used for
 				# charge type = 'On Previous Row Amount'
 				tax.tax_amount_for_current_item = current_tax_amount
 
 				# accumulate tax amount into tax.tax_amount
-				tax.tax_amount += current_tax_amount
+				if not self.discount_amount_applied:
+					tax.tax_amount += current_tax_amount
+
+				tax.tax_amount_after_discount_amount += current_tax_amount
 				
 				if tax.category:
 					# if just for valuation, do not add the tax amount in total
 					# hence, setting it as 0 for further steps
-					current_tax_amount = 0.0 if (tax.category == "Valuation") else current_tax_amount
+					current_tax_amount = 0.0 if (tax.category == "Valuation") \
+						else current_tax_amount
 					
 					current_tax_amount *= -1.0 if (tax.add_deduct_tax == "Deduct") else 1.0
 				
@@ -260,17 +271,36 @@ class AccountsController(TransactionBase):
 				# note: grand_total_for_current_item contains the contribution of 
 				# item's amount, previously applied tax and the current tax on that item
 				if i==0:
-					tax.grand_total_for_current_item = flt(item.amount +
-						current_tax_amount, self.precision("total", tax))
-						
+					tax.grand_total_for_current_item = flt(item.amount + current_tax_amount,
+						self.precision("total", tax))
 				else:
 					tax.grand_total_for_current_item = \
-						flt(self.tax_doclist[i-1].grand_total_for_current_item +
+						flt(self.tax_doclist[i-1].grand_total_for_current_item + 
 							current_tax_amount, self.precision("total", tax))
 				
 				# in tax.total, accumulate grand total of each item
 				tax.total += tax.grand_total_for_current_item
-				
+
+				# set precision in the last item iteration
+				if n == len(self.item_doclist) - 1:
+					self.round_off_totals(tax)
+
+					# adjust Discount Amount loss in last tax iteration
+					if i == (len(self.tax_doclist) - 1) and self.discount_amount_applied:
+						self.adjust_discount_amount_loss(tax)
+
+	def round_off_totals(self, tax):
+		tax.total = flt(tax.total, self.precision("total", tax))
+		tax.tax_amount = flt(tax.tax_amount, self.precision("tax_amount", tax))
+		tax.tax_amount_after_discount_amount = flt(tax.tax_amount_after_discount_amount, 
+			self.precision("tax_amount", tax))
+
+	def adjust_discount_amount_loss(self, tax):
+		discount_amount_loss = self.doc.grand_total - flt(self.doc.discount_amount) - tax.total
+		tax.tax_amount_after_discount_amount = flt(tax.tax_amount_after_discount_amount + 
+			discount_amount_loss, self.precision("tax_amount", tax))
+		tax.total = flt(tax.total + discount_amount_loss, self.precision("total", tax))
+
 	def get_current_tax_amount(self, item, tax, item_tax_map):
 		tax_rate = self._get_tax_rate(tax, item_tax_map)
 		current_tax_amount = 0.0
@@ -289,9 +319,9 @@ class AccountsController(TransactionBase):
 		elif tax.charge_type == "On Previous Row Total":
 			current_tax_amount = (tax_rate / 100.0) * \
 				self.tax_doclist[cint(tax.row_id) - 1].grand_total_for_current_item
-		
+
 		current_tax_amount = flt(current_tax_amount, self.precision("tax_amount", tax))
-		
+
 		# store tax breakup for each item
 		key = item.item_code or item.item_name
 		if tax.item_wise_tax_detail.get(key):
@@ -384,24 +414,45 @@ class AccountsController(TransactionBase):
 			})
 			
 	def validate_multiple_billing(self, ref_dt, item_ref_dn, based_on, parentfield):
+		from erpnext.controllers.status_updater import get_tolerance_for
+		item_tolerance = {}
+		global_tolerance = None
+		
 		for item in self.doclist.get({"parentfield": "entries"}):
 			if item.fields.get(item_ref_dn):
-				already_billed = webnotes.conn.sql("""select sum(%s) from `tab%s` 
-					where %s=%s and docstatus=1""" % (based_on, self.tname, item_ref_dn, '%s'), 
-					item.fields[item_ref_dn])[0][0]
-				
-				max_allowed_amt = flt(webnotes.conn.get_value(ref_dt + " Item", 
+				ref_amt = flt(webnotes.conn.get_value(ref_dt + " Item", 
 					item.fields[item_ref_dn], based_on), self.precision(based_on, item))
+				if not ref_amt:
+					webnotes.msgprint(_("As amount for item") + ": " + item.item_code + _(" in ") + 
+						ref_dt + _(" is zero, system will not check for over-billed"))
+				else:
+					already_billed = webnotes.conn.sql("""select sum(%s) from `tab%s` 
+						where %s=%s and docstatus=1 and parent != %s""" % 
+						(based_on, self.tname, item_ref_dn, '%s', '%s'), 
+						(item.fields[item_ref_dn], self.doc.name))[0][0]
 				
-				total_billed_amt = flt(flt(already_billed) + flt(item.fields[based_on]), 
-					self.precision(based_on, item))
+					total_billed_amt = flt(flt(already_billed) + flt(item.fields[based_on]), 
+						self.precision(based_on, item))
+				
+					tolerance, item_tolerance, global_tolerance = get_tolerance_for(item.item_code, 
+						item_tolerance, global_tolerance)
 					
-				if max_allowed_amt and total_billed_amt - max_allowed_amt > 0.02:
-					webnotes.msgprint(_("Row ")+ cstr(item.idx) + ": " + cstr(item.item_code) + 
-						_(" will be over-billed against mentioned ") + cstr(ref_dt) +  
-						_(". Max allowed " + cstr(based_on) + ": " + cstr(max_allowed_amt)), 
-						raise_exception=1)
-		
+					max_allowed_amt = flt(ref_amt * (100 + tolerance) / 100)
+				
+					if total_billed_amt - max_allowed_amt > 0.01:
+						reduce_by = total_billed_amt - max_allowed_amt
+					
+						webnotes.throw(_("Row #") + cstr(item.idx) + ": " + 
+							_(" Max amount allowed for Item ") + cstr(item.item_code) + 
+							_(" against ") + ref_dt + " " + 
+							cstr(item.fields[ref_dt.lower().replace(" ", "_")]) + _(" is ") + 
+							cstr(max_allowed_amt) + ". \n" + 
+							_("""If you want to increase your overflow tolerance, please increase \
+							tolerance % in Global Defaults or Item master. 				
+							Or, you must reduce the amount by """) + cstr(reduce_by) + "\n" + 
+							_("""Also, please check if the order item has already been billed \
+								in the Sales Order"""))
+				
 	def get_company_default(self, fieldname):
 		from erpnext.accounts.utils import get_company_default
 		return get_company_default(self.doc.company, fieldname)

erpnext/controllers/buying_controller.py

@@ -5,7 +5,6 @@ from __future__ import unicode_literals
 import webnotes
 from webnotes import _, msgprint
 from webnotes.utils import flt, _round
-
 from erpnext.buying.utils import get_item_details
 from erpnext.setup.utils import get_company_currency
 
@@ -122,8 +121,8 @@ class BuyingController(StockController):
 		self.round_floats_in(self.doc, ["net_total", "net_total_import"])
 		
 	def calculate_totals(self):
-		self.doc.grand_total = flt(self.tax_doclist and \
-			self.tax_doclist[-1].total or self.doc.net_total, self.precision("grand_total"))
+		self.doc.grand_total = flt(self.tax_doclist[-1].total if self.tax_doclist 
+			else self.doc.net_total, self.precision("grand_total"))
 		self.doc.grand_total_import = flt(self.doc.grand_total / self.doc.conversion_rate,
 			self.precision("grand_total_import"))
 
@@ -135,6 +134,24 @@ class BuyingController(StockController):
 		
 		if self.meta.get_field("rounded_total_import"):
 			self.doc.rounded_total_import = _round(self.doc.grand_total_import)
+				
+		if self.meta.get_field("other_charges_added"):
+			self.doc.other_charges_added = flt(sum([flt(d.tax_amount) for d in self.tax_doclist 
+				if d.add_deduct_tax=="Add" and d.category in ["Valuation and Total", "Total"]]), 
+				self.precision("other_charges_added"))
+				
+		if self.meta.get_field("other_charges_deducted"):
+			self.doc.other_charges_deducted = flt(sum([flt(d.tax_amount) for d in self.tax_doclist 
+				if d.add_deduct_tax=="Deduct" and d.category in ["Valuation and Total", "Total"]]), 
+				self.precision("other_charges_deducted"))
+				
+		if self.meta.get_field("other_charges_added_import"):
+			self.doc.other_charges_added_import = flt(self.doc.other_charges_added / 
+				self.doc.conversion_rate, self.precision("other_charges_added_import"))
+				
+		if self.meta.get_field("other_charges_deducted_import"):
+			self.doc.other_charges_deducted_import = flt(self.doc.other_charges_deducted / 
+				self.doc.conversion_rate, self.precision("other_charges_deducted_import"))
 			
 	def calculate_outstanding_amount(self):
 		if self.doc.doctype == "Purchase Invoice" and self.doc.docstatus < 2:
@@ -148,7 +165,7 @@ class BuyingController(StockController):
 	def _cleanup(self):
 		super(BuyingController, self)._cleanup()
 			
-		# except in purchase invoice, rate field is purchase_rate		
+		# except in purchase invoice, rate field is purchase_rate
 		# reset fieldname of rate
 		if self.doc.doctype != "Purchase Invoice":
 			df = self.meta.get_field("rate", parentfield=self.fname)
@@ -162,29 +179,53 @@ class BuyingController(StockController):
 			for item in self.item_doclist:
 				del item.fields["item_tax_amount"]
 				
-	def set_item_tax_amount(self, item, tax, current_tax_amount):
+		if not self.meta.get_field("tax_amount_after_discount_amount", 
+				parentfield=self.other_fname):
+			for tax in self.tax_doclist:
+				del tax.fields["tax_amount_after_discount_amount"]
+				
+	# update valuation rate
+	def update_valuation_rate(self, parentfield):
 		"""
 			item_tax_amount is the total tax amount applied on that item
 			stored for valuation 
 			
 			TODO: rename item_tax_amount to valuation_tax_amount
 		"""
-		if tax.category in ["Valuation", "Valuation and Total"] and \
-			self.meta.get_field("item_tax_amount", parentfield=self.fname):
-				item.item_tax_amount += flt(current_tax_amount, self.precision("item_tax_amount", item))
-				
-	# update valuation rate
-	def update_valuation_rate(self, parentfield):
-		for item in self.doclist.get({"parentfield": parentfield}):
-			item.conversion_factor = item.conversion_factor or flt(webnotes.conn.get_value(
-				"UOM Conversion Detail", {"parent": item.item_code, "uom": item.uom}, 
-				"conversion_factor")) or 1
+		stock_items = self.get_stock_items()
+		
+		stock_items_qty, stock_items_amount = 0, 0
+		last_stock_item_idx = 1
+		for d in self.doclist.get({"parentfield": parentfield}):
+			if d.item_code and d.item_code in stock_items:
+				stock_items_qty += flt(d.qty)
+				stock_items_amount += flt(d.amount)
+				last_stock_item_idx = d.idx
 			
-			if item.item_code and item.qty:
+		total_valuation_amount = sum([flt(d.tax_amount) for d in 
+			self.doclist.get({"parentfield": "purchase_tax_details"}) 
+			if d.category in ["Valuation", "Valuation and Total"]])
+			
+		
+		valuation_amount_adjustment = total_valuation_amount
+		for i, item in enumerate(self.doclist.get({"parentfield": parentfield})):
+			if item.item_code and item.qty and item.item_code in stock_items:
+				item_proportion = flt(item.amount) / stock_items_amount if stock_items_amount \
+					else flt(item.qty) / stock_items_qty
+				
+				if i == (last_stock_item_idx - 1):
+					item.item_tax_amount = flt(valuation_amount_adjustment, 
+						self.precision("item_tax_amount", item))
+				else:
+					item.item_tax_amount = flt(item_proportion * total_valuation_amount, 
+						self.precision("item_tax_amount", item))
+					valuation_amount_adjustment -= item.item_tax_amount
+
 				self.round_floats_in(item)
-								
-				# if no item code, which is sometimes the case in purchase invoice, 
-				# then it is not possible to track valuation against it
+				
+				item.conversion_factor = item.conversion_factor or flt(webnotes.conn.get_value(
+					"UOM Conversion Detail", {"parent": item.item_code, "uom": item.uom}, 
+					"conversion_factor")) or 1
 				qty_in_stock_uom = flt(item.qty * item.conversion_factor)
 				item.valuation_rate = ((item.amount + item.item_tax_amount + item.rm_supp_cost)
 					/ qty_in_stock_uom)

erpnext/controllers/selling_controller.py

@@ -122,7 +122,7 @@ class SellingController(StockController):
 						
 				cumulated_tax_fraction += tax.tax_fraction_for_current_item
 			
-			if cumulated_tax_fraction:
+			if cumulated_tax_fraction and not self.discount_amount_applied:
 				item.amount = flt((item.export_amount * self.doc.conversion_rate) /
 					(1 + cumulated_tax_fraction), self.precision("amount", item))
 					
@@ -159,22 +159,23 @@ class SellingController(StockController):
 		return current_tax_fraction
 		
 	def calculate_item_values(self):
-		for item in self.item_doclist:
-			self.round_floats_in(item)
-			
-			if item.adj_rate == 100:
-				item.export_rate = 0
-			elif not item.export_rate:
-				item.export_rate = flt(item.ref_rate * (1.0 - (item.adj_rate / 100.0)),
-					self.precision("export_rate", item))
-						
-			item.export_amount = flt(item.export_rate * item.qty,
-				self.precision("export_amount", item))
+		if not self.discount_amount_applied:
+			for item in self.item_doclist:
+				self.round_floats_in(item)
+
+				if item.adj_rate == 100:
+					item.export_rate = 0
+				elif not item.export_rate:
+					item.export_rate = flt(item.ref_rate * (1.0 - (item.adj_rate / 100.0)),
+						self.precision("export_rate", item))
+
+				item.export_amount = flt(item.export_rate * item.qty,
+					self.precision("export_amount", item))
+
+				self._set_in_company_currency(item, "ref_rate", "base_ref_rate")
+				self._set_in_company_currency(item, "export_rate", "basic_rate")
+				self._set_in_company_currency(item, "export_amount", "amount")
 
-			self._set_in_company_currency(item, "ref_rate", "base_ref_rate")
-			self._set_in_company_currency(item, "export_rate", "basic_rate")
-			self._set_in_company_currency(item, "export_amount", "amount")
-			
 	def calculate_net_total(self):
 		self.doc.net_total = self.doc.net_total_export = 0.0
 
@@ -192,12 +193,42 @@ class SellingController(StockController):
 			
 		self.doc.other_charges_total = flt(self.doc.grand_total - self.doc.net_total,
 			self.precision("other_charges_total"))
-		self.doc.other_charges_total_export = flt(self.doc.grand_total_export - self.doc.net_total_export,
+
+		self.doc.other_charges_total_export = flt(self.doc.grand_total_export - 
+			self.doc.net_total_export + flt(self.doc.discount_amount), 
 			self.precision("other_charges_total_export"))
 		
 		self.doc.rounded_total = _round(self.doc.grand_total)
 		self.doc.rounded_total_export = _round(self.doc.grand_total_export)
-		
+
+	def apply_discount_amount(self):
+		if self.doc.discount_amount:
+			grand_total_for_discount_amount = self.get_grand_total_for_discount_amount()
+
+			if grand_total_for_discount_amount:
+				# calculate item amount after Discount Amount
+				for item in self.item_doclist:
+					distributed_amount = flt(self.doc.discount_amount) * item.amount / grand_total_for_discount_amount
+					item.amount = flt(item.amount - distributed_amount, self.precision("amount", item))
+
+				self.discount_amount_applied = True
+				self._calculate_taxes_and_totals()
+
+	def get_grand_total_for_discount_amount(self):
+		actual_taxes_dict = {}
+
+		for tax in self.tax_doclist:
+			if tax.charge_type == "Actual":
+				actual_taxes_dict.setdefault(tax.idx, tax.tax_amount)
+			elif tax.row_id in actual_taxes_dict:
+				actual_tax_amount = flt(actual_taxes_dict.get(tax.row_id, 0)) * \
+					flt(tax.rate) / 100
+				actual_taxes_dict.setdefault(tax.idx, actual_tax_amount)
+
+		grand_total_for_discount_amount = flt(self.doc.grand_total - sum(actual_taxes_dict.values()), 
+			self.precision("grand_total"))
+		return grand_total_for_discount_amount
+
 	def calculate_outstanding_amount(self):
 		# NOTE: 
 		# write_off_amount is only for POS Invoice

erpnext/controllers/status_updater.py

@@ -151,7 +151,9 @@ class StatusUpdater(DocListController):
 		"""
 	
 		# check if overflow is within tolerance
-		tolerance = self.get_tolerance_for(item['item_code'])
+		tolerance, self.tolerance, self.global_tolerance = get_tolerance_for(item['item_code'], 
+			self.tolerance, self.global_tolerance)
+			
 		overflow_percent = ((item[args['target_field']] - item[args['target_ref_field']]) / 
 		 	item[args['target_ref_field']]) * 100
 	
@@ -170,23 +172,6 @@ class StatusUpdater(DocListController):
 				
 				Also, please check if the order item has already been billed in the Sales Order""" % 
 				item, raise_exception=1)
-				
-	def get_tolerance_for(self, item_code):
-		"""
-			Returns the tolerance for the item, if not set, returns global tolerance
-		"""
-		if self.tolerance.get(item_code): return self.tolerance[item_code]
-		
-		tolerance = flt(webnotes.conn.get_value('Item',item_code,'tolerance') or 0)
-
-		if not tolerance:
-			if self.global_tolerance == None:
-				self.global_tolerance = flt(webnotes.conn.get_value('Global Defaults', None, 
-					'tolerance'))
-			tolerance = self.global_tolerance
-		
-		self.tolerance[item_code] = tolerance
-		return tolerance
 	
 
 	def update_qty(self, change_modified=True):
@@ -245,4 +230,59 @@ class StatusUpdater(DocListController):
 							set %(status_field)s = if(ifnull(%(target_parent_field)s,0)<0.001, 
 								'Not %(keyword)s', if(%(target_parent_field)s>=99.99, 
 								'Fully %(keyword)s', 'Partly %(keyword)s'))
-							where name='%(name)s'""" % args)
+							where name='%(name)s'""" % args)
+							
+							
+	def update_billing_status_for_zero_amount_refdoc(self, ref_dt):
+		ref_fieldname = ref_dt.lower().replace(" ", "_")
+		zero_amount_refdoc = []
+		all_zero_amount_refdoc = webnotes.conn.sql_list("""select name from `tab%s` 
+			where docstatus=1 and net_total = 0""" % ref_dt)
+	
+		for item in self.doclist.get({"parentfield": "entries"}):
+			if item.fields.get(ref_fieldname) \
+				and item.fields.get(ref_fieldname) in all_zero_amount_refdoc \
+				and item.fields.get(ref_fieldname) not in zero_amount_refdoc:
+					zero_amount_refdoc.append(item.fields[ref_fieldname])
+		
+		if zero_amount_refdoc:
+			self.update_biling_status(zero_amount_refdoc, ref_dt, ref_fieldname)
+	
+	def update_biling_status(self, zero_amount_refdoc, ref_dt, ref_fieldname):
+		for ref_dn in zero_amount_refdoc:
+			ref_doc_qty = flt(webnotes.conn.sql("""select sum(ifnull(qty, 0)) from `tab%s Item` 
+				where parent=%s""" % (ref_dt, '%s'), (ref_dn))[0][0])
+			
+			billed_qty = flt(webnotes.conn.sql("""select sum(ifnull(qty, 0)) 
+				from `tab%s Item` where %s=%s and docstatus=1""" % 
+				(self.doc.doctype, ref_fieldname, '%s'), (ref_dn))[0][0])
+			
+			per_billed = ((ref_doc_qty if billed_qty > ref_doc_qty else billed_qty)\
+				/ ref_doc_qty)*100
+			webnotes.conn.set_value(ref_dt, ref_dn, "per_billed", per_billed)
+			
+			from webnotes.model.meta import has_field
+			if has_field(ref_dt, "billing_status"):
+				if per_billed < 0.001: billing_status = "Not Billed"
+				elif per_billed >= 99.99: billing_status = "Fully Billed"
+				else: billing_status = "Partly Billed"
+			
+				webnotes.conn.set_value(ref_dt, ref_dn, "billing_status", billing_status)
+							
+def get_tolerance_for(item_code, item_tolerance={}, global_tolerance=None):
+	"""
+		Returns the tolerance for the item, if not set, returns global tolerance
+	"""
+	if item_tolerance.get(item_code):
+		return item_tolerance[item_code], item_tolerance, global_tolerance
+	
+	tolerance = flt(webnotes.conn.get_value('Item',item_code,'tolerance') or 0)
+
+	if not tolerance:
+		if global_tolerance == None:
+			global_tolerance = flt(webnotes.conn.get_value('Global Defaults', None, 
+				'tolerance'))
+		tolerance = global_tolerance
+	
+	item_tolerance[item_code] = tolerance
+	return tolerance, item_tolerance, global_tolerance