WebSVN – SmartDukaan – Diff – /trunk/profitmandi-fofo/src/main/java/com/spice/profitmandi/web/controller/OrderController.java

 package com.spice.profitmandi.web.controller;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.InputStream;
-import java.lang.ProcessBuilder.Redirect;
+import java.time.DateTimeException;
+import java.time.LocalDate;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import com.spice.profitmandi.common.model.CartFofo;
 import com.spice.profitmandi.common.model.CustomAddress;
 import com.spice.profitmandi.common.model.CustomCustomer;
 import com.spice.profitmandi.common.model.CustomFofoLineItem;
 import com.spice.profitmandi.common.model.CustomFofoOrderItem;
+import com.spice.profitmandi.common.model.CustomInsurancePolicy;
 import com.spice.profitmandi.common.model.CustomRetailer;
+import com.spice.profitmandi.common.model.GadgetCopsInsuranceModel;
 import com.spice.profitmandi.common.model.GstRate;
 import com.spice.profitmandi.common.model.PdfModel;
 import com.spice.profitmandi.common.model.ProfitMandiConstants;
+import com.spice.profitmandi.common.model.SerialNumberDetail;
+import com.spice.profitmandi.common.util.InsuranceUtils;
 import com.spice.profitmandi.common.util.PdfUtils;
 import com.spice.profitmandi.common.util.StringUtils;
 import com.spice.profitmandi.common.util.Utils;
 import com.spice.profitmandi.dao.entity.catalog.Item;
+import com.spice.profitmandi.dao.entity.dtr.GadgetCopsInsuranceCalc;
+import com.spice.profitmandi.dao.entity.dtr.InsurancePolicy;
+import com.spice.profitmandi.dao.entity.dtr.InsuranceProvider;
+import com.spice.profitmandi.dao.entity.dtr.PolicyNumberGenerationSequence;
 import com.spice.profitmandi.dao.entity.dtr.Retailer;
 import com.spice.profitmandi.dao.entity.dtr.User;
 import com.spice.profitmandi.dao.entity.fofo.CurrentInventorySnapshot;
 import com.spice.profitmandi.dao.entity.fofo.Customer;
 import com.spice.profitmandi.dao.entity.fofo.CustomerAddress;
 import com.spice.profitmandi.dao.entity.fofo.PaymentOption;
 import com.spice.profitmandi.dao.entity.fofo.ScanRecord;
 import com.spice.profitmandi.dao.entity.user.Address;
 import com.spice.profitmandi.dao.enumuration.fofo.ScanType;
 import com.spice.profitmandi.dao.repository.catalog.ItemRepository;
+import com.spice.profitmandi.dao.repository.dtr.InsurancePolicyRepository;
+import com.spice.profitmandi.dao.repository.dtr.InsuranceProviderRepository;
+import com.spice.profitmandi.dao.repository.dtr.PolicyNumberGenerationSequenceRepository;
 import com.spice.profitmandi.dao.repository.dtr.RetailerRegisteredAddressRepository;
 import com.spice.profitmandi.dao.repository.dtr.RetailerRepository;
 import com.spice.profitmandi.dao.repository.dtr.UserAccountRepository;
 import com.spice.profitmandi.dao.repository.dtr.UserRepository;
 import com.spice.profitmandi.dao.repository.fofo.CurrentInventorySnapshotRepository;
 	@Autowired
 	CustomerAddressRepository customerAddressRepository;
 	@Autowired
 	ItemRepository itemRepository;
+	@Autowired
+	InsuranceProviderRepository insuranceProviderRepository;
+	@Autowired
+	InsurancePolicyRepository insurancePolicyRepository;
+	@Autowired
+	PolicyNumberGenerationSequenceRepository policyNumberGenerationSequenceRepository;
 	@Autowired
 	MVCResponseSender mvcResponseSender;
 	@Autowired
 	CookiesProcessor cookiesProcessor;
 	@Autowired
 	PricingService pricingService;
 	@RequestMapping(value = "/order")
 	public String orderIndex(HttpServletRequest request, @RequestParam(name = "cartData") String cartData, Model model) throws Exception{
 		try {
 			cookiesProcessor.getCookiesObject(request);
 				System.out.println(cartObject.get(key));
+			}
 			CartFofo cf = new CartFofo();
 			cf.setItemId(cartObject.getJSONObject(key).getInt("itemId"));
 			cf.setQuantity(cartObject.getJSONObject(key).getInt("quantity"));
 			if (cf.getQuantity() <= 0){
 				continue;
+			}
 			cartItems.add(cf);
 			itemIds.add(cartObject.getJSONObject(key).getInt("itemId"));
+		}
 		Map<Integer, Item>  itemMap = new HashMap<Integer, Item>();
