Subversion Repositories SmartDukaan

import java.util.Collections;

import java.util.LinkedHashMap;

import java.util.Map.Entry;

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

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

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

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

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

import com.spice.profitmandi.dao.repository.dtr.RetailerBlockBrandsRepository;

import com.spice.profitmandi.dao.repository.transaction.OrderRepository;

import com.spice.profitmandi.service.NotificationService;

import com.spice.profitmandi.service.inventory.FocusedShortageModel;

import com.spice.profitmandi.service.transaction.TransactionService;

	@Autowired

	private FocusedModelRepository focusedModelRepository;

	@Autowired

	private PartnerRegionRepository partnerRegionRepository;

	@Autowired

	private TransactionService transactionService;

	@Autowired

	private RetailerBlockBrandsRepository retailerBlockBrandRepository;

	@Autowired

	private OrderRepository orderRepository;

	@Autowired

	private NotificationService notificationService;

	@Override

	public List<FocusedShortageModel> focusedModelShortageValidation(int fofoId,

			Map<Integer, Integer> catalogCartQtyMap) throws ProfitMandiBusinessException {

		logger.info("fofoId {}", fofoId);

		Map<Integer, Long> inStockItemModel = new HashMap<>();

		Map<Integer, Long> itempendingIndent = new HashMap<>();

		Map<Integer, Long> grnItemPendingOrders = new HashMap<>();

		Map<Integer, Integer> focusedModelMap = null;

		inStockItemModel = currentInventorySnapshotRepository.selectSumInMobileStockGroupByCatalog(fofoId).stream()

				.collect(Collectors.toMap(x -> x.getCatalogItemId(), x -> x.getQty()));

		itempendingIndent = transactionService.getInTransitOrders(fofoId).stream()

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

						Collectors.summingLong(x -> (long) x.getLineItem().getQuantity())));

		grnItemPendingOrders = orderRepository.selectPendingGrnOrders(fofoId).stream()

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

						Collectors.summingLong(x -> (long) x.getLineItem().getQuantity())));

		List<PartnerRegion> partnerRegions = partnerRegionRepository.selectByfofoId(fofoId);

		FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(fofoId);

		List<String> retailerBlockBrands = retailerBlockBrandRepository.selectAllByRetailer(fofoId).stream()

				.map(x -> x.getBlockBrands()).collect(Collectors.toList());

		if (partnerRegions.size() > 0) {

			focusedModelMap = focusedModelRepository

					.selectAllByRegionIds(

							partnerRegions.stream().map(x -> x.getRegionId()).collect(Collectors.toList()))

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

		} else {

			focusedModelMap = new HashMap<>();

		}

		Map<Integer, List<SaholicCIS>> itemAvailabilityMap = saholicInventoryService.getSaholicStock()

				.get(fofoStore.getWarehouseId());

		Map<Integer, Integer> catalogItemAailabilityMap = new HashMap<>();

		for (Entry<Integer, Integer> fm : focusedModelMap.entrySet()) {

			List<Item> items = itemRepository.selectAllByCatalogItemId(fm.getKey());

			int allColorNetAvailability = 0;

			for (Item item : items) {

				if (retailerBlockBrands.contains(item.getBrand()))

					continue;

				List<SaholicCIS> currentAvailability = itemAvailabilityMap.get(item.getId());

				if (currentAvailability != null) {

					allColorNetAvailability += currentAvailability.stream()

							.collect(Collectors.summingInt(SaholicCIS::getNetavailability));

				}

			}

			catalogItemAailabilityMap.put(fm.getKey(), allColorNetAvailability);

		}

		List<FocusedShortageModel> focusedModelShortageList = new ArrayList<>();

		for (Entry<Integer, Integer> fm : focusedModelMap.entrySet()) {

			logger.info("fm {}", fm);

			long overallStock = (inStockItemModel.get(fm.getKey()) == null ? 0 : inStockItemModel.get(fm.getKey()))

					+ (itempendingIndent.get(fm.getKey()) == null ? 0 : itempendingIndent.get(fm.getKey()))

					+ (grnItemPendingOrders.get(fm.getKey()) == null ? 0 : grnItemPendingOrders.get(fm.getKey()));

			logger.info("overallStock {}", overallStock);

			// Blocked brands available quantity is discussed to zero

			long warehouseStock = catalogItemAailabilityMap.get(fm.getKey()) == null ? 0

					: catalogItemAailabilityMap.get(fm.getKey());

			logger.info("warehouseStock {}", warehouseStock);

			long cartValue = catalogCartQtyMap.get(fm.getKey()) == null ? 0 : catalogCartQtyMap.get(fm.getKey());

			logger.info("cartValue" + cartValue);

			long totalStock = overallStock + cartValue;

			logger.info("totalStock" + totalStock);

			long shortQty = Math.min(fm.getValue() - totalStock, warehouseStock);

			logger.info("shortQty {}", shortQty);

			if (shortQty > 0) {

				Map<Integer, Integer> requiredItemQty = new HashMap<>();

				List<Item> it = itemRepository.selectAllByCatalogItemId(fm.getKey());

				FocusedShortageModel fms = new FocusedShortageModel();

				fms.setShortageQty((int) shortQty);

				fms.setCatalogId(fm.getKey());

				fms.setAvailabitiy(fm.getValue());

				fms.setInStock(overallStock);

				fms.setItemName(it.get(0).getBrand() + it.get(0).getModelNumber() + it.get(0).getModelName());

				Map<Integer, Integer> itemQtyMap = new HashMap<>();

				for (Item i : it) {

					List<SaholicCIS> ca = itemAvailabilityMap.get(i.getId());

					if (ca != null) {

						itemQtyMap.put(i.getId(),

								ca.stream().collect(Collectors.summingInt(SaholicCIS::getNetavailability)));

					}

				}

				itemQtyMap = itemQtyMap.entrySet().stream()

						.sorted(Collections.reverseOrder(Map.Entry.comparingByValue())).collect(Collectors

								.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e2, LinkedHashMap::new));

				for (long i = shortQty; i > 0; i--) {

					if (shortQty == 0) {

						break;

					}

					for (Entry<Integer, Integer> itemQty : itemQtyMap.entrySet()) {

						int availbleQty = itemQty.getValue();

						if (availbleQty == 0) {

							break;

						}

						if (requiredItemQty.get(itemQty.getKey()) == null) {

							requiredItemQty.put(itemQty.getKey(), 1);

							availbleQty = availbleQty - 1;

							if (availbleQty != 0) {

								itemQtyMap.put(itemQty.getKey(), availbleQty);

							}

							shortQty -= 1;

						} else {

							int qty = requiredItemQty.get(itemQty.getKey());

							requiredItemQty.put(itemQty.getKey(), qty + 1);

							availbleQty = availbleQty - 1;

							if (availbleQty != 0) {

								itemQtyMap.put(itemQty.getKey(), availbleQty);

							}

							shortQty -= 1;

						}

						if (shortQty == 0) {

							break;

						}

					}

				}

				Set<CartItem> cartItems = new HashSet<>();

				for (Entry<Integer, Integer> itemQtySet : requiredItemQty.entrySet()) {

					CartItem ci = new CartItem();

					Item item = itemRepository.selectById(itemQtySet.getKey());

					TagListing tl = tagListingRepository.selectByItemId(item.getId());

					ci.setItemId(item.getId());

					ci.setQuantity(itemQtySet.getValue());

					ci.setSellingPrice(tl.getSellingPrice());

					cartItems.add(ci);

				}

				fms.setCartItems(cartItems);

				// fms.setItemQtyAvailability(requiredItemQty);

				focusedModelShortageList.add(fms);

			}

		}

		logger.info("focusedModelShortageList {}", focusedModelShortageList);

		return focusedModelShortageList;

	}