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

 import com.spice.profitmandi.dao.repository.catalog.TagListingRepository;
 import com.spice.profitmandi.dao.repository.cs.CsService;
 import com.spice.profitmandi.dao.repository.cs.PartnerRegionRepository;
 import com.spice.profitmandi.dao.repository.cs.PositionRepository;
 import com.spice.profitmandi.dao.repository.cs.RegionRepository;
+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.SaholicInventoryCISRepository;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
 import java.util.*;
 import java.util.Map.Entry;
 import java.util.function.Function;
+import java.util.stream.Collector;
 import java.util.stream.Collectors;
 @Controller
 @Transactional(rollbackFor = Throwable.class)
 public class IndentController {
 	@Autowired
 	private SuggestedPoDetailRepository suggestedPoDetailRepository;
 	@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);
 		if (roleManager.isAdmin(roleIds) || loginDetails.getFofoId() == 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);
+	}
 	@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;
 				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);
+	}
 	@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);
 		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()) {
 		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 = "recommended", defaultValue = "0") int recommended,
-							   @RequestParam(name = "minimumQty", defaultValue = "0") int minimumQty,
+			@RequestParam(name = "minimumQty", defaultValue = "0") int minimumQty,
-							   @RequestParam(name = "obvrecommend", defaultValue = "0") int obvrecommend,
+			@RequestParam(name = "obvrecommend", defaultValue = "0") int obvrecommend,
-							   @RequestParam(name = "obvminimum", defaultValue = "0") int obvminimum, @RequestParam int regionId,
+			@RequestParam(name = "obvminimum", defaultValue = "0") int obvminimum, @RequestParam int regionId,
-							   Model model) throws ProfitMandiBusinessException {
+			Model model) throws ProfitMandiBusinessException {
 		FocusedModel fm = new FocusedModel();
 		fm.setCatalogId(catalogId);
 		fm.setMinimumQty(minimumQty);
 		fm.setRecommendedQty(recommended);
+	}
 	@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;
 	private com.spice.profitmandi.service.transaction.TransactionService transactionService;
 	@Autowired
 	private CategoryRepository categoryRepository;
+	@Autowired
+	private BrandLimitRepository brandLimitRepository;
 	private List<OrderStatus> orderStatusList = Arrays.asList(OrderStatus.SUBMITTED_FOR_PROCESSING,
 			OrderStatus.ACCEPTED);
 	public static final Map<String, Double> Brand_Amount_Limit = new HashMap<>();
 	static {
-		Brand_Amount_Limit.put("Vivo", 250000.00);
-		Brand_Amount_Limit.put("Samsung", 150000.00);
-		Brand_Amount_Limit.put("Realme", 150000.00);
-		Brand_Amount_Limit.put("Tecno", 80000.00);
-		Brand_Amount_Limit.put("Itel", 30000.00);
-		Brand_Amount_Limit.put("Lava", 15000.00);
-		Brand_Amount_Limit.put("OnePlus", 200000.00);
-		Brand_Amount_Limit.put("Oppo", 250000.00);
-		Brand_Amount_Limit.put("Xiaomi", 0.00);
-		Brand_Amount_Limit.put("Nokia", 0.00);
 		Brand_Amount_Limit.put("accessories", 10000.00);
 		Brand_Amount_Limit.put("TV", 27000.00);
+	}
 	@RequestMapping(value = "/getPartnersBrandWiseDetail", method = RequestMethod.GET)
 			List<Integer> fofoIdList = new ArrayList<>(fofoIds);
 			Map<Integer, FofoReportingModel> partnerSalesHeadersMap = csService.getPartnerIdSalesHeaders();
 			model.addAttribute("partnerSalesHeadersMap", partnerSalesHeadersMap);