+		Set<Float> prices = new HashSet<>();
+		Map<Float, GadgetCopsInsuranceCalc> insurancePriceMap = new HashMap<>();
+		Map<Integer, GadgetCopsInsuranceCalc> itemIdInsurancePrice = new HashMap<>();
 		if (itemIds.size() > 0){
 			List<Item> items = itemRepository.selectByIds(itemIds);
 			for (Item i : items){
 				itemMap.put(i.getId(), i);
+				prices.add(i.getSellingPrice());
+			}
+			try{
+				insurancePriceMap = pricingService.getInsurancePrices(prices, ProfitMandiConstants.GADGET_COPS);
+			}catch(ProfitMandiBusinessException profitMandiBusinessException){
+				LOGGER.error("Insurance Provider not found : ", profitMandiBusinessException);
+				return "error";
+			}
+			for(Item item : items){
+				itemIdInsurancePrice.put(item.getId(), insurancePriceMap.get(item.getSellingPrice()));
+			}
+		}
 		for (CartFofo cf : cartItems){
 			Item i = itemMap.get(cf.getItemId());
 			if (i == null){
 				continue;
+			}
 			cf.setDisplayName(getValidName(i.getBrand())+" "+getValidName(i.getModelName())+" "+getValidName(i.getModelNumber())+" "+getValidName(i.getColor()).replaceAll("\\s+", " "));
 			cf.setItemType(i.getType());
+		}
 		model.addAttribute("cartObj", cartItems);
+		model.addAttribute("itemIdInsurancePrice", itemIdInsurancePrice);
 		return "order-index";
