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

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.InputStream;
 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 javax.transaction.Transactional;
+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.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.transaction.OrderRepositoryImpl;
 import com.spice.profitmandi.dao.repository.user.AddressRepository;
 import com.spice.profitmandi.web.model.FofoDetails;
 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.CookiesFetcher;
 import com.spice.profitmandi.web.util.MVCResponseSender;
+import in.shop2020.model.v1.catalog.ItemType;
 @Controller
-@Transactional(rollbackFor = Throwable.class)
+@Transactional
 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
 	CookiesFetcher cookiesFetcher;
+	@RequestMapping(value = "/order")
+	public String orderIndex(HttpServletRequest request, @RequestParam(name = "cartData") String cartData, Model model) throws Exception{
+		FofoDetails fofoDetails;
+		try {
+			fofoDetails = cookiesFetcher.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{
+		FofoDetails fofoDetails;
+		try {
+			fofoDetails = cookiesFetcher.getCookiesObject(request);
+		} catch (ProfitMandiBusinessException e) {
+			model.addAttribute("loginResponse", mvcResponseSender.createResponseString("RTLR_1009", false, "/login"));
+			return "response";
+		}
+		FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(fofoDetails.getFofoId(), orderId);
+		LOGGER.info(fofoOrder.toString());
+		LOGGER.info(fofoOrder.getCustomer().toString());
+		LOGGER.info(fofoOrder.getCustomer().getCustomerAddress().toString());
+		LOGGER.info(fofoOrder.getFofoLineItem().toString());
+		LOGGER.info(fofoOrder.getFofoLineItem().get(0).getFofoLineItemSerialNumbers().toString());
+		LOGGER.info(fofoOrder.getPaymentOption().toString());
+		return null;
+	}
-	@RequestMapping(value = "/order", method = RequestMethod.POST)
+	@RequestMapping(value = "/create-order", method = RequestMethod.POST)
-	public String createOrder(HttpServletRequest request, @RequestBody CreateOrderRequest createOrderRequest)  throws Throwable{
+	public String createOrder(HttpServletRequest request, @RequestBody CreateOrderRequest createOrderRequest, Model model)  throws Throwable{
 		//FofoDetails fofoDetails = cookiesFetcher.getCookiesObject(request);
 		LOGGER.info("/order request {}", createOrderRequest);
-		FofoDetails fofoDetails = new FofoDetails();
+		FofoDetails fofoDetails;
+		try {
-		fofoDetails.setFofoId(963490);
+			fofoDetails = cookiesFetcher.getCookiesObject(request);
-		return this.createOrder(createOrderRequest, fofoDetails);
+		} catch (ProfitMandiBusinessException e) {
+			model.addAttribute("loginResponse", mvcResponseSender.createResponseString("RTLR_1009", false, "/login"));
+			return "response";
-	}
+		}
-	private String createOrder(CreateOrderRequest createOrderRequest, FofoDetails fofoDetails) throws ProfitMandiBusinessException{
 		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;
 		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<>();
+		//		Set<Integer> invalidItemIdSerialNumbers = new HashSet<>();
-		Map<Integer, Set<String>> itemIdSerialNumbers = new HashMap<>();
+		//		Map<Integer, Set<String>> itemIdSerialNumbers = new HashMap<>();
-		List<InventoryItem> inventoryItems = inventoryItemRepository.selectByFofoIdItemIds(fofoDetails.getFofoId(), itemIds);
+		//		List<InventoryItem> inventoryItems = inventoryItemRepository.selectByFofoIdItemIds(fofoDetails.getFofoId(), itemIds); //change it
+		//
-		Map<Integer, Float> itemIdPriceDropAmount = new HashMap<>();
+		//		Map<Integer, Float> itemIdPriceDropAmount = new HashMap<>();
+		//
-		for(InventoryItem inventoryItem : inventoryItems){
+		//		for(InventoryItem inventoryItem : inventoryItems){
-			CustomFofoLineItem customFofoLineItem = customFofoLineItemMap.get(inventoryItem.getItemId());
+		//			CustomFofoLineItem customFofoLineItem = customFofoLineItemMap.get(inventoryItem.getItemId());
-			if(customFofoLineItem.getSerialNumbers().isEmpty()){
+		//			if(customFofoLineItem.getSerialNumbers().isEmpty()){
-				if(!(inventoryItem.getSerialNumber() == null && inventoryItem.getSerialNumber().equals(""))){
+		//				if(!(inventoryItem.getSerialNumber() == null && inventoryItem.getSerialNumber().equals(""))){
-					invalidItemIdSerialNumbers.add(inventoryItem.getItemId());
+		//					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{
-			if(!customFofoLineItem.getSerialNumbers().isEmpty()){
+				nonSerializedItemIds.add(cli.getItemId());
+			}
+		}
-				if(!customFofoLineItem.getSerialNumbers().contains(inventoryItem.getSerialNumber())){
+		Map<Integer, List<InventoryItem>> serializedInventoryItemMap = new HashMap<Integer, List<InventoryItem>>();
-					if(!itemIdSerialNumbers.containsKey(customFofoLineItem.getItemId())){
+		Map<Integer, List<InventoryItem>> nonSerializedInventoryItemMap = new HashMap<Integer, List<InventoryItem>>();
-						Set<String> serialNumbers = new HashSet<>();
+		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){
-						serialNumbers.add(inventoryItem.getSerialNumber());
+					if (serializedInventoryItemMap.containsKey(it.getItemId())){
-						itemIdSerialNumbers.put(customFofoLineItem.getItemId(), serialNumbers);
+						serializedInventoryItemMap.get(it.getItemId()).add(it);
+						itemIdPriceDropAmount.get(it.getItemId()).add(it.getUnitPrice() - (it.getPriceDropAmount()==null?0:it.getPriceDropAmount()));
+					}
-					}else{
+					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()));
-						itemIdSerialNumbers.get(customFofoLineItem.getItemId()).add(inventoryItem.getSerialNumber());
+						itemIdPriceDropAmount.put(it.getItemId(), priceDropAmouts);
+					}
+				}
+			}
-			itemIdPriceDropAmount.put(inventoryItem.getItemId(), inventoryItem.getUnitPrice() - inventoryItem.getPriceDropAmount());
+		}
+		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";
+		}
-		List<Item> items = itemRepository.selectByIds(itemIds);
 		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){
-		Map<Integer, Item> itemIdDetails = this.toItemMap(items);
+					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);
+			}
+		}
 		InvoiceNumberGenerationSequence invoiceNumberGenerationSequence = null;
 		try{
 			invoiceNumberGenerationSequence = invoiceNumberGenerationSequenceRepository.selectByFofoId(fofoDetails.getFofoId());
 			invoiceNumberGenerationSequence.setSequence(invoiceNumberGenerationSequence.getSequence() + 1);
 			invoiceNumberGenerationSequenceRepository.persist(invoiceNumberGenerationSequence);
 			invoiceNumberGenerationSequence = new InvoiceNumberGenerationSequence();
 			invoiceNumberGenerationSequence.setFofoId(fofoDetails.getFofoId());
 			invoiceNumberGenerationSequence.setPrefix("INVOICE");
 			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;
-		boolean foundCustomer = false;
-		if(customCustomer.getCustomerAddressId() > 0){
-			try{
+		try{
-				customer = customerRepository.selectById(customCustomer.getCustomerAddressId());
-			}catch(ProfitMandiBusinessException profitMandiBusinessException){
-				LOGGER.error("Error : ", profitMandiBusinessException);
-				foundCustomer = true;
+			//TODO:remove email id
-			}
-		}else{
-			try{
-				customer = customerRepository.selectByMobileNumber(customCustomer.getMobileNumber());
+			customer = customerRepository.selectByMobileNumber(customCustomer.getMobileNumber());
-			}catch(ProfitMandiBusinessException profitMandiBusinessException){
+		}catch(ProfitMandiBusinessException profitMandiBusinessException){
-				LOGGER.error("Error : ", profitMandiBusinessException);
+			LOGGER.error("Error : ", profitMandiBusinessException);
-				foundCustomer = true;
-			}
-		}
-		LOGGER.error("Error occured : {}", foundCustomer);
-		if(foundCustomer){
 			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);
-			/*InvoiceNumberGenerationSequence invoiceNumberGenerationSequence = */
+		/*InvoiceNumberGenerationSequence invoiceNumberGenerationSequence = */
 		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())){
-			LOGGER.info("inter gstRate = true");
-			gstRateMap = Utils.getInterGstRates();
-		}else{
-			gstRateMap = Utils.getGstRates(retailerAddress.getState());
+		Map<String, GstRate> gstRateMap = Utils.getGstRates(retailerAddress.getState());
-		}
-		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 = itemIdDetails.get(customFofoLineItem.getItemId());
+			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());
-			fofoLineItem.setCost(itemIdPriceDropAmount.get(customFofoLineItem.getItemId()));
+			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);
 					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){
-				if(inventoryItem.getItemId() == fofoLineItem.getItemId()){
-					if(inventoryItem.getSerialNumber() == null || inventoryItem.getSerialNumber().isEmpty()){
-						if(fofoLineItem.getQuantity() > 0)
-						if(fofoLineItem.getQuantity() <= inventoryItem.getGoodQuantity()){
-							inventoryItem.setGoodQuantity(inventoryItem.getGoodQuantity() - fofoLineItem.getQuantity());
-							inventoryItem.setLastScanType(ScanType.SALE);
+				inventoryItem.setLastScanType(ScanType.SALE);
-							inventoryItemRepository.persist(inventoryItem);
+				inventoryItemRepository.persist(inventoryItem);
-							ScanRecord scanRecord = new ScanRecord();
+				ScanRecord scanRecord = new ScanRecord();
-							scanRecord.setInventoryItemId(inventoryItem.getId());
+				scanRecord.setInventoryItemId(inventoryItem.getId());
-							scanRecord.setFofoId(fofoDetails.getFofoId());
+				scanRecord.setFofoId(fofoDetails.getFofoId());
-							scanRecord.setQuantity(fofoLineItem.getQuantity());
-							scanRecord.setType(ScanType.SALE);
-							scanRecordRepository.persist(scanRecord);
-						}else{
+				//correct this
-							int availableGoodQuantity = inventoryItem.getGoodQuantity();
-							inventoryItem.setGoodQuantity(0);
-							fofoLineItem.setQuantity(fofoLineItem.getQuantity() - availableGoodQuantity);
-							inventoryItem.setLastScanType(ScanType.SALE);
-							inventoryItemRepository.persist(inventoryItem);
-							ScanRecord scanRecord = new ScanRecord();
-							scanRecord.setInventoryItemId(inventoryItem.getId());
-							scanRecord.setFofoId(fofoDetails.getFofoId());
-							scanRecord.setQuantity(availableGoodQuantity);
-							scanRecord.setType(ScanType.SALE);
-							scanRecordRepository.persist(scanRecord);
-						}
-					}else{
-						inventoryItem.setGoodQuantity(0);
-						inventoryItem.setLastScanType(ScanType.SALE);
-						inventoryItemRepository.persist(inventoryItem);
-						ScanRecord scanRecord = new ScanRecord();
-						scanRecord.setInventoryItemId(inventoryItem.getId());
+				scanRecord.setQuantity(inventoryItemQuantityUsed.get(inventoryItem.getId()));
-						scanRecord.setFofoId(fofoDetails.getFofoId());
-						scanRecord.setQuantity(1);
-						scanRecord.setType(ScanType.SALE);
+				scanRecord.setType(ScanType.SALE);
-						scanRecordRepository.persist(scanRecord);
+				scanRecordRepository.persist(scanRecord);
-					}
-				}
+			}
-			}
+		}
 		return null;
