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

 import com.mongodb.DBObject;
 import com.spice.profitmandi.common.enumuration.CounterSize;
 import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
 import com.spice.profitmandi.common.model.BrandStockPrice;
+import com.spice.profitmandi.common.model.CatalogIdAggregateValue;
 import com.spice.profitmandi.common.model.CatalogListingModel;
 import com.spice.profitmandi.common.model.CustomRetailer;
 import com.spice.profitmandi.common.model.ItemIdAvailability;
 import com.spice.profitmandi.common.model.PlannedModel;
 import com.spice.profitmandi.common.model.StockAllocationModel;
 import com.spice.profitmandi.common.util.Utils;
 import com.spice.profitmandi.common.util.Utils.Attachment;
 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.fofo.CurrentInventorySnapshot;
+import com.spice.profitmandi.dao.entity.fofo.FofoOrderItem;
 import com.spice.profitmandi.dao.entity.fofo.FofoStore;
 import com.spice.profitmandi.dao.entity.fofo.MonthlyPlanned;
 import com.spice.profitmandi.dao.entity.fofo.PlannedDetail;
 import com.spice.profitmandi.dao.entity.transaction.Order;
 import com.spice.profitmandi.dao.entity.user.User;
 		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
 		Set<Integer> roleIds = loginDetails.getRoleIds();
 		LOGGER.info("Counter size is {}", counterSize);
 		LOGGER.info("Fofo Id is {}", fofoId);
 		boolean isAdmin = roleManager.isAdmin(roleIds);
+		Map<String, Object> equalsMap = new HashMap<>();
+		equalsMap.put("categoryId", 10006);
+		Map<String, List<?>> notEqualsMap = new HashMap<>();
+		Map<String, List<?>> notEqualsJoinMap = new HashMap<>();
-		Map<Integer, Integer> itemCisMap;
+		Map<Integer, Integer> currentStockMap;
 		if (!isAdmin && fofoId == 0) {
 			fofoId = cookiesProcessor.getCookiesObject(request).getFofoId();
-			List<ItemIdAvailability> currentInventorySnapshots = currentInventorySnapshotRepository
+			Map<String, Object> equalsStockJoinMap = new HashMap<>();
-					.selectItemsStock(fofoId);
+			equalsStockJoinMap.put("fofoId", fofoId);
-			LOGGER.info("currentInventorySnapshots" + currentInventorySnapshots);
+			currentStockMap = itemRepository
-			itemCisMap = currentInventorySnapshots.stream().filter(x -> x.getAvailability() > 0)
+					.selectItems(CurrentInventorySnapshot.class, "itemId", equalsMap, notEqualsMap, equalsStockJoinMap,
+							notEqualsJoinMap, "availability")
-					.collect(Collectors.toMap(x -> x.getItemId(), x -> x.getAvailability()));
+					.stream().collect(Collectors.toMap(x -> x.getCatalogId(), x -> (int) x.getAggregateValue()));
 		} else {
 			if (fofoId == 0) {
-				List<ItemIdAvailability> currentInventorySnapshots = currentInventorySnapshotRepository
+				Map<String, Object> equalsStockJoinMap = new HashMap<>();
+				equalsStockJoinMap.put("fofoId", fofoId);
-						.selectItemsStock();
+				currentStockMap = itemRepository
-				LOGGER.info("currentInventorySnapshots2" + currentInventorySnapshots);
+						.selectItems(CurrentInventorySnapshot.class, "itemId", equalsMap, notEqualsMap,
-				itemCisMap = currentInventorySnapshots.stream().filter(x -> x.getAvailability() > 0)
+								equalsStockJoinMap, notEqualsJoinMap, "availability")
-						.collect(Collectors.toMap(x -> x.getItemId(), x -> x.getAvailability()));
+						.stream().collect(Collectors.toMap(x -> x.getCatalogId(), x -> (int) x.getAggregateValue()));
 			} else {
-				List<ItemIdAvailability> currentInventorySnapshots = currentInventorySnapshotRepository
+				Map<String, Object> equalsStockJoinMap = new HashMap<>();
-						.selectItemsStock(fofoId);
+				equalsStockJoinMap.put("fofoId", fofoId);
+				currentStockMap = itemRepository
-				LOGGER.info("currentInventorySnapshots3" + currentInventorySnapshots);
+						.selectItems(CurrentInventorySnapshot.class, "itemId", equalsMap, notEqualsMap,
-				itemCisMap = currentInventorySnapshots.stream().filter(x -> x.getAvailability() > 0)
+								equalsStockJoinMap, notEqualsJoinMap, "availability")
-						.collect(Collectors.toMap(x -> x.getItemId(), x -> x.getAvailability()));
+						.stream().collect(Collectors.toMap(x -> x.getCatalogId(), x -> (int) x.getAggregateValue()));
+			}
+		}
-		Map<Integer, Integer> currentStock = null;
+		LOGGER.info("currentStock" + currentStockMap);
-		if (!itemCisMap.isEmpty()) {
-			currentStock = itemRepository.selectByIds(itemCisMap.keySet()).stream().collect(Collectors
-					.groupingBy(x -> x.getCatalogItemId(), Collectors.summingInt(x -> itemCisMap.get(x.getId()))));
-		}
 		List<StockAllocationModel> stockAllocationList;
 		if (fofoId > 0) {
 			stockAllocationList = stockAllocationService.getStockAllocation(fofoId, true);
 		} else {
 			stockAllocationList = stockAllocationService.getStockAllocation(counterSize, true);
+		}
-		LOGGER.info("Stock Allocation list  is {}", stockAllocationList);
 		Map<Integer, StockAllocationModel> itemStockAllocationMap = stockAllocationList.stream()
 				.collect(Collectors.toMap(x -> x.getCatalogId(), x -> x));
 		Map<Integer, Integer> itemsInTransit = null;
