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

 package com.spice.profitmandi.web.controller;
 import java.io.Serializable;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
-import java.util.DoubleSummaryStatistics;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 import java.util.Set;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 import javax.servlet.http.HttpServletRequest;
 import org.apache.commons.io.output.ByteArrayOutputStream;
 import org.apache.logging.log4j.Logger;
 import org.apache.thrift.TException;
 import org.json.JSONArray;
 import org.json.JSONObject;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.core.io.ByteArrayResource;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
+import org.springframework.mail.javamail.JavaMailSender;
 import org.springframework.stereotype.Controller;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.ui.Model;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.RequestParam;
 import com.spice.profitmandi.common.enumuration.CounterSize;
 import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
-import com.spice.profitmandi.common.model.BrandPerformance;
 import com.spice.profitmandi.common.model.CatalogListingModel;
 import com.spice.profitmandi.common.model.CustomRetailer;
+import com.spice.profitmandi.common.model.FocusedModelShortageModel;
 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.FileUtil;
+import com.spice.profitmandi.common.util.FormattingUtils;
+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.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;
+import com.spice.profitmandi.dao.repository.catalog.FocusedModelRepository;
 import com.spice.profitmandi.dao.repository.catalog.ItemRepository;
 import com.spice.profitmandi.dao.repository.catalog.TagListingRepository;
+import com.spice.profitmandi.dao.repository.cs.CsService;
 import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;
 import com.spice.profitmandi.dao.repository.fofo.CurrentInventorySnapshotRepository;
+import com.spice.profitmandi.dao.repository.fofo.FofoOrderRepository;
+import com.spice.profitmandi.dao.repository.fofo.MonthlyPlannedRepository;
+import com.spice.profitmandi.dao.repository.fofo.PlannedDetailRepository;
 import com.spice.profitmandi.dao.repository.fofo.PurchaseRepository;
 import com.spice.profitmandi.dao.repository.transaction.OrderRepository;
 import com.spice.profitmandi.dao.repository.transaction.UserWalletRepository;
 import com.spice.profitmandi.dao.repository.user.UserRepository;
 import com.spice.profitmandi.service.authentication.RoleManager;
 	private final List<OrderStatus> partnerPendingOrderList = Arrays.asList(OrderStatus.ACCEPTED,
 			OrderStatus.SUBMITTED_FOR_PROCESSING, OrderStatus.BILLED, OrderStatus.SHIPPED_FROM_WH,
 			OrderStatus.SHIPPED_TO_DESTINATION_CITY, OrderStatus.SHIPPED_TO_LOGST,
 			OrderStatus.REACHED_DESTINATION_CITY);
 	@Autowired
 	WalletService walletService;
 	@Autowired
+	private JavaMailSender googleMailSender;
+	@Autowired
 	private CookiesProcessor cookiesProcessor;
 	@Autowired
 	private UserWalletRepository userWalletRepository;
 	@Autowired
 	private MVCResponseSender mvcResponseSender;
 	@Autowired
+	private FocusedModelRepository focusedModelRepository;
+	@Autowired
+	private MonthlyPlannedRepository monthlyPlannedRepository;
+	@Autowired
+	private FofoOrderRepository fofoOrderRepository;
+	@Autowired
+	private PlannedDetailRepository plannedDetailRepository;
+	@Autowired
 	RoleManager roleManager;
+	@Autowired
+	CsService csService;
+	/*
+	 * @RequestMapping(value = "/open-indent/save", method = RequestMethod.POST)
+	 * public String saveOpenIndent(HttpServletRequest request, Model model,
+	 *
+	 * @RequestBody List<StockAllocationModel>
+	 * stockAllocationModelList, @RequestParam int fofoId,
+	 *
+	 * @RequestParam(defaultValue = "TEN_LAC") CounterSize counterSize) throws
+	 * Exception { LoginDetails loginDetails =
+	 * cookiesProcessor.getCookiesObject(request); boolean response = false; if
+	 * (fofoId > 0) { FofoStore fs = fofoStoreRepository.selectByRetailerId(fofoId);
+	 * stockAllocationModelList.forEach(x -> { x.setFofoId(fofoId);
+	 * x.setCounterSize(fs.getCounterSize()); }); } else {
+	 * stockAllocationModelList.forEach(x -> { x.setFofoId(fofoId);
+	 * x.setCounterSize(counterSize); }); } if
+	 * (roleManager.isAdmin(loginDetails.getRoleIds())) { response =
+	 * stockAllocationService.addToAllocation(stockAllocationModelList);
+	 * model.addAttribute("response",
+	 * mvcResponseSender.createResponseString(response)); } return "response"; }
+	 */
 	@RequestMapping(value = "/open-indent/save", method = RequestMethod.POST)
