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

 import com.spice.profitmandi.dao.entity.auth.AuthUser;
 import com.spice.profitmandi.dao.entity.catalog.Category;
 import com.spice.profitmandi.dao.entity.catalog.FocusedModel;
 import com.spice.profitmandi.dao.entity.catalog.Item;
 import com.spice.profitmandi.dao.entity.catalog.TagListing;
-import com.spice.profitmandi.dao.entity.cs.Position;
 import com.spice.profitmandi.dao.entity.cs.Region;
 import com.spice.profitmandi.dao.entity.fofo.*;
-import com.spice.profitmandi.dao.entity.inventory.SaholicCIS;
+import com.spice.profitmandi.dao.entity.inventory.SaholicCISTable;
 import com.spice.profitmandi.dao.entity.inventory.SaholicPOItem;
 import com.spice.profitmandi.dao.entity.transaction.Order;
 import com.spice.profitmandi.dao.entity.transaction.UserWallet;
 import com.spice.profitmandi.dao.entity.user.User;
 import com.spice.profitmandi.dao.entity.warehouse.BrandRegionMapping;
 import com.spice.profitmandi.dao.repository.dtr.BrandLimitRepository;
 import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;
 import com.spice.profitmandi.dao.repository.dtr.Mongo;
 import com.spice.profitmandi.dao.repository.dtr.UserAccountRepository;
 import com.spice.profitmandi.dao.repository.fofo.*;
+import com.spice.profitmandi.dao.repository.inventory.SaholicCISTableRepository;
 import com.spice.profitmandi.dao.repository.inventory.SaholicInventoryCISRepository;
 import com.spice.profitmandi.dao.repository.inventory.WarehouseRepository;
 import com.spice.profitmandi.dao.repository.transaction.OrderRepository;
 import com.spice.profitmandi.dao.repository.transaction.UserWalletRepository;
 import com.spice.profitmandi.dao.repository.user.UserRepository;
 	@Autowired
 	private PartnerDailyInvestmentRepository partnerDailyInvestmentRepository;
 	@Autowired
 	private SuggestedPoDetailRepository suggestedPoDetailRepository;