-		LOGGER.info("Item Stock Allocation Model Map {}", itemStockAllocationMap);
 		List<TagListing> tagListings = tagListingRepository.selectAll(true);
 		if (!isAdmin) {
 			tagListings = new ArrayList<>(tagListings);
 			List<Order> inTransitOrders = orderRepository.selectOrders(fofoId, validOrderStatusList);
 			inTransitOrders = this.filterValidOrders(inTransitOrders);
 		Iterator<TagListing> iterator = tagListings.iterator();
 		int totalPcs = 0;
 		int toBeOrdered = 0;
 		float totalAmount = 0;
 		Map<Integer, CatalogListingModel> catalogListingMap = new HashMap<>();
 		Map<Integer, FocusedModel> focusedModelMap = focusedModelRepository.selectAll().stream()
 				.collect(Collectors.toMap(FocusedModel::getCatalogId, Function.identity()));
-		LOGGER.info("fofoId" + loginDetails.getFofoId());
-		Map<Integer, Item> items = itemRepository
-				.selectByIds(tagListings.stream().map(x -> x.getItemId()).collect(Collectors.toSet())).stream()
-				.collect(Collectors.toMap(x -> x.getId(), x -> x));
-		List<Integer> fofoOrderIds = fofoOrderRepository.selectByFofoIdBetweenCreatedTimeStamp(loginDetails.getFofoId(),
-				LocalDateTime.now().minusDays(15), LocalDateTime.now()).stream().map(x -> x.getId())
-				.collect(Collectors.toList());
-		Map<Integer, Integer> fofoOrderMap = fofoOrderItemRepository.selectByOrderIds(fofoOrderIds).stream()
-				.collect(Collectors.groupingBy(y -> y.getItemId(), Collectors.summingInt(y -> y.getQuantity())));
-		LOGGER.info("fofoOrderMap" + fofoOrderMap);
-		Map<Integer, Integer> last15DaysMap = null;
-		if (!fofoOrderMap.isEmpty()) {
-			last15DaysMap = itemRepository.selectByIds(fofoOrderMap.keySet()).stream().collect(Collectors
-					.groupingBy(x -> x.getCatalogItemId(), Collectors.summingInt(x -> fofoOrderMap.get(x.getId()))));
-		}
-		LOGGER.info("last15DaysMap" + last15DaysMap);
 		MonthlyPlanned monthlyPlanned = monthlyPlannedRepository.selectByFofoIdYearMonth(loginDetails.getFofoId(),
 				LocalDate.now().withDayOfMonth(1));
 		Map<Integer, Integer> plannedDetailMap = null;
 		if (monthlyPlanned != null) {
 			plannedDetailMap = plannedDetailRepository.selectByPlannedId(monthlyPlanned.getId()).stream()
 					.collect(Collectors.toMap(x -> x.getCatalogId(), x -> x.getQuantity()));
+		}
+		List<Integer> fofoOrderIds = fofoOrderRepository.selectByFofoIdBetweenCreatedTimeStamp(loginDetails.getFofoId(),
+				LocalDateTime.now().minusDays(15), LocalDateTime.now()).stream().map(x -> x.getId())
-		while (iterator.hasNext()) {
+				.collect(Collectors.toList());
+		LOGGER.info("fofoOrderIds" + fofoOrderIds);
-			TagListing tagListing = iterator.next();
+		Map<String, Object> equalsJoinMap = new HashMap<>();
+		equalsJoinMap.put("orderId", fofoOrderIds);
-			Item item = items.get(tagListing.getItemId());
+		Map<Integer, Integer> last15daysMap = itemRepository
+				.selectItems(FofoOrderItem.class, "itemId", equalsMap, notEqualsMap, equalsJoinMap, notEqualsJoinMap,
-			// itemRepository.select
+						"quantity")
+				.stream().collect(Collectors.toMap(x -> x.getCatalogId(), x -> (int) x.getAggregateValue()));
-			// catalogTagListingMap
+		LOGGER.info("last15daysMap" + last15daysMap);
-			if (item.getBrand() == null || item.getCategoryId() != 10006) {
+		Map<Integer, TagListing> taglistingMap = tagListings.stream()
-				iterator.remove();
+				.collect(Collectors.toMap(x -> x.getItemId(), x -> x));
-				continue;
+		List<Item> items = itemRepository.selectByIds(taglistingMap.keySet());
+		Map<Integer, List<Item>> catalogIdItemMap = items.stream().collect(
+				Collectors.groupingBy(x -> x.getCatalogItemId(), Collectors.mapping(y -> y, Collectors.toList())));
-			}
+		LOGGER.info("itemId" + new ArrayList<>(taglistingMap.keySet()));
+		Map<String, Object> equalsItemJoinMap = new HashMap<>();
+		equalsItemJoinMap.put("itemId", new ArrayList<>(taglistingMap.keySet()));
+		List<CatalogIdAggregateValue> tagListingCatalogIds = itemRepository.selectItems(TagListing.class, "itemId",
-			int catalogId = item.getCatalogItemId();
+				equalsMap, notEqualsMap, equalsItemJoinMap, notEqualsJoinMap, "tagId");
+		for (CatalogIdAggregateValue catalogIdAggregateValue : tagListingCatalogIds) {
+			int catalogId = catalogIdAggregateValue.getCatalogId();
+			Item item = catalogIdItemMap.get(catalogId).get(0);
+			TagListing tagListing = taglistingMap.get(item.getId());
 			CatalogListingModel catalogListingModel = catalogListingMap.get(catalogId);
 			if (!catalogListingMap.containsKey(catalogId)) {
 				catalogListingModel = new CatalogListingModel();
 				catalogListingModel.setCatalogId(catalogId);
 				catalogListingModel.setDp(tagListing.getSellingPrice());
 						catalogListingModel.setAllocatedQuantity(stockAllocationQuantity);
+					}
 				} else {
 					catalogListingModel.setAllocatedQuantity(stockAllocationQuantity);
+				}
-				if (last15DaysMap != null) {
+				if (last15daysMap != null) {
-					Integer last15DaysSale = last15DaysMap.get(catalogId);
+					Integer last15DaysSale = last15daysMap.get(catalogId);
 					if (last15DaysSale != null) {
 						catalogListingModel.setLast15DaysSale(last15DaysSale);
 					} else {
 						catalogListingModel.setLast15DaysSale(0);
 				catalogListingMap.put(catalogId, catalogListingModel);
+			}
 			int itemAvailability = 0;
-			if (currentStock != null) {
+			if (currentStockMap != null) {
-				Integer qty = currentStock.get(catalogId);
+				Integer qty = currentStockMap.get(catalogId);
 				itemAvailability = qty == null ? 0 : qty;
 				catalogListingModel.setStockInHand(itemAvailability);
 			} else {
 				catalogListingModel.setStockInHand(0);
+			}
 			Integer inTransitQuantity = itemsInTransit.get(item.getId());
 			int inTransitQty = (inTransitQuantity == null ? 0 : inTransitQuantity);
 			catalogListingModel.setInTransitQuantity(catalogListingModel.getInTransitQuantity() + inTransitQty);
-			if (catalogListingModel.getAllocatedQuantity() > 0) {
-				toBeOrdered = Math.max(catalogListingModel.getToBeOrdered() - inTransitQty - itemAvailability, 0);
-				catalogListingModel.setToBeOrdered(toBeOrdered);
-			}
+		}
 		Map<Integer, CustomRetailer> customRetailersMap = retailerService.getFofoRetailers();
 		if (fofoId > 0) {
 			CustomRetailer customRetailer = customRetailersMap.get(fofoId);
 			model.addAttribute("counterSize", counterSize.toString());
+		}
 		String customRetailers = JSONObject.valueToString(customRetailersMap.values());
 		List<CatalogListingModel> catalogModelList = new ArrayList<>(catalogListingMap.values());
-		List<CatalogListingModel> catalogModel = catalogModelList.stream()
-				.filter(x -> !(x.getBrand().equals("Live Demo"))).collect(Collectors.toList());
 		Comparator<CatalogListingModel> firstCmp = Comparator.comparing(CatalogListingModel::getMinimumQty,
 				Comparator.reverseOrder());
 		LOGGER.info("monthlyPlanned" + monthlyPlanned);
+		model.addAttribute("catalogTagListings",
-		model.addAttribute("catalogTagListings", catalogModel.stream().sorted(firstCmp).collect(Collectors.toList()));
+				catalogModelList.stream().sorted(firstCmp).collect(Collectors.toList()));
 		model.addAttribute("isAdmin", roleManager.isAdmin(roleIds));
-		model.addAttribute("brandStockPrices",this.getBrandStockPrices(loginDetails.getFofoId()));
+		// model.addAttribute("brandStockPrices",this.getBrandStockPrices(loginDetails.getFofoId()));
 		model.addAttribute("customRetailers", customRetailers);
 		model.addAttribute("totalAmount", totalAmount);
 		model.addAttribute("monthlyPlanned", monthlyPlanned);
 		model.addAttribute("totalPcs", totalPcs);
 		return "open-indent";
+	}
 	private List<Order> filterValidOrders(List<Order> lastOrdersList) {
 		Iterator<Order> orderIterator = lastOrdersList.iterator();
 		while (orderIterator.hasNext()) {
 		focusedModelRepository.deleteById(catalogId);
 		model.addAttribute("response", mvcResponseSender.createResponseString(true));
 		return "response";
+	}
+	/*
-	private List<BrandStockPrice> getBrandStockPrices(int fofoId) throws Exception {
+	 * private List<BrandStockPrice> getBrandStockPrices(int fofoId) throws
+	 * Exception { Map<String, BrandStockPrice> brandStockPricesMap =
-		Map<String, BrandStockPrice> brandStockPricesMap = inventoryService.getBrandWiseStockValue(fofoId);
+	 * inventoryService.getBrandWiseStockValue(fofoId);
+	 *
-		List<DBObject> mobileBrands = mongoClient.getMongoBrands(fofoId, "", 3);
+	 * List<DBObject> mobileBrands = mongoClient.getMongoBrands(fofoId, "", 3);
-		List<BrandStockPrice> brandStockPrices = new ArrayList<>();
+	 * List<BrandStockPrice> brandStockPrices = new ArrayList<>();
+	 *
-		mobileBrands.stream().forEach(x -> {
-			String brand = (String) x.get("name");
+	 * mobileBrands.stream().forEach(x -> { String brand = (String) x.get("name");
-			if (brandStockPricesMap.containsKey(brand)) {
+	 * if (brandStockPricesMap.containsKey(brand)) { BrandStockPrice brandStockPrice
-				BrandStockPrice brandStockPrice = brandStockPricesMap.get(brand);
+	 * = brandStockPricesMap.get(brand); brandStockPrice.setBrandUrl((String)
-				brandStockPrice.setBrandUrl((String) x.get("url"));
-				brandStockPrice.setRank(((Double) x.get("rank")).intValue());
+	 * x.get("url")); brandStockPrice.setRank(((Double) x.get("rank")).intValue());
-				brandStockPrices.add(brandStockPrice);
+	 * brandStockPrices.add(brandStockPrice); } });
-			}
+	 *
-		});
-		return brandStockPrices.stream().filter(x -> x.getTotalQty() > 0).sorted((x, y) -> x.getRank() - y.getRank())
+	 * return brandStockPrices.stream().filter(x -> x.getTotalQty() > 0).sorted((x,
-				.collect(Collectors.toList());
+	 * y) -> x.getRank() - y.getRank()) .collect(Collectors.toList()); }
-	}
+	 */
+}

Subversion Repositories SmartDukaan

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