-	public String saveOpenIndent(HttpServletRequest request, Model model,
+	public String saveOpenIndent(HttpServletRequest request, Model model, @RequestParam int catalogId,
-			@RequestBody List<StockAllocationModel> stockAllocationModelList, @RequestParam int fofoId,
-			@RequestParam(defaultValue = "TEN_LAC") CounterSize counterSize) throws Exception {
+			@RequestParam int itemQty) throws Exception {
 		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
+		LocalDate currentMonthdate = LocalDate.now().withDayOfMonth(1);
+		LOGGER.info("currentMonthdate" + currentMonthdate);
+		LOGGER.info("catalogId" + catalogId);
+		LOGGER.info("itemQty" + itemQty);
+		MonthlyPlanned monthlyPlanned = monthlyPlannedRepository.selectByFofoIdYearMonth(loginDetails.getFofoId(),
-		boolean response = false;
+				currentMonthdate);
-		if (fofoId > 0) {
+		if (monthlyPlanned == null) {
+			monthlyPlanned = new MonthlyPlanned();
-			FofoStore fs = fofoStoreRepository.selectByRetailerId(fofoId);
+			monthlyPlanned.setFofoId(loginDetails.getFofoId());
+			monthlyPlanned.setYearMonth(currentMonthdate);
-			stockAllocationModelList.forEach(x -> {
+			monthlyPlannedRepository.persist(monthlyPlanned);
+			PlannedDetail pd = new PlannedDetail();
-				x.setFofoId(fofoId);
+			pd.setCatalogId(catalogId);
+			pd.setPlannedId(monthlyPlanned.getId());
+			pd.setQuantity(itemQty);
-				x.setCounterSize(fs.getCounterSize());
+			pd.setUpdatedTimestamp(LocalDateTime.now());
+			plannedDetailRepository.persist(pd);
-			});
 		} else {
+			PlannedDetail plannedDetail = plannedDetailRepository.selectByPlannedIdCatalogId(monthlyPlanned.getId(),
+					catalogId);
-			stockAllocationModelList.forEach(x -> {
+			if (plannedDetail == null) {
+				plannedDetail = new PlannedDetail();
-				x.setFofoId(fofoId);
+				plannedDetail.setCatalogId(catalogId);
+				plannedDetail.setPlannedId(monthlyPlanned.getId());
-				x.setCounterSize(counterSize);
+				plannedDetail.setQuantity(itemQty);
+				plannedDetail.setUpdatedTimestamp(LocalDateTime.now());
+				plannedDetailRepository.persist(plannedDetail);
-			});
+			} else if (itemQty == 0) {
+				plannedDetailRepository.delete(plannedDetail);
-		}
+			} else {
-		if (roleManager.isAdmin(loginDetails.getRoleIds())) {
+				plannedDetail.setCatalogId(catalogId);
-			response = stockAllocationService.addToAllocation(stockAllocationModelList);
+				plannedDetail.setQuantity(itemQty);
-			model.addAttribute("response", mvcResponseSender.createResponseString(response));
+				plannedDetail.setUpdatedTimestamp(LocalDateTime.now());
+			}
+		}
+		model.addAttribute("response", mvcResponseSender.createResponseString(true));
+		return "response";
+	}
+	@RequestMapping(value = "/open-indent/confirm", method = RequestMethod.POST)
+	public String confirmOpenIndent(HttpServletRequest request, Model model) throws Exception {
+		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
+		int fofoId = loginDetails.getFofoId();
+		CustomRetailer customRetailer = retailerService.getFofoRetailer(fofoId);
+		MonthlyPlanned monthlyPlanned = monthlyPlannedRepository.selectByFofoId(fofoId);
+		LOGGER.info("monthlyPlanned" + monthlyPlanned);
+		List<PlannedDetail> plannedDetails = plannedDetailRepository.selectByPlannedId(monthlyPlanned.getId());
+		List<PlannedModel> plannedModel = new ArrayList<>();
+		for (PlannedDetail plannedDetail : plannedDetails) {
+			List<Item> items = itemRepository.selectAllByCatalogItemId(plannedDetail.getCatalogId());
+			String itemDesription = items.get(0).getItemDescriptionNoColor();
+			PlannedModel pm = new PlannedModel();
+			pm.setItemDescription(itemDesription);
+			pm.setStoreName(customRetailer.getBusinessName());
+			pm.setQty(plannedDetail.getQuantity());
+			pm.setFofoId(loginDetails.getFofoId());
+			plannedModel.add(pm);
+			LOGGER.info("plannedModel" + plannedModel);
+		}
+		List<String> emails = csService.getAuthUserByPartnerId(fofoId);
+		emails.add(customRetailer.getEmail());
+		LOGGER.info("emails" + emails);
+		ByteArrayOutputStream baos = FileUtil.getCSVByteStream(
+				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, emails.toArray(new String[emails.size()]), null,
+				"Planned Indent", "PFA",
+				new Attachment[] { new Attachment("PlannedIndent.csv", new ByteArrayResource(baos.toByteArray())), });
+		model.addAttribute("response", mvcResponseSender.createResponseString(true));
 		return "response";
+	}
 	@RequestMapping(value = "/indent/download", method = RequestMethod.GET)
 	public ResponseEntity<ByteArrayResource> downloadIndent(HttpServletRequest request, Model model,
 			@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) {
+		if (roleManager.isAdmin(roleIds) || loginDetails.getFofoId() == fofoId) {
 			List<Integer> fofoIds = fofoStoreRepository.selectAll().stream().map(x -> x.getId())
 					.collect(Collectors.toList());
 			Map<Integer, CustomRetailer> customRetailersMap = retailerService.getFofoRetailers(fofoIds);
 			List<StockAllocationModel> stockAllocationList = stockAllocationService.getStockAllocation(counterSize,
 		Set<Integer> roleIds = loginDetails.getRoleIds();
 		LOGGER.info("Counter size is {}", counterSize);
 		LOGGER.info("Fofo Id is {}", fofoId);
 		boolean isAdmin = !roleManager.isAdmin(roleIds);
 		Map<Integer, ItemIdAvailability> itemCisMap = null;
-		if (!isAdmin && fofoId==0) {
+		if (!isAdmin && fofoId == 0) {
 			fofoId = cookiesProcessor.getCookiesObject(request).getFofoId();
 			List<ItemIdAvailability> currentInventorySnapshots = currentInventorySnapshotRepository
 					.selectItemsStock(fofoId);
 			itemCisMap = currentInventorySnapshots.stream().filter(x -> x.getAvailability() > 0)
 					.collect(Collectors.toMap(x -> x.getItemId(), x -> x));
 		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()));
+		Map<Integer, Item> items = itemRepository
-		Map<Integer, Item> items = itemRepository.selectByIds(tagListings.stream().map(x->x.getItemId()).collect(Collectors.toSet())).stream().
+				.selectByIds(tagListings.stream().map(x -> x.getItemId()).collect(Collectors.toSet())).stream()
-				collect(Collectors.toMap(x->x.getId(), x->x));
+				.collect(Collectors.toMap(x -> x.getId(), x -> x));
+		Map<Integer, Integer> fofoOrderMap = fofoOrderRepository
+				.selectByFofoIdBetweenCreatedTimeStamp(loginDetails.getFofoId(), LocalDateTime.now().minusDays(15),
+						LocalDateTime.now())
+				.stream()
+				.collect(Collectors.toMap(x -> x.getOrderItem().getItemId(), x -> x.getOrderItem().getQuantity()));
+		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()))));
+		}
+		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()));
+		}
 		while (iterator.hasNext()) {
 			TagListing tagListing = iterator.next();
 			Item item = items.get(tagListing.getItemId());
 			// itemRepository.select
 						|| itemStockAllocationMap.containsKey(tagListing.getItemId()))) {
 					iterator.remove();
 					continue;
+				}
+			}
 			int catalogId = item.getCatalogItemId();
 			CatalogListingModel catalogListingModel = catalogListingMap.get(catalogId);
 			if (!catalogListingMap.containsKey(catalogId)) {
 				catalogListingModel = new CatalogListingModel();
 				catalogListingModel.setDp(tagListing.getSellingPrice());
 				catalogListingModel.setMop(tagListing.getMop());
 				catalogListingModel.setItemDescription(item.getItemDescriptionNoColor());
 				StockAllocationModel stockAllocationModel = itemStockAllocationMap.get(item.getCatalogItemId());
 				int stockAllocationQuantity = stockAllocationModel == null ? 0 : stockAllocationModel.getQuantity();
+				if (plannedDetailMap != null) {
+					Integer quantity = plannedDetailMap.get(catalogId);
+					if (quantity != null) {
+						catalogListingModel.setAllocatedQuantity(quantity);
+					} else {
+						catalogListingModel.setAllocatedQuantity(stockAllocationQuantity);
+					}
+				} else {
-				catalogListingModel.setAllocatedQuantity(stockAllocationQuantity);
+					catalogListingModel.setAllocatedQuantity(stockAllocationQuantity);
+				}
+				if (last15DaysMap != null) {
+					Integer last15DaysSale = last15DaysMap.get(catalogId);
+					if (last15DaysSale != null) {
+						catalogListingModel.setLast15DaysSale(last15DaysSale);
+					} else {
+						catalogListingModel.setLast15DaysSale(0);
+					}
+				} else {
+					catalogListingModel.setLast15DaysSale(0);
+				}
 				catalogListingModel.setToBeOrdered(stockAllocationQuantity);
 				catalogListingModel.setBrand(item.getBrand());
 				if (item.getCategoryId() == 10006) {
 					catalogListingModel.setCategoryId(item.getCategoryId());
+				}
+				FocusedModel fm = focusedModelMap.get(catalogId);
+				if (fm != null) {
+					catalogListingModel.setRecommendedQty(fm.getRecommendedQty());
+					catalogListingModel.setMinimumQty(fm.getMinimumQty());
+				} else {
+					catalogListingModel.setRecommendedQty(0);
+					catalogListingModel.setMinimumQty(0);
+				}
 				catalogListingMap.put(catalogId, catalogListingModel);
+			}
 			ItemIdAvailability itemIdAvailability = itemCisMap.get(tagListing.getItemId());
 			int itemAvailability = itemIdAvailability == null ? 0 : itemIdAvailability.getAvailability();
 			catalogListingModel.setStockInHand(catalogListingModel.getStockInHand() + itemAvailability);
 			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("retailerName",
 					customRetailer.getBusinessName() + "-" + customRetailer.getAddress().getCity());
 			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());
