WebSVN – SmartDukaan – Diff – /trunk/profitmandi-dao/src/main/java/com/spice/profitmandi/service/order/OrderServiceImpl.java

 package com.spice.profitmandi.service.order;
+import java.io.IOException;
+import java.net.URISyntaxException;
 import java.time.DateTimeException;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.Random;
 import java.util.Set;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 import org.json.JSONObject;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
+import com.spice.profitmandi.common.ResponseCodeHolder;
 import com.spice.profitmandi.common.enumuration.SearchType;
 import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
 import com.spice.profitmandi.common.model.CartFofo;
 import com.spice.profitmandi.common.model.CreateOrderRequest;
 import com.spice.profitmandi.common.model.CustomAddress;
 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.Otp;
 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.FofoOrderItem;
 import com.spice.profitmandi.dao.entity.fofo.FofoOrderPaymentOption;
 import com.spice.profitmandi.dao.entity.fofo.FofoStore;
 import com.spice.profitmandi.dao.entity.fofo.InventoryItem;
 import com.spice.profitmandi.dao.entity.fofo.InvoiceNumberGenerationSequence;
+import com.spice.profitmandi.dao.entity.fofo.PrebookingListing;
+import com.spice.profitmandi.dao.entity.fofo.PrebookingOrder;
+import com.spice.profitmandi.dao.entity.fofo.PrebookingOrderItem;
 import com.spice.profitmandi.dao.entity.fofo.ScanRecord;
 import com.spice.profitmandi.dao.entity.user.Address;
 import com.spice.profitmandi.dao.entity.user.Counter;
 import com.spice.profitmandi.dao.entity.user.PrivateDealUser;
+import com.spice.profitmandi.dao.enumuration.dtr.OtpType;
 import com.spice.profitmandi.dao.enumuration.fofo.ScanType;
 import com.spice.profitmandi.dao.repository.catalog.ItemRepository;
 import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;
 import com.spice.profitmandi.dao.repository.dtr.InsurancePolicyRepository;
 import com.spice.profitmandi.dao.repository.dtr.InsuranceProviderRepository;
+import com.spice.profitmandi.dao.repository.dtr.OtpRepository;
 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.FofoOrderPaymentOptionRepository;
 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.PrebookingListingRepository;
+import com.spice.profitmandi.dao.repository.fofo.PrebookingOrderItemRepository;
+import com.spice.profitmandi.dao.repository.fofo.PrebookingOrderRepository;
 import com.spice.profitmandi.dao.repository.fofo.ScanRecordRepository;
 import com.spice.profitmandi.dao.repository.user.AddressRepository;
 import com.spice.profitmandi.dao.repository.user.CounterRepository;
 import com.spice.profitmandi.dao.repository.user.PrivateDealUserRepository;
+import com.spice.profitmandi.service.inventory.InventoryService;
 import com.spice.profitmandi.service.pricing.PricingService;
 import com.spice.profitmandi.service.scheme.SchemeService;
 import com.spice.profitmandi.service.wallet.WalletService;
 import in.shop2020.model.v1.catalog.ItemType;
 	@Autowired
 	private FofoOrderPaymentOptionRepository fofoOrderPaymentOptionRepository;
 	@Autowired
+	private PrebookingListingRepository prebookingListingRepository;
+	@Autowired
+	private PrebookingOrderRepository prebookingOrderRepository;
+	@Autowired
+	private PrebookingOrderItemRepository prebookingOrderItemRepository;
+	@Autowired
 	private SchemeService schemeService;
