Subversion Repositories SmartDukaan

import java.util.Optional;

import com.spice.profitmandi.common.model.FocusedModelShortageModel;

import com.spice.profitmandi.common.model.IntegerIdAggregateValue;

import com.spice.profitmandi.common.model.ProfitMandiConstants;

import com.spice.profitmandi.dao.entity.catalog.Category;

import com.spice.profitmandi.dao.entity.cs.Position;

import com.spice.profitmandi.dao.entity.fofo.PartnerDailyInvestment;

import com.spice.profitmandi.dao.entity.fofo.PartnerType;

import com.spice.profitmandi.dao.entity.inventory.SaholicPOItem;

import com.spice.profitmandi.dao.model.FofoReportingModel;

import com.spice.profitmandi.dao.model.InStockAccessoriesTvFofoIdModel;

import com.spice.profitmandi.dao.model.InStockBrandFofoIdModel;

import com.spice.profitmandi.dao.repository.catalog.CategoryRepository;

import com.spice.profitmandi.dao.repository.cs.PositionRepository;

import com.spice.profitmandi.dao.repository.fofo.PartnerDailyInvestmentRepository;

import com.spice.profitmandi.dao.repository.fofo.PartnerTypeChangeService;

	@Autowired

	private PartnerDailyInvestmentRepository partnerDailyInvestmentRepository;

	List<String> emails = Arrays.asList("kamini.sharma@smartdukaan.com", "neeraj.gupta@smartdukaan.com",

			"niranjan.kala@smartdukaan.com", "amit.gupta@shop2020.in", "tejbeer.kaur@shop2020.in");

	@Autowired

	private PositionRepository positionRepository;

	@Autowired

	private PartnerTypeChangeService partnerTypeChangeService;

	@Autowired

	private com.spice.profitmandi.service.transaction.TransactionService transactionService;

	@Autowired

	private CategoryRepository categoryRepository;

	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)

	public String getPartnersBrandWiseDetail(HttpServletRequest request, Model model) throws Exception {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		String email = loginDetails.getEmailId();

		List<String> brands = Arrays.asList("Vivo", "Samsung", "Oppo", "Tecno", "Itel", "OnePlus", "Lava", "Realme",

				"Xiaomi", "Nokia");

		AuthUser authUser = authRepository.selectByEmailOrMobile(email);

		Map<String, Set<Integer>> storeGuyMap = csService.getAuthUserPartnerIdMapping();

		Set<Integer> fofoIds = storeGuyMap.get(authUser.getEmailId());

		if (emails.contains(authUser.getEmailId())) {

			fofoIds = storeGuyMap.get("tarun.verma@smartdukaan.com");

			LOGGER.info("fofoIds" + fofoIds);

		}

		if (fofoIds == null) {

			List<Position> positions1 = positionRepository.selectAll(authUser.getId());

			if (positions1.stream().filter(x -> x.getCategoryId() == ProfitMandiConstants.TICKET_CATEGORY_MASTER)

					.count() > 0) {

				fofoIds = csService.getPositionCustomRetailerMap(positions1).values().stream().flatMap(x -> x.stream())

						.map(x -> x.getPartnerId()).collect(Collectors.toSet());

			}

		}

		Map<Integer, PartnerDailyInvestment> partnerDailyInvestmentMap = new HashMap<>();

		Map<Integer, Map<String, Double>> inStockBrandModel = new HashMap<>();

		Map<Integer, Map<String, Double>> pendingIndent = new HashMap<>();

		Map<Integer, Map<String, Double>> grnPendingOrders = new HashMap<>();

		Map<Integer, InStockAccessoriesTvFofoIdModel> inStockAccessTv = new HashMap<>();

		Map<Integer, InStockAccessoriesTvFofoIdModel> pendingIndentAccessTv = new HashMap<>();

		Map<Integer, InStockAccessoriesTvFofoIdModel> grnPendingAccessTvOrders = new HashMap<>();

		Map<Integer, CustomRetailer> customRetailers = new HashMap<>();

		Map<Integer, PartnerType> fofoIdPartnerTypeMap = new HashMap<>();

		if (fofoIds.size() > 0 && fofoIds != null) {

			List<Integer> fofoIdList = new ArrayList<>(fofoIds);

			Map<Integer, FofoReportingModel> partnerSalesHeadersMap = csService.getPartnerIdSalesHeaders();

			model.addAttribute("partnerSalesHeadersMap", partnerSalesHeadersMap);

			customRetailers = retailerService.getFofoRetailers(fofoIdList);

			for (Entry<Integer, CustomRetailer> customRetailer : customRetailers.entrySet()) {

				PartnerType partnerType = partnerTypeChangeService.getTypeOnDate(customRetailer.getKey(),

						LocalDate.now());

				fofoIdPartnerTypeMap.put(customRetailer.getKey(), partnerType);

			}

			List<PartnerDailyInvestment> partnerDailyInvestments = partnerDailyInvestmentRepository

					.selectAll(new ArrayList<>(fofoIdList), LocalDate.now().minusDays(1));

			if (!partnerDailyInvestments.isEmpty()) {

				partnerDailyInvestmentMap = partnerDailyInvestments.stream()

						.collect(Collectors.toMap(x -> x.getFofoId(), x -> x));

			}

			inStockBrandModel = currentInventorySnapshotRepository.selectSumInStockMobiletabletGroupByBrand(fofoIdList)

					.stream()

					.collect(Collectors.groupingBy(InStockBrandFofoIdModel::getFofoId,

							Collectors.groupingBy(InStockBrandFofoIdModel::getBrand,

									Collectors.summingDouble(InStockBrandFofoIdModel::getAmount))));

			pendingIndent = transactionService.getInTransitOrders(fofoIdList).stream()

					.filter(x -> x.getLineItem().getItem().equals("10006"))

					.collect(Collectors.groupingBy(x -> x.getRetailerId(),

							Collectors.groupingBy(y -> y.getLineItem().getBrand(),

									Collectors.summingDouble(y -> (double) y.getTotalAmount()))));

			grnPendingOrders = orderRepository.selectPendingGrnOrders(fofoIdList).stream()

					.filter(x -> x.getLineItem().getItem().equals("10006"))

					.collect(Collectors.groupingBy(x -> x.getRetailerId(),

							Collectors.groupingBy(y -> y.getLineItem().getBrand(),

									Collectors.summingDouble(y -> (double) y.getTotalAmount()))));

			inStockAccessTv = currentInventorySnapshotRepository.selectSumInStockAccessoriesAndTv(fofoIdList).stream()

					.collect(Collectors.toMap(x -> x.getFofoId(), x -> x));

			pendingIndentAccessTv = orderRepository.selectAllPendingIndentAccessoriesTvGroupByFofoId(fofoIdList)

					.stream().collect(Collectors.toMap(x -> x.getFofoId(), x -> x));

			grnPendingAccessTvOrders = orderRepository.selectAllGrnPendingAccessoriesTvGroupByFofoId(fofoIdList)

					.stream().collect(Collectors.toMap(x -> x.getFofoId(), x -> x));

		}

		model.addAttribute("customRetailers", customRetailers);

		LOGGER.info("partnerDailyInvestmentMap" + partnerDailyInvestmentMap);

		model.addAttribute("partnerDailyInvestmentMap", partnerDailyInvestmentMap);

		LOGGER.info("inStockBrandModel" + inStockBrandModel);

		model.addAttribute("brands", brands);

		model.addAttribute("brandAmountLimit", Brand_Amount_Limit);

		model.addAttribute("inStockBrandModel", inStockBrandModel);

		model.addAttribute("pendingIndent", pendingIndent);

		model.addAttribute("grnPendingOrders", grnPendingOrders);

		model.addAttribute("inStockAccessTv", inStockAccessTv);

		model.addAttribute("pendingIndentAccessTv", pendingIndentAccessTv);

		model.addAttribute("grnPendingAccessTvOrders", grnPendingAccessTvOrders);

		model.addAttribute("fofoIdPartnerTypeMap", fofoIdPartnerTypeMap);

		return "partner-brandwise-detail";

	}

	@RequestMapping(value = "/getPartnerShortageStock", method = RequestMethod.GET)

	public String getPartnerShortageStock(HttpServletRequest request,

			@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<>();

		CustomRetailer customRetailer = retailerService.getFofoRetailer(fofoId);

		Map<Integer, Integer> processingOrderMap = null;

		Map<Integer, Integer> catalogIdAndQtyMap = null;

		Map<Integer, Integer> grnPendingOrdersMap = null;

		Map<Integer, Integer> currentInventorySnapshot = currentInventorySnapshotRepository.selectByFofoId(fofoId)

				.stream().collect(Collectors.toMap(x -> x.getItemId(), x -> x.getAvailability()));

		if (!currentInventorySnapshot.isEmpty()) {

			catalogIdAndQtyMap = itemRepository.selectByIds(currentInventorySnapshot.keySet()).stream()

					.collect(Collectors.groupingBy(x -> x.getCatalogItemId(),

							Collectors.summingInt(x -> currentInventorySnapshot.get(x.getId()))));

		}

		Map<Integer, Integer> grnPendingOrders = orderRepository.selectPendingGrnOrders(fofoId).stream()

				.collect(Collectors.groupingBy(x -> x.getLineItem().getItemId(),

						Collectors.summingInt(x -> x.getLineItem().getQuantity())));

		if (!grnPendingOrders.isEmpty()) {

			grnPendingOrdersMap = itemRepository.selectByIds(grnPendingOrders.keySet()).stream()

					.collect(Collectors.groupingBy(x -> x.getCatalogItemId(),

							Collectors.summingInt(x -> grnPendingOrders.get(x.getId()))));

		}

		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()) {

			processingOrderMap = itemRepository.selectByIds(processingOrder.keySet()).stream().collect(Collectors

					.groupingBy(x -> x.getCatalogItemId(), Collectors.summingInt(x -> processingOrder.get(x.getId()))));

		}

		List<Integer> regionIds = partnerRegionRepository.selectByfofoId(fofoId).stream().map(x -> x.getRegionId())

				.collect(Collectors.toList());

		LOGGER.info("regionIds" + regionIds);

		if (regionIds.size() == 0) {

			LOGGER.info("No region found for partner {}", fofoId);

		}

		Map<Integer, Optional<Integer>> focusedCatalogIdAndQtyMap = focusedModelRepository

				.selectAllByRegionIds(regionIds).stream().collect(Collectors.groupingBy(FocusedModel::getCatalogId,

						Collectors.mapping(FocusedModel::getObsMinimumQty, Collectors.maxBy(Integer::compareTo))));

		for (Map.Entry<Integer, Optional<Integer>> entry : focusedCatalogIdAndQtyMap.entrySet()) {

			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);

				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,

									warehouseItemAvailabilityMap, warehousePoItemAvailabilityMap, items,

									customRetailer);

							focusedModelShortageList.add(fm);

						}

					}

				}

			} else if (brand.equals("TV")) {

				if (items.get(0).getCategoryId() != ProfitMandiConstants.MOBILE_CATEGORY_ID) {

					LOGGER.info("items.get(0).getCategoryId()" + items.get(0).getCategoryId());

					if (items.get(0).getCategoryId() != 0) {

						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,

									customRetailer);

							focusedModelShortageList.add(fm);

						}

					}

				}

			}

		}

		LOGGER.info("focusedModelShortageList" + focusedModelShortageList);

		model.addAttribute("focusedModelShortageList", focusedModelShortageList);

		model.addAttribute("customRetailer", customRetailer);

		return "partner-stock";

	}

	private FocusedModelShortageModel getFocusedModelShortage(int qty, int catalogId,

			Map<Integer, Integer> processingOrderMap, Map<Integer, Integer> grnPendingOrdersMap,

			Map<Integer, Integer> catalogIdAndQtyMap, int fofoId,

			Map<Integer, Map<Integer, List<SaholicCIS>>> warehouseItemAvailabilityMap,

			Map<Integer, Map<Integer, List<SaholicPOItem>>> warehousePoItemAvailabilityMap, List<Item> items,

			CustomRetailer customRetailer) throws ProfitMandiBusinessException {

		int minQty = qty;

		int inStockQty = 0;

		int processingQty = 0;

		int grnPendingQty = 0;

		int allColorNetAvailability = 0;

		int allColorPoAvailability = 0;

		if (processingOrderMap != null) {

			processingQty = (processingOrderMap.get(catalogId) == null) ? 0 : processingOrderMap.get(catalogId);

		}

		if (grnPendingOrdersMap != null) {

			grnPendingQty = (grnPendingOrdersMap.get(catalogId) == null) ? 0 : grnPendingOrdersMap.get(catalogId);

		}

		if (catalogIdAndQtyMap != null) {

			inStockQty = (catalogIdAndQtyMap.get(catalogId) == null) ? 0 : catalogIdAndQtyMap.get(catalogId);

		}

		int grnStockQty = grnPendingQty + inStockQty;

		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<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));

			}

			if (poItemAvailability != null) {

				allColorPoAvailability += poItemAvailability.stream()

						.collect(Collectors.summingInt(SaholicPOItem::getUnfulfilledQty));

			}

		}

		FocusedModelShortageModel fm = new FocusedModelShortageModel();

		fm.setFofoId(fofoId);

		fm.setStoreCode(fofoStore.getCode());

		fm.setStoreName(customRetailer.getBusinessName());

		fm.setBrandName(items.get(0).getBrand());

		fm.setModelName(items.get(0).getModelName());

		fm.setModelNumber(items.get(0).getModelNumber());

		fm.setGrnStockQty(grnStockQty);

		fm.setPendingIndentQty(processingQty);

		fm.setShortageQty(shortageQty);

		fm.setPoAvailabitiy(allColorPoAvailability);

		fm.setItemName(items.get(0).getBrand() + items.get(0).getModelNumber() + items.get(0).getModelName());

		fm.setAvailabitiy(allColorNetAvailability);

		return fm;

	}