Subversion Repositories SmartDukaan

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.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.json.JSONObject;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.core.io.InputStreamResource;

import org.springframework.http.HttpHeaders;

import org.springframework.http.HttpStatus;

import org.springframework.http.MediaType;

import org.springframework.http.ResponseEntity;

import org.springframework.stereotype.Controller;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.ui.Model;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.bind.annotation.RequestParam;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;

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.CustomRetailer;

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.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.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.FofoItemId;

import com.spice.profitmandi.dao.entity.fofo.FofoLineItem;

import com.spice.profitmandi.dao.entity.fofo.FofoLineItemSerialNumber;

import com.spice.profitmandi.dao.entity.fofo.FofoOrder;

import com.spice.profitmandi.dao.entity.fofo.InventoryItem;

import com.spice.profitmandi.dao.entity.fofo.InvoiceNumberGenerationSequence;

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.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;

import com.spice.profitmandi.dao.repository.fofo.CustomerAddressRepository;

import com.spice.profitmandi.dao.repository.fofo.CustomerRepository;

import com.spice.profitmandi.dao.repository.fofo.FofoLineItemRepository;

import com.spice.profitmandi.dao.repository.fofo.FofoLineItemSerialNumberRepository;

import com.spice.profitmandi.dao.repository.fofo.FofoOrderRepository;

import com.spice.profitmandi.dao.repository.fofo.InventoryItemRepository;

import com.spice.profitmandi.dao.repository.fofo.InvoiceNumberGenerationSequenceRepository;

import com.spice.profitmandi.dao.repository.fofo.PaymentOptionRepository;

import com.spice.profitmandi.dao.repository.fofo.ScanRecordRepository;

import com.spice.profitmandi.dao.repository.transaction.OrderRepository;

import com.spice.profitmandi.dao.repository.user.AddressRepository;

import com.spice.profitmandi.service.pricing.PricingService;

import com.spice.profitmandi.web.model.LoginDetails;

import com.spice.profitmandi.web.request.CreateOrderRequest;

import com.spice.profitmandi.web.request.CustomPaymentOption;

import com.spice.profitmandi.web.response.ItemIdQuantityAvailability;

import com.spice.profitmandi.web.response.Quantity;

import com.spice.profitmandi.web.util.CookiesProcessor;

import com.spice.profitmandi.web.util.MVCResponseSender;

import in.shop2020.model.v1.catalog.ItemType;

@Controller

@Transactional(rollbackFor=Throwable.class)

public class OrderController {

	private static final Logger LOGGER = LoggerFactory.getLogger(OrderController.class);

	@Autowired

	OrderRepository orderRepository;

	@Autowired

	InventoryItemRepository inventoryItemRepository;

	@Autowired

	CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

	@Autowired

	InvoiceNumberGenerationSequenceRepository invoiceNumberGenerationSequenceRepository;

	@Autowired

	CustomerRepository customerRepository;

	@Autowired

	AddressRepository addressRepository;

	@Autowired

	FofoLineItemSerialNumberRepository fofoLineItemSerialNumberRepository;

	@Autowired

	FofoLineItemRepository fofoLineItemRepository;

	@Autowired

	PaymentOptionRepository paymentOptionRepository;

	@Autowired

	ScanRecordRepository scanRecordRepository;

	@Autowired

	FofoOrderRepository fofoOrderRepository;

	@Autowired

	RetailerRepository retailerRepository;

	@Autowired

	UserRepository userRepository;

	@Autowired

	UserAccountRepository userAccountRepository;

	@Autowired

	RetailerRegisteredAddressRepository retailerRegisteredAddressRepository;

	@Autowired

	CustomerAddressRepository customerAddressRepository;

	@Autowired

	ItemRepository itemRepository;