+	@Autowired
+	private InventoryService inventoryService;
+	@Autowired
+	private OtpRepository otpRepository;
 	@Override
 	public int createOrder(CreateOrderRequest createOrderRequest, int fofoId) throws ProfitMandiBusinessException {
 		CustomCustomer customCustomer = createOrderRequest.getCustomer();
 		Map<Integer, Integer> itemIdQuantity = new HashMap<>(); //this is for error
 		Map<Integer, CustomFofoOrderItem> itemIdCustomFofoOrderItemMap = new HashMap<>();
 		Map<Integer, Float> lineItemPrice = new HashMap<>(); //this is for pricing error
+		Map<Integer, Integer> prebookingOrderItemIdQuantityMap = new HashMap<>(); // for prebooking order adjustment
 		float totalAmount = 0;
 		for(CustomFofoOrderItem customFofoOrderItem : createOrderRequest.getFofoOrderItems()){
 			//itemIds.add(customFofoOrderItem.getItemId());
+			if(customFofoOrderItem.isPrebookingOrder()) {
+				prebookingOrderItemIdQuantityMap.put(customFofoOrderItem.getItemId(), customFofoOrderItem.getQuantity());
+			}
 			Set<String> serialNumbers = this.serialNumberDetailsToSerialNumbers(customFofoOrderItem.getSerialNumberDetails());
 			if(!serialNumbers.isEmpty() && customFofoOrderItem.getQuantity() != serialNumbers.size()){
 				itemIdQuantity.put(customFofoOrderItem.getItemId(), customFofoOrderItem.getQuantity());
+			}
 			if(!(customFofoOrderItem.getSellingPrice() > 0)){
 			LOGGER.error("itemId's quantity should be equal to given serialnumber size {} ", itemIdQuantity);
 			throw new ProfitMandiBusinessException("itemIdQuantity", itemIdQuantity, "FFORDR_1001");
 			//return "error";
+		}
+		List<PrebookingListing> prebookingListings = prebookingListingRepository.selectAllByItemIds(prebookingOrderItemIdQuantityMap.keySet());
+		Map<Integer, PrebookingListing> itemIdPrebookingListingMap = this.prebookingListingsToItemIdPrebookingListingMap(prebookingListings);
+		List<PrebookingOrder> prebookingOrders = prebookingOrderRepository.selectByFofoIdCustomerMobileNumberItemIds(fofoId, customCustomer.getMobileNumber(), prebookingOrderItemIdQuantityMap.keySet());
+		float prebookingOrdersTotalAmount = this.calculatePrebookingOrdersAmount(prebookingOrders, prebookingOrderItemIdQuantityMap, itemIdPrebookingListingMap);
-		this.validatePaymentOptionsAndTotalAmount(createOrderRequest.getPaymentOptions(), totalAmount);
+		this.validatePaymentOptionsAndTotalAmount(createOrderRequest.getPaymentOptions(), totalAmount - prebookingOrdersTotalAmount);
 		if(!lineItemPrice.isEmpty()){
 			// given fofo line item price must be greater than zero
 			LOGGER.error("requested itemId's selling price must greater than 0");
 			throw new ProfitMandiBusinessException(ProfitMandiConstants.PRICE, lineItemPrice, "FFORDR_1002");
 			// invalid itemIds
 			throw new ProfitMandiBusinessException("invalidItemIds", itemIdCustomFofoOrderItemMap.keySet(), "FFORDR_1003");
+		}
 		Map<Integer, Item>  itemMap = this.toItemMap(items);
 		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<>();
+			}
 			else{
 				nonSerializedItemIds.add(customFofoOrderItem.getItemId());
+			}
+		}
 		Map<Integer, Set<InventoryItem>> serializedInventoryItemMap = new HashMap<>();
 		Map<Integer, Set<InventoryItem>> nonSerializedInventoryItemMap = new HashMap<>();
 		//Map<String, Float> serialNumberItemPrice = new HashMap<>();
 		if (!serialNumbers.isEmpty()){
 			List<InventoryItem> serializedInventoryItems = inventoryItemRepository.selectByFofoIdSerialNumbers(fofoId, serialNumbers);
 			LOGGER.info("serializedInventoryItems {}", serializedInventoryItems);
 			for (InventoryItem inventoryItem : serializedInventoryItems){
 				if (inventoryItem.getGoodQuantity() == 1){
 					if (serializedInventoryItemMap.containsKey(inventoryItem.getItemId())){
 						serializedInventoryItemMap.get(inventoryItem.getItemId()).add(inventoryItem);
-					}
-					else{
+					}else{
 						Set<InventoryItem> itemIdInventoryItems = new HashSet<>();
 						itemIdInventoryItems.add(inventoryItem);
 						serializedInventoryItemMap.put(inventoryItem.getItemId(), itemIdInventoryItems);
+					}
+				}
+			}
+		}
 		if (!nonSerializedItemIds.isEmpty()){
 			List<InventoryItem> nonSerializedInventoryItems = inventoryItemRepository.selectByFofoIdItemIds(fofoId, nonSerializedItemIds);
 			LOGGER.info("nonSerializedInventoryItems {}", nonSerializedInventoryItems);
 			for (InventoryItem it : nonSerializedInventoryItems){
 				if (it.getGoodQuantity() > 0){
 		Customer customer = this.createAndGetCustomer(customCustomer);
 		CustomerAddress customerAddress = this.createCustomerAddress(customCustomer.getAddress(), customer.getId());
-		FofoOrder fofoOrder = this.createAndGetFofoOrder(customer.getId(), customCustomer.getGstNumber(), fofoId, invoiceNumberGenerationSequence, totalAmount, customerAddress.getId());
+		FofoOrder fofoOrder = this.createAndGetFofoOrder(customer.getId(), customCustomer.getGstNumber(), fofoId, invoiceNumberGenerationSequence, totalAmount - prebookingOrdersTotalAmount, customerAddress.getId());
 		this.createPaymentOptions(fofoOrder.getId(), createOrderRequest.getPaymentOptions());
+		this.processPrebookingOrders(fofoOrder.getId(), prebookingOrders, prebookingOrderItemIdQuantityMap, itemIdPrebookingListingMap);
 		int retailerAddressId = retailerRegisteredAddressRepository.selectAddressIdByRetailerId(fofoId);
 		Address retailerAddress = addressRepository.selectById(retailerAddressId);
 		Integer stateId = null;
 		schemeService.processSchemeOut(fofoOrder.getId(), fofoId);
 		return fofoOrder.getId();
+	}
+	private float calculatePrebookingOrdersAmount(List<PrebookingOrder> prebookingOrders, Map<Integer, Integer> prebookingOrderItemIdQuantityMap, Map<Integer, PrebookingListing> itemIdPrebookingListingMap) {
+		//List<PrebookingOrder> prebookingOrders = prebookingOrderRepository.selectByFofoIdCustomerMobileNumberItemIds(fofoId, customerMobileNumber, prebookingOrderItemIdQuantityMap.keySet());
+		float totalAmount = 0;
+		for(PrebookingOrder prebookingOrder : prebookingOrders) {
+			int requestedQuantity = prebookingOrderItemIdQuantityMap.get(prebookingOrder.getItemId());
+			PrebookingListing prebookingListing = itemIdPrebookingListingMap.get(prebookingOrder.getItemId());
+			if(requestedQuantity < prebookingOrder.getAvailableQuantity()) {
+				LOGGER.info("when requestedQuantity < then requestedQuantity [{}] * advanceAmount [{}]", requestedQuantity, prebookingListing.getAdvanceAmount());
+				totalAmount = totalAmount + (requestedQuantity * prebookingListing.getAdvanceAmount());
+			}else if(requestedQuantity >= prebookingOrder.getAvailableQuantity()) {
+				LOGGER.info("else requestedQuantity [{}] * advanceAmount [{}]", requestedQuantity, prebookingListing.getAdvanceAmount());
+				totalAmount = totalAmount + (prebookingOrder.getAvailableQuantity() * prebookingListing.getAdvanceAmount());
+			}
+		}
+		return totalAmount;
+	}
+	private void processPrebookingOrders(int orderId, List<PrebookingOrder> prebookingOrders, Map<Integer, Integer> prebookingOrderItemIdQuantityMap, Map<Integer, PrebookingListing> itemIdPrebookingListingMap) {
+		//Map<Integer, PrebookingOrder> prebookingOrderIdPrebookingOrderMap = this.prebookingOrdersToPrebookingOrderIdPrebookingOrderMap(prebookingOrders);
+		for(PrebookingOrder prebookingOrder : prebookingOrders) {
+			if(prebookingOrder.getCompleteTimestamp() == null) {
+				int requestedQuantity = prebookingOrderItemIdQuantityMap.get(prebookingOrder.getItemId());
+				PrebookingOrderItem prebookingOrderItem = new PrebookingOrderItem();
+				if(requestedQuantity < prebookingOrder.getAvailableQuantity()) {
+					prebookingOrder.setAvailableQuantity(prebookingOrder.getAvailableQuantity() - requestedQuantity);
+					prebookingOrderItem.setQuantity(requestedQuantity);
+				}else if(requestedQuantity >= prebookingOrder.getAvailableQuantity()) {
+					prebookingOrderItem.setQuantity(prebookingOrder.getAvailableQuantity());
+					prebookingOrder.setAvailableQuantity(0);
+				}
+				if(prebookingOrder.getAvailableQuantity() == 0) {
+					prebookingOrder.setCompleteTimestamp(LocalDateTime.now());
+				}
+				prebookingOrderRepository.persist(prebookingOrder);
+				prebookingOrderItem.setOrderId(orderId);
+				prebookingOrderItem.setItemId(prebookingOrder.getItemId());
+				PrebookingListing prebookingListing = itemIdPrebookingListingMap.get(prebookingOrder.getItemId());
+				prebookingOrderItem.setAdvanceAmount(prebookingListing.getAdvanceAmount());
+				prebookingOrderItemRepository.persist(prebookingOrderItem);
+			}
+		}
+	}
+	private Map<Integer, PrebookingListing> prebookingListingsToItemIdPrebookingListingMap(List<PrebookingListing> prebookingListings){
+		Map<Integer, PrebookingListing> itemIdPrebookingListingMap = new HashMap<>();
+		for(PrebookingListing prebookingListing : prebookingListings) {
+			itemIdPrebookingListingMap.put(prebookingListing.getItemId(), prebookingListing);
+		}
+		return itemIdPrebookingListingMap;
+	}
 	private Set<String> serialNumberDetailsToSerialNumbers(Set<SerialNumberDetail> serialNumberDetails){
 		Set<String> serialNumbers = new HashSet<>();
 		for(SerialNumberDetail serialNumberDetail : serialNumberDetails) {
 			if(serialNumberDetail.getSerialNumber() != null && !serialNumberDetail.getSerialNumber().isEmpty()) {
 				serialNumbers.add(serialNumberDetail.getSerialNumber());
 				fofoOrderItem.setIgstRate(itemIdIgstTaxRateMap.get(inventoryItem.getItemId()));
 			}else{
 				fofoOrderItem.setCgstRate(itemIdStateTaxRateMap.get(inventoryItem.getItemId()).getCgstRate());
 				fofoOrderItem.setSgstRate(itemIdStateTaxRateMap.get(inventoryItem.getItemId()).getSgstRate());
+			}
 			fofoOrderItem.setHsnCode(inventoryItem.getHsnCode());
 			break;
+		}
 		for(InventoryItem inventoryItem : inventoryItems){
 			if(inventoryItem.getSerialNumber() != null) {
 					quantity.setAvailable(currentInventorySnapshot.getAvailability());
 					quantity.setRequested(customFofoOrderItem.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);
 			throw new ProfitMandiBusinessException("itemIdQuantityAvailabilities", itemIdQuantityAvailabilities, "FFORDR_1015");
+		}
 				fofoOrderItemIdFofoLineItemsMap.get(fofoLineItem.getFofoOrderItemId()).add(fofoLineItem);
+			}
+		}
 		return fofoOrderItemIdFofoLineItemsMap;
+	}
+	private String getOtpString(){
+		Random rndm_method = new Random();
+		String numbers ="0123456789";
+		char[] otp = new char[5];
+		for (int i = 0; i < 5; i++){
+			otp[i] = numbers.charAt(rndm_method.nextInt(numbers.length()));
+		}
+		return String.valueOf(otp);
+	}
+	private void sendOtp(String otp_text, String phone, Map<Integer, Float> itemIdAdvanceAmount){
+		Map<Integer, String> itemIdDescriptionMap = inventoryService.getItemIdDescriptionMap(itemIdAdvanceAmount.keySet());
+		StringBuilder itemIdAdvanceAmountString = new StringBuilder();
+		int index = 0;
+		for(Map.Entry<Integer, Float> itemIdAdvanceAmountEntry : itemIdAdvanceAmount.entrySet()) {
+			itemIdAdvanceAmountString.append(itemIdDescriptionMap.get(itemIdAdvanceAmountEntry.getKey()));
+			itemIdAdvanceAmountString.append("'s Advance amount [");
+			itemIdAdvanceAmountString.append(itemIdAdvanceAmountEntry.getValue());
+			itemIdAdvanceAmountString.append("]");
+			if(index + 1 < itemIdAdvanceAmount.size()) {
+				itemIdAdvanceAmountString.append(", ");
+			}
+			index++;
+		}
+		String text = "Dear Customer, {0} is the OTP that you have requested for prebooking orders for items {1} Don't share your OTP with anyone.";
+		String msg = java.text.MessageFormat.format(text, otp_text, itemIdAdvanceAmountString);
+		try {
+			Utils.sendSms(msg, phone);
+		} catch (URISyntaxException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		} catch (IOException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+	}
+	@Override
+	public int generatePrebookingOrdersOtp(String customerEmailId, String customerMobileNumber, Map<Integer, Float> itemIdAdvanceAmount) throws ProfitMandiBusinessException {
+		if(!StringUtils.isValidEmailAddress(customerEmailId)){
+			LOGGER.error("invalid customer emailId {} ", customerEmailId);
+			throw new ProfitMandiBusinessException(ProfitMandiConstants.EMAIL_ID, customerEmailId, "VE_1016");
+		}
+		if(!StringUtils.isValidMobile(customerMobileNumber)){
+			LOGGER.error("invalid customer mobileNumber {} ", customerMobileNumber);
+			throw new ProfitMandiBusinessException(ProfitMandiConstants.MOBILE_NUMBER, customerMobileNumber, "VE_1071");
+		}
+		List<Otp> otps = otpRepository.selectAllByEmailWithTime(customerEmailId);
+		String otp = null;
+		if (otps.size() >= 5){
+			throw new ProfitMandiBusinessException(ProfitMandiConstants.CUSTOMER_EMAIL_ID, customerEmailId, "FFORDR_1019");
+		}
+		if (!otps.isEmpty()){
+			if (otps.get(0).getCreatedOn().isAfter(LocalDateTime.now().minusMinutes(2))){
+				return otps.get(0).getId();
+			}else if(otps.get(0).getCreatedOn().isAfter(LocalDateTime.now().minusMinutes(10))){
+				otp = otps.get(0).getOtp();
+			}
+		}
+		if (otp == null || otp.isEmpty()){
+			otp = getOtpString();
+		}
+		this.sendOtp(otp, customerMobileNumber, itemIdAdvanceAmount);
+		Otp otp_bean = new Otp();
+		otp_bean.setEmail(customerEmailId);
+		otp_bean.setMobile(customerMobileNumber);
+		otp_bean.setOtp(otp);
+		otp_bean.setOtpType(OtpType.PREBOOKING_ORDER);
+		otp_bean.setCreatedOn(LocalDateTime.now());
+		otp_bean.setExpiryTimestamp(LocalDateTime.now().plusMinutes(10));
+		otpRepository.persist(otp_bean);
+		return otp_bean.getId();
+	}
+	@Override
+	public String validateOtp(String customerEmailId, String customerMobileNumber, int otpId, String otpValue)
+			throws ProfitMandiBusinessException {
+		Otp otp = otpRepository.selectByIdEmailIdMobileNumber(otpId, customerEmailId, customerMobileNumber);
+		otp.setTryCount(otp.getTryCount() + 1);
+		if (!otp.getOtp().equalsIgnoreCase(otpValue)){
+			throw new ProfitMandiBusinessException("otpValue", otpValue, "FFORDR_1020");
+		}
+		if (otp.isExpired() || otp.isVerified() || otp.getExpiryTimestamp().isBefore(LocalDateTime.now())){
+			throw new ProfitMandiBusinessException("otpValue", otpValue, "FFORDR_1021");
+		}
+		if (otp.getTryCount() >5){
+			throw new ProfitMandiBusinessException("otpValue", otpValue, "FFORDR_1022");
+		}
+		otp.setExpired(true);
+		otp.setVerified(true);
+		otpRepository.persist(otp);
+		return ResponseCodeHolder.getMessage("FFORDR_OK_1002");
+	}
+}

Subversion Repositories SmartDukaan

(root)/trunk/profitmandi-dao/src/main/java/com/spice/profitmandi/service/order/OrderServiceImpl.java – Rev 23397 → 23418