+	}
 	private String getValidName(String name){
 		return name!=null?name:"";
 		Map<Integer, CustomFofoLineItem> customFofoLineItemMap = new HashMap<>();
 		Map<Integer, Float> lineItemPrice = new HashMap<>(); //this is for pricing error
 		float totalAmount = 0;
 		for(CustomFofoLineItem customFofoLineItem : createOrderRequest.getFofoLineItems()){
 			itemIds.add(customFofoLineItem.getItemId());
-			if(!customFofoLineItem.getSerialNumbers().isEmpty() && customFofoLineItem.getQuantity() != customFofoLineItem.getSerialNumbers().size()){
+			if(!customFofoLineItem.getSerialNumberDetails().isEmpty() && customFofoLineItem.getQuantity() != customFofoLineItem.getSerialNumberDetails().size()){
 				itemIdQuantity.put(customFofoLineItem.getItemId(), customFofoLineItem.getQuantity());
+			}
 			if(!(customFofoLineItem.getSellingPrice() > 0)){
 				lineItemPrice.put(customFofoLineItem.getItemId(), customFofoLineItem.getSellingPrice());
 			}else{
 				totalAmount = totalAmount + customFofoLineItem.getSellingPrice() * customFofoLineItem.getQuantity();
+				for(SerialNumberDetail serialNumberDetail : customFofoLineItem.getSerialNumberDetails()){
+					if(serialNumberDetail.isInsurance() && serialNumberDetail.getAmount() > 0){
+						totalAmount = totalAmount + serialNumberDetail.getAmount();
+					}
+				}
+			}
 			customFofoLineItemMap.put(customFofoLineItem.getItemId(), customFofoLineItem);
+		}
 		if(!itemIdQuantity.isEmpty()){
 			// if item quantity does not match with given serialnumbers size
 			itemMap.put(i.getId(), i);
+		}
 		Set<Integer> nonSerializedItemIds = new HashSet<>();
 		Set<String> serialNumbers = new HashSet<>();
+		Map<String, Float> insuranceSerialNumberItemPrice = new HashMap<>();
+		Map<String, Float> insuranceSerialNumberSaleAmount = new HashMap<>();
+		Map<String, String> serialNumberModelName = new HashMap<>();
+		Map<String, String> serialNumberBrand = new HashMap<>();
 		Collection<CustomFofoLineItem> lineItemsValues = customFofoLineItemMap.values();
 		for (CustomFofoLineItem cli : lineItemsValues){
 			Item item = itemMap.get(cli.getItemId());
 			if (item.getType().equals(ItemType.SERIALIZED)){
-				for (String s : cli.getSerialNumbers()){
+				for (SerialNumberDetail serialNumberDetail : cli.getSerialNumberDetails()){
+					serialNumbers.add(serialNumberDetail.getSerialNumber());
-					serialNumbers.add(s);
+					if(serialNumberDetail.isInsurance()){
+						insuranceSerialNumberItemPrice.put(serialNumberDetail.getSerialNumber(), cli.getSellingPrice());
+						insuranceSerialNumberSaleAmount.put(serialNumberDetail.getSerialNumber(), serialNumberDetail.getAmount());
+						serialNumberModelName.put(serialNumberDetail.getSerialNumber(), item.getModelName());
+						serialNumberBrand.put(serialNumberDetail.getSerialNumber(), item.getBrand());
+					}
+				}
+			}
 			else{
 				nonSerializedItemIds.add(cli.getItemId());
+			}
 		Map<Integer, List<InventoryItem>> serializedInventoryItemMap = new HashMap<Integer, List<InventoryItem>>();
 		Map<Integer, List<InventoryItem>> nonSerializedInventoryItemMap = new HashMap<Integer, List<InventoryItem>>();
 		Map<Integer, List<Float>> itemIdPriceDropAmount = new HashMap<>();
-		if (serialNumbers.size() > 0 ){
+		if (!serialNumbers.isEmpty()){
 			List<InventoryItem> serializedInventoryItems = inventoryItemRepository.selectByFofoIdSerialNumbers(fofoDetails.getFofoId(), serialNumbers);
+			LOGGER.info("serializedInventoryItems {}", serializedInventoryItems);
 			for (InventoryItem it : serializedInventoryItems){
 				if (it.getGoodQuantity() == 1){
 					if (serializedInventoryItemMap.containsKey(it.getItemId())){
 						serializedInventoryItemMap.get(it.getItemId()).add(it);
 						itemIdPriceDropAmount.get(it.getItemId()).add(it.getUnitPrice() - (it.getPriceDropAmount()==null?0:it.getPriceDropAmount()));
+					}
+				}
+			}
+		}
-		if (nonSerializedItemIds.size() > 0){
+		if (!nonSerializedItemIds.isEmpty()){
 			List<InventoryItem> nonSerializedInventoryItems = inventoryItemRepository.selectByFofoIdItemIds(fofoDetails.getFofoId(), nonSerializedItemIds);
 			for (InventoryItem it : nonSerializedInventoryItems){
 				if (it.getGoodQuantity() > 0){
 					if (nonSerializedInventoryItemMap.containsKey(it.getItemId())){
 						nonSerializedInventoryItemMap.get(it.getItemId()).add(it);
 		List<Integer> itemIdSerialNumbers = new ArrayList<Integer>();
 		for (Item i : items){
 			CustomFofoLineItem customFofoLineItem = customFofoLineItemMap.get(i.getId());
 			if (i.getType().equals(ItemType.SERIALIZED)){
-				if (customFofoLineItem ==null || customFofoLineItem.getSerialNumbers().size() ==0){
+				if (customFofoLineItem ==null || customFofoLineItem.getSerialNumberDetails().isEmpty()){
 					invalidItemIdSerialNumbers.add(i.getId());
+				}
+			}
 			else{
-				if (customFofoLineItem == null || customFofoLineItem.getSerialNumbers().size() > 0 ){
+				if (customFofoLineItem == null || !customFofoLineItem.getSerialNumberDetails().isEmpty()){
 					itemIdSerialNumbers.add(i.getId());
+				}
+			}
+		}
 		//Lets reduce quantity and decide what inventory items to use.
 		for (Item i : items){
 			CustomFofoLineItem customFofoLineItem = customFofoLineItemMap.get(i.getId());
 			if (i.getType().equals(ItemType.SERIALIZED)){
 				//TODO:handle null
-				if (serializedInventoryItemMap.get(i.getId()) == null || customFofoLineItem.getSerialNumbers().size() != serializedInventoryItemMap.get(i.getId()).size()){
+				if (serializedInventoryItemMap.get(i.getId()) == null || customFofoLineItem.getSerialNumberDetails().size() != serializedInventoryItemMap.get(i.getId()).size()){
 					//not enough serial numbers
+					LOGGER.info("serialNumbers {}", serialNumbers);
+					LOGGER.info("serializedInventoryItemMap {}", serializedInventoryItemMap);
+					LOGGER.info("itemId {}", i.getId());
-					System.out.println("not enough serial numbers");
+					LOGGER.error("not enough serial numbers");
 					return "error";
+				}
 				List<InventoryItem> inventoryItemsSerializedserialized = serializedInventoryItemMap.get(i.getId());
 				for (InventoryItem it : inventoryItemsSerializedserialized){
 					it.setGoodQuantity(0);
 				inventoryItemsToBill.put(i.getId(), inventoryItemsNonSerializedUsed);
+			}
+		}
 		// mop price validation
-		//TODO: Amit Gupta need to be commented out
-		/*Map<Integer, Float> invalidMopItemIdPriceMap = new HashMap<>();
+		Map<Integer, Float> invalidMopItemIdPriceMap = new HashMap<>();
-		Map<Integer, Float> itemIdPrinceMap = pricingService.getPrice(itemIds, fofoDetails.getFofoId());
+		Map<Integer, Float> itemIdPriceMap = pricingService.getPrices(itemIds, fofoDetails.getFofoId());
+		//LOGGER.info("itemIdPriceMap = {}", itemIdPriceMap);
-		for(Map.Entry<Integer, Float> entry : itemIdPrinceMap.entrySet()){
+		for(Map.Entry<Integer, Float> entry : itemIdPriceMap.entrySet()){
 			CustomFofoLineItem customFofoLineItem = customFofoLineItemMap.get(entry.getKey());
 			if(customFofoLineItem.getSellingPrice() < entry.getValue()){
 				invalidMopItemIdPriceMap.put(entry.getKey(), customFofoLineItem.getSellingPrice());
+			}
+		}
-		if(invalidMopItemIdPriceMap.isEmpty()){
+		if(!invalidMopItemIdPriceMap.isEmpty()){
 			LOGGER.error("Invalid itemIds mop prices should be greater than mop prices {}", invalidMopItemIdPriceMap);
 			return "error";
-		}*/
+		}
 		InvoiceNumberGenerationSequence invoiceNumberGenerationSequence = null;
 		try{
 			invoiceNumberGenerationSequence = invoiceNumberGenerationSequenceRepository.selectByFofoId(fofoDetails.getFofoId());
 			invoiceNumberGenerationSequence.setSequence(invoiceNumberGenerationSequence.getSequence() + 1);
 		if(!StringUtils.isValidMobile(customCustomer.getMobileNumber())){
 			LOGGER.error("invalid customer mobileNumber {} ", customCustomer.getMobileNumber());
 			return "error";
+		}
+		LocalDate dateOfBirth = null;
+		try{
+			dateOfBirth = StringUtils.toDate(customCustomer.getDateOfBirth());
+		}catch(DateTimeException dateTimeException){
+			LOGGER.error("Unable to parse dateOfBirth", dateTimeException);
+			return "error";
+		}
 		Customer customer = null;
 		try{
 			customer = customerRepository.selectByMobileNumber(customCustomer.getMobileNumber());
 		}catch(ProfitMandiBusinessException profitMandiBusinessException){
 			LOGGER.error("Error : ", profitMandiBusinessException);
 			customer = new Customer();
+			customer.setFirstName(customCustomer.getFirstName());
-			customer.setName(customCustomer.getName());
+			customer.setLastName(customCustomer.getLastName());
+			customer.setDateOfBirth(dateOfBirth);
 			customer.setEmailId(customCustomer.getEmailId());
 			customer.setMobileNumber(customCustomer.getMobileNumber());
 			customerRepository.persist(customer);
+		}
 		//TODO:Check if createOrderRequest contains addressId
 			fofoLineItem.setModelName(item.getModelName());
 			fofoLineItem.setModelNumber(item.getModelNumber());
 			fofoLineItem.setColor(item.getColor());
 			fofoLineItemRepository.persist(fofoLineItem);
 			LOGGER.info("\n\n");
-			if(!customFofoLineItem.getSerialNumbers().isEmpty()){
+			if(!customFofoLineItem.getSerialNumberDetails().isEmpty()){
-				for(String serialNumber : customFofoLineItem.getSerialNumbers()){
+				for(SerialNumberDetail serialNumberDetail : customFofoLineItem.getSerialNumberDetails()){
 					FofoLineItemSerialNumber fofoLineItemSerialNumber = new FofoLineItemSerialNumber();
 					fofoLineItemSerialNumber.setFofoLineItemId(fofoLineItem.getId());
-					fofoLineItemSerialNumber.setSerialNumber(serialNumber);
+					fofoLineItemSerialNumber.setSerialNumber(serialNumberDetail.getSerialNumber());
 					fofoLineItemSerialNumberRepository.persist(fofoLineItemSerialNumber);
+				}
+			}
 			for(CurrentInventorySnapshot currentInventorySnapshot : currentInventorySnapshots){
 				scanRecord.setQuantity(inventoryItemQuantityUsed.get(inventoryItem.getId()));
 				scanRecord.setType(ScanType.SALE);
 				scanRecordRepository.persist(scanRecord);
+			}
+		}
+		// insurance calculation is insurance flag is enabled
+		if(!insuranceSerialNumberItemPrice.isEmpty()){
+			Map<Float, GadgetCopsInsuranceCalc> insurancePricesMap = pricingService.getInsurancePrices(new HashSet<>(insuranceSerialNumberItemPrice.values()), ProfitMandiConstants.GADGET_COPS);
+			InsuranceProvider insuranceProvider = insuranceProviderRepository.selectByName(ProfitMandiConstants.GADGET_COPS);
+			Map<Float, Float> invalidInsurancePurchaseSaleAmount = new HashMap<>();
+			Map<Float, Float> invalidInsuranceSalePurchaseAmount = new HashMap<>();
+			for(Map.Entry<String, Float> entry : insuranceSerialNumberItemPrice.entrySet()){
+				if(insuranceSerialNumberSaleAmount.get(entry.getKey()) < insurancePricesMap.get(entry.getValue()).getDealerPrice()){
+					invalidInsurancePurchaseSaleAmount.put(insurancePricesMap.get(entry.getValue()).getDealerPrice(), insuranceSerialNumberSaleAmount.get(entry.getKey()));
+				}
+				if(insuranceSerialNumberSaleAmount.get(entry.getKey()) > insurancePricesMap.get(entry.getValue()).getSellingPrice()){
+					invalidInsuranceSalePurchaseAmount.put(insuranceSerialNumberSaleAmount.get(entry.getKey()), insurancePricesMap.get(entry.getValue()).getDealerPrice());
+				}
+			}
+			// insurance sale amount can not be lesser than insurance purchase amount
+			if(!invalidInsurancePurchaseSaleAmount.isEmpty()){
+				LOGGER.error("Invalid Insurance prices [{}], insurance sale amount can not be lesser than insurance purchase amount", invalidInsurancePurchaseSaleAmount);
+				return "error";
+			}
+			if(!invalidInsuranceSalePurchaseAmount.isEmpty()){
+				LOGGER.error("Invalid Insurance prices [{}], insurance sale amount can not be greater than than insurance max amount", invalidInsuranceSalePurchaseAmount);
+				return "error";
+			}
+			for(Map.Entry<String, Float> entry : insuranceSerialNumberItemPrice.entrySet()){
+				PolicyNumberGenerationSequence policyNumberGenerationSequence = null;
+				try{
+					policyNumberGenerationSequence = policyNumberGenerationSequenceRepository.select();
+					policyNumberGenerationSequence.setSequence(policyNumberGenerationSequence.getSequence() + 1);
+					policyNumberGenerationSequenceRepository.persist(policyNumberGenerationSequence);
+				}catch(ProfitMandiBusinessException profitMandiBusinessException){
+					policyNumberGenerationSequence = new PolicyNumberGenerationSequence();
+					policyNumberGenerationSequence.setSequence(1);
+					policyNumberGenerationSequenceRepository.persist(policyNumberGenerationSequence);
+				}
+				InsurancePolicy insurancePolicy = new InsurancePolicy();
+				insurancePolicy.setInvoiceNumber(invoiceNumberGenerationSequence.getPrefix() + invoiceNumberGenerationSequence.getSequence());
+				insurancePolicy.setRetailerId(fofoDetails.getFofoId());
+				insurancePolicy.setPurchaseAmount(insurancePricesMap.get(entry.getValue()).getDealerPrice());
+				insurancePolicy.setSaleAmount(insuranceSerialNumberSaleAmount.get(entry.getKey()));
+				insurancePolicy.setSellingPrice(entry.getValue());
+				insurancePolicy.setSerialNumber(entry.getKey());
+				insurancePolicy.setModelName(serialNumberModelName.get(entry.getKey()));
+				insurancePolicy.setBrand(serialNumberBrand.get(entry.getKey()));
+				insurancePolicy.setPolicyNumber(StringUtils.generatePolicyNumber(ProfitMandiConstants.POLICY_NUMBER_PREFIX, policyNumberGenerationSequence.getSequence()));
+				insurancePolicy.setProviderId(insuranceProvider.getId());
+				insurancePolicyRepository.persist(insurancePolicy);
+				GadgetCopsInsuranceModel gadgetCopsInsuranceModel = new GadgetCopsInsuranceModel();
+				gadgetCopsInsuranceModel.setBrand(serialNumberBrand.get(entry.getKey()));
+				gadgetCopsInsuranceModel.setModelName(serialNumberModelName.get(entry.getKey()));
+				gadgetCopsInsuranceModel.setSerialNumber(entry.getKey());
+				gadgetCopsInsuranceModel.setCustomerFirstName(customer.getFirstName());
+				gadgetCopsInsuranceModel.setCustomerLastName(customer.getLastName());
+				gadgetCopsInsuranceModel.setCustomerDateOfBirth(customer.getDateOfBirth());
+				gadgetCopsInsuranceModel.setCustomerMobileNumber(customer.getMobileNumber());
+				gadgetCopsInsuranceModel.setCustomerEmailId(customer.getEmailId());
+				gadgetCopsInsuranceModel.setCustomerAddress1(customerAddress.getLine1());
+				gadgetCopsInsuranceModel.setCustomerAddress2(customerAddress.getLine2());
+				gadgetCopsInsuranceModel.setCustomerCity(customerAddress.getCity());
+				gadgetCopsInsuranceModel.setCustomerPinCode(customerAddress.getPinCode());
+				gadgetCopsInsuranceModel.setCustomerState(customerAddress.getState());
+				gadgetCopsInsuranceModel.setPrice(insurancePolicy.getSellingPrice());
+				gadgetCopsInsuranceModel.setInvoiceNumber(insurancePolicy.getInvoiceNumber());
+				gadgetCopsInsuranceModel.setPolicyNumber(insurancePolicy.getPolicyNumber());
+				InsuranceUtils.submitToGadgetCops(gadgetCopsInsuranceModel);
+			}
+		}
 		return "redirect:/get-order/?orderId="+fofoOrder.getId();
+	}
 	private CustomerAddress createCustomerAddress(CustomAddress customAddress){
 		CustomerAddress customerAddress = new CustomerAddress();
 	@RequestMapping(value = "/generateInvoice")
 	public ResponseEntity<?> generateInvoice(HttpServletRequest request, HttpServletResponse response, @RequestParam(name = ProfitMandiConstants.ORDER_ID) int orderId) throws Throwable{
 		LOGGER.info("Request received at url {} with params [{}={}] ", request.getRequestURI(), ProfitMandiConstants.ORDER_ID, orderId);
 		LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);
 		FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(fofoDetails.getFofoId(), orderId);
 		PdfModel pdfModel = new PdfModel();
 		pdfModel.setAuther("profitmandi");
 		pdfModel.setTitle("Retailer Invoice");
+		// insurance calculation
+		float insuranceTotalAmount = 0;
+		List<InsurancePolicy> insurancePolicies = insurancePolicyRepository.selectByInvoiceNumber(fofoOrder.getInvoiceNumber());
+		Set<Integer> insuranceProviderIds = new HashSet<>(insurancePolicies.size());
+		for(InsurancePolicy insurancePolicy : insurancePolicies){
+			insuranceProviderIds.add(insurancePolicy.getProviderId());
+			insuranceTotalAmount = insuranceTotalAmount + insurancePolicy.getSaleAmount();
+		}
+		List<InsuranceProvider> insuranceProviders = insuranceProviderRepository.selectByIds(insuranceProviderIds);
+		Map<Integer, String> insuranceProviderIdNameMap = new HashMap<>(insuranceProviders.size());
+		for(InsuranceProvider insuranceProvider : insuranceProviders){
+			insuranceProviderIdNameMap.put(insuranceProvider.getId(), insuranceProvider.getName());
+		}
+		Set<CustomInsurancePolicy> customInsurancePolicies = new HashSet<>();
+		final float totalInsuranceTaxRate = 18;
+		for(InsurancePolicy insurancePolicy : insurancePolicies){
+			float taxableInsurancePrice = insurancePolicy.getSaleAmount() / (1 + totalInsuranceTaxRate / 100);
+			CustomInsurancePolicy customInsurancePolicy = new CustomInsurancePolicy();
+			customInsurancePolicy.setDescription(insuranceProviderIdNameMap.get(insurancePolicy.getProviderId()) + " Protection (" + insurancePolicy.getSerialNumber() + ")");
+			customInsurancePolicy.setHsnCode("");
+			customInsurancePolicy.setRate(taxableInsurancePrice);
+			customInsurancePolicy.setIgstRate(18);
+			customInsurancePolicy.setIgstAmount(taxableInsurancePrice * 18 /100);
+			customInsurancePolicy.setCgstRate(18);
+			customInsurancePolicy.setCgstAmount(taxableInsurancePrice * 9 /100);
+			customInsurancePolicy.setSgstRate(9);
+			customInsurancePolicy.setSgstAmount(taxableInsurancePrice * 9 /100);
+			customInsurancePolicies.add(customInsurancePolicy);
+		}
+		pdfModel.setInsurancePolicies(customInsurancePolicies);
 		Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());
 		CustomCustomer customCustomer = new CustomCustomer();
+		customCustomer.setFirstName(customer.getFirstName());
-		customCustomer.setName(customer.getName());
+		customCustomer.setLastName(customer.getLastName());
+		customCustomer.setDateOfBirth(StringUtils.toString(customer.getDateOfBirth()));
 		customCustomer.setEmailId(customer.getEmailId());
 		customCustomer.setMobileNumber(customer.getMobileNumber());
 		CustomerAddress customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());
 		customCustomer.setAddress(this.createCustomAddress(customerAddress));
 		pdfModel.setCustomer(customCustomer);
 		pdfModel.setInvoiceNumber(fofoOrder.getInvoiceNumber());
-		pdfModel.setTotalAmount(fofoOrder.getTotalAmount());
+		pdfModel.setTotalAmount(fofoOrder.getTotalAmount() + insuranceTotalAmount);
 		Retailer retailer = retailerRepository.selectById(fofoDetails.getFofoId());
 		User user = userRepository.selectById(userAccountRepository.selectUserIdByRetailerId(retailer.getId()));
 		CustomRetailer customRetailer = new CustomRetailer();
 		customRetailer.setBusinessName(retailer.getName());

Subversion Repositories SmartDukaan

(root)/trunk/profitmandi-fofo/src/main/java/com/spice/profitmandi/web/controller/OrderController.java – Rev 22189 → 22217