+		LOGGER.info("item" + catalogModelList);
-		Comparator<CatalogListingModel> firstCmp = Comparator.comparing(CatalogListingModel::getToBeOrdered,
+		Comparator<CatalogListingModel> firstCmp = Comparator.comparing(CatalogListingModel::getMinimumQty,
 				Comparator.reverseOrder());
-		model.addAttribute("catalogTagListings",
+		LOGGER.info("monthlyPlanned" + monthlyPlanned);
-				catalogModelList.stream().sorted(firstCmp).collect(Collectors.toList()));
+		model.addAttribute("catalogTagListings", catalogModel.stream().sorted(firstCmp).collect(Collectors.toList()));
 		model.addAttribute("isAdmin", roleManager.isAdmin(roleIds));
 		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) {
 			LOGGER.error("Unexpected exception", e);
+		}
 		return sum;
+	}
+	@RequestMapping(value = "/getFocusedModel", method = RequestMethod.GET)
+	public String getFocusedModel(HttpServletRequest request,
+			@RequestParam(name = "offset", defaultValue = "0") int offset,
+			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model)
+			throws ProfitMandiBusinessException {
+		List<FocusedModel> focusedModels = focusedModelRepository.selectAll(offset, limit);
+		Map<Integer, Item> itemMap = this.getItemByCatalogId(focusedModels);
+		model.addAttribute("focusedModels", focusedModels);
+		model.addAttribute("itemMap", itemMap);
+		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;
+	}
+	@RequestMapping(value = "/focusedModel", method = RequestMethod.POST)
+	public String focusedModel(HttpServletRequest request, @RequestParam int catalogId, @RequestParam int recommended,
+			@RequestParam int minimumQty, Model model) throws ProfitMandiBusinessException {
+		FocusedModel fm = new FocusedModel();
+		fm.setCatalogId(catalogId);
+		fm.setMinimumQty(minimumQty);
+		fm.setRecommendedQty(recommended);
+		fm.setCreatedTimestamp(LocalDateTime.now());
+		focusedModelRepository.persist(fm);
+		return "focused_model";
+	}
+	@RequestMapping(value = "/removeItem", method = RequestMethod.DELETE)
+	public String removeFocusedModelItem(HttpServletRequest request,
+			@RequestParam(name = "catalogId", defaultValue = "0") int catalogId, Model model) throws Exception {
+		focusedModelRepository.deleteById(catalogId);
+		model.addAttribute("response", mvcResponseSender.createResponseString(true));
+		return "response";
+	}
 }

Subversion Repositories SmartDukaan

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