+	}
 	private Map<Integer, Item> toItemMap(List<Item> items){
 		Map<Integer, Item> map = new HashMap<>();
 		for(Item item : items){
 			map.put(item.getId(), item);
+		}
 		return map;
+	}
 	/*private Address createAddress(CustomAddress customAddress){
 		Address address = new Address();
 		address.setName(customAddress.getName());
 		address.setLine1(customAddress.getLine1());
 		address.setLine2(customAddress.getLine2());
 		address.setCountry(customAddress.getCountry());
 		address.setPhoneNumber(customAddress.getPhoneNumber());
 		address.setEnabled(true);
 		return address;
 	}*/
 	private CustomerAddress createCustomerAddress(CustomAddress customAddress){
 		CustomerAddress customerAddress = new CustomerAddress();
 		customerAddress.setName(customAddress.getName());
 		customerAddress.setLine1(customAddress.getLine1());
 		customerAddress.setLine2(customAddress.getLine2());
 		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.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.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(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(), request.getParameterMap());
-		//FofoDetails fofoDetails = cookiesFetcher.getCookiesObject(request);
+		FofoDetails fofoDetails;
+		try {
-		FofoDetails fofoDetails = new FofoDetails();
+			fofoDetails = cookiesFetcher.getCookiesObject(request);
-		fofoDetails.setFofoId(963490);
+		} catch (ProfitMandiBusinessException e) {
+			return null;
+		}
 		FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(fofoDetails.getFofoId(), orderId);
 		PdfModel pdfModel = new PdfModel();
 		pdfModel.setAuther("profitmandi");
 		pdfModel.setTitle("Retailer Invoice");
 		Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());
 		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();
 			customFofoOrderItem.setAmount(fofoLineItem.getQuantity() * fofoLineItem.getSellingPrice());
 			customFofoOrderItem.setDescription(fofoLineItem.getBrand() + " " + fofoLineItem.getModelName() + " " + fofoLineItem.getModelNumber() + " " + fofoLineItem.getColor());