+			Map<Integer, Map<String, Float>> partnerBrandLimitMap = brandLimitRepository.selectAllPartnerBrandLimit()
+					.stream().collect(Collectors.groupingBy(x -> x.getFofoId(),
+							Collectors.toMap(x -> x.getBrand(), x -> x.getBrandLimit())));
+			model.addAttribute("partnerBrandLimitMap", partnerBrandLimitMap);
 			customRetailers = retailerService.getFofoRetailers(fofoIdList);
 			Map<Integer, Map<String, Double>> inStockBrandModel = new HashMap<>();
 			Map<Integer, Map<String, Double>> pendingIndent = new HashMap<>();
 			Map<Integer, Map<String, Double>> grnPendingOrders = new HashMap<>();
 		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();
 		CustomRetailer customRetailer = retailerService.getFofoRetailer(fofoId);
 		Map<Integer, Integer> processingOrderMap = null;
 		Map<Integer, Integer> catalogIdAndQtyMap = null;
 		Map<Integer, Integer> grnPendingOrdersMap = null;
+		List<PartnerStockDescriptionModel> inStocks = new ArrayList<>();
+		List<PartnerStockDescriptionModel> grnPendings = new ArrayList<>();
+		List<PartnerStockDescriptionModel> pendingIndents = new ArrayList<>();
 		Map<Integer, Integer> currentInventorySnapshot = currentInventorySnapshotRepository.selectByFofoId(fofoId)
 				.stream().collect(Collectors.toMap(x -> x.getItemId(), x -> x.getAvailability()));
 		if (!currentInventorySnapshot.isEmpty()) {
+			if (!brand.equals("undefined") && !brand.equals("accessories") && !brand.equals("TV")) {
-			catalogIdAndQtyMap = itemRepository.selectByIds(currentInventorySnapshot.keySet()).stream()
+				catalogIdAndQtyMap = itemRepository.selectByIds(currentInventorySnapshot.keySet()).stream()
+						.filter(x -> x.getBrand().equals(brand))
-					.collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
+						.collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
-							Collectors.summingInt(x -> currentInventorySnapshot.get(x.getId()))));
+								Collectors.summingInt(x -> currentInventorySnapshot.get(x.getId()))));
+			} else {
+				catalogIdAndQtyMap = itemRepository.selectByIds(currentInventorySnapshot.keySet()).stream()
+						.collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
+								Collectors.summingInt(x -> currentInventorySnapshot.get(x.getId()))));
+			}
+			inStocks.addAll(getBrandItemwiseDescription(brand, catalogIdAndQtyMap));
+		}
 		Map<Integer, Integer> grnPendingOrders = orderRepository.selectPendingGrnOrders(fofoId).stream()
 				.collect(Collectors.groupingBy(x -> x.getLineItem().getItemId(),
 						Collectors.summingInt(x -> x.getLineItem().getQuantity())));
 		if (!grnPendingOrders.isEmpty()) {
+			if (!brand.equals("undefined") && !brand.equals("accessories") && !brand.equals("TV")) {
-			grnPendingOrdersMap = itemRepository.selectByIds(grnPendingOrders.keySet()).stream()
+				grnPendingOrdersMap = itemRepository.selectByIds(grnPendingOrders.keySet()).stream()
+						.filter(x -> x.getBrand().equals(brand))
+						.collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
+								Collectors.summingInt(x -> grnPendingOrders.get(x.getId()))));
+			} else {
+				grnPendingOrdersMap = itemRepository.selectByIds(grnPendingOrders.keySet()).stream()
-					.collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
+						.collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
-							Collectors.summingInt(x -> grnPendingOrders.get(x.getId()))));
+								Collectors.summingInt(x -> grnPendingOrders.get(x.getId()))));
+			}
+			grnPendings.addAll(getBrandItemwiseDescription(brand, grnPendingOrdersMap));
+		}
 		Map<Integer, Integer> processingOrder = orderRepository.selectOrders(fofoId, orderStatusList).stream()
 				.collect(Collectors.groupingBy(x -> x.getLineItem().getItemId(),
 						Collectors.summingInt(x -> x.getLineItem().getQuantity())));
 		if (!processingOrder.isEmpty()) {
+			if (!brand.equals("undefined") && !brand.equals("accessories") && !brand.equals("TV")) {
-			processingOrderMap = itemRepository.selectByIds(processingOrder.keySet()).stream().collect(Collectors
+				processingOrderMap = itemRepository.selectByIds(processingOrder.keySet()).stream()
+						.filter(x -> x.getBrand().equals(brand)).collect(Collectors.groupingBy(
-					.groupingBy(x -> x.getCatalogItemId(), Collectors.summingInt(x -> processingOrder.get(x.getId()))));
+								x -> x.getCatalogItemId(), Collectors.summingInt(x -> processingOrder.get(x.getId()))));
+			} else {
+				processingOrderMap = itemRepository.selectByIds(processingOrder.keySet()).stream()
+						.collect(Collectors.groupingBy(x -> x.getCatalogItemId(),
+								Collectors.summingInt(x -> processingOrder.get(x.getId()))));
+			}
+			pendingIndents.addAll(getBrandItemwiseDescription(brand, processingOrderMap));
+		}
 		List<Integer> regionIds = partnerRegionRepository.selectByfofoId(fofoId).stream().map(x -> x.getRegionId())
 				.collect(Collectors.toList());
 		LOGGER.info("focusedModelShortageList" + focusedModelShortageList);
 		model.addAttribute("focusedModelShortageList", focusedModelShortageList);
