[selling] [calculations] client side calculations, cleanup, patch fixes

controllers/selling_controller.py

@@ -16,7 +16,7 @@
 
 from __future__ import unicode_literals
 import webnotes
-from webnotes.utils import cint, flt
+from webnotes.utils import cint, flt, comma_or
 from setup.utils import get_company_currency
 from webnotes import msgprint, _
 import json
@@ -24,9 +24,73 @@ import json
 from controllers.stock_controller import StockController
 
 class SellingController(StockController):
+	def onload_post_render(self):
+		self.set_price_list_currency()
+
+		# contact, address, item details and pos details (if applicable)
+		self.set_missing_values()
+		
+		if self.meta.get_field("other_charges"):
+			self.set_taxes()
+			
 	def validate(self):
 		super(SellingController, self).validate()
+		# self.calculate_taxes_and_totals()
 		self.set_total_in_words()
+		self.set_missing_values(for_validate=True)
+		
+	def set_price_list_currency(self):
+		if self.doc.price_list_name and not self.doc.price_list_currency:
+			# TODO - change this, since price list now has only one currency allowed
+			from setup.utils import get_price_list_currency
+			self.doc.fields.update(get_price_list_currency(
+				{"price_list_name": self.doc.price_list_name, "use_for": "selling"}))
+		
+	def set_missing_values(self, for_validate=False):
+		# set contact and address details for customer, if they are not mentioned
+		if self.doc.customer and not (self.doc.contact_person and self.doc.customer_address):
+			for fieldname, val in self.get_default_address_and_contact("customer").items():
+				if not self.doc.fields.get(fieldname) and self.meta.get_field(fieldname):
+					self.doc.fields[fieldname] = val
+					
+		# set missing item values
+		from selling.utils import get_item_details
+		for item in self.doclist.get({"parentfield": "entries"}):
+			if item.fields.get("item_code"):
+				ret = get_item_details(item.fields)
+				for fieldname, value in ret.items():
+					if self.meta.get_field(fieldname, parentfield="entries") and \
+						not item.fields.get(fieldname):
+							item.fields[fieldname] = value
+							
+	def set_taxes(self):
+		if not self.doclist.get({"parentfield": "other_charges"}):
+			if not self.doc.charge:
+				# get the default tax master
+				self.doc.charge = webnotes.conn.get_value("Sales Taxes and Charges Master",
+					{"is_default": 1})
+			
+			if self.doc.charge:
+				from webnotes.model import default_fields
+				tax_master = webnotes.bean("Sales Taxes and Charges Master", self.doc.charge)
+				for i, tax in enumerate(tax_master.doclist.get({"parentfield": "other_charges"})):
+					for fieldname in default_fields:
+						tax.fields[fieldname] = None
+					
+					tax.fields.update({
+						"doctype": "Sales Taxes and Charges",
+						"parentfield": "other_charges",
+						"idx": i+1
+					})
+					
+					self.doclist.append(tax)
+					
+	def get_other_charges(self):
+		self.doclist = self.doc.clear_table(self.doclist, "other_charges")
+		self.set_taxes()
+		
+	def set_customer_defaults(self):
+		self.get_default_customer_address()
 		
 	def set_total_in_words(self):
 		from webnotes.utils import money_in_words
@@ -81,25 +145,19 @@ class SellingController(StockController):
 		
 		self.calculate_item_values()
 		self.initialize_taxes()
-		
-		self.determin_exclusive_rate()
-		
-		# TODO
-		# code: save net_total_export on client side
-		# print format: show net_total_export instead of net_total
-		
+		self.determine_exclusive_rate()
 		self.calculate_net_total()
 		self.calculate_taxes()
 		self.calculate_totals()
+		self.calculate_commission()
+		self.calculate_contribution()
 		# self.calculate_outstanding_amount()
-
-		# TODO
-		# allocated amount of sales person
-		# total commission
-
 		self._cleanup()
 		
-	def determin_exclusive_rate(self):
+		# TODO
+		# print format: show net_total_export instead of net_total
+		
+	def determine_exclusive_rate(self):
 		if not any((cint(tax.included_in_print_rate) for tax in self.tax_doclist)):
 			# no inclusive tax
 			return
@@ -108,15 +166,10 @@ class SellingController(StockController):
 			item_tax_map = self._load_item_tax_rate(item.item_tax_rate)
 			cumulated_tax_fraction = 0
 			for i, tax in enumerate(self.tax_doclist):
