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

 import org.springframework.cache.annotation.Cacheable;
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Controller;
 import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
 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.google.common.collect.Ordering;
 import com.google.gson.Gson;
 import com.google.gson.reflect.TypeToken;
 import com.spice.profitmandi.common.enumuration.SchemeType;
 import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
+import com.spice.profitmandi.common.model.CreatePendingOrderItem;
 import com.spice.profitmandi.common.model.CreatePendingOrderRequest;
 import com.spice.profitmandi.common.model.CustomRetailer;
 import com.spice.profitmandi.common.model.CustomerOrderDetail;
 import com.spice.profitmandi.common.model.ProfitMandiConstants;
 import com.spice.profitmandi.common.model.UserInfo;
 import com.spice.profitmandi.dao.entity.fofo.Customer;
 import com.spice.profitmandi.dao.entity.fofo.CustomerAddress;
 import com.spice.profitmandi.dao.entity.fofo.PendingOrder;
 import com.spice.profitmandi.dao.entity.fofo.PendingOrderItem;
 import com.spice.profitmandi.dao.entity.fofo.PincodePartner;
-import com.spice.profitmandi.dao.entity.inventory.ItemAvailabilityCache;
 import com.spice.profitmandi.dao.enumuration.dtr.OtpType;
 import com.spice.profitmandi.dao.model.AddCartRequest;
 import com.spice.profitmandi.dao.model.CartItem;
 import com.spice.profitmandi.dao.model.CartItemResponseModel;
 import com.spice.profitmandi.dao.model.CartResponse;
 import com.spice.profitmandi.dao.repository.fofo.PendingOrderService;
 import com.spice.profitmandi.dao.repository.fofo.PincodePartnerRepository;
 import com.spice.profitmandi.dao.repository.inventory.ItemAvailabilityCacheRepository;
 import com.spice.profitmandi.service.CustomerService;
 import com.spice.profitmandi.service.authentication.RoleManager;
+import com.spice.profitmandi.service.inventory.AvailabilityModel;
 import com.spice.profitmandi.service.inventory.FofoAvailabilityInfo;
 import com.spice.profitmandi.service.inventory.FofoCatalogResponse;
+import com.spice.profitmandi.service.inventory.InventoryService;
 import com.spice.profitmandi.service.inventory.SaholicInventoryService;
 import com.spice.profitmandi.service.scheme.SchemeService;
 import com.spice.profitmandi.service.user.RetailerService;
 import com.spice.profitmandi.web.processor.OtpProcessor;
 import com.spice.profitmandi.web.res.DealBrands;
 	private static final int DEFAULT_STORE = 171912487;
 	@Autowired
 	CustomerAddressRepository customerAddressRepository;
+	@Autowired
+	InventoryService inventoryService;
 	@Value("${python.api.host}")
 	private String host;
 	@Autowired
 	CustomerService customerService;
 	@Value("${python.api.port}")
 	private int port;
 	@Autowired
 	private SaholicInventoryService saholicInventoryService;
 	// This is now unused as we are not supporting multiple companies.
 	@Value("${gadgetCops.invoice.cc}")
 			throw new ProfitMandiBusinessException("", "", "Could not connect to host");
+		}
 		JSONObject solrResponseJSONObj = new JSONObject(response).getJSONObject("response");
 		JSONArray docs = solrResponseJSONObj.getJSONArray("docs");
 		final Ordering<Integer> rankOrdering = Ordering.explicit(webProducts);