-			float totalTaxRate = fofoLineItem.getIgstRate() + fofoLineItem.getSgstRate() + fofoLineItem.getCgstRate();
-			float taxableAmount = customFofoOrderItem.getAmount() / (1 + (totalTaxRate / 100));
-			//float itemTotal = customFofoOrderItem.getAmount() + taxableAmount;
+			float itemTotal = customFofoOrderItem.getAmount();
-			//LOGGER.info("totalTaxRate ={}, taxableAmount ={}, itemTotal ={}", totalTaxRate, taxableAmount, itemTotal);
 			customFofoOrderItem.setRate(fofoLineItem.getSellingPrice());
 			customFofoOrderItem.setQuantity(fofoLineItem.getQuantity());
-			float igstAmount = (taxableAmount * fofoLineItem.getIgstRate()) / 100;
-			float cgstAmount = (taxableAmount * fofoLineItem.getCgstRate()) / 100;
-			float sgstAmount = (taxableAmount * fofoLineItem.getSgstRate()) / 100;
-			LOGGER.info("igst [{},{}], cgst [{},{}], sgst[{},{}]", fofoLineItem.getIgstRate(), igstAmount, fofoLineItem.getCgstRate(), cgstAmount, fofoLineItem.getSgstRate(), sgstAmount);
 			customFofoOrderItem.setIgstRate(fofoLineItem.getIgstRate());