	@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);

		} catch (ProfitMandiBusinessException e) {

			model.addAttribute("loginResponse", mvcResponseSender.createResponseString("RTLR_1009", false, "/login"));

			return "response";

		}

		JSONObject cartObject = new JSONObject(cartData);

		Iterator<?> keys = cartObject.keys();

		Set<Integer> itemIds = new HashSet<>();

		List<CartFofo> cartItems = new ArrayList<CartFofo>();

		while( keys.hasNext() ) {

			String key = (String)keys.next();

			if ( cartObject.get(key) instanceof JSONObject ) {

				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>();

		if (itemIds.size() > 0){

			List<Item> items = itemRepository.selectByIds(itemIds);

			for (Item i : items){

				itemMap.put(i.getId(), i);

			}

		}

		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);

		return "order-index";

	}

	private String getValidName(String name){

		return name!=null?name:"";

	}

	@RequestMapping(value = "/get-order", method = RequestMethod.GET)

	public String getOrder(HttpServletRequest request, @RequestParam(name = "orderId") int orderId, Model model) throws ProfitMandiBusinessException, Exception{

		LoginDetails fofoDetails;

		try {

			fofoDetails = cookiesProcessor.getCookiesObject(request);

		} catch (ProfitMandiBusinessException e) {

			model.addAttribute("loginResponse", mvcResponseSender.createResponseString("RTLR_1009", false, "/login"));

			return "response";

		}

		FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(fofoDetails.getFofoId(), orderId);

		List<FofoLineItem> fofoLineItems = fofoLineItemRepository.selectByOrderId(fofoOrder.getId());

		CustomerAddress customerAddress = customerAddressRepository.selectById(fofoOrder.getCustomerAddressId());

		List<PaymentOption> paymentOptions = paymentOptionRepository.selectByOrderId(fofoOrder.getId());

		model.addAttribute("fofoOrder", fofoOrder);

		model.addAttribute("fofoLineItems", fofoLineItems);

		model.addAttribute("customerBillingAddress", getBillingAddress(customerAddress));

		model.addAttribute("customerBillingAddressObj", customerAddress);

		model.addAttribute("paymentOptions", paymentOptions);

		return "order-details";

	}

	private String getBillingAddress(CustomerAddress customerAddress) {

		String address = "";

		if ((customerAddress.getLine1() != null) && (!customerAddress.getLine1().isEmpty())) {

			address = address + customerAddress.getLine1();

			address = address + ", ";

		}

		if ((customerAddress.getLine2() != null) && (!customerAddress.getLine2().isEmpty())) {

			address = address + customerAddress.getLine2();

			address = address + ", ";

		}

		if ((customerAddress.getLandmark() != null) && (!customerAddress.getLandmark().isEmpty())) {

			address = address + customerAddress.getLandmark();

			address = address + ", ";

		}

		if ((customerAddress.getCity() != null) && (!customerAddress.getCity().isEmpty())) {

			address = address + customerAddress.getCity();

			address = address + ", ";

		}

		if ((customerAddress.getState() != null) && (!customerAddress.getState().isEmpty())) {

			address = address + customerAddress.getState();

		}

		if ((customerAddress.getPinCode() != null) && (!customerAddress.getPinCode().isEmpty())) {

			address = address + "- " + customerAddress.getPinCode();

		}

		return address;

	}

	@RequestMapping(value = "/create-order", method = RequestMethod.POST)

	public String createOrder(HttpServletRequest request, @RequestBody CreateOrderRequest createOrderRequest, Model model)  throws Throwable{

		LOGGER.info("request at uri {} body {}", request.getRequestURI(), createOrderRequest);

		LoginDetails fofoDetails;

		try {

			fofoDetails = cookiesProcessor.getCookiesObject(request);

		} catch (ProfitMandiBusinessException e) {

			model.addAttribute("loginResponse", mvcResponseSender.createResponseString("RTLR_1009", false, "/login"));

			return "response";

		}

		Set<Integer> itemIds = new HashSet<>();

		Map<Integer, Integer> itemIdQuantity = new HashMap<>(); //this is for error

		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()){

				itemIdQuantity.put(customFofoLineItem.getItemId(), customFofoLineItem.getQuantity());

			}

			if(!(customFofoLineItem.getSellingPrice() > 0)){

				lineItemPrice.put(customFofoLineItem.getItemId(), customFofoLineItem.getSellingPrice());

			}else{

				totalAmount = totalAmount + customFofoLineItem.getSellingPrice() * customFofoLineItem.getQuantity();

			}

			customFofoLineItemMap.put(customFofoLineItem.getItemId(), customFofoLineItem);

		}

		if(!itemIdQuantity.isEmpty()){

			// if item quantity does not match with given serialnumbers size

			LOGGER.error("itemId's quantity should be equal to given serialnumber size {} ", itemIdQuantity);

			return "error";

		}

		try{

			this.validatePaymentOptionsAndTotalAmount(createOrderRequest.getPaymentOptions(), totalAmount);

		}catch(ProfitMandiBusinessException profitMandiBusinessException){

			LOGGER.error("Error occured while validating payment options : ", profitMandiBusinessException);

			return "error";

		}

		if(!lineItemPrice.isEmpty()){

			// given fofo line item price must be greater than zero

			LOGGER.error("requested itemId's selling price must greater than 0");

			return "error";

		}

		List<CurrentInventorySnapshot> currentInventorySnapshots = currentInventorySnapshotRepository.selectByFofoItemIds(fofoDetails.getFofoId(), itemIds);

		if(itemIds.size() != currentInventorySnapshots.size()){

			// error

		}

		List<ItemIdQuantityAvailability> itemIdQuantityAvailabilities = new ArrayList<>(); //this is for error

		LOGGER.info("currentInventorySnapshots "+currentInventorySnapshots);

		for(CurrentInventorySnapshot currentInventorySnapshot : currentInventorySnapshots){

			CustomFofoLineItem customFofoLineItem = customFofoLineItemMap.get(currentInventorySnapshot.getId().getItemId());

			LOGGER.info("customFofoLineItem "+customFofoLineItem);

			if(customFofoLineItem.getQuantity() > currentInventorySnapshot.getAvailability()){

				ItemIdQuantityAvailability itemIdQuantityAvailability = new ItemIdQuantityAvailability();

				itemIdQuantityAvailability.setItemId(customFofoLineItem.getItemId());

				Quantity quantity = new Quantity();

				quantity.setAvailable(currentInventorySnapshot.getAvailability());

				quantity.setRequested(customFofoLineItem.getQuantity());

				itemIdQuantityAvailability.setQuantity(quantity);

				itemIdQuantityAvailabilities.add(itemIdQuantityAvailability);

			}

		}

		if(!itemIdQuantityAvailabilities.isEmpty()){

			// itemIdQuantity request is not valid

			LOGGER.error("Requested quantities should not be greater than currently available quantities {}", itemIdQuantityAvailabilities);

			return "error";

		}

		//		Set<Integer> invalidItemIdSerialNumbers = new HashSet<>();

		//		Map<Integer, Set<String>> itemIdSerialNumbers = new HashMap<>();

		//		List<InventoryItem> inventoryItems = inventoryItemRepository.selectByFofoIdItemIds(fofoDetails.getFofoId(), itemIds); //change it

		//		

		//		Map<Integer, Float> itemIdPriceDropAmount = new HashMap<>();

		//		

		//		for(InventoryItem inventoryItem : inventoryItems){

		//			CustomFofoLineItem customFofoLineItem = customFofoLineItemMap.get(inventoryItem.getItemId());

		//			if(customFofoLineItem.getSerialNumbers().isEmpty()){

		//				if(!(inventoryItem.getSerialNumber() == null && inventoryItem.getSerialNumber().equals(""))){

		//					invalidItemIdSerialNumbers.add(inventoryItem.getItemId());

		//				}

		//			}

		//			if(!customFofoLineItem.getSerialNumbers().isEmpty()){

		//				if(!customFofoLineItem.getSerialNumbers().contains(inventoryItem.getSerialNumber())){

		//					if(!itemIdSerialNumbers.containsKey(customFofoLineItem.getItemId())){

		//						Set<String> serialNumbers = new HashSet<>();

		//						serialNumbers.add(inventoryItem.getSerialNumber());

		//						itemIdSerialNumbers.put(customFofoLineItem.getItemId(), serialNumbers);

		//					}else{

		//						itemIdSerialNumbers.get(customFofoLineItem.getItemId()).add(inventoryItem.getSerialNumber());

		//				}

		//			}

		//			itemIdPriceDropAmount.put(inventoryItem.getItemId(), inventoryItem.getUnitPrice() - inventoryItem.getPriceDropAmount());

		//		}

		Map<Integer, Item>  itemMap = new HashMap<Integer, Item>();

		List<Item> items = itemRepository.selectByIds(itemIds);

		for (Item i : items){

			itemMap.put(i.getId(), i);

		}

		Set<Integer> nonSerializedItemIds = new HashSet<>();

		Set<String> serialNumbers = new HashSet<>();

		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()){

					serialNumbers.add(s);

				}

			}

			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 ){

			List<InventoryItem> serializedInventoryItems = inventoryItemRepository.selectByFofoIdSerialNumbers(fofoDetails.getFofoId(), serialNumbers);

			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()));

					}

					else{

						ArrayList<InventoryItem> tmp = new ArrayList<InventoryItem>();

						tmp.add(it);

						serializedInventoryItemMap.put(it.getItemId(), tmp);

						ArrayList<Float> priceDropAmouts = new ArrayList<>();

						priceDropAmouts.add(it.getUnitPrice() - (it.getPriceDropAmount()==null?0:it.getPriceDropAmount()));

						itemIdPriceDropAmount.put(it.getItemId(), priceDropAmouts);

					}

				}

			}

		}

		if (nonSerializedItemIds.size() > 0){

			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);

					}

					else{

						ArrayList<InventoryItem> tmp = new ArrayList<InventoryItem>();

						tmp.add(it);

						nonSerializedInventoryItemMap.put(it.getItemId(), tmp);

					}

				}

			}

		}

		List<Integer> invalidItemIdSerialNumbers = new ArrayList<Integer>();

		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){

					invalidItemIdSerialNumbers.add(i.getId());

				}

			}

			else{

				if (customFofoLineItem == null || customFofoLineItem.getSerialNumbers().size() > 0 ){

					itemIdSerialNumbers.add(i.getId());

				}

			}

		}

		if(!invalidItemIdSerialNumbers.isEmpty()){

			LOGGER.error("Invalid itemId's serialNumbers {}", invalidItemIdSerialNumbers);

			// itemId's are serialized you are saying these are not serialized

			return "error";

		}

		if(!itemIdSerialNumbers.isEmpty()){

			LOGGER.error("Invalid itemId's serialNumbers {}", itemIdSerialNumbers);

			// itemId's are non serialized you are saying these are serialized

			return "error";

		}

		if(items.size() != itemIds.size()){

			LOGGER.error("Requested ItemIds not found in catalog");

			// invalid itemIds 

			return "error";

		}

		Map<Integer, List<InventoryItem>> inventoryItemsToBill = new HashMap<Integer,List<InventoryItem>>();

		Map<Integer, Integer> inventoryItemQuantityUsed = new HashMap<>(); //to keep track of inventoryitem quanity used for scan records insertion

		//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()){

					//not enough serial numbers

					System.out.println("not enough serial numbers");

					return "error";

				}

				List<InventoryItem> inventoryItemsSerializedserialized = serializedInventoryItemMap.get(i.getId());

				for (InventoryItem it : inventoryItemsSerializedserialized){

					it.setGoodQuantity(0);

					inventoryItemQuantityUsed.put(it.getId(), 1);

				}

				inventoryItemsToBill.put(i.getId(), inventoryItemsSerializedserialized);

			}

			else{

				List<InventoryItem> inventoryItemsNonSerialized = nonSerializedInventoryItemMap.get(i.getId());

				int quantityToBill = customFofoLineItem.getQuantity();

				int totalLeft = quantityToBill;

				List<InventoryItem> inventoryItemsNonSerializedUsed = new ArrayList<InventoryItem>();

				if (inventoryItemsNonSerialized!=null){

					for (InventoryItem it : inventoryItemsNonSerialized){

						if (totalLeft > 0){

							int toUse = Math.min(totalLeft, it.getGoodQuantity());

							inventoryItemQuantityUsed.put(it.getId(), toUse);

							it.setGoodQuantity(it.getGoodQuantity()  - toUse);

							totalLeft = totalLeft - toUse;

							inventoryItemsNonSerializedUsed.add(it);

						}

					}

				}

				if (totalLeft > 0){

					//not enough quanity for non-serialized

					System.out.println("not enough quanity for non-serialized");

					return "error";

				}

				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> itemIdPrinceMap = pricingService.getPrice(itemIds, fofoDetails.getFofoId());

		for(Map.Entry<Integer, Float> entry : itemIdPrinceMap.entrySet()){

			CustomFofoLineItem customFofoLineItem = customFofoLineItemMap.get(entry.getKey());

			if(customFofoLineItem.getSellingPrice() < entry.getValue()){

				invalidMopItemIdPriceMap.put(entry.getKey(), customFofoLineItem.getSellingPrice());

			}

		}

		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);

			invoiceNumberGenerationSequenceRepository.persist(invoiceNumberGenerationSequence);

		}catch(ProfitMandiBusinessException profitMandiBusinessException){

			invoiceNumberGenerationSequence = new InvoiceNumberGenerationSequence();

			invoiceNumberGenerationSequence.setFofoId(fofoDetails.getFofoId());

			invoiceNumberGenerationSequence.setPrefix("INVOICE");

			invoiceNumberGenerationSequence.setSequence(1);

			invoiceNumberGenerationSequenceRepository.persist(invoiceNumberGenerationSequence);

		}

		CustomCustomer customCustomer = createOrderRequest.getCustomer();

		if(!StringUtils.isValidEmailAddress(customCustomer.getEmailId())){

			LOGGER.error("invalid customer emailId {} ", customCustomer.getEmailId());

			return "error";

		}

		if(!StringUtils.isValidMobile(customCustomer.getMobileNumber())){

			LOGGER.error("invalid customer mobileNumber {} ", customCustomer.getMobileNumber());

			return "error";

		}

		Customer customer = null;

		try{

			customer = customerRepository.selectByMobileNumber(customCustomer.getMobileNumber());

		}catch(ProfitMandiBusinessException profitMandiBusinessException){

			LOGGER.error("Error : ", profitMandiBusinessException);

			customer = new Customer();

			customer.setName(customCustomer.getName());

			customer.setEmailId(customCustomer.getEmailId());

			customer.setMobileNumber(customCustomer.getMobileNumber());

			customerRepository.persist(customer);

		}

		//TODO:Check if createOrderRequest contains addressId

		CustomerAddress customerAddress = this.createCustomerAddress(customCustomer.getAddress());

		customerAddress.setCustomerId(customer.getId());

		customerAddressRepository.persist(customerAddress);

		FofoOrder fofoOrder = new FofoOrder();

		fofoOrder.setCustomerId(customer.getId());

		fofoOrder.setFofoId(fofoDetails.getFofoId());

		fofoOrder.setInvoiceNumber(invoiceNumberGenerationSequence.getPrefix() + invoiceNumberGenerationSequence.getSequence());

		fofoOrder.setTotalAmount(totalAmount);

		fofoOrder.setCustomerAddressId(customerAddress.getId());

		fofoOrderRepository.persist(fofoOrder);

		for(CustomPaymentOption customPaymentOption : createOrderRequest.getPaymentOptions()){

			PaymentOption paymentOption = new PaymentOption();

			paymentOption.setOrderId(fofoOrder.getId());

			paymentOption.setAmount(customPaymentOption.getAmount());

			paymentOption.setType(customPaymentOption.getType());

			paymentOptionRepository.persist(paymentOption);

		}

		Address retailerAddress = addressRepository.selectById(retailerRegisteredAddressRepository.selectAddressIdByRetailerId(fofoDetails.getFofoId()));

		Map<String, GstRate> gstRateMap = null;

		if(retailerAddress.getState().equals(customerAddress.getState())){

			gstRateMap = Utils.getGstRates(retailerAddress.getState());

		}else{

			LOGGER.info("inter gstRate = true");

			gstRateMap = Utils.getInterGstRates();

		}

		LOGGER.info("gstRateMap {}", gstRateMap);

		for(CustomFofoLineItem customFofoLineItem : createOrderRequest.getFofoLineItems()){

			FofoLineItem fofoLineItem = new FofoLineItem();

			fofoLineItem.setItemId(customFofoLineItem.getItemId());

			fofoLineItem.setQuantity(customFofoLineItem.getQuantity());

			fofoLineItem.setSellingPrice(customFofoLineItem.getSellingPrice());

			fofoLineItem.setOrderId(fofoOrder.getId());

			fofoLineItem.setDp(customFofoLineItem.getSellingPrice());

			Item item = itemMap.get(customFofoLineItem.getItemId());

			GstRate gstRate = gstRateMap.get(item.getHsnCode());

			fofoLineItem.setIgstRate(gstRate.getIgstRate());

			fofoLineItem.setCgstRate(gstRate.getCgstRate());

			fofoLineItem.setSgstRate(gstRate.getSgstRate());

			fofoLineItem.setHsnCode(gstRate.getHsnCode());

			List<Float> priceDropAmounts = itemIdPriceDropAmount.get(customFofoLineItem.getItemId());

			float cost = 0;

			if (priceDropAmounts!=null){

				for (Float pda : priceDropAmounts){

					cost = cost + pda;

				}

			}

			else{

				cost = customFofoLineItem.getSellingPrice()* customFofoLineItem.getQuantity();

			}

			fofoLineItem.setCost(cost);

			fofoLineItem.setBrand(item.getBrand());

			fofoLineItem.setModelName(item.getModelName());

			fofoLineItem.setModelNumber(item.getModelNumber());

			fofoLineItem.setColor(item.getColor());

			fofoLineItemRepository.persist(fofoLineItem);

			LOGGER.info("\n\n");

			if(!customFofoLineItem.getSerialNumbers().isEmpty()){

				for(String serialNumber : customFofoLineItem.getSerialNumbers()){

					FofoLineItemSerialNumber fofoLineItemSerialNumber = new FofoLineItemSerialNumber();

					fofoLineItemSerialNumber.setFofoLineItemId(fofoLineItem.getId());

					fofoLineItemSerialNumber.setSerialNumber(serialNumber);

					fofoLineItemSerialNumberRepository.persist(fofoLineItemSerialNumber);

				}

			}

			for(CurrentInventorySnapshot currentInventorySnapshot : currentInventorySnapshots){

				FofoItemId fofoItemId = new FofoItemId();

				fofoItemId.setFofoId(fofoDetails.getFofoId());

				fofoItemId.setItemId(fofoLineItem.getItemId());

				if(currentInventorySnapshot.getId().equals(fofoItemId)){

					currentInventorySnapshotRepository.updateAvailabilityByFofoItemId(fofoItemId, currentInventorySnapshot.getAvailability() - customFofoLineItem.getQuantity());

				}

			}

			List<InventoryItem> inventoryItems = inventoryItemsToBill.get(fofoLineItem.getItemId());

			for(InventoryItem inventoryItem : inventoryItems){

				inventoryItem.setLastScanType(ScanType.SALE);

				inventoryItemRepository.persist(inventoryItem);

				ScanRecord scanRecord = new ScanRecord();

				scanRecord.setInventoryItemId(inventoryItem.getId());

				scanRecord.setFofoId(fofoDetails.getFofoId());

				//correct this

				scanRecord.setQuantity(inventoryItemQuantityUsed.get(inventoryItem.getId()));

				scanRecord.setType(ScanType.SALE);

				scanRecordRepository.persist(scanRecord);

			}

		}

		return "redirect:/get-order/?orderId="+fofoOrder.getId();

	}

	private CustomerAddress createCustomerAddress(CustomAddress customAddress){

		CustomerAddress customerAddress = new CustomerAddress();

		customerAddress.setName(customAddress.getName());

		customerAddress.setLine1(customAddress.getLine1());

		customerAddress.setLine2(customAddress.getLine2());

		customerAddress.setLandmark(customAddress.getLandmark());

		customerAddress.setCity(customAddress.getCity());

		customerAddress.setPinCode(customAddress.getPinCode());

		customerAddress.setState(customAddress.getState());

		customerAddress.setCountry(customAddress.getCountry());

		customerAddress.setPhoneNumber(customAddress.getPhoneNumber());

		return customerAddress;

	}

	private CustomAddress createCustomAddress(Address address){

		CustomAddress customAddress = new CustomAddress();

		customAddress.setName(address.getName());

		customAddress.setLine1(address.getLine1());

		customAddress.setLine2(address.getLine2());

		customAddress.setLandmark(address.getLandmark());

		customAddress.setCity(address.getCity());

		customAddress.setPinCode(address.getPinCode());

		customAddress.setState(address.getState());

		customAddress.setCountry(address.getCountry());

		customAddress.setPhoneNumber(address.getPhoneNumber());

		return customAddress;

	}

	private CustomAddress createCustomAddress(CustomerAddress customerAddress){

		CustomAddress customAddress = new CustomAddress();

		customAddress.setName(customerAddress.getName());

		customAddress.setLine1(customerAddress.getLine1());

		customAddress.setLine2(customerAddress.getLine2());

		customAddress.setLandmark(customerAddress.getLandmark());

		customAddress.setCity(customerAddress.getCity());

		customAddress.setPinCode(customerAddress.getPinCode());

		customAddress.setState(customerAddress.getState());

		customAddress.setCountry(customerAddress.getCountry());

		customAddress.setPhoneNumber(customerAddress.getPhoneNumber());

		return customAddress;

	}

	private void validatePaymentOptionsAndTotalAmount(Set<CustomPaymentOption> customPaymentOptions, float totalAmount) throws ProfitMandiBusinessException

	{

		float calculatedAmount = 0;

		Set<String> paymentOptionTypes = new HashSet<>();

		for(CustomPaymentOption customPaymentOption : customPaymentOptions){

			if(paymentOptionTypes.contains(customPaymentOption.getType().name())){

				throw new ProfitMandiBusinessException(ProfitMandiConstants.PAYMENT_OPTION_TYPE, customPaymentOption.getType().name(), "");

			}else{

				paymentOptionTypes.add(customPaymentOption.getType().name());

				calculatedAmount = calculatedAmount + customPaymentOption.getAmount();

			}

		}

		if(calculatedAmount != totalAmount){

			throw new ProfitMandiBusinessException(ProfitMandiConstants.PAYMENT_OPTION_CALCULATED_AMOUNT, calculatedAmount, "");

		}

	}

	@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");

		Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());

		CustomCustomer customCustomer = new CustomCustomer();

		customCustomer.setName(customer.getName());

		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());

		Retailer retailer = retailerRepository.selectById(fofoDetails.getFofoId());

		User user = userRepository.selectById(userAccountRepository.selectUserIdByRetailerId(retailer.getId()));

		CustomRetailer customRetailer = new CustomRetailer();

		customRetailer.setBusinessName(retailer.getName());

		customRetailer.setMobileNumber(user.getMobileNumber());

		customRetailer.setTinNumber(retailer.getNumber());

		Address retailerAddress = addressRepository.selectById(retailerRegisteredAddressRepository.selectAddressIdByRetailerId(retailer.getId()));

		customRetailer.setAddress(this.createCustomAddress(retailerAddress));

		pdfModel.setRetailer(customRetailer);

		List<FofoLineItem> fofoLineItems = fofoLineItemRepository.selectByOrderId(fofoOrder.getId());

		Set<CustomFofoOrderItem> customerFofoOrderItems = new HashSet<>();

		for(FofoLineItem fofoLineItem : fofoLineItems){

			CustomFofoOrderItem customFofoOrderItem = new CustomFofoOrderItem();

			float totalTaxRate = fofoLineItem.getIgstRate() + fofoLineItem.getSgstRate() + fofoLineItem.getCgstRate();

			float taxableSellingPrice = fofoLineItem.getSellingPrice() / (1 + totalTaxRate / 100);

			customFofoOrderItem.setAmount(fofoLineItem.getQuantity() * taxableSellingPrice);

			customFofoOrderItem.setDescription(fofoLineItem.getBrand() + " " + fofoLineItem.getModelName() + " " + fofoLineItem.getModelNumber() + " " + fofoLineItem.getColor());

			customFofoOrderItem.setRate(taxableSellingPrice);

			customFofoOrderItem.setQuantity(fofoLineItem.getQuantity());

			float igstAmount = (customFofoOrderItem.getAmount() * fofoLineItem.getIgstRate()) / 100;

			float cgstAmount = (customFofoOrderItem.getAmount() * fofoLineItem.getCgstRate()) / 100;

			float sgstAmount = (customFofoOrderItem.getAmount() * fofoLineItem.getSgstRate()) / 100;

			customFofoOrderItem.setIgstRate(fofoLineItem.getIgstRate());

			customFofoOrderItem.setIgstAmount(igstAmount);

			customFofoOrderItem.setCgstRate(fofoLineItem.getCgstRate());

			customFofoOrderItem.setCgstAmount(cgstAmount);

			customFofoOrderItem.setSgstRate(fofoLineItem.getSgstRate());

			customFofoOrderItem.setSgstAmount(sgstAmount);

			customFofoOrderItem.setHsnCode(fofoLineItem.getHsnCode());

			customFofoOrderItem.setSerialNumbers(String.join(", ",this.toSerialNumbers(fofoLineItem.getFofoLineItemSerialNumbers())));

			customerFofoOrderItems.add(customFofoOrderItem);

		}

		pdfModel.setOrderItems(customerFofoOrderItems);

		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

		PdfUtils.generateAndWrite(pdfModel, byteArrayOutputStream);

		//final MediaType mediaType=MediaType.parseMediaType(profilePhotoModel.getContentType().getValue());

		LOGGER.info("Pdf Stream length {}", byteArrayOutputStream.toByteArray().length);

        final HttpHeaders headers=new HttpHeaders();

        headers.setContentType(MediaType.APPLICATION_PDF);

        headers.set("Content-disposition", "inline; filename=invoice-" + fofoOrder.getInvoiceNumber() + ".pdf");

        headers.setContentLength(byteArrayOutputStream.toByteArray().length);

        final InputStream inputStream=new ByteArrayInputStream(byteArrayOutputStream.toByteArray());

        final InputStreamResource inputStreamResource=new InputStreamResource(inputStream);

        return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);

	}

	private Set<String> toSerialNumbers(Set<FofoLineItemSerialNumber> fofoLineItemSerialNumbers){

		Set<String> serialNumbers = new HashSet<>(fofoLineItemSerialNumbers.size());

		for(FofoLineItemSerialNumber fofoLineItemSerialNumber : fofoLineItemSerialNumbers){

			serialNumbers.add(fofoLineItemSerialNumber.getSerialNumber());

		}

		return serialNumbers;

	}

}