+	@Autowired
+	SaholicCISTableRepository saholicCISTableRepository;
 	@RequestMapping(value = "/open-indent/save", method = RequestMethod.POST)
 	public String saveOpenIndent(HttpServletRequest request, Model model, @RequestParam int catalogId,
-			@RequestParam int itemQty, @RequestParam int fofoId) throws Exception {
+								 @RequestParam int itemQty, @RequestParam int fofoId) throws Exception {
 		if (fofoId == 0) {
 			LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
 			fofoId = loginDetails.getFofoId();
 		model.addAttribute("response", mvcResponseSender.createResponseString(false));
 		return "response";
+	}
 	private void saveMonthlyPlanned(MonthlyPlanned monthlyPlanned, int fofoId, LocalDate currentMonthDate,
-			int catalogId, int itemQty) {
+									int catalogId, int itemQty) {
 		if (monthlyPlanned == null) {
 			monthlyPlanned = new MonthlyPlanned();
 			monthlyPlanned.setFofoId(fofoId);
 			monthlyPlanned.setYearMonth(currentMonthDate);
 			monthlyPlannedRepository.persist(monthlyPlanned);
+	}
 	@RequestMapping(value = "/open-indent/confirm", method = RequestMethod.POST)
 	public String confirmOpenIndent(HttpServletRequest request,
-			@RequestParam(required = false, defaultValue = "0") int fofoId, Model model) throws Exception {
+									@RequestParam(required = false, defaultValue = "0") int fofoId, Model model) throws Exception {
 		if (fofoId == 0) {
 			LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
 			fofoId = loginDetails.getFofoId();
+		}
 				Arrays.asList("Partner Id", "Partner Name", "Model Name", "Qty"),
 				plannedModel.stream()
 						.map(x -> Arrays.asList(x.getFofoId(), x.getStoreName(), x.getItemDescription(), x.getQty()))
 						.collect(Collectors.toList()));
 		LOGGER.info("baos" + baos);
-		Utils.sendMailWithAttachments(googleMailSender, new String[] { customRetailer.getEmail() },
+		Utils.sendMailWithAttachments(googleMailSender, new String[]{customRetailer.getEmail()},
 				ccemails.toArray(new String[ccemails.size()]), bccemails.toArray(new String[bccemails.size()]),
 				"Planned Indent", "PFA",
-				new Attachment[] { new Attachment("PlannedIndent.csv", new ByteArrayResource(baos.toByteArray())), });
+				new Attachment[]{new Attachment("PlannedIndent.csv", new ByteArrayResource(baos.toByteArray())),});
+	}
 	@RequestMapping(value = "/indent/download", method = RequestMethod.GET)
 	public ResponseEntity<ByteArrayResource> downloadIndent(HttpServletRequest request, Model model,
-			@RequestParam(required = false, defaultValue = "0") int fofoId,
+															@RequestParam(required = false, defaultValue = "0") int fofoId,
-			@RequestParam(defaultValue = "TEN_LAC") CounterSize counterSize) throws Exception {
+															@RequestParam(defaultValue = "TEN_LAC") CounterSize counterSize) throws Exception {
 		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
 		Set<Integer> roleIds = loginDetails.getRoleIds();
 		LOGGER.info("Counter size is {}", counterSize);
 		LOGGER.info("Fofo Id is {}", fofoId);
+	}
 	@RequestMapping(value = "/itemsByCatalogId")
 	public String getItemsByCatalogId(HttpServletRequest request, Model model,
-			@RequestParam(required = false) int catalogId, @RequestParam(required = false) int itemId)
+									  @RequestParam(required = false) int catalogId, @RequestParam(required = false) int itemId)
 			throws ProfitMandiBusinessException {
 		if (catalogId == 0) {
 			catalogId = itemRepository.selectById(itemId).getCatalogItemId();
+		}
 		List<Item> items = itemRepository.selectAllByCatalogItemId(catalogId);
+	}
 	@RequestMapping(value = "/hotdealsitemsByCatalogId")
 	public String getHotdealsitemsByCatalogId(HttpServletRequest request, Model model,
-			@RequestParam(required = false) int catalogId, @RequestParam(required = false) int itemId)
+											  @RequestParam(required = false) int catalogId, @RequestParam(required = false) int itemId)
 			throws ProfitMandiBusinessException {
 		if (catalogId == 0) {
 			catalogId = itemRepository.selectById(itemId).getCatalogItemId();
+		}
 		List<Item> items = itemRepository.selectAllByCatalogItemId(catalogId);
 		model.addAttribute("response", response.toString());
 		return "response";
+	}
+	private List<Order> filterValidOrders(List<Order> lastOrdersList) {
+		int orderRemovedCount = 0;
+		Iterator<Order> orderIterator = lastOrdersList.iterator();
+		while (orderIterator.hasNext()) {
+			Order o = orderIterator.next();
+			if (o.getInvoiceNumber() != null) {
+				try {
+					purchaseRepository.selectByPurchaseReferenceAndFofoId(o.getInvoiceNumber(), o.getRetailerId());
+					orderIterator.remove();
+					orderRemovedCount++;
+				} catch (Exception e) {
+				}
+			}
+		}
+		LOGGER.info("Order removed count is {}", orderRemovedCount);
+		return lastOrdersList;
+	}
+	@RequestMapping(value = "/indent/confirm-pause", method = RequestMethod.POST)
+	public String raisePO(HttpServletRequest request, Model model, @RequestBody String jsonArrayString)
+			throws Exception {
+		JSONArray jsonArray = new JSONArray(jsonArrayString);
+		for (int i = 0; i < jsonArray.length(); i++) {
+			JSONObject obj = jsonArray.getJSONObject(i);
+			TagListing tl = tagListingRepository.selectByItemId(obj.getInt("id"));
+			if (tl == null) {
+				continue;
+			} else {
+				tl.setActive(obj.getBoolean("active"));
+				tagListingRepository.persist(tl);
+			}
+		}
+		model.addAttribute("response", true);
+		return "response";
+	}
+	@RequestMapping(value = "/indent/confirm-hotdeals-pause", method = RequestMethod.POST)
+	public String hotdealUpdate(HttpServletRequest request, Model model, @RequestBody String jsonArrayString)
+			throws Exception {
+		JSONArray jsonArray = new JSONArray(jsonArrayString);
+		for (int i = 0; i < jsonArray.length(); i++) {
+			JSONObject obj = jsonArray.getJSONObject(i);
+			TagListing tl = tagListingRepository.selectByItemId(obj.getInt("id"));
+			if (tl == null) {
+				continue;
+			} else {
+				tl.setHotDeals(obj.getBoolean("hotDeals"));
+				tagListingRepository.persist(tl);
+			}
+		}
+		model.addAttribute("response", true);
+		return "response";
+	}
+	@RequestMapping(value = "/indent/create-po", method = RequestMethod.POST)
+	public String raisePO(HttpServletRequest request, Model model) throws Exception {
+		boolean success = false;
+		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
+		int fofoId = loginDetails.getFofoId();
+		List<ItemPriceQuantity> itemQuantities = this.getItemQuantities(fofoId);
+		CustomRetailer customRetailer = retailerService.getFofoRetailer(fofoId);
+		Client userClient = new UserClient().getClient();
+		double totalAmount = itemQuantities.stream().mapToDouble(x -> x.getQty() * x.getPrice()).sum();
+		if (totalAmount > 0) {
+			userClient.addItemPricingToCart(customRetailer.getCartId(), itemQuantities);
+			User user = userRepository.selectById(loginDetails.getFofoId());
+			userClient = new UserClient().getClient();
+			LOGGER.info("Setting wallet amount in cart");
+			long transactionId = userClient.createOrders(user.getActiveCartId(), "", 0, "", 0, loginDetails.getFofoId(),
+, OrderSource.WEBSITE.getValue(), true);
+			LOGGER.info("Creating wallet payment for transactionId - {}", transactionId);
+			createPayment(user, totalAmount, transactionId);
+			TransactionService.Client transactionClient = new TransactionClient().getClient();
+			transactionClient.changeTransactionStatus(transactionId, TransactionStatus.AUTHORIZED,
+					"Payment received for the order", PickUpType.RUNNER.getValue(), OrderType.B2B, OrderSource.WEBSITE);
+			transactionClient.changeTransactionStatus(Long.valueOf(transactionId), TransactionStatus.IN_PROCESS,
+					"Paid fully through wallet", PickUpType.RUNNER.getValue(), OrderType.B2B, OrderSource.WEBSITE);
+			LOGGER.info("Successfully created transaction: " + transactionId + " for amount: " + totalAmount);
+			transactionClient = new TransactionClient().getClient();
+			transactionClient.markOrderForRegisteredGstInvoice(Collections.singletonList(Long.valueOf(transactionId)));
+			try {
+				transactionClient.enqueueTransactionInfoEmail(transactionId);
+			} catch (Exception e1) {
+				e1.printStackTrace();
+				LOGGER.error("Unable to update status of transaction. Thrift Exception:", e1);
+			}
+			resetCart(transactionClient.getTransaction(transactionId));
+		}
+		model.addAttribute("response", mvcResponseSender.createResponseString(success));
+		return "response";
+	}
+	private void createPayment(User user, double totalAmount, long transactionId)
+			throws NumberFormatException, PaymentException, TException {
+		List<Attribute> paymentAttributes = new ArrayList<Attribute>();
+		in.shop2020.payments.PaymentService.Client paymentClient = new PaymentClient().getClient();
+		paymentAttributes.add(new Attribute("payMethod", "7890"));
+		long paymentId = paymentClient.createPayment(user.getId(), totalAmount, WALLET_GATEWAY_ID, transactionId,
+				false);
+		paymentClient.updatePaymentDetails(paymentId, null, null, null, null, null, null, null, null,
+				PaymentStatus.SUCCESS, null, paymentAttributes);
+	}
 	@RequestMapping(value = "/indent/loadIndent")
 	public String loadOpenIndent(HttpServletRequest request, Model model,
-			@RequestParam(required = false, defaultValue = "0") int fofoId,
+								 @RequestParam(required = false, defaultValue = "0") int fofoId,
-			@RequestParam(defaultValue = "TEN_LAC") CounterSize counterSize) throws Exception {
+								 @RequestParam(defaultValue = "TEN_LAC") CounterSize counterSize) throws Exception {
 		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
 		Set<Integer> roleIds = loginDetails.getRoleIds();
 		LOGGER.info("Counter size is {}", counterSize);
 		LOGGER.info("Fofo Id is {}", fofoId);
 		if (LocalDate.now().isAfter(LocalDate.now().withDayOfMonth(PLANNING_OPEN_DAY))) {
 			planningMonthDate = LocalDate.now().plusMonths(1).withDayOfMonth(1);
 			monthlyPlanned = monthlyPlannedRepository.selectByFofoIdYearMonth(fofoId, planningMonthDate);
 			LOGGER.info("monthlyPlanned2" + monthlyPlanned);
 			fofoOrderIds = fofoOrderRepository.selectByFofoIdBetweenCreatedTimeStamp(loginDetails.getFofoId(),
-					LocalDateTime.now().minusDays(15), LocalDateTime.now()).stream().map(x -> x.getId())
+							LocalDateTime.now().minusDays(15), LocalDateTime.now()).stream().map(x -> x.getId())
 					.collect(Collectors.toList());
 			model.addAttribute("planningMonth", LocalDate.now().plusMonths(1).getMonth());
 		} else {
 			planningMonthDate = LocalDate.now().withDayOfMonth(1);
 			monthlyPlanned = monthlyPlannedRepository.selectByFofoIdYearMonth(fofoId, planningMonthDate);
 			model.addAttribute("planningMonth", planningMonthDate.getMonth());
 			model.addAttribute("mtd", true);
 			model.addAttribute("freezed", true);
 			fofoOrderIds = fofoOrderRepository.selectByFofoIdBetweenCreatedTimeStamp(loginDetails.getFofoId(),
-					curDate.withDayOfMonth(1), curDate.with(LocalTime.MAX)).stream().map(x -> x.getId())
+							curDate.withDayOfMonth(1), curDate.with(LocalTime.MAX)).stream().map(x -> x.getId())
 					.collect(Collectors.toList());
 			LOGGER.info("monthlyPlanned1" + monthlyPlanned);