-		dealResponse = getCatalogResponse(docs, false, userInfo.getRetailerId()).stream().sorted(new Comparator<FofoCatalogResponse>() {
+		dealResponse = getCatalogResponse(docs, false, userInfo.getRetailerId()).stream()
+				.sorted(new Comparator<FofoCatalogResponse>() {
-			@Override
+					@Override
-			public int compare(FofoCatalogResponse o1, FofoCatalogResponse o2) {
+					public int compare(FofoCatalogResponse o1, FofoCatalogResponse o2) {
-				return rankOrdering.compare(o1.getCatalogId(), o2.getCatalogId());
+						return rankOrdering.compare(o1.getCatalogId(), o2.getCatalogId());
-			}
+					}
-		}).collect(Collectors.toList());
+				}).collect(Collectors.toList());
 		webListing.setFofoCatalogResponses(dealResponse);
 		return responseSender.ok(webListing);
+	}
 	@RequestMapping(value = "/store/otp/generateOTP", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
 			return responseSender.ok(true);
 		} else {
 			return responseSender.ok(false);
+		}
+	}
 	@RequestMapping(value = "/store/resetPassword", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE)
-	public ResponseEntity<?> resetPassword(HttpServletRequest request, @RequestBody UserModel userModel) throws Exception {
+	public ResponseEntity<?> resetPassword(HttpServletRequest request, @RequestBody UserModel userModel)
+			throws Exception {
 		customerService.changePassword(userModel.getMobile(), userModel.getPassword());
 		return responseSender.ok(true);
+	}
 	@RequestMapping(value = "/store/register", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE)
 	public ResponseEntity<?> confirmOrder(HttpServletRequest request,
 			@RequestBody CreatePendingOrderRequest createPendingOrderRequest) throws Exception {
 		UserInfo userInfo = (UserInfo) request.getAttribute("userInfo");
 		Integer storeId = userInfo.getRetailerId();
 		createPendingOrderRequest.setFofoId(storeId);
+		List<CreatePendingOrderItem> pendingOrderItems = createPendingOrderRequest.getCreatePendingOrderItem();
+		List<CartItem> cartItems = new ArrayList<>();
+		pendingOrderItems.stream().forEach(x -> {
+			CartItem ci = new CartItem();
+			ci.setItemId(x.getItemId());
+			ci.setQuantity(x.getQuantity());
+			ci.setSellingPrice(x.getSellingPrice());
+			cartItems.add(ci);
+		});
+		CartResponse cr = this.validateCart(storeId, cartItems);
+		if (cr.getCartMessageChanged() > 0 || cr.getTotalAmount() != createPendingOrderRequest.getTotalAmount()) {
+			return responseSender.badRequest("Invalid request");
+		}
-		return responseSender.ok(this.pendingOrderService.createPendingOrder(createPendingOrderRequest));
+		return responseSender.ok(this.pendingOrderService.createPendingOrder(createPendingOrderRequest, cr));
+	}
 	@RequestMapping(value = "/store/address", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
 	@ApiImplicitParams({
 		if (pincodePartners.size() > 0) {
 			fofoId = pincodePartners.get(0).getFofoId();
+		}
 		return responseSender.ok(fofoStoreRepository.selectByRetailerId(fofoId).getCode());
+	}
 	@RequestMapping(value = "/store/order", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
 	public ResponseEntity<?> getOrderDetail(HttpServletRequest request, @RequestParam(value = "id") int id,
 			@RequestParam(name = "offset") int offset, @RequestParam(name = "limit") int limit)
 			throws ProfitMandiBusinessException {
 		List<CustomerOrderDetail> customerOrderDetails = new ArrayList<>();
 					customerOrderDetail.setId(poi.getOrderId());
 					customerOrderDetail.setItemId(poi.getItemId());
 					customerOrderDetail.setModelName(item.getModelName());
 					customerOrderDetail.setModelNumber(item.getModelNumber());
 					customerOrderDetail.setQuantity(poi.getQuantity());
-					customerOrderDetail.setStatus(poi.getStatus());
+					customerOrderDetail.setStatus(po.getStatus());
 					customerOrderDetail.setTotalPrice(poi.getSellingPrice());
 					customerOrderDetail.setPayMethod(po.getPayMethod());
 					customerOrderDetail.setCreatedTimeStamp(po.getCreateTimestamp());
 					customerOrderDetails.add(customerOrderDetail);
+				}
+		}
 		return responseSender.ok(customerOrderDetails);
+	}
 	@RequestMapping(value = "/store/listing", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
 	@Cacheable(value = "storelisting.all", cacheManager = "thirtyMinsTimeOutCacheManager")
 	public ResponseEntity<?> getStoresListing(HttpServletRequest request) throws Exception {
 		List<WebListing> webListings = webListingRepository.selectAllWebListing(Optional.of(true));
 		for (WebListing webListing : webListings) {
 			UserInfo userInfo = (UserInfo) request.getAttribute("userInfo");
 			Integer storeId = userInfo.getRetailerId();
 			List<Integer> webProducts = webProductListingRepository.selectAllByWebListingId(webListing.getId()).stream()
 					.filter(x -> x.getRank() > 0).map(x -> x.getEntityId()).collect(Collectors.toList());
 			RestClient rc = new RestClient();
 			Map<String, String> params = new HashMap<>();
 	@ApiImplicitParams({
 			@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header") })
 	@ApiOperation(value = "Get brand list and count for category")
 	public ResponseEntity<?> cart(HttpServletRequest request, @RequestBody AddCartRequest cartRequest)
 			throws Exception {
+		UserInfo userInfo = (UserInfo) request.getAttribute("userInfo");
+		Integer storeId = userInfo.getRetailerId();
+		ValidateCartResponse vc = new ValidateCartResponse(this.validateCart(storeId, cartRequest.getCartItems()),
+				"Success", "Items added to cart successfully");
+		return responseSender.ok(vc);
+	}
+	// Validate Cart for B2C Customers
+	private CartResponse validateCart(int storeId, List<CartItem> cartItems) throws Exception {
+		cartItems = cartItems.stream().filter(x -> x.getQuantity() > 0).collect(Collectors.toList());
+		List<Integer> itemIds = cartItems.stream().map(x -> x.getItemId()).collect(Collectors.toList());
+		Map<Integer, AvailabilityModel> inventoryItemAvailabilityMap = inventoryService.getStoreAndOurStock(storeId,
+				itemIds);
 		CartResponse cartResponse = new CartResponse();
 		List<CartItemResponseModel> cartItemResponseModels = new ArrayList<>();
 		cartResponse.setCartItems(cartItemResponseModels);
-		UserInfo userInfo = (UserInfo) request.getAttribute("userInfo");
-		Integer storeId = userInfo.getRetailerId();
-		List<Integer> itemIds = cartRequest.getCartItems().stream().map(x -> x.getItemId())
-				.collect(Collectors.toList());
 		Set<Integer> itemsIdsSet = new HashSet<>(itemIds);
 		logger.info("Store Id {}, Item Ids {}", storeId, itemsIdsSet);
-		List<CurrentInventorySnapshot> currentInventorySnapshot = currentInventorySnapshotRepository
-				.selectByFofoItemIds(storeId, itemsIdsSet);
-		Map<Integer, Integer> storeItemAvailabilityMap = currentInventorySnapshot.stream()
-				.filter(x -> x.getAvailability() > 0)
-				.collect(Collectors.toMap(x -> x.getItemId(), x -> x.getAvailability()));
 		Map<Integer, Item> itemsMap = itemRepository.selectByIds(itemsIdsSet).stream()
 				.collect(Collectors.toMap(x -> x.getId(), x -> x));
-		Map<Integer, TagListing> sdItemAvailabilityMap = tagListingRepository
+		Map<Integer, TagListing> tagListingMap = tagListingRepository
 				.selectByItemIdsAndTagIds(new HashSet<>(itemIds), new HashSet<>(Arrays.asList(4))).stream()
 				.collect(Collectors.toMap(x -> x.getItemId(), x -> x));
 		List<Integer> catalogIds = itemsMap.values().stream().map(x -> x.getCatalogItemId())
 				.collect(Collectors.toList());
 		Map<Integer, JSONObject> contentMap = commonSolrService.getContentByCatalogIds(catalogIds);
 		// cartResponse.getCartItems()
-		for (CartItem cartItem : cartRequest.getCartItems()) {
+		int cartMessageChanged = 0;
-			if (cartItem.getQuantity() == 0) {
+		int cartMessageOOS = 0;
-				continue;
+		int totalAmount = 0;
-			}
+		int totalQty = 0;
+		for (CartItem cartItem : cartItems) {
 			Item item = itemsMap.get(cartItem.getItemId());
-			TagListing tagListing = sdItemAvailabilityMap.get(cartItem.getItemId());
+			TagListing tagListing = tagListingMap.get(cartItem.getItemId());
+			Float cashback = schemeService.getItemSchemeCashBack().get(cartItem.getItemId());
+			cashback = cashback == null ? 0 : cashback;
+			float itemSellingPrice = tagListing.getMop() - cashback;
 			CartItemResponseModel cartItemResponseModel = new CartItemResponseModel();
+			cartItemResponseModel.setSellingPrice(cartItem.getSellingPrice());
+			if (itemSellingPrice != cartItem.getSellingPrice()) {
+				cartItemResponseModel.setSellingPrice(itemSellingPrice);
+				cartMessageChanged++;
+			}
 			int estimate = -2;
+			int qtyRequired = (int) cartItem.getQuantity();
-			if (storeItemAvailabilityMap.containsKey(cartItem.getItemId())) {
+			AvailabilityModel availabilityModel = inventoryItemAvailabilityMap.get(cartItem.getItemId());
+			cartItemResponseModel.setMaxQuantity(availabilityModel.getMaxAvailability());
-				if (storeItemAvailabilityMap.get(cartItem.getItemId()) >= cartItem.getQuantity()) {
+			if (availabilityModel.getStoreAvailability() >= qtyRequired) {
-					estimate = 0;
+				estimate = 0;
-				} else if (tagListing.isActive()) {
+			} else if (availabilityModel.getWarehouseAvailability() >= qtyRequired) {
-					estimate = 2;
+				estimate = 2;
-				} else {
+			} else if (availabilityModel.getStoreAvailability() > 0) {
-					estimate = -2;
+				estimate = 0;
+				qtyRequired = availabilityModel.getStoreAvailability();
-				}
+				cartMessageChanged++;
-			} else if (tagListing.isActive()) {
+			} else if (availabilityModel.getWarehouseAvailability() > 0) {
+				qtyRequired = availabilityModel.getWarehouseAvailability();
 				estimate = 2;
+				cartMessageChanged++;
 			} else {
-				estimate = -2;
+				qtyRequired = 0;
+				cartMessageOOS++;
+			}
+			cartItemResponseModel.setQuantity(qtyRequired);
 			if (estimate >= 0 && LocalTime.now().isAfter(CUTOFF_TIME)) {
 				estimate = estimate + 1;
+			}
+			totalQty += qtyRequired;
+			totalAmount += qtyRequired * itemSellingPrice;
 			cartItemResponseModel.setEstimate(estimate);
 			cartItemResponseModel.setTitle(item.getItemDescriptionNoColor());
 			cartItemResponseModel.setItemId(cartItem.getItemId());
 			cartItemResponseModel.setMinBuyQuantity(1);
-			cartItemResponseModel.setQuantity(cartItem.getQuantity());
+			cartItemResponseModel.setQuantity(qtyRequired);
 			cartItemResponseModel.setQuantityStep(1);
-			Float cashback = schemeService.getItemSchemeCashBack().get(cartItem.getItemId());
-			cashback = cashback == null ? 0 : cashback;
-			cartItemResponseModel.setSellingPrice(tagListing.getMop() - cashback);
+			cartItemResponseModel.setMaxQuantity(availabilityModel.getMaxAvailability());
-			cartItemResponseModel.setMaxQuantity(2);
 			cartItemResponseModel.setCatalogItemId(item.getCatalogItemId());
 			cartItemResponseModel.setImageUrl(contentMap.get(item.getCatalogItemId()).getString("imageUrl_s"));
 			cartItemResponseModel.setColor(item.getColor());
 			cartItemResponseModels.add(cartItemResponseModel);
+		}
+		cartResponse.setCartItems(cartItemResponseModels);
+		cartResponse.setCartMessageChanged(cartMessageChanged);
+		cartResponse.setCartMessageOOS(cartMessageOOS);
-		ValidateCartResponse vc = new ValidateCartResponse(cartResponse, "Success", "Items added to cart successfully");
+		int maxEstimate = cartItemResponseModels.stream().mapToInt(x -> x.getEstimate()).max().getAsInt();
+		cartResponse.setMaxEstimate(maxEstimate);
+		cartResponse.setTotalAmount(totalAmount);
-		return responseSender.ok(vc);
+		cartResponse.setTotalQty(totalQty);
-	}
+		return cartResponse;
-	private boolean validateCart(int storeId, List<CartItem> cartItems) {
-		return false;
+	}
 	private List<FofoCatalogResponse> getCatalogResponse(JSONArray docs, boolean hotDeal, int fofoId)
 			throws ProfitMandiBusinessException {
 		Map<Integer, Integer> ourItemAvailabilityMap = null;
+					}
+				}
+			}
 			if (fofoAvailabilityInfoMap.values().size() > 0) {
 				ffdr.setItems(fofoAvailabilityInfoMap.values().stream()
-							.sorted((x,y)->y.getAvailability()-x.getAvailability())
+						.sorted((x, y) -> y.getAvailability() - x.getAvailability()).collect(Collectors.toList()));
-							.collect(Collectors.toList()));
 				dealResponse.add(ffdr);
+			}
+		}
 		return dealResponse;
+	}
+	@GetMapping(value = "store/order-status/{pendingOrderId}")
+	public ResponseEntity<?> orderStatus(HttpServletRequest request, @PathVariable int pendingOrderId) throws Exception {
+		PendingOrder pendingOrder = pendingOrderRepository.selectById(pendingOrderId);
+		List<PendingOrderItem> pendingOrderItems = pendingOrderItemRepository.selectByOrderId(pendingOrder.getId());
+		List<Integer> catalogIds = new ArrayList<>();
+		for(PendingOrderItem pendingOrderItem: pendingOrderItems) {
+			Item item = itemRepository.selectById(pendingOrderItem.getItemId());
+			pendingOrderItem.setItemName(item.getItemDescription());
+			catalogIds.add(item.getCatalogItemId());
+		}
+		Map<Integer, JSONObject> contentMap = commonSolrService.getContentByCatalogIds(catalogIds);
+		for(PendingOrderItem pendingOrderItem: pendingOrderItems) {
+			Item item = itemRepository.selectById(pendingOrderItem.getItemId());
+			JSONObject jsonObj = contentMap.get(item.getCatalogItemId());
+			pendingOrderItem.setImgUrl(jsonObj.getString("imageUrl_s"));
+		}
+		pendingOrder.setPendingOrderItems(pendingOrderItems);
+		return responseSender.ok(pendingOrder);
+	}
 	@RequestMapping(value = "/store/addresses/{customerId}", method = RequestMethod.GET)
 	public ResponseEntity<?> getAll(HttpServletRequest request, @PathVariable int customerId) throws Throwable {
 		return responseSender.ok(customerAddressRepository.selectByCustomerId(customerId));
+	}

Subversion Repositories SmartDukaan

(root)/trunk/profitmandi-web/src/main/java/com/spice/profitmandi/web/controller/StoreController.java – Rev 26909 → 26923