+		model.addAttribute("inStocks", inStocks);
+		model.addAttribute("grnPendings", grnPendings);
+		model.addAttribute("pendingIndents", pendingIndents);
 		model.addAttribute("customRetailer", customRetailer);
+		model.addAttribute("brand", brand);
+		if (brand.equals("undefined")) {
+			Map<String, List<FocusedModelShortageModel>> focusedModelShortageBrandMap = focusedModelShortageList
+					.stream().collect(Collectors.groupingBy(x -> x.getBrandName()));
+			Map<String, List<PartnerStockDescriptionModel>> inStockBrandMap = inStocks.stream()
+					.collect(Collectors.groupingBy(x -> x.getBrand()));
+			LOGGER.info("inStockBrandMap" + inStockBrandMap);
+			Map<String, List<PartnerStockDescriptionModel>> grnPendingBrandMap = grnPendings.stream()
+					.collect(Collectors.groupingBy(x -> x.getBrand()));
+			LOGGER.info("grnPendingBrandMap" + grnPendingBrandMap);
+			Map<String, List<PartnerStockDescriptionModel>> pendingIndentBrandMap = pendingIndents.stream()
+					.collect(Collectors.groupingBy(x -> x.getBrand()));
+			LOGGER.info("pendingIndentBrandMap" + pendingIndentBrandMap);
+			model.addAttribute("inStockBrandMap", inStockBrandMap);
+			model.addAttribute("grnPendingBrandMap", grnPendingBrandMap);
+			model.addAttribute("focusedModelShortageBrandMap", focusedModelShortageBrandMap);
+			model.addAttribute("pendingIndentBrandMap", pendingIndentBrandMap);
+		}
 		return "partner-stock";
