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

 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;
 		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();
 		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<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;
 		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> selectedItemsMap = itemRepository.selectByIds(poItemWarehouseModel.getItemIdQuantityList()
+		Map<Integer, Item> selectedCatalogItemMap = itemRepository.selectAllByCatalogIds(new HashSet<>(poItemWarehouseModel.getCatalogIds()))
-				.stream().map(x -> x.getItemId()).collect(Collectors.toSet())).stream()
-				.collect(Collectors.toMap(x -> x.getId(), x -> x));
+				.stream().collect(Collectors.toMap(x -> x.getCatalogItemId(), x -> x, (existing, replacement) -> existing));
-		Set<String> brands = selectedItemsMap.values().stream().map(x -> x.getBrand().toLowerCase())
+		Set<String> brands = selectedCatalogItemMap.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");
-		});
-		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);
+		int warehouseId = poItemWarehouseModel.getWarehouseId();
+		for (String brand : brands) {
+			Map<Integer, Item> brandSpecificCatalogItemMap = selectedCatalogItemMap.entrySet().stream()
+					.filter(x -> x.getValue().getBrand().equals(brand)).collect(Collectors.toMap(x -> x.getKey(), x -> x.getValue()));
+			SendNotificationModel sendNotificationModel = new SendNotificationModel();
+			sendNotificationModel.setCampaignName("SendPo");
+			sendNotificationModel.setTitle(String.format(PO_TITLE_STRING));
+			StringBuilder stringBuilder = new StringBuilder();
+		/*poItemWarehouseModel.getCatalogIds().stream().forEach(catalogId -> {
+			stringBuilder.append(selectedCatalogItemMap.get(catalogId).getItemDescription()).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())
+					.selectAll().stream().filter(x -> brand.equals(x.getBrand().toLowerCase())
-						&& x.getFromWarehouseId() == warehouseId && x.isAccessory() == false)
+							&& x.getFromWarehouseId() == warehouseId && !x.isAccessory())
-				.collect(Collectors.toList());
+					.collect(Collectors.toList());
-		List<Integer> toWarehouseIds = brandRegionMappings.stream().map(x -> x.getToWarehouseId())
+			List<Integer> toWarehouseIds = brandRegionMappings.stream().map(x -> x.getToWarehouseId())
-				.collect(Collectors.toList());
+					.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);
+			List<Integer> userIds = userAccountRepository.selectUserIdsByRetailerIds(fofoIds);
-		sendNotificationModel.setUserIds(userIds);
+			sendNotificationModel.setUserIds(userIds);
-		notificationService.sendNotification(sendNotificationModel);
+			notificationService.sendNotification(sendNotificationModel);
+		}
 		model.addAttribute("response", true);
 		return "response";
+	}
+}

Subversion Repositories SmartDukaan

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