+		}
 		Map<Integer, Integer> plannedDetailMap = null;
 		model.addAttribute("totalPcs", totalPcs);
 		return "open-indent";
+	}
-	private List<Order> filterValidOrders(List<Order> lastOrdersList) {
+	private long resetCart(Transaction transaction) {
-		int orderRemovedCount = 0;
+		long sum = 0;
-		Iterator<Order> orderIterator = lastOrdersList.iterator();
+		Map<Long, Double> items = new HashMap<Long, Double>();
-		while (orderIterator.hasNext()) {
+		for (in.shop2020.model.v1.order.Order order : transaction.getOrders()) {
-			Order o = orderIterator.next();
+			sum += order.getGvAmount();
-			if (o.getInvoiceNumber() != null) {
+			for (LineItem lineitem : order.getLineitems()) {
-				try {
+				Long itemId = lineitem.getItem_id();
-					purchaseRepository.selectByPurchaseReferenceAndFofoId(o.getInvoiceNumber(), o.getRetailerId());
+				Double quantity = items.get(itemId);
-					orderIterator.remove();
+				if (quantity == null) {
-					orderRemovedCount++;
+					quantity = lineitem.getQuantity();
-				} catch (Exception e) {
+				} else {
+					quantity = quantity + lineitem.getQuantity();
+				}
+				items.put(itemId, quantity);
+			}
+		}
-		LOGGER.info("Order removed count is {}", orderRemovedCount);
-		return lastOrdersList;
-	}
-	@RequestMapping(value = "/indent/confirm-pause", method = RequestMethod.POST)
-	public String raisePO(HttpServletRequest request, Model model, @RequestBody String jsonArrayString)
-			throws Exception {
-		JSONArray jsonArray = new JSONArray(jsonArrayString);
-		for (int i = 0; i < jsonArray.length(); i++) {
-			JSONObject obj = jsonArray.getJSONObject(i);
-			TagListing tl = tagListingRepository.selectByItemId(obj.getInt("id"));
-			if (tl == null) {
-				continue;
-			} else {
-				tl.setActive(obj.getBoolean("active"));
-				tagListingRepository.persist(tl);
-			}
-		}
-		model.addAttribute("response", true);
-		return "response";
-	}
-	@RequestMapping(value = "/indent/confirm-hotdeals-pause", method = RequestMethod.POST)
-	public String hotdealUpdate(HttpServletRequest request, Model model, @RequestBody String jsonArrayString)
-			throws Exception {
-		JSONArray jsonArray = new JSONArray(jsonArrayString);
+		LOGGER.debug("Items to reset in cart are: " + items);
-		for (int i = 0; i < jsonArray.length(); i++) {
-			JSONObject obj = jsonArray.getJSONObject(i);
+		try {
-			TagListing tl = tagListingRepository.selectByItemId(obj.getInt("id"));
+			Client userClient = new UserClient().getClient();
-			if (tl == null) {
+			userClient.resetCart(transaction.getShoppingCartid(), items);
-				continue;
+		} catch (TException e) {
+			LOGGER.error("Error while updating information in payment database.", e);
-			} else {
+		} catch (ShoppingCartException e) {
-				tl.setHotDeals(obj.getBoolean("hotDeals"));
+			LOGGER.error("Error while reseting the cart in cart database.", e);
+		} catch (Exception e) {
-				tagListingRepository.persist(tl);
+			LOGGER.error("Unexpected exception", e);
-			}
+		}
-		model.addAttribute("response", true);
-		return "response";
+		return sum;
+	}
-	@RequestMapping(value = "/indent/create-po", method = RequestMethod.POST)
+	private List<ItemPriceQuantity> getItemQuantities(int fofoId) throws ProfitMandiBusinessException {
-	public String raisePO(HttpServletRequest request, Model model) throws Exception {
+		List<ItemPriceQuantity> itemQuantities = new ArrayList<>();
+		/*
-		boolean success = false;
+		 * Map<Integer, ItemIdAvailability> itemCisMap = null; List<ItemIdAvailability>
-		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
+		 * currentInventorySnapshots = currentInventorySnapshotRepository
-		int fofoId = loginDetails.getFofoId();
+		 * .selectItemsStock(fofoId); itemCisMap =
-		List<ItemPriceQuantity> itemQuantities = this.getItemQuantities(fofoId);
+		 * currentInventorySnapshots.stream().filter(x -> x.getAvailability() > 0)
-		CustomRetailer customRetailer = retailerService.getFofoRetailer(fofoId);
+		 * .collect(Collectors.toMap(x -> x.getItemId(), x -> x));
-		Client userClient = new UserClient().getClient();
+		 * List<StockAllocationModel> stockAllocationList =
-		double totalAmount = itemQuantities.stream().mapToDouble(x -> x.getQty() * x.getPrice()).sum();
+		 * stockAllocationService.getStockAllocation(fofoId, true);
+		 *
-		if (totalAmount > 0) {
+		 * Map<Integer, StockAllocationModel> itemStockAllocationMap =
-			userClient.addItemPricingToCart(customRetailer.getCartId(), itemQuantities);
+		 * stockAllocationList.stream() .collect(Collectors.toMap(x -> x.catalogId(), x
-			User user = userRepository.selectById(loginDetails.getFofoId());
+		 * -> x)); Map<Integer, Integer> itemsInTransit = null;
-			userClient = new UserClient().getClient();
+		 * LOGGER.info("Item Stock Allocation Model Map {}", itemStockAllocationMap);
-			LOGGER.info("Setting wallet amount in cart");
+		 * List<TagListing> tagListings = tagListingRepository.selectAll(false);
-			long transactionId = userClient.createOrders(user.getActiveCartId(), "", 0, "", 0, loginDetails.getFofoId(),
+		 * List<Order> inTransitOrders = orderRepository.selectOrders(fofoId,
-, OrderSource.WEBSITE.getValue(), true);
+		 * validOrderStatusList); inTransitOrders =
-			LOGGER.info("Creating wallet payment for transactionId - {}", transactionId);
+		 * this.filterValidOrders(inTransitOrders); itemsInTransit =
+		 * inTransitOrders.stream().collect(Collectors.groupingBy(x ->
-			createPayment(user, totalAmount, transactionId);
+		 * x.getLineItem().getItemId(), Collectors.summingInt(x ->
+		 * x.getLineItem().getQuantity())));
+		 *
-			TransactionService.Client transactionClient = new TransactionClient().getClient();
+		 * Iterator<TagListing> iterator = tagListings.iterator();
+		 *
-			transactionClient.changeTransactionStatus(transactionId, TransactionStatus.AUTHORIZED,
+		 * int toBeOrdered = 0; while (iterator.hasNext()) { TagListing tagListing =
-					"Payment received for the order", PickUpType.RUNNER.getValue(), OrderType.B2B, OrderSource.WEBSITE);
+		 * iterator.next(); LOGGER.info(" tagListing.setAllocatedQuantity {}",
+		 * tagListing.getAllocatedQuantity()); if
-			transactionClient.changeTransactionStatus(Long.valueOf(transactionId), TransactionStatus.IN_PROCESS,
+		 * (!itemCisMap.containsKey(tagListing.getItemId()) &&
-					"Paid fully through wallet", PickUpType.RUNNER.getValue(), OrderType.B2B, OrderSource.WEBSITE);
+		 * !itemStockAllocationMap.containsKey(tagListing.getItemId())) {
-			LOGGER.info("Successfully created transaction: " + transactionId + " for amount: " + totalAmount);
+		 * iterator.remove(); continue; } ItemIdAvailability itemIdAvailability =
-			transactionClient = new TransactionClient().getClient();
+		 * itemCisMap.get(tagListing.getItemId());
+		 * tagListing.setStockInHand(itemIdAvailability == null ? 0 :
+		 * itemIdAvailability.getAvailability()); StockAllocationModel
-			transactionClient.markOrderForRegisteredGstInvoice(Collections.singletonList(Long.valueOf(transactionId)));
+		 * stockAllocationModel = itemStockAllocationMap.get(tagListing.getItemId());
-			try {
+		 *
+		 * if (itemsInTransit.containsKey(tagListing.getItemId())) {
+		 * tagListing.setInTransitQuantity(itemsInTransit.get(tagListing.getItemId()));
-				transactionClient.enqueueTransactionInfoEmail(transactionId);
+		 * } else { tagListing.setInTransitQuantity(0); } if (stockAllocationModel !=
+		 * null) { tagListing.setAllocatedQuantity(stockAllocationModel.getQuantity());
-			} catch (Exception e1) {
+		 * toBeOrdered = Math.max(tagListing.getAllocatedQuantity() -
-				e1.printStackTrace();
+		 * tagListing.getInTransitQuantity() - tagListing.getStockInHand(), 0); if
-				LOGGER.error("Unable to update status of transaction. Thrift Exception:", e1);
+		 * (toBeOrdered > 0) { ItemPriceQuantity ipq = new ItemPriceQuantity();
-			}
-			resetCart(transactionClient.getTransaction(transactionId));
+		 * ipq.setItemId(tagListing.getItemId()); ipq.setQty((long) toBeOrdered);
+		 * ipq.setPrice(tagListing.getSellingPrice()); itemQuantities.add(ipq); } } }
-		}
+		 */
-		model.addAttribute("response", mvcResponseSender.createResponseString(success));
-		return "response";
+		return itemQuantities;
-	}
-	private void createPayment(User user, double totalAmount, long transactionId)
-			throws NumberFormatException, PaymentException, TException {
-		List<Attribute> paymentAttributes = new ArrayList<Attribute>();
-		in.shop2020.payments.PaymentService.Client paymentClient = new PaymentClient().getClient();
-		paymentAttributes.add(new Attribute("payMethod", "7890"));
-		long paymentId = paymentClient.createPayment(user.getId(), totalAmount, WALLET_GATEWAY_ID, transactionId,
-				false);
-		paymentClient.updatePaymentDetails(paymentId, null, null, null, null, null, null, null, null,
-				PaymentStatus.SUCCESS, null, paymentAttributes);
+	}
 	@RequestMapping(value = "/indent/loadIndentPreviousMonth")
 	public String previousMonthLoadOpenIndent(HttpServletRequest request, Model model,
-			@RequestParam(required = false, defaultValue = "0") int fofoId,
+											  @RequestParam(required = false, defaultValue = "0") int fofoId,
-			@RequestParam(defaultValue = "TEN_LAC") CounterSize counterSize) throws Exception {
+											  @RequestParam(defaultValue = "TEN_LAC") CounterSize counterSize) throws Exception {
 		LocalDate planMonthStart = null;
 		if (LocalDate.now().isAfter(LocalDate.now().withDayOfMonth(PLANNING_OPEN_DAY))) {
 			planMonthStart = LocalDate.now().plusMonths(1).withDayOfMonth(1);
 		} else {
 			planMonthStart = LocalDate.now().withDayOfMonth(1);
 		model.addAttribute("totalPcs", totalPcs);
 		return "open-indent";
+	}
-	private long resetCart(Transaction transaction) {
+	private Map<Integer, Item> getItemByCatalogId(List<FocusedModel> focusedModels) {
-		long sum = 0;
-		Map<Long, Double> items = new HashMap<Long, Double>();
+		Map<Integer, Item> itemMap = new HashMap<>();
-		for (in.shop2020.model.v1.order.Order order : transaction.getOrders()) {
+		for (FocusedModel focusedModel : focusedModels) {
-			sum += order.getGvAmount();
-			for (LineItem lineitem : order.getLineitems()) {
-				Long itemId = lineitem.getItem_id();
-				Double quantity = items.get(itemId);
-				if (quantity == null) {
-					quantity = lineitem.getQuantity();
-				} else {
-					quantity = quantity + lineitem.getQuantity();
+			List<Item> items = itemRepository.selectAllByCatalogItemId(focusedModel.getCatalogId());
-				}
-				items.put(itemId, quantity);
+			itemMap.put(items.get(0).getCatalogItemId(), items.get(0));
-			}
+		}
-		LOGGER.debug("Items to reset in cart are: " + items);
-		try {
-			Client userClient = new UserClient().getClient();
-			userClient.resetCart(transaction.getShoppingCartid(), items);
-		} catch (TException e) {
-			LOGGER.error("Error while updating information in payment database.", e);
-		} catch (ShoppingCartException e) {
-			LOGGER.error("Error while reseting the cart in cart database.", e);
-		} catch (Exception e) {
-			LOGGER.error("Unexpected exception", e);
-		}
-		return sum;
+		return itemMap;
+	}
-	private List<ItemPriceQuantity> getItemQuantities(int fofoId) throws ProfitMandiBusinessException {
+	private Map<Integer, Region> getRegionByRegionId(List<FocusedModel> focusedModels) {
-		List<ItemPriceQuantity> itemQuantities = new ArrayList<>();
+		Map<Integer, Region> regionMap = new HashMap<>();
-		/*
-		 * Map<Integer, ItemIdAvailability> itemCisMap = null; List<ItemIdAvailability>
-		 * currentInventorySnapshots = currentInventorySnapshotRepository
-		 * .selectItemsStock(fofoId); itemCisMap =
-		 * currentInventorySnapshots.stream().filter(x -> x.getAvailability() > 0)
-		 * .collect(Collectors.toMap(x -> x.getItemId(), x -> x));
-		 * List<StockAllocationModel> stockAllocationList =
+		for (FocusedModel focusedModel : focusedModels) {
-		 * stockAllocationService.getStockAllocation(fofoId, true);
-		 *
-		 * Map<Integer, StockAllocationModel> itemStockAllocationMap =
-		 * stockAllocationList.stream() .collect(Collectors.toMap(x -> x.catalogId(), x
-		 * -> x)); Map<Integer, Integer> itemsInTransit = null;
-		 * LOGGER.info("Item Stock Allocation Model Map {}", itemStockAllocationMap);
-		 * List<TagListing> tagListings = tagListingRepository.selectAll(false);
+			Region region = regionRepository.selectById(focusedModel.getRegionId());
-		 * List<Order> inTransitOrders = orderRepository.selectOrders(fofoId,
-		 * validOrderStatusList); inTransitOrders =
-		 * this.filterValidOrders(inTransitOrders); itemsInTransit =
-		 * inTransitOrders.stream().collect(Collectors.groupingBy(x ->
-		 * x.getLineItem().getItemId(), Collectors.summingInt(x ->
-		 * x.getLineItem().getQuantity())));
-		 *
-		 * Iterator<TagListing> iterator = tagListings.iterator();
-		 *
-		 * int toBeOrdered = 0; while (iterator.hasNext()) { TagListing tagListing =
-		 * iterator.next(); LOGGER.info(" tagListing.setAllocatedQuantity {}",
-		 * tagListing.getAllocatedQuantity()); if
-		 * (!itemCisMap.containsKey(tagListing.getItemId()) &&
-		 * !itemStockAllocationMap.containsKey(tagListing.getItemId())) {
-		 * iterator.remove(); continue; } ItemIdAvailability itemIdAvailability =
-		 * itemCisMap.get(tagListing.getItemId());
+			regionMap.put(region.getId(), region);
-		 * tagListing.setStockInHand(itemIdAvailability == null ? 0 :
-		 * itemIdAvailability.getAvailability()); StockAllocationModel
-		 * stockAllocationModel = itemStockAllocationMap.get(tagListing.getItemId());
-		 *
+		}
-		 * if (itemsInTransit.containsKey(tagListing.getItemId())) {
-		 * tagListing.setInTransitQuantity(itemsInTransit.get(tagListing.getItemId()));
-		 * } else { tagListing.setInTransitQuantity(0); } if (stockAllocationModel !=
-		 * null) { tagListing.setAllocatedQuantity(stockAllocationModel.getQuantity());
-		 * toBeOrdered = Math.max(tagListing.getAllocatedQuantity() -
-		 * tagListing.getInTransitQuantity() - tagListing.getStockInHand(), 0); if
-		 * (toBeOrdered > 0) { ItemPriceQuantity ipq = new ItemPriceQuantity();
-		 * ipq.setItemId(tagListing.getItemId()); ipq.setQty((long) toBeOrdered);
-		 * ipq.setPrice(tagListing.getSellingPrice()); itemQuantities.add(ipq); } } }
-		 */
-		return itemQuantities;
+		return regionMap;
+	}
 	@RequestMapping(value = "/getFocusedModel", method = RequestMethod.GET)
 	public String getFocusedModel(HttpServletRequest request,
-			@RequestParam(name = "offset", defaultValue = "0") int offset,
+								  @RequestParam(name = "offset", defaultValue = "0") int offset,
-			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
+								  @RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
 			throws ProfitMandiBusinessException {
 		long size = 0;
 		List<FocusedModel> focusedModels = focusedModelRepository.selectAll(offset, limit);
 		model.addAttribute("regions", regions);
 		return "focused_model";
+	}
-	private Map<Integer, Item> getItemByCatalogId(List<FocusedModel> focusedModels) {
-		Map<Integer, Item> itemMap = new HashMap<>();
-		for (FocusedModel focusedModel : focusedModels) {
-			List<Item> items = itemRepository.selectAllByCatalogItemId(focusedModel.getCatalogId());
-			itemMap.put(items.get(0).getCatalogItemId(), items.get(0));
-		}
-		return itemMap;
-	}
-	private Map<Integer, Region> getRegionByRegionId(List<FocusedModel> focusedModels) {
-		Map<Integer, Region> regionMap = new HashMap<>();
-		for (FocusedModel focusedModel : focusedModels) {
-			Region region = regionRepository.selectById(focusedModel.getRegionId());
-			regionMap.put(region.getId(), region);
-		}
-		return regionMap;
-	}
 	@RequestMapping(value = "/getPaginatedFocusedModel", method = RequestMethod.GET)
 	public String getPaginatedFocusedModel(HttpServletRequest request,
-			@RequestParam(name = "offset", defaultValue = "0") int offset,
+										   @RequestParam(name = "offset", defaultValue = "0") int offset,
-			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
+										   @RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
 			throws ProfitMandiBusinessException {
 		LOGGER.info("requested offset=[{}], limit = [{}]", offset, limit);
 		List<FocusedModel> focusedModels = focusedModelRepository.selectAll(offset, limit);
 		if (!focusedModels.isEmpty()) {
 		model.addAttribute("regions", regions);
 		return "focused-model-paginated";
+	}
-	@RequestMapping(value = "/focusedModel", method = RequestMethod.POST)
-	public String focusedModel(HttpServletRequest request, @RequestParam int catalogId,
-			@RequestParam(name = "recommended", defaultValue = "0") int recommended,
-			@RequestParam(name = "minimumQty", defaultValue = "0") int minimumQty,
-			@RequestParam(name = "obvrecommend", defaultValue = "0") int obvrecommend,
-			@RequestParam(name = "obvminimum", defaultValue = "0") int obvminimum, @RequestParam int regionId,
-			Model model) throws ProfitMandiBusinessException {
-		FocusedModel fm = new FocusedModel();
-		fm.setCatalogId(catalogId);
-		fm.setMinimumQty(minimumQty);
-		fm.setRecommendedQty(recommended);
-		fm.setRegionId(regionId);
-		fm.setObsRecommendedQty(obvrecommend);
-		fm.setObsMinimumQty(obvminimum);
-		fm.setCreatedTimestamp(LocalDateTime.now());
-		focusedModelRepository.persist(fm);
-		return "focused_model";
-	}
 	private List<BrandStockPrice> getBrandStockPrices(int fofoId) throws Exception {
 		Map<String, BrandStockPrice> brandStockPricesMap = inventoryService.getBrandWiseStockValue(fofoId);
 		List<DBObject> mobileBrands = mongoClient.getMongoBrands(fofoId, "", 3);
 		List<BrandStockPrice> brandStockPrices = new ArrayList<>();
 		return "partner-po";
+	}
+	@RequestMapping(value = "/focusedModel", method = RequestMethod.POST)
+	public String focusedModel(HttpServletRequest request, @RequestParam int catalogId,
+							   @RequestParam(name = "recommended", defaultValue = "0") int recommended,
+							   @RequestParam(name = "minimumQty", defaultValue = "0") int minimumQty,
+							   @RequestParam(name = "obvrecommend", defaultValue = "0") int obvrecommend,
+							   @RequestParam(name = "obvminimum", defaultValue = "0") int obvminimum, @RequestParam int regionId,
+							   Model model) throws ProfitMandiBusinessException {
+		FocusedModel fm = new FocusedModel();
+		fm.setCatalogId(catalogId);
+		fm.setMinimumQty(minimumQty);
+		fm.setRecommendedQty(recommended);
+		fm.setRegionId(regionId);
+		fm.setObsRecommendedQty(obvrecommend);
+		fm.setObsMinimumQty(obvminimum);
+		fm.setCreatedTimestamp(LocalDateTime.now());
+		focusedModelRepository.persist(fm);
+		return "focused_model";
+	}
 	@RequestMapping(value = "/removeItem", method = RequestMethod.DELETE)
 	public String removeFocusedModelItem(HttpServletRequest request,
-			@RequestParam(name = "id", defaultValue = "0") int id, Model model) throws Exception {
+										 @RequestParam(name = "id", defaultValue = "0") int id, Model model) throws Exception {
 		focusedModelRepository.deleteById(id);
 		model.addAttribute("response", mvcResponseSender.createResponseString(true));
 		return "response";
+	}
 	@RequestMapping(value = "/getPartnerloadContent")
 	public String getPartnerloadContent(HttpServletRequest request, Model model,
-			@RequestParam(required = false, defaultValue = "0") int fofoId,
+										@RequestParam(required = false, defaultValue = "0") int fofoId,
-			@RequestParam(defaultValue = "TEN_LAC") CounterSize counterSize) throws Exception {
+										@RequestParam(defaultValue = "TEN_LAC") CounterSize counterSize) throws Exception {
 		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
 		Set<Integer> roleIds = loginDetails.getRoleIds();
 		LOGGER.info("Counter size is {}", counterSize);
 		LOGGER.info("Fofo Id is {}", fofoId);
 		if (LocalDate.now().isAfter(LocalDate.now().withDayOfMonth(PLANNING_OPEN_DAY))) {
 			currentMonthDate = LocalDate.now().plusMonths(1).withDayOfMonth(1);
 			monthlyPlanned = monthlyPlannedRepository.selectByFofoIdYearMonth(fofoId, currentMonthDate);
 			LOGGER.info("monthlyPlanned2" + monthlyPlanned);
 			fofoOrderIds = fofoOrderRepository.selectByFofoIdBetweenCreatedTimeStamp(loginDetails.getFofoId(),
-					LocalDateTime.now().minusDays(15), LocalDateTime.now()).stream().map(x -> x.getId())
+							LocalDateTime.now().minusDays(15), LocalDateTime.now()).stream().map(x -> x.getId())
 					.collect(Collectors.toList());
 			model.addAttribute("planningMonth", LocalDate.now().plusMonths(1).getMonth());
 		} else {
 			currentMonthDate = LocalDate.now().withDayOfMonth(1);
 			monthlyPlanned = monthlyPlannedRepository.selectByFofoIdYearMonth(fofoId, currentMonthDate);
 			model.addAttribute("planningMonth", currentMonthDate.getMonth());
 			model.addAttribute("mtd", true);
 			model.addAttribute("freezed", true);
 			fofoOrderIds = fofoOrderRepository.selectByFofoIdBetweenCreatedTimeStamp(loginDetails.getFofoId(),
-					curDate.withDayOfMonth(1), curDate.with(LocalTime.MAX)).stream().map(x -> x.getId())
+							curDate.withDayOfMonth(1), curDate.with(LocalTime.MAX)).stream().map(x -> x.getId())
 					.collect(Collectors.toList());
 			LOGGER.info("monthlyPlanned1" + monthlyPlanned);
+		}
 		Map<Integer, Integer> plannedDetailMap = null;
 		Map<String, Object> equalsItemJoinMap = new HashMap<>();
 		equalsItemJoinMap.put("active", 1);
 		List<IntegerIdAggregateValue> tagListingCatalogIds = itemRepository.selectItems(TagListing.class, "id",
 				"itemId", equalsMap, notEqualsMap, equalsItemJoinMap, notEqualsJoinMap, "tagId");
 		Map<Integer, Integer> ourStockAvailability = new HashMap<>();
-		Map<Integer, List<SaholicCIS>> itemAvailabilityMap = saholicInventoryService.getSaholicStock()
-				.get(fofoStore.getWarehouseId());
 		Map<Integer, List<Integer>> catalogItemIdMap = itemRepository
 				.selectAllByCatalogIds(new HashSet<>(
 						tagListingCatalogIds.stream().map(x -> x.getCatalogId()).collect(Collectors.toList())))
 				.stream().collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
 						Collectors.mapping(y -> y.getId(), Collectors.toList())));
 		for (Entry<Integer, List<Integer>> catalogItem : catalogItemIdMap.entrySet()) {
 			List<Integer> itemIds = catalogItem.getValue();
 			int availability = 0;
 			for (Integer itemId : itemIds) {
-				List<SaholicCIS> scis = itemAvailabilityMap.get(itemId);
+				List<SaholicCISTable> saholicCISTableList = saholicCISTableRepository.selectByItemWarehouse(itemId, fofoStore.getWarehouseId());
-				if (scis != null) {
+				if (saholicCISTableList != null) {
-					availability += scis.stream().collect(Collectors.summingInt(x -> x.getAvailability()));
+					availability += saholicCISTableList.stream().collect(Collectors.summingInt(x -> x.getAvailability()));
+				}
+			}
 			Integer catalogItemId = catalogItem.getKey();
 			ourStockAvailability.put(catalogItemId, availability);
+		}
 		return "partner-brandwise-detail";
+	}
 	@RequestMapping(value = "/changeActivationType", method = RequestMethod.POST)
 	public String changeActivationType(HttpServletRequest request, @RequestParam String code,
-			@RequestParam ActivationType activationType, Model model) throws Exception {
+									   @RequestParam ActivationType activationType, Model model) throws Exception {
 		FofoStore fofoStore = fofoStoreRepository.selectByStoreCode(code);
 		fofoStore.setActivationType(activationType);
 		return "response";
+	}
 	@RequestMapping(value = "/getPartnerShortageStock", method = RequestMethod.GET)
 	public String getPartnerShortageStock(HttpServletRequest request,
-			@RequestParam(required = false, defaultValue = "") String brand, @RequestParam int fofoId, Model model)
+										  @RequestParam(required = false, defaultValue = "") String brand, @RequestParam int fofoId, Model model)
 			throws Exception {
-		Map<Integer, Map<Integer, List<SaholicCIS>>> warehouseItemAvailabilityMap = saholicInventoryService
-				.getSaholicStock();
 		Map<Integer, Map<Integer, List<SaholicPOItem>>> warehousePoItemAvailabilityMap = saholicInventoryService
 				.getSaholicPOItems();
 		List<FocusedModelShortageModel> focusedModelShortageList = new ArrayList<>();
 			List<Item> items = itemRepository.selectAllByCatalogItemId(entry.getKey());
 			if (brand.equals("undefined") || items.get(0).getBrand().equals(brand)) {
 				FocusedModelShortageModel fm = this.getFocusedModelShortage(entry.getValue().get(), entry.getKey(),
-						processingOrderMap, grnPendingOrdersMap, catalogIdAndQtyMap, fofoId,
-						warehouseItemAvailabilityMap, warehousePoItemAvailabilityMap, items, customRetailer);
+						processingOrderMap, grnPendingOrdersMap, catalogIdAndQtyMap, fofoId, warehousePoItemAvailabilityMap, items, customRetailer);
 				focusedModelShortageList.add(fm);
 			} else if (brand.equals("accessories")) {
 				if (items.get(0).getCategoryId() != ProfitMandiConstants.MOBILE_CATEGORY_ID) {
 					if (items.get(0).getCategoryId() != 0) {
 						Category category = categoryRepository.selectById(items.get(0).getCategoryId());
 						if (category.getParentCategoryId() == 10011) {
 							FocusedModelShortageModel fm = this.getFocusedModelShortage(entry.getValue().get(),
-									entry.getKey(), processingOrderMap, grnPendingOrdersMap, catalogIdAndQtyMap, fofoId,
+									entry.getKey(), processingOrderMap, grnPendingOrdersMap, catalogIdAndQtyMap, fofoId
-									warehouseItemAvailabilityMap, warehousePoItemAvailabilityMap, items,
+									, warehousePoItemAvailabilityMap, items,
 									customRetailer);
 							focusedModelShortageList.add(fm);
+						}
 						Category category = categoryRepository.selectById(items.get(0).getCategoryId());
 						if (category.getParentCategoryId() == 14200) {
 							FocusedModelShortageModel fm = this.getFocusedModelShortage(entry.getValue().get(),
 									entry.getKey(), processingOrderMap, grnPendingOrdersMap, catalogIdAndQtyMap, fofoId,
-									warehouseItemAvailabilityMap, warehousePoItemAvailabilityMap, items,
+									warehousePoItemAvailabilityMap, items,
 									customRetailer);
 							focusedModelShortageList.add(fm);
+						}
 		return "partner-stock";
+	}
 	private List<PartnerStockDescriptionModel> getBrandItemwiseDescription(String brand,
-			Map<Integer, Integer> catalogIdAndQtyMap) throws ProfitMandiBusinessException {
+																		   Map<Integer, Integer> catalogIdAndQtyMap) throws ProfitMandiBusinessException {
 		List<PartnerStockDescriptionModel> inStocks = new ArrayList<>();
 		for (Entry<Integer, Integer> inStock : catalogIdAndQtyMap.entrySet()) {
 			List<Item> items = itemRepository.selectAllByCatalogItemId(inStock.getKey());
 		return inStocks;
+	}
 	private FocusedModelShortageModel getFocusedModelShortage(int qty, int catalogId,
-			Map<Integer, Integer> processingOrderMap, Map<Integer, Integer> grnPendingOrdersMap,
+															  Map<Integer, Integer> processingOrderMap, Map<Integer, Integer> grnPendingOrdersMap,
-			Map<Integer, Integer> catalogIdAndQtyMap, int fofoId,
+															  Map<Integer, Integer> catalogIdAndQtyMap, int fofoId,
-			Map<Integer, Map<Integer, List<SaholicCIS>>> warehouseItemAvailabilityMap,
-			Map<Integer, Map<Integer, List<SaholicPOItem>>> warehousePoItemAvailabilityMap, List<Item> items,
+															  Map<Integer, Map<Integer, List<SaholicPOItem>>> warehousePoItemAvailabilityMap, List<Item> items,
-			CustomRetailer customRetailer) throws ProfitMandiBusinessException {
+															  CustomRetailer customRetailer) throws ProfitMandiBusinessException {
 		int minQty = qty;
 		int inStockQty = 0;
 		int processingQty = 0;
 		int grnPendingQty = 0;
 		int totalQty = processingQty + grnPendingQty + inStockQty;
 		int shortageQty = minQty - totalQty;
 		FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(fofoId);
-		Map<Integer, List<SaholicCIS>> itemAvailabilityMap = warehouseItemAvailabilityMap
-				.get(fofoStore.getWarehouseId());
 		Map<Integer, List<SaholicPOItem>> poItemAvailabilityMap = warehousePoItemAvailabilityMap
 				.get(fofoStore.getWarehouseId());
 		for (Item it : items) {
-			List<SaholicCIS> currentAvailability = null;
+			List<SaholicCISTable> currentAvailability = saholicCISTableRepository.selectByItemWarehouse(it.getId(), fofoStore.getWarehouseId());
 			List<SaholicPOItem> poItemAvailability = null;
-			if (itemAvailabilityMap != null) {
-				currentAvailability = itemAvailabilityMap.get(it.getId());
-			}
 			if (poItemAvailabilityMap != null) {
 				poItemAvailability = poItemAvailabilityMap.get(it.getId());
+			}
 			if (currentAvailability != null) {
 				allColorNetAvailability += currentAvailability.stream()
-						.collect(Collectors.summingInt(SaholicCIS::getNetavailability));
+						.collect(Collectors.summingInt(SaholicCISTable::getNetAvailability));
+			}
 			if (poItemAvailability != null) {
 				allColorPoAvailability += poItemAvailability.stream()
 						.collect(Collectors.summingInt(SaholicPOItem::getUnfulfilledQty));
 		return "send-po-notification";
+	}
 	@RequestMapping(value = "/indent/send-po-notification", method = RequestMethod.POST)
 	public String sendPONotification(HttpServletRequest request, @RequestBody POItemWarehouseModel poItemWarehouseModel,
-			Model model) throws Exception {
+									 Model model) throws Exception {
 		Map<Integer, Item> selectedCatalogItemMap = itemRepository
 				.selectAllByCatalogIds(new HashSet<>(poItemWarehouseModel.getCatalogIds())).stream()
 				.collect(Collectors.toMap(x -> x.getCatalogItemId(), x -> x, (existing, replacement) -> existing));

Subversion Repositories SmartDukaan

(root)/trunk/profitmandi-fofo/src/main/java/com/spice/profitmandi/web/controller/IndentController.java – Rev 30564 → 30664