+	}
+	private List<PartnerStockDescriptionModel> getBrandItemwiseDescription(String brand,
+			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());
+			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) {
+							PartnerStockDescriptionModel psdp = new PartnerStockDescriptionModel();
+							psdp.setBrand(items.get(0).getBrand());
+							psdp.setItemDescription(items.get(0).getBrand() + " " + items.get(0).getModelName() + " "
+									+ items.get(0).getModelNumber());
+							psdp.setQty(inStock.getValue());
+							inStocks.add(psdp);
+						}
+					}
+				}
+			} else if (brand.equals("TV")) {
+				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() == 14200) {
+							PartnerStockDescriptionModel psdp = new PartnerStockDescriptionModel();
+							psdp.setBrand(items.get(0).getBrand());
+							psdp.setItemDescription(items.get(0).getBrand() + " " + items.get(0).getModelName() + " "
+									+ items.get(0).getModelNumber());
+							psdp.setQty(inStock.getValue());
+							inStocks.add(psdp);
+						}
+					}
+				}
+			} else {
+				PartnerStockDescriptionModel psdp = new PartnerStockDescriptionModel();
+				psdp.setBrand(items.get(0).getBrand());
+				psdp.setItemDescription(items.get(0).getBrand() + " " + items.get(0).getModelName() + " "
+						+ items.get(0).getModelNumber());
+				psdp.setQty(inStock.getValue());
+				inStocks.add(psdp);
+			}
+		}
+		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<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;
 		model.addAttribute("warehouses", ProfitMandiConstants.WAREHOUSE_MAP);
 		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 {
+	public String sendPONotification(HttpServletRequest request, @RequestBody POItemWarehouseModel poItemWarehouseModel,
+			Model model) throws Exception {
-		Map<Integer, Item> selectedItemsMap = itemRepository.selectByIds(poItemWarehouseModel.getItemIdQuantityList().stream().map(x -> x.getItemId()).collect(Collectors.toSet())).stream().collect(Collectors.toMap(x -> x.getId(), x -> x));
+		Map<Integer, Item> selectedItemsMap = itemRepository.selectByIds(poItemWarehouseModel.getItemIdQuantityList()
+				.stream().map(x -> x.getItemId()).collect(Collectors.toSet())).stream()
+				.collect(Collectors.toMap(x -> x.getId(), x -> x));
-		Set<String> brands = selectedItemsMap.values().stream().map(x -> x.getBrand().toLowerCase()).collect(Collectors.toSet());
+		Set<String> brands = selectedItemsMap.values().stream().map(x -> x.getBrand().toLowerCase())
+				.collect(Collectors.toSet());
 		int warehouseId = poItemWarehouseModel.getWarehouseId();
 		SendNotificationModel sendNotificationModel = new SendNotificationModel();
 		sendNotificationModel.setCampaignName("SendPo");
 		sendNotificationModel.setTitle(String.format(PO_TITLE_STRING));
 		StringBuilder stringBuilder = new StringBuilder();
 		poItemWarehouseModel.getItemIdQuantityList().stream().forEach(itemIdQuantity -> {
-			stringBuilder.append(selectedItemsMap.get(itemIdQuantity.getItemId()).getItemDescription()).append("-").append(itemIdQuantity.getQuantity()).append("pcs").append("\n");
+			stringBuilder.append(selectedItemsMap.get(itemIdQuantity.getItemId()).getItemDescription()).append("-")
+					.append(itemIdQuantity.getQuantity()).append("pcs").append("\n");
 		});
 		sendNotificationModel.setMessage(stringBuilder.toString());
 		sendNotificationModel.setType("url");
 		sendNotificationModel.setUrl("https://app.smartdukaan.com/pages/home/notifications");
 		sendNotificationModel.setExpiresat(LocalDateTime.now().plusDays(1));
 		sendNotificationModel.setMessageType(MessageType.notification);
+		List<BrandRegionMapping> brandRegionMappings = brandRegionMappingRepository
-		List<BrandRegionMapping> brandRegionMappings = brandRegionMappingRepository.selectAll().stream().filter(x -> brands.contains(x.getBrand().toLowerCase()) && x.getFromWarehouseId() == warehouseId && x.isAccessory() == false).collect(Collectors.toList());
+				.selectAll().stream().filter(x -> brands.contains(x.getBrand().toLowerCase())
+						&& x.getFromWarehouseId() == warehouseId && x.isAccessory() == false)
+				.collect(Collectors.toList());
-		List<Integer> toWarehouseIds = brandRegionMappings.stream().map(x -> x.getToWarehouseId()).collect(Collectors.toList());
+		List<Integer> toWarehouseIds = brandRegionMappings.stream().map(x -> x.getToWarehouseId())
+				.collect(Collectors.toList());
+		List<Integer> fofoIds = fofoStoreRepository.selectByWarehouseIds(toWarehouseIds).stream()
-		List<Integer> fofoIds = fofoStoreRepository.selectByWarehouseIds(toWarehouseIds).stream().filter(x -> !x.isInternal() && x.isActive()).map(x -> x.getId()).collect(Collectors.toList());
+				.filter(x -> !x.isInternal() && x.isActive()).map(x -> x.getId()).collect(Collectors.toList());
 		List<Integer> userIds = userAccountRepository.selectUserIdsByRetailerIds(fofoIds);
 		sendNotificationModel.setUserIds(userIds);
 		notificationService.sendNotification(sendNotificationModel);
 		model.addAttribute("response", true);

Subversion Repositories SmartDukaan

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