Subversion Repositories SmartDukaan

	private static final Logger LOGGER = LogManager.getLogger(IndentController.class);

    private static final Logger LOGGER = LogManager.getLogger(IndentController.class);

	private static final int WALLET_GATEWAY_ID = 8;

    private static final int WALLET_GATEWAY_ID = 8;

	private static final Set<Integer> defaultTags = new HashSet<Integer>(Arrays.asList(4));

    private static final Set<Integer> defaultTags = new HashSet<Integer>(Arrays.asList(4));

	private final List<OrderStatus> partnerPendingOrderList = Arrays.asList(OrderStatus.ACCEPTED,

    private final List<OrderStatus> partnerPendingOrderList = Arrays.asList(OrderStatus.ACCEPTED,

			OrderStatus.SUBMITTED_FOR_PROCESSING, OrderStatus.BILLED, OrderStatus.SHIPPED_FROM_WH,

            OrderStatus.SUBMITTED_FOR_PROCESSING, OrderStatus.BILLED, OrderStatus.SHIPPED_FROM_WH,

			OrderStatus.SHIPPED_TO_DESTINATION_CITY, OrderStatus.SHIPPED_TO_LOGST,

            OrderStatus.SHIPPED_TO_DESTINATION_CITY, OrderStatus.SHIPPED_TO_LOGST,

			OrderStatus.REACHED_DESTINATION_CITY);

            OrderStatus.REACHED_DESTINATION_CITY);

	private static final int PLANNING_OPEN_DAY = 20;

    private static final int PLANNING_OPEN_DAY = 20;

	private static final int PLANNING_CLOSE_DAY = 1;

    private static final int PLANNING_CLOSE_DAY = 1;

	private static final String PO_TITLE_STRING = "Alert - Stock Arriving at SD Warehouse";

    private static final String PO_TITLE_STRING = "Alert - Stock Arriving at SD Warehouse";

	@Autowired

    @Autowired

	WalletService walletService;

    WalletService walletService;

	@Autowired

    @Autowired

	BrandRegionMappingRepository brandRegionMappingRepository;

    BrandRegionMappingRepository brandRegionMappingRepository;

	@Autowired

    @Autowired

	private JavaMailSender googleMailSender;

    private JavaMailSender googleMailSender;

	@Autowired

    @Autowired

	private CookiesProcessor cookiesProcessor;

    private CookiesProcessor cookiesProcessor;

	@Autowired

    @Autowired

	private UserWalletRepository userWalletRepository;

    private UserWalletRepository userWalletRepository;

	@Autowired

    @Autowired

	private UserRepository userRepository;

    private UserRepository userRepository;

	@Autowired

    @Autowired

	FofoStoreRepository fofoStoreRepository;

    FofoStoreRepository fofoStoreRepository;

	@Autowired

    @Autowired

	private OrderRepository orderRepository;

    private OrderRepository orderRepository;

	@Autowired

    @Autowired

	private UserAccountRepository userAccountRepository;

    private UserAccountRepository userAccountRepository;

	@Autowired

    @Autowired

	private ItemRepository itemRepository;

    private ItemRepository itemRepository;

	@Autowired

    @Autowired

	private StockAllocationService stockAllocationService;

    private StockAllocationService stockAllocationService;

	@Autowired

    @Autowired

	private RetailerService retailerService;

    private RetailerService retailerService;

	@Autowired

    @Autowired

	private TagListingRepository tagListingRepository;

    private TagListingRepository tagListingRepository;

	@Autowired

    @Autowired

	private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

    private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

	@Autowired

    @Autowired

	private PurchaseRepository purchaseRepository;

    private PurchaseRepository purchaseRepository;

	@Autowired

    @Autowired

	private MVCResponseSender mvcResponseSender;

    private MVCResponseSender mvcResponseSender;

	@Autowired

    @Autowired

	private FocusedModelRepository focusedModelRepository;

    private FocusedModelRepository focusedModelRepository;

	@Autowired

    @Autowired

	private MonthlyPlannedRepository monthlyPlannedRepository;

    private MonthlyPlannedRepository monthlyPlannedRepository;

	@Autowired

    @Autowired

	private FofoOrderRepository fofoOrderRepository;

    private FofoOrderRepository fofoOrderRepository;

	@Autowired

    @Autowired

	private FofoOrderItemRepository fofoOrderItemRepository;

    private FofoOrderItemRepository fofoOrderItemRepository;

	@Autowired

    @Autowired

	private PlannedDetailRepository plannedDetailRepository;

    private PlannedDetailRepository plannedDetailRepository;

	@Autowired

    @Autowired

	RoleManager roleManager;

    RoleManager roleManager;

	@Autowired

    @Autowired

	PartnerTypeChangeRepository partnerTypeChangeRepository;

    PartnerTypeChangeRepository partnerTypeChangeRepository;

	@Autowired

    @Autowired

	private Mongo mongoClient;

    private Mongo mongoClient;

	@Autowired

    @Autowired

	private InventoryService inventoryService;

    private InventoryService inventoryService;

	@Autowired

    @Autowired

	private CsService1 csService1;

    private CsService1 csService1;

	@Autowired

    @Autowired

	private CsService csService;

    private CsService csService;

	@Autowired

    @Autowired

	private AuthRepository authRepository;

    private AuthRepository authRepository;

	@Autowired

    @Autowired

	WarehouseRepository warehouseRepository;

    WarehouseRepository warehouseRepository;

	@Autowired

    @Autowired

	private SuggestedPoRepository suggestedPoRepository;

    private SuggestedPoRepository suggestedPoRepository;

	@Autowired

    @Autowired

	private NotificationService notificationService;

    private NotificationService notificationService;

	@Autowired

    @Autowired

	private RegionRepository regionRepository;

    private RegionRepository regionRepository;

	@Autowired

    @Autowired

	private PartnerRegionRepository partnerRegionRepository;

    private PartnerRegionRepository partnerRegionRepository;

	@Autowired

    @Autowired

	private SaholicInventoryCISRepository saholicInventoryCISRepository;

    private SaholicInventoryCISRepository saholicInventoryCISRepository;

	@Autowired

    @Autowired

	private SaholicInventoryService saholicInventoryService;

    private SaholicInventoryService saholicInventoryService;

	@Autowired

    @Autowired

	private PartnerDailyInvestmentRepository partnerDailyInvestmentRepository;

    private PartnerDailyInvestmentRepository partnerDailyInvestmentRepository;

	@Autowired

    @Autowired

	private SuggestedPoDetailRepository suggestedPoDetailRepository;

    private SuggestedPoDetailRepository suggestedPoDetailRepository;

	@Autowired

    @Autowired

	SaholicCISTableRepository saholicCISTableRepository;

    SaholicCISTableRepository saholicCISTableRepository;

	@RequestMapping(value = "/open-indent/save", method = RequestMethod.POST)

    @RequestMapping(value = "/open-indent/save", method = RequestMethod.POST)

	public String saveOpenIndent(HttpServletRequest request, Model model, @RequestParam int catalogId,

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

        if (fofoId == 0) {

			LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

            LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

			fofoId = loginDetails.getFofoId();

            fofoId = loginDetails.getFofoId();

		}

        }

		LocalDate currentMonthDate = LocalDate.now();

        LocalDate currentMonthDate = LocalDate.now();

		MonthlyPlanned monthlyPlanned = null;

        MonthlyPlanned monthlyPlanned = null;

		if (LocalDate.now().isAfter(LocalDate.now().withDayOfMonth(PLANNING_OPEN_DAY))) {

        if (LocalDate.now().isAfter(LocalDate.now().withDayOfMonth(PLANNING_OPEN_DAY))) {

			currentMonthDate = LocalDate.now().plusMonths(1).withDayOfMonth(1);

            currentMonthDate = LocalDate.now().plusMonths(1).withDayOfMonth(1);

			monthlyPlanned = monthlyPlannedRepository.selectByFofoIdYearMonth(fofoId, currentMonthDate);

            monthlyPlanned = monthlyPlannedRepository.selectByFofoIdYearMonth(fofoId, currentMonthDate);

			LOGGER.info("monthlyPlanned" + monthlyPlanned);

            LOGGER.info("monthlyPlanned" + monthlyPlanned);

			saveMonthlyPlanned(monthlyPlanned, fofoId, currentMonthDate, catalogId, itemQty);

            saveMonthlyPlanned(monthlyPlanned, fofoId, currentMonthDate, catalogId, itemQty);

		}

        }

		model.addAttribute("response1", mvcResponseSender.createResponseString(false));

        model.addAttribute("response1", mvcResponseSender.createResponseString(false));

		return "response";

        return "response";

	}

    }

	private void saveMonthlyPlanned(MonthlyPlanned monthlyPlanned, int fofoId, LocalDate currentMonthDate,

    private void saveMonthlyPlanned(MonthlyPlanned monthlyPlanned, int fofoId, LocalDate currentMonthDate,

			int catalogId, int itemQty) {

                                    int catalogId, int itemQty) {

		if (monthlyPlanned == null) {

        if (monthlyPlanned == null) {

			monthlyPlanned = new MonthlyPlanned();

            monthlyPlanned = new MonthlyPlanned();

			monthlyPlanned.setFofoId(fofoId);

            monthlyPlanned.setFofoId(fofoId);

			monthlyPlanned.setYearMonth(currentMonthDate);

            monthlyPlanned.setYearMonth(currentMonthDate);

			monthlyPlannedRepository.persist(monthlyPlanned);

            monthlyPlannedRepository.persist(monthlyPlanned);

			PlannedDetail pd = new PlannedDetail();

            PlannedDetail pd = new PlannedDetail();

			pd.setCatalogId(catalogId);

            pd.setCatalogId(catalogId);

			pd.setPlannedId(monthlyPlanned.getId());

            pd.setPlannedId(monthlyPlanned.getId());

			pd.setQuantity(itemQty);

            pd.setQuantity(itemQty);

			pd.setUpdatedTimestamp(LocalDateTime.now());

            pd.setUpdatedTimestamp(LocalDateTime.now());

			plannedDetailRepository.persist(pd);

            plannedDetailRepository.persist(pd);

		} else {

        } else {

			PlannedDetail plannedDetail = plannedDetailRepository.selectByPlannedIdCatalogId(monthlyPlanned.getId(),

            PlannedDetail plannedDetail = plannedDetailRepository.selectByPlannedIdCatalogId(monthlyPlanned.getId(),

					catalogId);

                    catalogId);

			if (plannedDetail == null) {

            if (plannedDetail == null) {

				plannedDetail = new PlannedDetail();

                plannedDetail = new PlannedDetail();

				plannedDetail.setCatalogId(catalogId);

                plannedDetail.setCatalogId(catalogId);

				plannedDetail.setPlannedId(monthlyPlanned.getId());

                plannedDetail.setPlannedId(monthlyPlanned.getId());

				plannedDetail.setQuantity(itemQty);

                plannedDetail.setQuantity(itemQty);

				plannedDetail.setUpdatedTimestamp(LocalDateTime.now());

                plannedDetail.setUpdatedTimestamp(LocalDateTime.now());

				plannedDetailRepository.persist(plannedDetail);

                plannedDetailRepository.persist(plannedDetail);

			} else if (itemQty == 0) {

            } else if (itemQty == 0) {

				plannedDetailRepository.delete(plannedDetail);

                plannedDetailRepository.delete(plannedDetail);

			} else {

            } else {

				plannedDetail.setCatalogId(catalogId);

                plannedDetail.setCatalogId(catalogId);

				plannedDetail.setQuantity(itemQty);

                plannedDetail.setQuantity(itemQty);

				plannedDetail.setUpdatedTimestamp(LocalDateTime.now());

                plannedDetail.setUpdatedTimestamp(LocalDateTime.now());

			}

            }

		}

        }

	}

    }

	@RequestMapping(value = "/open-indent/confirm", method = RequestMethod.POST)

    @RequestMapping(value = "/open-indent/confirm", method = RequestMethod.POST)

	public String confirmOpenIndent(HttpServletRequest request,

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

        if (fofoId == 0) {

			LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

            LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

			fofoId = loginDetails.getFofoId();

            fofoId = loginDetails.getFofoId();

		}

        }

		CustomRetailer customRetailer = retailerService.getFofoRetailer(fofoId);

        CustomRetailer customRetailer = retailerService.getFofoRetailer(fofoId);

		LocalDate currentDate = LocalDate.now();

        LocalDate currentDate = LocalDate.now();

		LocalDate planningMonthDate = null;

        LocalDate planningMonthDate = null;

		MonthlyPlanned monthlyPlanned = null;

        MonthlyPlanned monthlyPlanned = null;

		if (currentDate.isAfter(currentDate.withDayOfMonth(PLANNING_OPEN_DAY))) {

        if (currentDate.isAfter(currentDate.withDayOfMonth(PLANNING_OPEN_DAY))) {

			planningMonthDate = LocalDate.now().plusMonths(1).withDayOfMonth(1);

            planningMonthDate = LocalDate.now().plusMonths(1).withDayOfMonth(1);

			monthlyPlanned = monthlyPlannedRepository.selectByFofoIdYearMonth(fofoId, planningMonthDate);

            monthlyPlanned = monthlyPlannedRepository.selectByFofoIdYearMonth(fofoId, planningMonthDate);

			confirmMonthlyPlanned(monthlyPlanned, customRetailer, fofoId);

            confirmMonthlyPlanned(monthlyPlanned, customRetailer, fofoId);

		}

        }

		model.addAttribute("response1", mvcResponseSender.createResponseString(true));

        model.addAttribute("response1", mvcResponseSender.createResponseString(true));

		return "response";

        return "response";

	}

    }

	private void confirmMonthlyPlanned(MonthlyPlanned monthlyPlanned, CustomRetailer customRetailer, int fofoId)

    private void confirmMonthlyPlanned(MonthlyPlanned monthlyPlanned, CustomRetailer customRetailer, int fofoId)

			throws Exception {

            throws Exception {

		List<PlannedDetail> plannedDetails = plannedDetailRepository.selectByPlannedId(monthlyPlanned.getId());

        List<PlannedDetail> plannedDetails = plannedDetailRepository.selectByPlannedId(monthlyPlanned.getId());

		List<PlannedModel> plannedModel = new ArrayList<>();

        List<PlannedModel> plannedModel = new ArrayList<>();

		for (PlannedDetail plannedDetail : plannedDetails) {

        for (PlannedDetail plannedDetail : plannedDetails) {

			List<Item> items = itemRepository.selectAllByCatalogItemId(plannedDetail.getCatalogId());

            List<Item> items = itemRepository.selectAllByCatalogItemId(plannedDetail.getCatalogId());

			String itemDesription = items.get(0).getItemDescriptionNoColor();

            String itemDesription = items.get(0).getItemDescriptionNoColor();

			PlannedModel pm = new PlannedModel();

            PlannedModel pm = new PlannedModel();

			pm.setItemDescription(itemDesription);

            pm.setItemDescription(itemDesription);

			pm.setStoreName(customRetailer.getBusinessName());

            pm.setStoreName(customRetailer.getBusinessName());

			pm.setQty(plannedDetail.getQuantity());

            pm.setQty(plannedDetail.getQuantity());

			pm.setFofoId(fofoId);

            pm.setFofoId(fofoId);

			plannedModel.add(pm);

            plannedModel.add(pm);

			LOGGER.info("plannedModel" + plannedModel);

            LOGGER.info("plannedModel" + plannedModel);

		}

        }

		List<String> ccemails = new ArrayList<>();

        List<String> ccemails = new ArrayList<>();

		LOGGER.info("ccemails" + ccemails);

        LOGGER.info("ccemails" + ccemails);

		Map<EscalationType, String> emailEsclationType = csService.getAuthUserAndEsclationTypeByPartnerId(fofoId);

        Map<EscalationType, String> emailEsclationType = csService.getAuthUserAndEsclationTypeByPartnerId(fofoId);

		LOGGER.info("emailEsclationType" + emailEsclationType);

        LOGGER.info("emailEsclationType" + emailEsclationType);

		if (emailEsclationType.get(EscalationType.L1) != null) {

        if (emailEsclationType.get(EscalationType.L1) != null) {

			ccemails.add(emailEsclationType.get(EscalationType.L1));

            ccemails.add(emailEsclationType.get(EscalationType.L1));

		}

        }

		if (emailEsclationType.get(EscalationType.L2) != null) {

        if (emailEsclationType.get(EscalationType.L2) != null) {

			ccemails.add(emailEsclationType.get(EscalationType.L2));

            ccemails.add(emailEsclationType.get(EscalationType.L2));

		}

        }

		LOGGER.info("ccemails" + ccemails);

        LOGGER.info("ccemails" + ccemails);

		List<String> bccemails = new ArrayList<>();

        List<String> bccemails = new ArrayList<>();

		bccemails.add(emailEsclationType.get(EscalationType.L3));

        bccemails.add(emailEsclationType.get(EscalationType.L3));

		LOGGER.info("bccemails" + bccemails);

        LOGGER.info("bccemails" + bccemails);

		ByteArrayOutputStream baos = FileUtil.getCSVByteStream(

        ByteArrayOutputStream baos = FileUtil.getCSVByteStream(

				Arrays.asList("Partner Id", "Partner Name", "Model Name", "Qty"),

                Arrays.asList("Partner Id", "Partner Name", "Model Name", "Qty"),

				plannedModel.stream()

                plannedModel.stream()

						.map(x -> Arrays.asList(x.getFofoId(), x.getStoreName(), x.getItemDescription(), x.getQty()))

                        .map(x -> Arrays.asList(x.getFofoId(), x.getStoreName(), x.getItemDescription(), x.getQty()))

						.collect(Collectors.toList()));

                        .collect(Collectors.toList()));

		LOGGER.info("baos" + baos);

        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()]),

                ccemails.toArray(new String[ccemails.size()]), bccemails.toArray(new String[bccemails.size()]),

				"Planned Indent", "PFA",

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

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

	public ResponseEntity<ByteArrayResource> downloadIndent(HttpServletRequest request, Model model,

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		Set<Integer> roleIds = loginDetails.getRoleIds();

        Set<Integer> roleIds = loginDetails.getRoleIds();

		LOGGER.info("Counter size is {}", counterSize);

        LOGGER.info("Counter size is {}", counterSize);

		LOGGER.info("Fofo Id is {}", fofoId);

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

            List<Integer> fofoIds = fofoStoreRepository.selectAll().stream().map(x -> x.getId())

					.collect(Collectors.toList());

                    .collect(Collectors.toList());

			Map<Integer, CustomRetailer> customRetailerMap = retailerService.getAllFofoRetailers();

            Map<Integer, CustomRetailer> customRetailerMap = retailerService.getAllFofoRetailers();

			Map<Integer, CustomRetailer> crm = fofoIds.stream().map(x -> customRetailerMap.get(x))

            Map<Integer, CustomRetailer> crm = fofoIds.stream().map(x -> customRetailerMap.get(x))

					.filter(x -> x != null).collect(Collectors.toList()).stream()

                    .filter(x -> x != null).collect(Collectors.toList()).stream()

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

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

			List<StockAllocationModel> stockAllocationList = stockAllocationService.getStockAllocation(counterSize,

            List<StockAllocationModel> stockAllocationList = stockAllocationService.getStockAllocation(counterSize,

					true);

                    true);

			Map<Integer, Integer> modelStockAllocationMap = stockAllocationList.stream()

            Map<Integer, Integer> modelStockAllocationMap = stockAllocationList.stream()

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

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

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

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

			currentInventorySnapshotRepository.selectByFofoId(fofoId).stream().forEach(x -> {

            currentInventorySnapshotRepository.selectByFofoId(fofoId).stream().forEach(x -> {

				int retailerId = x.getFofoId();

                int retailerId = x.getFofoId();

				int catalogId;

                int catalogId;

				try {

                try {

					catalogId = itemRepository.selectById(x.getItemId()).getCatalogItemId();

                    catalogId = itemRepository.selectById(x.getItemId()).getCatalogItemId();

					String key = catalogId + "-" + retailerId;

                    String key = catalogId + "-" + retailerId;

					if (!catalogUserQtyMap.containsKey(key)) {

                    if (!catalogUserQtyMap.containsKey(key)) {

						catalogUserQtyMap.put(key, 0);

                        catalogUserQtyMap.put(key, 0);

					}

                    }

					catalogUserQtyMap.put(key, catalogUserQtyMap.get(key) + x.getAvailability());

                    catalogUserQtyMap.put(key, catalogUserQtyMap.get(key) + x.getAvailability());

				} catch (ProfitMandiBusinessException e) {

                } catch (ProfitMandiBusinessException e) {

					// TODO Auto-generated catch block

                    // TODO Auto-generated catch block

					throw new RuntimeException(e);

                    throw new RuntimeException(e);

				}

                }

			});

            });

			List<Order> inTransitOrders = orderRepository.selectOrders(fofoIds, partnerPendingOrderList);

            List<Order> inTransitOrders = orderRepository.selectOrders(fofoIds, partnerPendingOrderList);

			Map<String, Integer> catalogUserInTransit = inTransitOrders.stream().collect(Collectors.groupingBy(x -> {

            Map<String, Integer> catalogUserInTransit = inTransitOrders.stream().collect(Collectors.groupingBy(x -> {

				try {

                try {

					return itemRepository.selectById(x.getLineItem().getItemId()).getCatalogItemId() + "-"

                    return itemRepository.selectById(x.getLineItem().getItemId()).getCatalogItemId() + "-"

							+ x.getRetailerId();

                            + x.getRetailerId();

				} catch (ProfitMandiBusinessException e) {

                } catch (ProfitMandiBusinessException e) {

					// TODO Auto-generated catch block

                    // TODO Auto-generated catch block

					return "";

                    return "";

				}

                }

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

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

			Map<String, CatalogListingModel> catalogListingMap = new HashMap<>();

            Map<String, CatalogListingModel> catalogListingMap = new HashMap<>();

			List<TagListing> tagListings = tagListingRepository.selectAll(true);

            List<TagListing> tagListings = tagListingRepository.selectAll(true);

			Iterator<TagListing> iterator = tagListings.iterator();

            Iterator<TagListing> iterator = tagListings.iterator();

			while (iterator.hasNext()) {

            while (iterator.hasNext()) {

				TagListing tagListing = iterator.next();

                TagListing tagListing = iterator.next();

				Item item = itemRepository.selectById(tagListing.getItemId());

                Item item = itemRepository.selectById(tagListing.getItemId());

				int catalogId = item.getCatalogItemId();

                int catalogId = item.getCatalogItemId();

				if (item.getCategoryId() != 10006) {

                if (item.getCategoryId() != 10006) {

					continue;

                    continue;

				}

                }

				int catalogStockAllocationQuantity = modelStockAllocationMap.containsKey(catalogId)

                int catalogStockAllocationQuantity = modelStockAllocationMap.containsKey(catalogId)

						? modelStockAllocationMap.get(catalogId)

                        ? modelStockAllocationMap.get(catalogId)

						: 0;

                        : 0;

				for (int retailerId : fofoIds) {

                for (int retailerId : fofoIds) {

					String key = catalogId + "-" + retailerId;

                    String key = catalogId + "-" + retailerId;

					if (catalogListingMap.containsKey(key)) {

                    if (catalogListingMap.containsKey(key)) {

						continue;

                        continue;

					}

                    }

					int catalogInTransit = catalogUserInTransit.containsKey(key) ? catalogUserInTransit.get(key) : 0;

                    int catalogInTransit = catalogUserInTransit.containsKey(key) ? catalogUserInTransit.get(key) : 0;

					int catalogInStock = catalogUserQtyMap.containsKey(key) ? catalogUserQtyMap.get(key) : 0;

                    int catalogInStock = catalogUserQtyMap.containsKey(key) ? catalogUserQtyMap.get(key) : 0;

					if (catalogInTransit + catalogInStock == 0 && catalogStockAllocationQuantity == 0) {

                    if (catalogInTransit + catalogInStock == 0 && catalogStockAllocationQuantity == 0) {

						continue;

                        continue;

					}

                    }

					CatalogListingModel catalogListingModel = new CatalogListingModel();

                    CatalogListingModel catalogListingModel = new CatalogListingModel();

					catalogListingModel.setFofoId(retailerId);

                    catalogListingModel.setFofoId(retailerId);

					catalogListingModel.setModelName(item.getModelName());

                    catalogListingModel.setModelName(item.getModelName());

					catalogListingModel.setModelNumber(item.getModelNumber());

                    catalogListingModel.setModelNumber(item.getModelNumber());

					catalogListingModel.setCatalogId(catalogId);

                    catalogListingModel.setCatalogId(catalogId);

					catalogListingModel.setDp(tagListing.getSellingPrice());

                    catalogListingModel.setDp(tagListing.getSellingPrice());

					catalogListingModel.setMop(tagListing.getMop());

                    catalogListingModel.setMop(tagListing.getMop());

					catalogListingModel.setItemDescription(item.getItemDescriptionNoColor());

                    catalogListingModel.setItemDescription(item.getItemDescriptionNoColor());

					catalogListingModel.setAllocatedQuantity(catalogStockAllocationQuantity);

                    catalogListingModel.setAllocatedQuantity(catalogStockAllocationQuantity);

					catalogListingModel.setInTransitQuantity(catalogInTransit);

                    catalogListingModel.setInTransitQuantity(catalogInTransit);

					catalogListingModel

                    catalogListingModel

							.setToBeOrdered(catalogStockAllocationQuantity - catalogInTransit - catalogInStock);

                            .setToBeOrdered(catalogStockAllocationQuantity - catalogInTransit - catalogInStock);

					catalogListingModel.setStockInHand(catalogInStock);

                    catalogListingModel.setStockInHand(catalogInStock);

					catalogListingModel.setBrand(item.getBrand());

                    catalogListingModel.setBrand(item.getBrand());

					catalogListingModel.setModelName(item.getModelName());

                    catalogListingModel.setModelName(item.getModelName());

					catalogListingModel.setModelNumber(item.getModelNumber());

                    catalogListingModel.setModelNumber(item.getModelNumber());

					catalogListingModel.setCategoryId(item.getCategoryId());

                    catalogListingModel.setCategoryId(item.getCategoryId());

					catalogListingMap.put(key, catalogListingModel);

                    catalogListingMap.put(key, catalogListingModel);

				}

                }

			}

            }

			List<List<?>> listOfRows = new ArrayList<>();

            List<List<?>> listOfRows = new ArrayList<>();

			for (CatalogListingModel clm : catalogListingMap.values()) {

            for (CatalogListingModel clm : catalogListingMap.values()) {

				CustomRetailer cr = crm.get(clm.getFofoId());

                CustomRetailer cr = crm.get(clm.getFofoId());

				listOfRows.add(Arrays.asList(cr.getPartnerId(), cr.getBusinessName(), clm.getCatalogId(),

                listOfRows.add(Arrays.asList(cr.getPartnerId(), cr.getBusinessName(), clm.getCatalogId(),

						clm.getBrand(), clm.getModelName(), clm.getModelNumber(), clm.getDp(), clm.getMop(),

                        clm.getBrand(), clm.getModelName(), clm.getModelNumber(), clm.getDp(), clm.getMop(),

						clm.getAllocatedQuantity(), clm.getInTransitQuantity(), clm.getStockInHand(),

                        clm.getAllocatedQuantity(), clm.getInTransitQuantity(), clm.getStockInHand(),

						clm.getToBeOrdered()));

                        clm.getToBeOrdered()));

			}

            }

			ByteArrayOutputStream baos = FileUtil

            ByteArrayOutputStream baos = FileUtil

					.getCSVByteStream(

                    .getCSVByteStream(

							Arrays.asList("StoreId", "StoreName", "Catalog Id", "Brand", "Model Name", "Model Number",

                            Arrays.asList("StoreId", "StoreName", "Catalog Id", "Brand", "Model Name", "Model Number",

									"DP", "MOP", "Allocated Quantity", "In Transit", "Stock In hand", "Shortage"),

                                    "DP", "MOP", "Allocated Quantity", "In Transit", "Stock In hand", "Shortage"),

							listOfRows);

                            listOfRows);

			HttpHeaders headers = new HttpHeaders();

            HttpHeaders headers = new HttpHeaders();

			headers.set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");

            headers.set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");

			headers.set("Content-disposition", "inline; filename=retailer-allocation.csv");

            headers.set("Content-disposition", "inline; filename=retailer-allocation.csv");

			return new ResponseEntity<ByteArrayResource>(new ByteArrayResource(baos.toByteArray()), headers,

            return new ResponseEntity<ByteArrayResource>(new ByteArrayResource(baos.toByteArray()), headers,

					HttpStatus.OK);

                    HttpStatus.OK);

		}

        }

		return null;

        return null;

	}

    }

	@RequestMapping(value = "/itemsByCatalogId")

    @RequestMapping(value = "/itemsByCatalogId")

	public String getItemsByCatalogId(HttpServletRequest request, Model model,

    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 {

            throws ProfitMandiBusinessException {

		if (catalogId == 0) {

        if (catalogId == 0) {

			catalogId = itemRepository.selectById(itemId).getCatalogItemId();

            catalogId = itemRepository.selectById(itemId).getCatalogItemId();

		}

        }

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

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

		LOGGER.info("Items {}", items);

        LOGGER.info("Items {}", items);

		Map<Integer, String> itemsColorMap = items.stream().filter(x -> x.getColorNatural().startsWith("f_"))

        Map<Integer, String> itemsColorMap = items.stream().filter(x -> x.getColorNatural().startsWith("f_"))

				.collect(Collectors.toMap(Item::getId, Item::getColor));

                .collect(Collectors.toMap(Item::getId, Item::getColor));

		Map<Integer, TagListing> tagsMap = tagListingRepository

        Map<Integer, TagListing> tagsMap = tagListingRepository

				.selectByItemIdsAndTagIds(items.stream().map(x -> x.getId()).collect(Collectors.toSet()), defaultTags)

                .selectByItemIdsAndTagIds(items.stream().map(x -> x.getId()).collect(Collectors.toSet()), defaultTags)

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

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

		LOGGER.info("Items color map {}", itemsColorMap);

        LOGGER.info("Items color map {}", itemsColorMap);

		JSONArray response = new JSONArray();

        JSONArray response = new JSONArray();

		itemsColorMap.keySet().stream().forEach(x -> {

        itemsColorMap.keySet().stream().forEach(x -> {

			response.put(new JSONObject().put("color", itemsColorMap.get(x)).put("id", x).put("active",

            response.put(new JSONObject().put("color", itemsColorMap.get(x)).put("id", x).put("active",

					tagsMap.get(x) == null ? false : tagsMap.get(x).isActive()));

                    tagsMap.get(x) == null ? false : tagsMap.get(x).isActive()));

		});

        });

		model.addAttribute("response1", response.toString());

        model.addAttribute("response1", response.toString());

		return "response";

        return "response";

	}

    }

	@RequestMapping(value = "/hotdealsitemsByCatalogId")

    @RequestMapping(value = "/hotdealsitemsByCatalogId")

	public String getHotdealsitemsByCatalogId(HttpServletRequest request, Model model,

    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 {

            throws ProfitMandiBusinessException {

		if (catalogId == 0) {

        if (catalogId == 0) {

			catalogId = itemRepository.selectById(itemId).getCatalogItemId();

            catalogId = itemRepository.selectById(itemId).getCatalogItemId();

		}

        }

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

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

		LOGGER.info("Items {}", items);

        LOGGER.info("Items {}", items);

		Map<Integer, String> itemsColorMap = items.stream().filter(x -> x.getColorNatural().startsWith("f_"))

        Map<Integer, String> itemsColorMap = items.stream().filter(x -> x.getColorNatural().startsWith("f_"))

				.collect(Collectors.toMap(Item::getId, Item::getColor));

                .collect(Collectors.toMap(Item::getId, Item::getColor));

		Map<Integer, TagListing> tagsMap = tagListingRepository

        Map<Integer, TagListing> tagsMap = tagListingRepository

				.selectByItemIdsAndTagIds(items.stream().map(x -> x.getId()).collect(Collectors.toSet()), defaultTags)

                .selectByItemIdsAndTagIds(items.stream().map(x -> x.getId()).collect(Collectors.toSet()), defaultTags)

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

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

		LOGGER.info("Items color map {}", itemsColorMap);

        LOGGER.info("Items color map {}", itemsColorMap);

		JSONArray response = new JSONArray();

        JSONArray response = new JSONArray();

		itemsColorMap.keySet().stream().forEach(x -> {

        itemsColorMap.keySet().stream().forEach(x -> {

			response.put(new JSONObject().put("color", itemsColorMap.get(x)).put("id", x).put("hotDeals",

            response.put(new JSONObject().put("color", itemsColorMap.get(x)).put("id", x).put("hotDeals",

					tagsMap.get(x) == null ? false : tagsMap.get(x).isHotDeals()));

                    tagsMap.get(x) == null ? false : tagsMap.get(x).isHotDeals()));

		});

        });

		model.addAttribute("response1", response.toString());

        model.addAttribute("response1", response.toString());

		return "response";

        return "response";

	}

    }

	private List<Order> filterValidOrders(List<Order> lastOrdersList) {

    private List<Order> filterValidOrders(List<Order> lastOrdersList) {

		int orderRemovedCount = 0;

        int orderRemovedCount = 0;

		Iterator<Order> orderIterator = lastOrdersList.iterator();

        Iterator<Order> orderIterator = lastOrdersList.iterator();

		while (orderIterator.hasNext()) {

        while (orderIterator.hasNext()) {

			Order o = orderIterator.next();

            Order o = orderIterator.next();

			if (o.getInvoiceNumber() != null) {

            if (o.getInvoiceNumber() != null) {

				try {

                try {

					purchaseRepository.selectByPurchaseReferenceAndFofoId(o.getInvoiceNumber(), o.getRetailerId());

                    purchaseRepository.selectByPurchaseReferenceAndFofoId(o.getInvoiceNumber(), o.getRetailerId());

					orderIterator.remove();

                    orderIterator.remove();

					orderRemovedCount++;

                    orderRemovedCount++;

				} catch (Exception e) {

                } catch (Exception e) {

				}

                }

			}

            }

		}

        }

		LOGGER.info("Order removed count is {}", orderRemovedCount);

        LOGGER.info("Order removed count is {}", orderRemovedCount);

		return lastOrdersList;

        return lastOrdersList;

	}

    }

	// Clean up the saholic cis table

    // Clean up the saholic cis table

	@RequestMapping(value = "/indent/confirm-pause", method = RequestMethod.POST)

    @RequestMapping(value = "/indent/confirm-pause", method = RequestMethod.POST)

	public String updateTagListing(HttpServletRequest request, Model model, @RequestBody String jsonArrayString)

    public String updateTagListing(HttpServletRequest request, Model model, @RequestBody String jsonArrayString)

			throws Exception {

            throws Exception {

		JSONArray jsonArray = new JSONArray(jsonArrayString);

        JSONArray jsonArray = new JSONArray(jsonArrayString);

		for (int i = 0; i < jsonArray.length(); i++) {

        for (int i = 0; i < jsonArray.length(); i++) {

			JSONObject obj = jsonArray.getJSONObject(i);

            JSONObject obj = jsonArray.getJSONObject(i);

			TagListing tl = tagListingRepository.selectByItemId(obj.getInt("id"));

            TagListing tl = tagListingRepository.selectByItemId(obj.getInt("id"));

			if (tl == null) {

            if (tl == null) {

				continue;

                continue;

			} else {

            } else {

				tl.setActive(obj.getBoolean("active"));

                tl.setActive(obj.getBoolean("active"));

				if (!tl.isActive()) {

                if (!tl.isActive()) {

					saholicCISTableRepository.selectAllByItemId(tl.getItemId()).stream()

                    saholicCISTableRepository.selectAllByItemId(tl.getItemId()).stream()

							.forEach(x -> saholicCISTableRepository.delete(x));

                            .forEach(x -> saholicCISTableRepository.delete(x));

				}

                }

			}

            }

		}

        }

		model.addAttribute("response1", true);

        model.addAttribute("response1", true);

		return "response";

        return "response";

	}

    }

	@RequestMapping(value = "/indent/confirm-hotdeals-pause", method = RequestMethod.POST)

    @RequestMapping(value = "/indent/confirm-hotdeals-pause", method = RequestMethod.POST)

	public String hotdealUpdate(HttpServletRequest request, Model model, @RequestBody String jsonArrayString)

    public String hotdealUpdate(HttpServletRequest request, Model model, @RequestBody String jsonArrayString)

			throws Exception {

            throws Exception {

		JSONArray jsonArray = new JSONArray(jsonArrayString);

        JSONArray jsonArray = new JSONArray(jsonArrayString);

		for (int i = 0; i < jsonArray.length(); i++) {

        for (int i = 0; i < jsonArray.length(); i++) {

			JSONObject obj = jsonArray.getJSONObject(i);

            JSONObject obj = jsonArray.getJSONObject(i);

			TagListing tl = tagListingRepository.selectByItemId(obj.getInt("id"));

            TagListing tl = tagListingRepository.selectByItemId(obj.getInt("id"));

			if (tl == null) {

            if (tl == null) {

				continue;

                continue;

			} else {

            } else {

				tl.setHotDeals(obj.getBoolean("hotDeals"));

                tl.setHotDeals(obj.getBoolean("hotDeals"));

				tagListingRepository.persist(tl);

                tagListingRepository.persist(tl);

			}

            }

		}

        }

		model.addAttribute("response1", true);

        model.addAttribute("response1", true);

		return "response";

        return "response";

	}

    }

	@RequestMapping(value = "/indent/create-po", method = RequestMethod.POST)

    @RequestMapping(value = "/indent/create-po", method = RequestMethod.POST)

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

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

		boolean success = false;

        boolean success = false;

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		int fofoId = loginDetails.getFofoId();

        int fofoId = loginDetails.getFofoId();

		List<ItemPriceQuantity> itemQuantities = this.getItemQuantities(fofoId);

        List<ItemPriceQuantity> itemQuantities = this.getItemQuantities(fofoId);

		CustomRetailer customRetailer = retailerService.getFofoRetailer(fofoId);

        CustomRetailer customRetailer = retailerService.getFofoRetailer(fofoId);

		Client userClient = new UserClient().getClient();

        Client userClient = new UserClient().getClient();

		double totalAmount = itemQuantities.stream().mapToDouble(x -> x.getQty() * x.getPrice()).sum();

        double totalAmount = itemQuantities.stream().mapToDouble(x -> x.getQty() * x.getPrice()).sum();

		if (totalAmount > 0) {

        if (totalAmount > 0) {

			userClient.addItemPricingToCart(customRetailer.getCartId(), itemQuantities);

            userClient.addItemPricingToCart(customRetailer.getCartId(), itemQuantities);

			User user = userRepository.selectById(loginDetails.getFofoId());

            User user = userRepository.selectById(loginDetails.getFofoId());

			userClient = new UserClient().getClient();

            userClient = new UserClient().getClient();

			LOGGER.info("Setting wallet amount in cart");

            LOGGER.info("Setting wallet amount in cart");

			long transactionId = userClient.createOrders(user.getActiveCartId(), "", 0, "", 0, loginDetails.getFofoId(),

            long transactionId = userClient.createOrders(user.getActiveCartId(), "", 0, "", 0, loginDetails.getFofoId(),

					7890, OrderSource.WEBSITE.getValue(), true);

                    7890, OrderSource.WEBSITE.getValue(), true);

			LOGGER.info("Creating wallet payment for transactionId - {}", transactionId);

            LOGGER.info("Creating wallet payment for transactionId - {}", transactionId);

			createPayment(user, totalAmount, transactionId);

            createPayment(user, totalAmount, transactionId);

			TransactionService.Client transactionClient = new TransactionClient().getClient();

            TransactionService.Client transactionClient = new TransactionClient().getClient();

			transactionClient.changeTransactionStatus(transactionId, TransactionStatus.AUTHORIZED,

            transactionClient.changeTransactionStatus(transactionId, TransactionStatus.AUTHORIZED,

					"Payment received for the order", PickUpType.RUNNER.getValue(), OrderType.B2B, OrderSource.WEBSITE);

                    "Payment received for the order", PickUpType.RUNNER.getValue(), OrderType.B2B, OrderSource.WEBSITE);

			transactionClient.changeTransactionStatus(Long.valueOf(transactionId), TransactionStatus.IN_PROCESS,

            transactionClient.changeTransactionStatus(Long.valueOf(transactionId), TransactionStatus.IN_PROCESS,

					"Paid fully through wallet", PickUpType.RUNNER.getValue(), OrderType.B2B, OrderSource.WEBSITE);

                    "Paid fully through wallet", PickUpType.RUNNER.getValue(), OrderType.B2B, OrderSource.WEBSITE);

			LOGGER.info("Successfully created transaction: " + transactionId + " for amount: " + totalAmount);

            LOGGER.info("Successfully created transaction: " + transactionId + " for amount: " + totalAmount);

			transactionClient = new TransactionClient().getClient();

            transactionClient = new TransactionClient().getClient();

			transactionClient.markOrderForRegisteredGstInvoice(Collections.singletonList(Long.valueOf(transactionId)));

            transactionClient.markOrderForRegisteredGstInvoice(Collections.singletonList(Long.valueOf(transactionId)));

			try {

            try {

				transactionClient.enqueueTransactionInfoEmail(transactionId);

                transactionClient.enqueueTransactionInfoEmail(transactionId);

			} catch (Exception e1) {

            } catch (Exception e1) {

				e1.printStackTrace();

                e1.printStackTrace();

				LOGGER.error("Unable to update status of transaction. Thrift Exception:", e1);

                LOGGER.error("Unable to update status of transaction. Thrift Exception:", e1);

			}

            }

			resetCart(transactionClient.getTransaction(transactionId));

            resetCart(transactionClient.getTransaction(transactionId));

		}

        }

		model.addAttribute("response1", mvcResponseSender.createResponseString(success));

        model.addAttribute("response1", mvcResponseSender.createResponseString(success));

		return "response";

        return "response";

	}

    }

	private void createPayment(User user, double totalAmount, long transactionId)

    private void createPayment(User user, double totalAmount, long transactionId)

			throws NumberFormatException, PaymentException, TException {

            throws NumberFormatException, PaymentException, TException {

		List<Attribute> paymentAttributes = new ArrayList<Attribute>();

        List<Attribute> paymentAttributes = new ArrayList<Attribute>();

		in.shop2020.payments.PaymentService.Client paymentClient = new PaymentClient().getClient();

        in.shop2020.payments.PaymentService.Client paymentClient = new PaymentClient().getClient();

		paymentAttributes.add(new Attribute("payMethod", "7890"));

        paymentAttributes.add(new Attribute("payMethod", "7890"));

		long paymentId = paymentClient.createPayment(user.getId(), totalAmount, WALLET_GATEWAY_ID, transactionId,

        long paymentId = paymentClient.createPayment(user.getId(), totalAmount, WALLET_GATEWAY_ID, transactionId,

				false);

                false);

		paymentClient.updatePaymentDetails(paymentId, null, null, null, null, null, null, null, null,

        paymentClient.updatePaymentDetails(paymentId, null, null, null, null, null, null, null, null,

				PaymentStatus.SUCCESS, null, paymentAttributes);

                PaymentStatus.SUCCESS, null, paymentAttributes);

	}

    }

	@RequestMapping(value = "/indent/loadIndent")

    @RequestMapping(value = "/indent/loadIndent")

	public String loadOpenIndent(HttpServletRequest request, Model model,

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		Set<Integer> roleIds = loginDetails.getRoleIds();

        Set<Integer> roleIds = loginDetails.getRoleIds();

		LOGGER.info("Counter size is {}", counterSize);

        LOGGER.info("Counter size is {}", counterSize);

		LOGGER.info("Fofo Id is {}", fofoId);

        LOGGER.info("Fofo Id is {}", fofoId);

		boolean isAdmin = roleManager.isAdmin(roleIds);

        boolean isAdmin = roleManager.isAdmin(roleIds);

		List<String> brands = mongoClient.getMongoBrands(fofoId, null, 3).stream().map(x -> (String) x.get("name"))

        List<String> brands = mongoClient.getMongoBrands(fofoId, null, 3).stream().map(x -> (String) x.get("name"))

				.collect(Collectors.toList());

                .collect(Collectors.toList());

		Map<String, Object> equalsMap = new HashMap<>();

        Map<String, Object> equalsMap = new HashMap<>();

		equalsMap.put("categoryId", 10006);

        equalsMap.put("categoryId", 10006);

		equalsMap.put("brand", brands);

        equalsMap.put("brand", brands);

		Map<String, List<?>> notEqualsMap = new HashMap<>();

        Map<String, List<?>> notEqualsMap = new HashMap<>();

		Map<String, List<?>> notEqualsJoinMap = new HashMap<>();

        Map<String, List<?>> notEqualsJoinMap = new HashMap<>();

		Map<Integer, Integer> currentStockMap;

        Map<Integer, Integer> currentStockMap;

		if (!isAdmin && fofoId == 0) {

        if (!isAdmin && fofoId == 0) {

			fofoId = cookiesProcessor.getCookiesObject(request).getFofoId();

            fofoId = cookiesProcessor.getCookiesObject(request).getFofoId();

			Map<String, Object> equalsStockJoinMap = new HashMap<>();

            Map<String, Object> equalsStockJoinMap = new HashMap<>();

			equalsStockJoinMap.put("fofoId", fofoId);

            equalsStockJoinMap.put("fofoId", fofoId);

			currentStockMap = itemRepository

            currentStockMap = itemRepository

					.selectItems(CurrentInventorySnapshot.class, "id", "itemId", equalsMap, notEqualsMap,

                    .selectItems(CurrentInventorySnapshot.class, "id", "itemId", equalsMap, notEqualsMap,

							equalsStockJoinMap, notEqualsJoinMap, "availability")

                            equalsStockJoinMap, notEqualsJoinMap, "availability")

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

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

			LOGGER.info("currentStock");

            LOGGER.info("currentStock");

		} else {

        } else {

			if (fofoId == 0) {

            if (fofoId == 0) {

				Map<String, Object> equalsStockJoinMap = new HashMap<>();

                Map<String, Object> equalsStockJoinMap = new HashMap<>();

				equalsStockJoinMap.put("fofoId", fofoId);

                equalsStockJoinMap.put("fofoId", fofoId);

				currentStockMap = itemRepository

                currentStockMap = itemRepository

						.selectItems(CurrentInventorySnapshot.class, "id", "itemId", equalsMap, notEqualsMap,

                        .selectItems(CurrentInventorySnapshot.class, "id", "itemId", equalsMap, notEqualsMap,

								equalsStockJoinMap, notEqualsJoinMap, "availability")

                                equalsStockJoinMap, notEqualsJoinMap, "availability")

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

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

			} else {

            } else {

				Map<String, Object> equalsStockJoinMap = new HashMap<>();

                Map<String, Object> equalsStockJoinMap = new HashMap<>();

				equalsStockJoinMap.put("fofoId", fofoId);

                equalsStockJoinMap.put("fofoId", fofoId);

				currentStockMap = itemRepository

                currentStockMap = itemRepository

						.selectItems(CurrentInventorySnapshot.class, "id", "itemId", equalsMap, notEqualsMap,

                        .selectItems(CurrentInventorySnapshot.class, "id", "itemId", equalsMap, notEqualsMap,

								equalsStockJoinMap, notEqualsJoinMap, "availability")

                                equalsStockJoinMap, notEqualsJoinMap, "availability")

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

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

			}

            }

		}

        }

		LOGGER.info("currentStock" + currentStockMap);

        LOGGER.info("currentStock" + currentStockMap);

		Map<Integer, Integer> itemsInTransit = null;

        Map<Integer, Integer> itemsInTransit = null;

		List<TagListing> tagListings = tagListingRepository.selectAll(true);

        List<TagListing> tagListings = tagListingRepository.selectAll(true);

		if (!isAdmin) {

        if (!isAdmin) {

			tagListings = new ArrayList<>(tagListings);

            tagListings = new ArrayList<>(tagListings);

			List<Order> inTransitOrders = orderRepository.selectPendingGrnOrder(fofoId,

            List<Order> inTransitOrders = orderRepository.selectPendingGrnOrder(fofoId,

					OrderRepository.validOrderStatusList);

                    OrderRepository.validOrderStatusList);

			inTransitOrders = this.filterValidOrders(inTransitOrders);

            inTransitOrders = this.filterValidOrders(inTransitOrders);

			itemsInTransit = inTransitOrders.stream().collect(Collectors.groupingBy(x -> x.getLineItem().getItemId(),

            itemsInTransit = inTransitOrders.stream().collect(Collectors.groupingBy(x -> x.getLineItem().getItemId(),

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

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

		} else {

        } else {

			itemsInTransit = new HashMap<>();

            itemsInTransit = new HashMap<>();

		}

        }

		int totalPcs = 0;

        int totalPcs = 0;

		float totalAmount = 0;

        float totalAmount = 0;

		Map<Integer, CatalogListingModel> catalogListingMap = new HashMap<>();

        Map<Integer, CatalogListingModel> catalogListingMap = new HashMap<>();

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

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

				.collect(Collectors.toList());

                .collect(Collectors.toList());

		LOGGER.info("regionIds" + regionIds);

        LOGGER.info("regionIds" + regionIds);

		Map<Integer, FocusedModel> focusedModelMap = focusedModelRepository.selectAllByRegionIds(regionIds).stream()

        Map<Integer, FocusedModel> focusedModelMap = focusedModelRepository.selectAllByRegionIds(regionIds).stream()

				.collect(Collectors.toMap(FocusedModel::getCatalogId, Function.identity()));

                .collect(Collectors.toMap(FocusedModel::getCatalogId, Function.identity()));

		LOGGER.info("focusedModelMap" + focusedModelMap);

        LOGGER.info("focusedModelMap" + focusedModelMap);

		LocalDate planningMonthDate = null;

        LocalDate planningMonthDate = null;

		MonthlyPlanned monthlyPlanned = null;

        MonthlyPlanned monthlyPlanned = null;

		List<Integer> fofoOrderIds = null;

        List<Integer> fofoOrderIds = null;

		LOGGER.info("localDate" + LocalDate.now());

        LOGGER.info("localDate" + LocalDate.now());

		if (LocalDate.now().isAfter(LocalDate.now().withDayOfMonth(PLANNING_OPEN_DAY))) {

        if (LocalDate.now().isAfter(LocalDate.now().withDayOfMonth(PLANNING_OPEN_DAY))) {

			planningMonthDate = LocalDate.now().plusMonths(1).withDayOfMonth(1);

            planningMonthDate = LocalDate.now().plusMonths(1).withDayOfMonth(1);

			monthlyPlanned = monthlyPlannedRepository.selectByFofoIdYearMonth(fofoId, planningMonthDate);

            monthlyPlanned = monthlyPlannedRepository.selectByFofoIdYearMonth(fofoId, planningMonthDate);

			LOGGER.info("monthlyPlanned2" + monthlyPlanned);

            LOGGER.info("monthlyPlanned2" + monthlyPlanned);

			fofoOrderIds = fofoOrderRepository.selectByFofoIdBetweenCreatedTimeStamp(loginDetails.getFofoId(),

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

                    .collect(Collectors.toList());

			model.addAttribute("planningMonth", LocalDate.now().plusMonths(1).getMonth());

            model.addAttribute("planningMonth", LocalDate.now().plusMonths(1).getMonth());

		} else {

        } else {

			planningMonthDate = LocalDate.now().withDayOfMonth(1);

            planningMonthDate = LocalDate.now().withDayOfMonth(1);

			LocalDateTime curDate = LocalDate.now().atStartOfDay();

            LocalDateTime curDate = LocalDate.now().atStartOfDay();

			monthlyPlanned = monthlyPlannedRepository.selectByFofoIdYearMonth(fofoId, planningMonthDate);

            monthlyPlanned = monthlyPlannedRepository.selectByFofoIdYearMonth(fofoId, planningMonthDate);

			model.addAttribute("planningMonth", planningMonthDate.getMonth());

            model.addAttribute("planningMonth", planningMonthDate.getMonth());

			model.addAttribute("mtd", true);

            model.addAttribute("mtd", true);

			model.addAttribute("freezed", true);

            model.addAttribute("freezed", true);

			fofoOrderIds = fofoOrderRepository.selectByFofoIdBetweenCreatedTimeStamp(loginDetails.getFofoId(),

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

                    .collect(Collectors.toList());

			LOGGER.info("monthlyPlanned1" + monthlyPlanned);

            LOGGER.info("monthlyPlanned1" + monthlyPlanned);

		}

        }

		Map<Integer, Integer> plannedDetailMap = null;

        Map<Integer, Integer> plannedDetailMap = null;

		if (monthlyPlanned != null) {

        if (monthlyPlanned != null) {

			plannedDetailMap = plannedDetailRepository.selectByPlannedId(monthlyPlanned.getId()).stream()

            plannedDetailMap = plannedDetailRepository.selectByPlannedId(monthlyPlanned.getId()).stream()

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

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

		}

        }

		LOGGER.info("plannedDetailMap" + plannedDetailMap);

        LOGGER.info("plannedDetailMap" + plannedDetailMap);

		LOGGER.info("fofoOrderIds" + fofoOrderIds);

        LOGGER.info("fofoOrderIds" + fofoOrderIds);

		Map<String, Object> equalsJoinMap = new HashMap<>();

        Map<String, Object> equalsJoinMap = new HashMap<>();

		equalsJoinMap.put("orderId", fofoOrderIds);

        equalsJoinMap.put("orderId", fofoOrderIds);

		Map<Integer, Integer> last15daysMap = null;

        Map<Integer, Integer> last15daysMap = null;

		if (fofoOrderIds != null && !fofoOrderIds.isEmpty()) {

        if (fofoOrderIds != null && !fofoOrderIds.isEmpty()) {

			last15daysMap = itemRepository

            last15daysMap = itemRepository

					.selectItems(FofoOrderItem.class, "id", "itemId", equalsMap, notEqualsMap, equalsJoinMap,

                    .selectItems(FofoOrderItem.class, "id", "itemId", equalsMap, notEqualsMap, equalsJoinMap,

							notEqualsJoinMap, "quantity")

                            notEqualsJoinMap, "quantity")

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

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

		}

        }

		LOGGER.info("last15daysMap" + last15daysMap);

        LOGGER.info("last15daysMap" + last15daysMap);

		Map<Integer, TagListing> taglistingMap = tagListings.stream()

        Map<Integer, TagListing> taglistingMap = tagListings.stream()

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

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

		List<Item> items = itemRepository.selectByIds(taglistingMap.keySet());

        List<Item> items = itemRepository.selectByIds(taglistingMap.keySet());

		Map<Integer, List<Item>> catalogIdItemMap = items.stream().collect(

        Map<Integer, List<Item>> catalogIdItemMap = items.stream().collect(

				Collectors.groupingBy(x -> x.getCatalogItemId(), Collectors.mapping(y -> y, Collectors.toList())));

                Collectors.groupingBy(x -> x.getCatalogItemId(), Collectors.mapping(y -> y, Collectors.toList())));

		LOGGER.info("catalogIdItemMap");

        LOGGER.info("catalogIdItemMap");

		Map<String, Object> equalsItemJoinMap = new HashMap<>();

        Map<String, Object> equalsItemJoinMap = new HashMap<>();

		equalsItemJoinMap.put("active", 1);

        equalsItemJoinMap.put("active", 1);

		List<IntegerIdAggregateValue> tagListingCatalogIds = itemRepository.selectItems(TagListing.class, "id",

        List<IntegerIdAggregateValue> tagListingCatalogIds = itemRepository.selectItems(TagListing.class, "id",

				"itemId", equalsMap, notEqualsMap, equalsItemJoinMap, notEqualsJoinMap, "tagId");

                "itemId", equalsMap, notEqualsMap, equalsItemJoinMap, notEqualsJoinMap, "tagId");

		LOGGER.info("tagListingCatalogIds");

        LOGGER.info("tagListingCatalogIds");

		for (IntegerIdAggregateValue catalogIdAggregateValue : tagListingCatalogIds) {

        for (IntegerIdAggregateValue catalogIdAggregateValue : tagListingCatalogIds) {

			int catalogId = catalogIdAggregateValue.getCatalogId();

            int catalogId = catalogIdAggregateValue.getCatalogId();

			Item item = catalogIdItemMap.get(catalogId).get(0);

            Item item = catalogIdItemMap.get(catalogId).get(0);

			TagListing tagListing = taglistingMap.get(item.getId());

            TagListing tagListing = taglistingMap.get(item.getId());

			CatalogListingModel catalogListingModel = catalogListingMap.get(catalogId);

            CatalogListingModel catalogListingModel = catalogListingMap.get(catalogId);

			if (!catalogListingMap.containsKey(catalogId)) {

            if (!catalogListingMap.containsKey(catalogId)) {

				catalogListingModel = new CatalogListingModel();

                catalogListingModel = new CatalogListingModel();

				catalogListingModel.setCatalogId(catalogId);

                catalogListingModel.setCatalogId(catalogId);

				catalogListingModel.setDp(tagListing.getSellingPrice());

                catalogListingModel.setDp(tagListing.getSellingPrice());

				catalogListingModel.setMop(tagListing.getMop());

                catalogListingModel.setMop(tagListing.getMop());

				catalogListingModel.setItemDescription(item.getItemDescriptionNoColor());

                catalogListingModel.setItemDescription(item.getItemDescriptionNoColor());

				if (plannedDetailMap != null) {

                if (plannedDetailMap != null) {

					Integer quantity = plannedDetailMap.get(catalogId);

                    Integer quantity = plannedDetailMap.get(catalogId);

					if (quantity != null) {

                    if (quantity != null) {

						catalogListingModel.setAllocatedQuantity(quantity);

                        catalogListingModel.setAllocatedQuantity(quantity);

					}

                    }

				}

                }

				if (last15daysMap != null) {

                if (last15daysMap != null) {

					Integer last15DaysSale = last15daysMap.get(catalogId);

                    Integer last15DaysSale = last15daysMap.get(catalogId);

					if (last15DaysSale != null) {

                    if (last15DaysSale != null) {

						catalogListingModel.setLast15DaysSale(last15DaysSale);

                        catalogListingModel.setLast15DaysSale(last15DaysSale);

					} else {

                    } else {

						catalogListingModel.setLast15DaysSale(0);

                        catalogListingModel.setLast15DaysSale(0);

					}

                    }

				} else {

                } else {

					catalogListingModel.setLast15DaysSale(0);

                    catalogListingModel.setLast15DaysSale(0);

				}

                }

				catalogListingModel.setBrand(item.getBrand());

                catalogListingModel.setBrand(item.getBrand());

				if (item.getCategoryId() == 10006) {

                if (item.getCategoryId() == 10006) {

					catalogListingModel.setCategoryId(item.getCategoryId());

                    catalogListingModel.setCategoryId(item.getCategoryId());

				}

                }

				FocusedModel fm = focusedModelMap.get(catalogId);

                FocusedModel fm = focusedModelMap.get(catalogId);

				if (fm != null) {

                if (fm != null) {

					catalogListingModel.setRecommendedQty(fm.getRecommendedQty());

                    catalogListingModel.setRecommendedQty(fm.getRecommendedQty());

					catalogListingModel.setMinimumQty(fm.getMinimumQty());

                    catalogListingModel.setMinimumQty(fm.getMinimumQty());

				} else {

                } else {

					catalogListingModel.setRecommendedQty(0);

                    catalogListingModel.setRecommendedQty(0);

					catalogListingModel.setMinimumQty(0);

                    catalogListingModel.setMinimumQty(0);

				}

                }

				catalogListingMap.put(catalogId, catalogListingModel);

                catalogListingMap.put(catalogId, catalogListingModel);

			}

            }

			int itemAvailability = 0;

            int itemAvailability = 0;

			if (currentStockMap != null) {

            if (currentStockMap != null) {

				Integer qty = currentStockMap.get(catalogId);

                Integer qty = currentStockMap.get(catalogId);

				itemAvailability = qty == null ? 0 : qty;

                itemAvailability = qty == null ? 0 : qty;

				catalogListingModel.setStockInHand(itemAvailability);

                catalogListingModel.setStockInHand(itemAvailability);

			} else {

            } else {

				catalogListingModel.setStockInHand(0);

                catalogListingModel.setStockInHand(0);

			}

            }

			Integer inTransitQuantity = itemsInTransit.get(item.getId());

            Integer inTransitQuantity = itemsInTransit.get(item.getId());

			int inTransitQty = (inTransitQuantity == null ? 0 : inTransitQuantity);

            int inTransitQty = (inTransitQuantity == null ? 0 : inTransitQuantity);

			catalogListingModel.setInTransitQuantity(catalogListingModel.getInTransitQuantity() + inTransitQty);

            catalogListingModel.setInTransitQuantity(catalogListingModel.getInTransitQuantity() + inTransitQty);

			if (plannedDetailMap != null) {

            if (plannedDetailMap != null) {

				if (plannedDetailMap.get(catalogId) != null) {

                if (plannedDetailMap.get(catalogId) != null) {

					int remaining = plannedDetailMap.get(catalogId) - catalogListingModel.getLast15DaysSale()

                    int remaining = plannedDetailMap.get(catalogId) - catalogListingModel.getLast15DaysSale()

							+ catalogListingModel.getStockInHand() + catalogListingModel.getInTransitQuantity();

                            + catalogListingModel.getStockInHand() + catalogListingModel.getInTransitQuantity();

					LOGGER.info("remaning" + remaining);

                    LOGGER.info("remaning" + remaining);

					if (remaining != 0) {

                    if (remaining != 0) {

						catalogListingModel.setRemaining(remaining);

                        catalogListingModel.setRemaining(remaining);

					} else {

                    } else {

						catalogListingModel.setRemaining(0);

                        catalogListingModel.setRemaining(0);

					}

                    }

				}

                }

			}

            }

		}

        }

		Map<Integer, CustomRetailer> customRetailersMap = retailerService.getFofoRetailers(false);

        Map<Integer, CustomRetailer> customRetailersMap = retailerService.getFofoRetailers(false);

		if (fofoId > 0) {

        if (fofoId > 0) {

			CustomRetailer customRetailer = customRetailersMap.get(fofoId);

            CustomRetailer customRetailer = customRetailersMap.get(fofoId);

			model.addAttribute("retailerName",

            model.addAttribute("retailerName",

					customRetailer.getBusinessName() + "-" + customRetailer.getAddress().getCity());

                    customRetailer.getBusinessName() + "-" + customRetailer.getAddress().getCity());

			FofoStore fs = fofoStoreRepository.selectByRetailerId(fofoId);

            FofoStore fs = fofoStoreRepository.selectByRetailerId(fofoId);

			model.addAttribute("retailerId", customRetailer.getPartnerId());

            model.addAttribute("retailerId", customRetailer.getPartnerId());

			model.addAttribute("counterSize", fs.getCounterSize().toString());

            model.addAttribute("counterSize", fs.getCounterSize().toString());

		} else {

        } else {

			model.addAttribute("counterSize", counterSize.toString());

            model.addAttribute("counterSize", counterSize.toString());

		}

        }

		String customRetailers = JSONObject.valueToString(customRetailersMap.values());

        String customRetailers = JSONObject.valueToString(customRetailersMap.values());

		List<CatalogListingModel> catalogModelList = new ArrayList<>(catalogListingMap.values());

        List<CatalogListingModel> catalogModelList = new ArrayList<>(catalogListingMap.values());

		Comparator<CatalogListingModel> firstCmp = Comparator.comparing(CatalogListingModel::getMinimumQty,

        Comparator<CatalogListingModel> firstCmp = Comparator.comparing(CatalogListingModel::getMinimumQty,

				Comparator.reverseOrder());

                Comparator.reverseOrder());

		LOGGER.info("monthlyPlanned" + monthlyPlanned);

        LOGGER.info("monthlyPlanned" + monthlyPlanned);

		model.addAttribute("catalogTagListings",

        model.addAttribute("catalogTagListings",

				catalogModelList.stream().sorted(firstCmp).collect(Collectors.toList()));

                catalogModelList.stream().sorted(firstCmp).collect(Collectors.toList()));

		model.addAttribute("isAdmin", roleManager.isAdmin(roleIds));

        model.addAttribute("isAdmin", roleManager.isAdmin(roleIds));

		model.addAttribute("brandStockPrices", this.getBrandStockPrices(loginDetails.getFofoId()));

        model.addAttribute("brandStockPrices", this.getBrandStockPrices(loginDetails.getFofoId()));

		model.addAttribute("previousPlanningMonth", planningMonthDate.minusMonths(1).getMonth());

        model.addAttribute("previousPlanningMonth", planningMonthDate.minusMonths(1).getMonth());

		model.addAttribute("currentPlanningMonth", planningMonthDate.getMonth());

        model.addAttribute("currentPlanningMonth", planningMonthDate.getMonth());

		model.addAttribute("customRetailers", customRetailers);

        model.addAttribute("customRetailers", customRetailers);

		model.addAttribute("totalAmount", totalAmount);

        model.addAttribute("totalAmount", totalAmount);

		model.addAttribute("monthlyPlanned", monthlyPlanned);

        model.addAttribute("monthlyPlanned", monthlyPlanned);

		model.addAttribute("totalPcs", totalPcs);

        model.addAttribute("totalPcs", totalPcs);

		return "open-indent";

        return "open-indent";

	}

    }

	private long resetCart(Transaction transaction) {

    private long resetCart(Transaction transaction) {

		long sum = 0;

        long sum = 0;

		Map<Long, Double> items = new HashMap<Long, Double>();

        Map<Long, Double> items = new HashMap<Long, Double>();

		for (in.shop2020.model.v1.order.Order order : transaction.getOrders()) {

        for (in.shop2020.model.v1.order.Order order : transaction.getOrders()) {

			sum += order.getGvAmount();

            sum += order.getGvAmount();

			for (LineItem lineitem : order.getLineitems()) {

            for (LineItem lineitem : order.getLineitems()) {

				Long itemId = lineitem.getItem_id();

                Long itemId = lineitem.getItem_id();

				Double quantity = items.get(itemId);

                Double quantity = items.get(itemId);

				if (quantity == null) {

                if (quantity == null) {

					quantity = lineitem.getQuantity();

                    quantity = lineitem.getQuantity();

				} else {

                } else {

					quantity = quantity + lineitem.getQuantity();

                    quantity = quantity + lineitem.getQuantity();

				}

                }

				items.put(itemId, quantity);

                items.put(itemId, quantity);

			}

            }

		}

        }

		LOGGER.debug("Items to reset in cart are: " + items);

        LOGGER.debug("Items to reset in cart are: " + items);

		try {

        try {

			Client userClient = new UserClient().getClient();

            Client userClient = new UserClient().getClient();

			userClient.resetCart(transaction.getShoppingCartid(), items);

            userClient.resetCart(transaction.getShoppingCartid(), items);

		} catch (TException e) {

        } catch (TException e) {

			LOGGER.error("Error while updating information in payment database.", e);

            LOGGER.error("Error while updating information in payment database.", e);

		} catch (ShoppingCartException e) {

        } catch (ShoppingCartException e) {

			LOGGER.error("Error while reseting the cart in cart database.", e);

            LOGGER.error("Error while reseting the cart in cart database.", e);

		} catch (Exception e) {

        } catch (Exception e) {

			LOGGER.error("Unexpected exception", e);

            LOGGER.error("Unexpected exception", e);

		}

        }

		return sum;

        return sum;

	}

    }

	private List<ItemPriceQuantity> getItemQuantities(int fofoId) throws ProfitMandiBusinessException {

    private List<ItemPriceQuantity> getItemQuantities(int fofoId) throws ProfitMandiBusinessException {

		List<ItemPriceQuantity> itemQuantities = new ArrayList<>();

        List<ItemPriceQuantity> itemQuantities = new ArrayList<>();

		/*

        /*

		 * Map<Integer, ItemIdAvailability> itemCisMap = null; List<ItemIdAvailability>

         * Map<Integer, ItemIdAvailability> itemCisMap = null; List<ItemIdAvailability>

		 * currentInventorySnapshots = currentInventorySnapshotRepository

         * currentInventorySnapshots = currentInventorySnapshotRepository

		 * .selectItemsStock(fofoId); itemCisMap =

         * .selectItemsStock(fofoId); itemCisMap =

		 * currentInventorySnapshots.stream().filter(x -> x.getAvailability() > 0)

         * currentInventorySnapshots.stream().filter(x -> x.getAvailability() > 0)

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

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

		 * List<StockAllocationModel> stockAllocationList =

         * List<StockAllocationModel> stockAllocationList =

		 * stockAllocationService.getStockAllocation(fofoId, true);

         * stockAllocationService.getStockAllocation(fofoId, true);

		 *

         *

		 * Map<Integer, StockAllocationModel> itemStockAllocationMap =

         * Map<Integer, StockAllocationModel> itemStockAllocationMap =

		 * stockAllocationList.stream() .collect(Collectors.toMap(x -> x.catalogId(), x

         * stockAllocationList.stream() .collect(Collectors.toMap(x -> x.catalogId(), x

		 * -> x)); Map<Integer, Integer> itemsInTransit = null;

         * -> x)); Map<Integer, Integer> itemsInTransit = null;

		 * LOGGER.info("Item Stock Allocation Model Map {}", itemStockAllocationMap);

         * LOGGER.info("Item Stock Allocation Model Map {}", itemStockAllocationMap);

		 * List<TagListing> tagListings = tagListingRepository.selectAll(false);

         * List<TagListing> tagListings = tagListingRepository.selectAll(false);

		 * List<Order> inTransitOrders = orderRepository.selectOrders(fofoId,

         * List<Order> inTransitOrders = orderRepository.selectOrders(fofoId,

		 * validOrderStatusList); inTransitOrders =

         * validOrderStatusList); inTransitOrders =

		 * this.filterValidOrders(inTransitOrders); itemsInTransit =

         * this.filterValidOrders(inTransitOrders); itemsInTransit =

		 * inTransitOrders.stream().collect(Collectors.groupingBy(x ->

         * inTransitOrders.stream().collect(Collectors.groupingBy(x ->

		 * x.getLineItem().getItemId(), Collectors.summingInt(x ->

         * x.getLineItem().getItemId(), Collectors.summingInt(x ->

		 * x.getLineItem().getQuantity())));

         * x.getLineItem().getQuantity())));

		 *

         *

		 * Iterator<TagListing> iterator = tagListings.iterator();

         * Iterator<TagListing> iterator = tagListings.iterator();

		 *

         *

		 * int toBeOrdered = 0; while (iterator.hasNext()) { TagListing tagListing =

         * int toBeOrdered = 0; while (iterator.hasNext()) { TagListing tagListing =

		 * iterator.next(); LOGGER.info(" tagListing.setAllocatedQuantity {}",

         * iterator.next(); LOGGER.info(" tagListing.setAllocatedQuantity {}",

		 * tagListing.getAllocatedQuantity()); if

         * tagListing.getAllocatedQuantity()); if

		 * (!itemCisMap.containsKey(tagListing.getItemId()) &&

         * (!itemCisMap.containsKey(tagListing.getItemId()) &&

		 * !itemStockAllocationMap.containsKey(tagListing.getItemId())) {

         * !itemStockAllocationMap.containsKey(tagListing.getItemId())) {

		 * iterator.remove(); continue; } ItemIdAvailability itemIdAvailability =

         * iterator.remove(); continue; } ItemIdAvailability itemIdAvailability =

		 * itemCisMap.get(tagListing.getItemId());

         * itemCisMap.get(tagListing.getItemId());

		 * tagListing.setStockInHand(itemIdAvailability == null ? 0 :

         * tagListing.setStockInHand(itemIdAvailability == null ? 0 :

		 * itemIdAvailability.getAvailability()); StockAllocationModel

         * itemIdAvailability.getAvailability()); StockAllocationModel

		 * stockAllocationModel = itemStockAllocationMap.get(tagListing.getItemId());

         * stockAllocationModel = itemStockAllocationMap.get(tagListing.getItemId());

		 *

         *

		 * if (itemsInTransit.containsKey(tagListing.getItemId())) {

         * if (itemsInTransit.containsKey(tagListing.getItemId())) {

		 * tagListing.setInTransitQuantity(itemsInTransit.get(tagListing.getItemId()));

         * tagListing.setInTransitQuantity(itemsInTransit.get(tagListing.getItemId()));

		 * } else { tagListing.setInTransitQuantity(0); } if (stockAllocationModel !=

         * } else { tagListing.setInTransitQuantity(0); } if (stockAllocationModel !=

		 * null) { tagListing.setAllocatedQuantity(stockAllocationModel.getQuantity());

         * null) { tagListing.setAllocatedQuantity(stockAllocationModel.getQuantity());

		 * toBeOrdered = Math.max(tagListing.getAllocatedQuantity() -

         * toBeOrdered = Math.max(tagListing.getAllocatedQuantity() -

		 * tagListing.getInTransitQuantity() - tagListing.getStockInHand(), 0); if

         * tagListing.getInTransitQuantity() - tagListing.getStockInHand(), 0); if

		 * (toBeOrdered > 0) { ItemPriceQuantity ipq = new ItemPriceQuantity();

         * (toBeOrdered > 0) { ItemPriceQuantity ipq = new ItemPriceQuantity();

		 * ipq.setItemId(tagListing.getItemId()); ipq.setQty((long) toBeOrdered);

         * ipq.setItemId(tagListing.getItemId()); ipq.setQty((long) toBeOrdered);

		 * ipq.setPrice(tagListing.getSellingPrice()); itemQuantities.add(ipq); } } }

         * ipq.setPrice(tagListing.getSellingPrice()); itemQuantities.add(ipq); } } }

		 */

         */

		return itemQuantities;

        return itemQuantities;

	}

    }

	@RequestMapping(value = "/indent/loadIndentPreviousMonth")

    @RequestMapping(value = "/indent/loadIndentPreviousMonth")

	public String previousMonthLoadOpenIndent(HttpServletRequest request, Model model,

    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;

        LocalDate planMonthStart = null;

		if (LocalDate.now().isAfter(LocalDate.now().withDayOfMonth(PLANNING_OPEN_DAY))) {

        if (LocalDate.now().isAfter(LocalDate.now().withDayOfMonth(PLANNING_OPEN_DAY))) {