-			customFofoOrderItem.setIgstAmount(igstAmount);
-			customFofoOrderItem.setCgstRate(fofoLineItem.getCgstRate());
+			customFofoOrderItem.setCgstRate(fofoLineItem.getIgstRate());
-			customFofoOrderItem.setCgstAmount(cgstAmount);
-			customFofoOrderItem.setSgstRate(fofoLineItem.getSgstRate());
+			customFofoOrderItem.setSgstRate(fofoLineItem.getIgstRate());
-			customFofoOrderItem.setSgstAmount(sgstAmount);
 			customFofoOrderItem.setHsnCode(fofoLineItem.getHsnCode());
-			customFofoOrderItem.setItemTotal(customFofoOrderItem.getAmount() + igstAmount + cgstAmount + sgstAmount);
+			customFofoOrderItem.setItemTotal(itemTotal);
 			customFofoOrderItem.setSerialNumbers(String.join(", ",this.toSerialNumbers(fofoLineItem.getFofoLineItemSerialNumbers())));
 			customerFofoOrderItems.add(customFofoOrderItem);
-			//pdfModel.setTotalAmount(pdfModel.getTotalAmount() + customFofoOrderItem.getItemTotal());
+		}
 		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();
+		final HttpHeaders headers=new HttpHeaders();
-        headers.setContentType(MediaType.APPLICATION_PDF);
+		headers.setContentType(MediaType.APPLICATION_PDF);
-        headers.set("Content-Disposition", "Order-"+orderId);
+		//headers.set("Content-Disposition", "Order-pdf-"+custom);
-        headers.setContentLength(byteArrayOutputStream.toByteArray().length);
+		headers.setContentLength(byteArrayOutputStream.toByteArray().length);
-        final InputStream inputStream=new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
+		final InputStream inputStream=new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
-        final InputStreamResource inputStreamResource=new InputStreamResource(inputStream);
+		final InputStreamResource inputStreamResource=new InputStreamResource(inputStream);
-        return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);
+		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;
+	}
+}

Subversion Repositories SmartDukaan

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