-				if cint(tax.included_in_print_rate):
-					tax.tax_fraction_for_current_item = \
-						self.get_current_tax_fraction(tax, item_tax_map)
-				else:
-					tax.tax_fraction_for_current_item = 0
-					
+				tax.tax_fraction_for_current_item = self.get_current_tax_fraction(tax, item_tax_map)
+				
 				if i==0:
-					tax.grand_total_fraction_for_current_item = 1 + \
-						tax.tax_fraction_for_current_item
+					tax.grand_total_fraction_for_current_item = 1 + tax.tax_fraction_for_current_item
 				else:
 					tax.grand_total_fraction_for_current_item = \
 						self.tax_doclist[i-1].grand_total_fraction_for_current_item \
@@ -130,8 +183,12 @@ class SellingController(StockController):
 				
 				item.amount = flt(item.basic_rate * item.qty, self.precision("amount", item))
 				
-				item.base_ref_rate = flt(item.basic_rate / (1 - (item.adj_rate / 100.0)),
-					self.precision("base_ref_rate", item))
+				if item.adj_rate == 100:
+					item.base_ref_rate = item.basic_rate
+					item.basic_rate = 0.0
+				else:
+					item.base_ref_rate = flt(item.basic_rate / (1 - (item.adj_rate / 100.0)),
+						self.precision("base_ref_rate", item))
 			
 	def get_current_tax_fraction(self, tax, item_tax_map):
 		"""
@@ -188,24 +245,23 @@ class SellingController(StockController):
 	def initialize_taxes(self):
 		for tax in self.tax_doclist:
 			tax.tax_amount = tax.total = 0.0
+			tax.item_wise_tax_detail = {}
+
 			# temporary fields
 			tax.tax_amount_for_current_item = tax.grand_total_for_current_item = 0.0
-			tax.item_wise_tax_detail = {}
+			
 			self.validate_on_previous_row(tax)
 			self.validate_inclusive_tax(tax)
 			self.round_floats_in(tax)
 			
 	def calculate_net_total(self):
-		self.doc.net_total = 0
-		self.doc.net_total_export = 0
+		self.doc.net_total = self.doc.net_total_export = 0.0
 
 		for item in self.item_doclist:
 			self.doc.net_total += item.amount
 			self.doc.net_total_export += item.export_amount
-			
-		self.doc.net_total = flt(self.doc.net_total, self.precision("net_total"))
-		self.doc.net_total_export = flt(self.doc.net_total_export,
-			self.precision("net_total_export"))
+		
+		self.round_floats_in(self.doc, ["net_total", "net_total_export"])
 		
 	def calculate_taxes(self):
 		for item in self.item_doclist:
@@ -218,8 +274,8 @@ class SellingController(StockController):
 				# 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 not (current_tax_amount or self.doc.net_total or tax.tax_amount) and \
-						tax.charge_type=="Actual":
+				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
 
@@ -228,7 +284,7 @@ class SellingController(StockController):
 				tax.tax_amount_for_current_item = current_tax_amount
 
 				# accumulate tax amount into tax.tax_amount
-				tax.tax_amount += tax.tax_amount_for_current_item
+				tax.tax_amount += current_tax_amount
 				
 				# Calculate tax.total viz. grand total till that step
 				# note: grand_total_for_current_item contains the contribution of 
@@ -245,8 +301,7 @@ class SellingController(StockController):
 				# in tax.total, accumulate grand total of each item
 				tax.total += tax.grand_total_for_current_item
 
-				# store tax_breakup for each item
-				# DOUBT: should valuation type amount also be stored?
+				# store tax breakup for each item
 				tax.item_wise_tax_detail[item.item_code] = current_tax_amount
 				
 	def calculate_totals(self):
@@ -254,12 +309,43 @@ class SellingController(StockController):
 			self.tax_doclist[-1].total or self.doc.net_total, self.precision("grand_total"))
 		self.doc.grand_total_export = flt(self.doc.grand_total / self.doc.conversion_rate, 
 			self.precision("grand_total_export"))
+			
+		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.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 calculate_commission(self):
+		if self.doc.commission_rate > 100:
+			msgprint(_(self.meta.get_label("commission_rate")) + " " + 
+				_("cannot be greater than 100"), raise_exception=True)
+		
+		self.doc.total_commission = flt(self.doc.net_total * self.doc.commission_rate / 100.0,
+			self.precision("total_commission"))
+
+	def calculate_contribution(self):
+		total = 0.0
+		sales_team = self.doclist.get({"parentfield": "sales_team"})
+		for sales_person in sales_team:
+			self.round_floats_in(sales_person)
+
+			sales_person.allocated_amount = flt(
+				self.doc.net_total * sales_person.allocated_percentage / 100.0,
+				self.precision("allocated_amount", sales_person))
+			
+			total += sales_person.allocated_percentage
+		
+		if sales_team and total != 100.0:
+			msgprint(_("Total") + " " + 
+				_(self.meta.get_label("allocated_percentage", parentfield="sales_team")) + 
+				" " + _("should be 100%"), raise_exception=True)
+	
 	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
 
 		if tax.charge_type == "Actual":
 			# distribute the tax amount proportionally to each item row
@@ -288,20 +374,18 @@ class SellingController(StockController):
 			msgprint((_("Row") + " # %(idx)s [%(taxes_doctype)s]: " + \
 				_("Please specify a valid") + " %(row_id_label)s") % {
 					"idx": tax.idx,
-					"taxes_doctype": tax.parenttype,
+					"taxes_doctype": tax.doctype,
 					"row_id_label": self.meta.get_label("row_id",
 						parentfield="other_charges")
 				}, raise_exception=True)
 				
 	def validate_inclusive_tax(self, tax):
-		def _on_previous_row_error(tax, row_range):
-			msgprint((_("Row") 
-				+ " # %(idx)s [%(taxes_doctype)s] [%(charge_type_label)s = \"%(charge_type)s\"]: " 
-				+ _("If:") + ' "%(inclusive_label)s" = ' + _("checked") + ", "
-				+ _("then it is required that:") + " [" + _("Row") + " # %(row_range)s] "
-				+ '"%(inclusive_label)s" = ' + _("checked")) % {
+		def _on_previous_row_error(row_range):
+			msgprint((_("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,
-					"taxes_doctype": tax.doctype,
+					"doctype": tax.doctype,
 					"inclusive_label": self.meta.get_label("included_in_print_rate",
 						parentfield="other_charges"),
 					"charge_type_label": self.meta.get_label("charge_type",
@@ -312,12 +396,12 @@ class SellingController(StockController):
 		
 		if cint(tax.included_in_print_rate):
 			if tax.charge_type == "Actual":
-				# inclusive cannot be of type Actual
+				# inclusive tax cannot be of type Actual
 				msgprint((_("Row") 
-					+ " # %(idx)s [%(taxes_doctype)s]: %(charge_type_label)s = \"%(charge_type)s\" " 
+					+ " # %(idx)s [%(doctype)s]: %(charge_type_label)s = \"%(charge_type)s\" " 
 					+ "cannot be included in Item's rate") % {
 						"idx": tax.idx,
-						"taxes_doctype": tax.doctype,
+						"doctype": tax.doctype,
 						"charge_type_label": self.meta.get_label("charge_type",
 							parentfield="other_charges"),
 						"charge_type": tax.charge_type,
@@ -325,16 +409,14 @@ class SellingController(StockController):
 			elif tax.charge_type == "On Previous Row Amount" and \
 					not cint(self.tax_doclist[tax.row_id - 1].included_in_print_rate):
 				# referred row should also be inclusive
-				_on_previous_row_error(tax, tax.row_id)
+				_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.idx - 1]]):
-				# all rows about this tax should be inclusive
-				_on_previous_row_error(tax, "1 - %d" % (tax.idx - 1,))
+					not all([cint(t.included_in_print_rate) for t in self.tax_doclist[:tax.row_id - 1]]):
+				# all rows about the reffered tax should be inclusive
+				_on_previous_row_error("1 - %d" % (tax.row_id,))
 				
 	def _load_item_tax_rate(self, item_tax_rate):
-		if not item_tax_rate:
-			return {}
-		return json.loads(item_tax_rate)
+		return json.loads(item_tax_rate) if item_tax_rate else {}
 		
 	def _get_tax_rate(self, tax, item_tax_map):
 		if item_tax_map.has_key(tax.account_head):
@@ -344,10 +426,9 @@ class SellingController(StockController):
 				
 	def _cleanup(self):
 		for tax in self.tax_doclist:
-			del tax.fields["grand_total_for_current_item"]
-			del tax.fields["tax_amount_for_current_item"]
-			
-			for fieldname in ("tax_fraction_for_current_item", 
+			for fieldname in ("grand_total_for_current_item",
+				"tax_amount_for_current_item",
+				"tax_fraction_for_current_item", 
 				"grand_total_fraction_for_current_item"):
 				if fieldname in tax.fields:
 					del tax.fields[fieldname]