Subversion Repositories SmartDukaan

package com.spice.profitmandi.service;

import com.google.gson.Gson;

import com.spice.profitmandi.common.enumuration.ReporticoProject;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;

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

import com.spice.profitmandi.dao.entity.auth.AuthUser;

import com.spice.profitmandi.dao.entity.auth.Menu;

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

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

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

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

import com.spice.profitmandi.dao.enumuration.cs.EscalationType;

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

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

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

import com.spice.profitmandi.dao.repository.auth.AuthRepository;

import com.spice.profitmandi.dao.repository.auth.MenuCategoryRepository;

import com.spice.profitmandi.dao.repository.auth.MenuRepository;

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

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

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

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

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

import com.spice.profitmandi.dao.repository.inventory.ReporticoCacheTableRepository;

import com.spice.profitmandi.dao.repository.inventory.SaholicInventoryCISRepository;

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

import com.spice.profitmandi.service.user.RetailerService;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Component;

import org.springframework.ui.Model;

import java.io.FileInputStream;

import java.io.ObjectInputStream;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.Period;

import java.time.YearMonth;

import java.time.format.DateTimeFormatter;

import java.time.temporal.ChronoUnit;

import java.util.*;

import java.util.Map.Entry;

import java.util.stream.Collectors;

import java.util.stream.LongStream;

@Component

public class AdminUser {

	@Autowired

	private Gson gson;

	@Autowired

	private OrderRepository orderRepository;

	@Autowired

	TicketRepository ticketRepository;

	@Autowired

	private ChartService chartService;

	@Autowired

	RetailerService retailerService;

	@Autowired

	AuthRepository authRepository;

	@Autowired

	FofoStoreRepository fofoStoreRepository;

	@Autowired

	CsService csService;

	@Autowired

	private MenuRepository menuRepository;

	@Autowired

	private PositionRepository positionRepository;

	@Autowired

	private MenuCategoryRepository menuCategoryRepository;

	@Autowired

	private SaholicInventoryCISRepository saholicInventoryCISRepository;

	@Autowired

	private ReporticoCacheTableRepository reporticoCacheTableRepository;

	@Autowired

	private ActivatedImeiRepository activatedImeiRepository;

	@Autowired

	private PartnerStatsService partnerStatsService;

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

			"niranjan.kala@smartdukaan.com", "hemant.kaura@smartdukaan.com", "amit.gupta@smartdukaan.com",

			"tejbeer.kaur@smartdukaan.com");

	List<String> colorList = Arrays.asList("mediumseagreen", "dodgerblue", "darkblue", "gold", "coral", "#63C5DA",

			"red", "deeppink", "midnightblue", "cornsilk");

	List<String> borderList = Arrays.asList("lawngreen", "lightblue", "#0000cd", "#f7e98e", "lightcoral", "#0000cd",

			"lightsalmon", "pink", "#0000cd", "cornsilk");

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

			"Nokia");

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

	public ChartModel getBrandWiseLmp(List<Integer> warehouseIds, List<Integer> fofoIds, LocalDate startDate,

			LocalDate endDate, String filterType) {

		LOGGER.info("params" + warehouseIds + fofoIds + startDate);

		List<BrandWiseModel> brandWiseLms = orderRepository.selectGroupByBrandLmp(fofoIds, warehouseIds, startDate,

				endDate, filterType);

		LOGGER.info("brandWiseLms" + brandWiseLms);

		ChartModel cm = null;

		if (filterType.equals("dateWise")) {

			DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("MM-dd-yyyy");

			Map<String, Map<LocalDate, Double>> brandDateValue = new HashMap<>();

			for (BrandWiseModel bwl : brandWiseLms) {

				if (!brandDateValue.containsKey(bwl.getBrand())) {

					brandDateValue.put(bwl.getBrand(), new HashMap<>());

				}

				Map<LocalDate, Double> dateWiseSalesMap = brandDateValue.get(bwl.getBrand());

				dateWiseSalesMap.put(LocalDate.parse(bwl.getYearMonth(), dateTimeFormatter), (double) bwl.getAmount());

			}

			long days = startDate.until(endDate, ChronoUnit.DAYS);

			List<LocalDate> allDatesBetween = LongStream.range(0, days).mapToObj(x -> startDate.plusDays(x))

					.collect(Collectors.toList());

			LOGGER.info("All dates between {}", allDatesBetween);

			Map<String, List<Double>> sortedBrandValue = new LinkedHashMap<>();

			for (String brand : brands) {

				if (!brandDateValue.containsKey(brand)) {

					brandDateValue.put(brand, new HashMap<>());

				}

				Map<LocalDate, Double> dateWiseBrand = brandDateValue.get(brand);

				for (LocalDate date : allDatesBetween) {

					if (dateWiseBrand.get(date) == null) {

						dateWiseBrand.put(date, 0.0);

					}

				}

				Map<LocalDate, Double> sortedMonthBrandValue = new TreeMap<>(dateWiseBrand);

				sortedBrandValue.put(brand, new ArrayList<>(sortedMonthBrandValue.values()));

				LOGGER.info("Sorted Brandwise values count {}", sortedMonthBrandValue.size());

			}

			LOGGER.info("brandMonthValueCount {}", brandDateValue.size());

			LOGGER.info("sortedBrandValueCount {}", sortedBrandValue.size());

			cm = chartService.createChartWithLabels(

					allDatesBetween.stream().map(x -> x.format((DateTimeFormatter.ofPattern("dd MMM''uu"))))

							.collect(Collectors.toCollection(LinkedHashSet::new)),

					sortedBrandValue, colorList, borderList, "Brand Wise Date Wise Purchase");

		} else {

			DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("MM-yyyy");

			Map<String, Map<YearMonth, Double>> brandMonthValue = new HashMap<>();

			for (BrandWiseModel bwl : brandWiseLms) {

				Map<YearMonth, Double> yearMonthValue = new HashMap<>();

				if (brandMonthValue.containsKey(bwl.getBrand())) {

					yearMonthValue = brandMonthValue.get(bwl.getBrand());

					yearMonthValue.put(YearMonth.parse(bwl.getYearMonth(), dateTimeFormatter),

							(double) bwl.getAmount());

				} else {

					yearMonthValue.put(YearMonth.parse(bwl.getYearMonth(), dateTimeFormatter),

							(double) bwl.getAmount());

				}

				brandMonthValue.put(bwl.getBrand(), yearMonthValue);

			}

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

			Period age = Period.between(startDate, endDate);

			int months = age.getMonths();

			LOGGER.info("months" + months);

			LOGGER.info("brandWiseLms" + brandWiseLms);

			LOGGER.info("brandMonthValue" + brandMonthValue);

			Map<String, List<Double>> sortedBrandValue = new LinkedHashMap<>();

			for (String brand : brands) {

				Map<YearMonth, Double> yearMonthValue = brandMonthValue.get(brand);

				for (int i = months; i >= 0; i--) {

					LocalDateTime startMonth = curDate.withDayOfMonth(1).minusMonths(i);

					if (yearMonthValue != null) {

						if (yearMonthValue.get(YearMonth.from(startMonth)) == null) {

							yearMonthValue.put(YearMonth.from(startMonth), 0.0);

						}

					} else {

						yearMonthValue = new HashMap<>();

						yearMonthValue.put(YearMonth.from(startMonth), 0.0);

					}

				}

				Map<YearMonth, Double> sortedMonthBrandValue = new TreeMap<>(yearMonthValue);

				brandMonthValue.put(brand, sortedMonthBrandValue);

				sortedBrandValue.put(brand, sortedMonthBrandValue.values().stream().collect(Collectors.toList()));

			}

			cm = chartService.createChart(months, sortedBrandValue, colorList, borderList,

					"Brand Wise Monthly Purchase");

		}

		return cm;

	}

	public ChartInvestmentModel getAllStatePartnerType(Map<Integer, PartnerDetailModel> fofoIdAndallValues)

			throws ProfitMandiBusinessException {

		Map<String, Float> partnerTypeCount = new HashMap<>();

		List<PartnerType> partnerTypes = Arrays.asList(PartnerType.values());

		for (PartnerType partnerType : partnerTypes) {

			float count = fofoIdAndallValues.entrySet().stream()

					.filter(x -> x.getValue().getPartnerType().equals(partnerType)).count();

			partnerTypeCount.put(partnerType.toString(), count);

		}

		ChartInvestmentModel cm = new ChartInvestmentModel();

		HashSet<String> labels = new HashSet<String>();

		labels.addAll(partnerTypes.stream().skip(1).map(x -> x.toString()).collect(Collectors.toList()));

		List<String> labelList = new ArrayList<>(labels);

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

		List<Float> values = new ArrayList<>();

		for (String label : labelList) {

			values.add(partnerTypeCount.get(label));

			if (label.equals("BRONZE")) {

				backgroundColor.add("#CD7F32");

			}

			if (label.equals("SILVER")) {

				backgroundColor.add("silver");

			}

			if (label.equals("GOLD")) {

				backgroundColor.add("#FFD700");

			}

			if (label.equals("DIAMOND")) {

				backgroundColor.add("#B9F2FF");

			}

			if (label.equals("PLATINUM")) {

				backgroundColor.add("#800080");

			}

			if (label.equals("NEW")) {

				backgroundColor.add("green");

			}

		}

		LOGGER.info("valuesPartnerType" + values);

		LOGGER.info("partnerTypeCount" + partnerTypeCount);

		Data data = new Data();

		data.setData(values);

		data.setBackgroundColor(backgroundColor);

		data.setLabel("DataSet 1");

		PieLables label = new PieLables();

		label.setFontColor("black");

		label.setFontSize(22);

		Legend legend = new Legend();

		legend.setLabels(label);

		legend.setPosition("left");

		List<Data> dataList = new ArrayList<>();

		dataList.add(data);

		DataInvestmentModel datasets = new DataInvestmentModel();

		datasets.setDatasets(dataList);

		datasets.setLabels(labels);

		OptionModel om = new OptionModel();

		om.setLegend(legend);

		cm.setType("pie");

		cm.setData(datasets);

		cm.setOptions(om);

		return cm;

	}

	public Map<String, Object> getFilter(int warehouseId, String email, LocalDateTime date, LocalDateTime endDate)

			throws ProfitMandiBusinessException {

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

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

		Map<Integer, CustomRetailer> crm = null;

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

		AuthUser authUser = authRepository.selectByEmailOrMobile(email);

		Map<Integer, String> warehouseMap = ProfitMandiConstants.WAREHOUSE_MAP;

		Set<Integer> fofoIds = null;

		fofoIds = storeGuyMap.get(authUser.getEmailId());

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

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

		}

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

			}

		}

		if (warehouseId != 0) {

			fofoIds = fofoStoreRepository.selectPartnerByfofoIdAndWarehouse(new ArrayList<>(fofoIds), warehouseId)

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

		}

		if (fofoIds != null) {

			crm = fofoIds.stream().map(x -> customRetailerMap.get(x)).filter(x -> x != null)

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

		}

		map.put("date", date);

		map.put("endDate", endDate);

		map.put("customRetailersMap", crm);

		map.put("fofoIds", fofoIds);

		map.put("warehouseMap", warehouseMap);

		return map;

	}

	public ChartModel getBrandWiseLms(List<Integer> warehouseIds, List<Integer> fofoIds, LocalDate startDate,

			LocalDate endDate, String filterType) {

		LOGGER.info("params" + warehouseIds + fofoIds + startDate);

		List<BrandWiseModel> brandWiseLms = fofoStoreRepository.selectGroupByBrandLms(fofoIds, warehouseIds, startDate,

				endDate, filterType);

		LOGGER.info("brandWiseLms" + brandWiseLms);

		ChartModel cm = null;

		if (filterType.equals("dateWise")) {

			DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("MM-dd-yyyy");

			Map<String, Map<LocalDate, Double>> brandDateValue = new HashMap<>();

			for (BrandWiseModel bwl : brandWiseLms) {

				if (!brandDateValue.containsKey(bwl.getBrand())) {

					brandDateValue.put(bwl.getBrand(), new HashMap<>());

				}

				Map<LocalDate, Double> dateWiseSalesMap = brandDateValue.get(bwl.getBrand());

				dateWiseSalesMap.put(LocalDate.parse(bwl.getYearMonth(), dateTimeFormatter), (double) bwl.getAmount());

			}

			long days = startDate.until(endDate, ChronoUnit.DAYS);

			List<LocalDate> allDatesBetween = LongStream.range(0, days).mapToObj(x -> startDate.plusDays(x))

					.collect(Collectors.toList());

			LOGGER.info("All dates between {}", allDatesBetween);

			Map<String, List<Double>> sortedBrandValue = new LinkedHashMap<>();

			for (String brand : brands) {

				if (!brandDateValue.containsKey(brand)) {

					brandDateValue.put(brand, new HashMap<>());

				}

				Map<LocalDate, Double> dateWiseBrand = brandDateValue.get(brand);

				for (LocalDate date : allDatesBetween) {

					if (dateWiseBrand.get(date) == null) {

						dateWiseBrand.put(date, 0.0);

					}

				}

				Map<LocalDate, Double> sortedMonthBrandValue = new TreeMap<>(dateWiseBrand);

				sortedBrandValue.put(brand, new ArrayList<>(sortedMonthBrandValue.values()));

				LOGGER.info("Sorted Brandwise values count {}", sortedMonthBrandValue.size());

			}

			LOGGER.info("brandMonthValueCount {}", brandDateValue.size());

			LOGGER.info("sortedBrandValueCount {}", sortedBrandValue.size());

			cm = chartService.createChartWithLabels(

					allDatesBetween.stream().map(x -> x.format((DateTimeFormatter.ofPattern("dd MMM''uu"))))

							.collect(Collectors.toCollection(LinkedHashSet::new)),

					sortedBrandValue, colorList, borderList, "Brand Wise Date Wise Sale");

		} else {

			DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("MM-yyyy");

			Map<String, Map<YearMonth, Double>> brandMonthValue = new HashMap<>();

			for (BrandWiseModel bwl : brandWiseLms) {

				Map<YearMonth, Double> yearMonthValue = new HashMap<>();

				if (brandMonthValue.containsKey(bwl.getBrand())) {

					yearMonthValue = brandMonthValue.get(bwl.getBrand());

					yearMonthValue.put(YearMonth.parse(bwl.getYearMonth(), dateTimeFormatter),

							(double) bwl.getAmount());

				} else {

					yearMonthValue.put(YearMonth.parse(bwl.getYearMonth(), dateTimeFormatter),

							(double) bwl.getAmount());

				}

				brandMonthValue.put(bwl.getBrand(), yearMonthValue);

			}

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

			Period age = Period.between(startDate, endDate);

			int months = age.getMonths();

			LOGGER.info("months" + months);

			LOGGER.info("brandWiseLms" + brandWiseLms);

			LOGGER.info("brandMonthValue" + brandMonthValue);

			Map<String, List<Double>> sortedBrandValue = new LinkedHashMap<>();

			for (String brand : brands) {

				Map<YearMonth, Double> yearMonthValue = brandMonthValue.get(brand);

				for (int i = months; i >= 0; i--) {

					LocalDateTime startMonth = curDate.withDayOfMonth(1).minusMonths(i);

					if (yearMonthValue != null) {

						if (yearMonthValue.get(YearMonth.from(startMonth)) == null) {

							yearMonthValue.put(YearMonth.from(startMonth), 0.0);

						}

					} else {

						yearMonthValue = new HashMap<>();

						yearMonthValue.put(YearMonth.from(startMonth), 0.0);

					}

				}

				Map<YearMonth, Double> sortedMonthBrandValue = new TreeMap<>(yearMonthValue);

				brandMonthValue.put(brand, sortedMonthBrandValue);

				sortedBrandValue.put(brand, sortedMonthBrandValue.values().stream().collect(Collectors.toList()));

			}

			cm = chartService.createChart(months, sortedBrandValue, colorList, borderList, "Brand Wise Monthly Sale");

		}

		return cm;

	}

	public String adminPanel(int fofoId, String email, Model model) throws Exception {

		List<Menu> menus = null;

		try {

			AuthUser authUser = authRepository.selectByEmailOrMobile(email);

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

			Map<Integer, PartnerDetailModel> warehousePartnerDetailMap = null;

			Map<Integer, WarehouseWiseStockModel> warehouseStockMap = new HashMap<>();

			LinkedHashMap<Integer, WarehouseWiseStockModel> warehouseStockSortedMap = new LinkedHashMap<>();

			Map<Integer, String> warehouseMap = ProfitMandiConstants.WAREHOUSE_MAP;

			Map<Integer, String> wm = new LinkedHashMap<>();

			Map<AuthUser, Long> authUserTicketCount = null;

			for (Map.Entry<Integer, String> entry : warehouseMap.entrySet()) {

				wm.put(entry.getKey(), entry.getValue());

			}

			wm.put(0, "Total Values");

			long stockValue = 0;

			long stockQty = 0;

			long pendingIndent = 0;

			long tertiary = 0;

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

				}

			}

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

				Map<Integer, List<Integer>> warehouseIdFofoIdMap = fofoStoreRepository

						.selectActivePartnersByRetailerIds(new ArrayList<>(fofoIds)).stream()

						.collect(Collectors.groupingBy(FofoStore::getWarehouseId,

								Collectors.mapping(FofoStore::getId, Collectors.toList())));

				// warehouseStock

				List<WarehouseWiseStockModel> warehouseStocks = saholicInventoryCISRepository

						.selectGroupByWarehouse(new ArrayList<>(warehouseIdFofoIdMap.keySet()));

				warehouseStockMap = warehouseStocks.stream().collect(Collectors.toMap(x -> x.getWarehouseId(), x -> x));

				if (!warehouseStockMap.isEmpty()) {

					for (Entry<Integer, WarehouseWiseStockModel> warehouseStock : warehouseStockMap.entrySet()) {

						stockValue += warehouseStock.getValue().getStockValue();

						stockQty += warehouseStock.getValue().getStockQty();

						pendingIndent += warehouseStock.getValue().getPendingIndent();

						tertiary += warehouseStock.getValue().getTertiary();

					}

					WarehouseWiseStockModel ws = new WarehouseWiseStockModel();

					ws.setStockQty(stockQty);

					ws.setStockValue(stockValue);

					ws.setPendingIndent(pendingIndent);

					ws.setTertiary(tertiary);

					ws.setWarehouseId(0);

					warehouseStockMap.put(0, ws);

				}

				warehouseStockMap.entrySet().stream().sorted(Map.Entry.comparingByKey(Comparator.reverseOrder()))

						.forEachOrdered(x -> warehouseStockSortedMap.put(x.getKey(), x.getValue()));

				ReporticoCacheTable rctSaholic = reporticoCacheTableRepository.selectByTableName("SaholicInventoryCIS");

				model.addAttribute("reporticoDate", rctSaholic);

				// warehouseStock

				warehousePartnerDetailMap = this.getWarehousePartnerDetail(warehouseIdFofoIdMap);

				ReporticoCacheTable rctPartneStat = reporticoCacheTableRepository.selectByTableName("partnerStat");

				Set<CustomRetailer> positionRetailers = fofoIds.stream()

						.map(x -> retailerService.getAllFofoRetailers().get(x)).filter(x -> x != null)

						.collect(Collectors.toSet());

				model.addAttribute("retailers", gson.toJson(positionRetailers));

				model.addAttribute("reporticoProjectMap", ReporticoProject.salesReporticoProjectMap);

				model.addAttribute("warehouses", getWarehouses(positionRetailers));

				model.addAttribute("rctPartneStat", rctPartneStat);

			} else {

				List<Position> warehousePositions = positions.stream()

						.filter(x -> x.getCategoryId() == ProfitMandiConstants.TICKET_CATEGORY_WAREHOUSE)

						.collect(Collectors.toList());

				if (warehousePositions.size() > 0) {

					Set<CustomRetailer> positionRetailers = new HashSet<>();

					csService.getPositionCustomRetailerMap(warehousePositions).values().forEach(customRetailers -> {

						positionRetailers.addAll(customRetailers);

					});

					model.addAttribute("reporticoProjectMap", ReporticoProject.warehouseReporticoMap);

					model.addAttribute("retailers", gson.toJson(positionRetailers));

					model.addAttribute("warehouses", getWarehouses(positionRetailers));

				}

				List<Position> categoryPositions = positions.stream()

						.filter(x -> x.getCategoryId() == ProfitMandiConstants.TICKET_CATEGORY_CATEGORY)

						.collect(Collectors.toList());

				if (categoryPositions.size() > 0) {

					Set<CustomRetailer> positionRetailers = new HashSet<>();

					csService.getPositionCustomRetailerMap(warehousePositions).values().forEach(customRetailers -> {

						positionRetailers.addAll(customRetailers);

					});

					model.addAttribute("reporticoProjectMap", ReporticoProject.warehouseReporticoMap);

					model.addAttribute("retailers", gson.toJson(positionRetailers));

					model.addAttribute("warehouses", getWarehouses(positionRetailers));

				}

			}

			if (positions.size() > 0) {

				if (positions.stream()

						.filter(x -> x.getEscalationType().equals(EscalationType.L3)

								|| x.getEscalationType().equals(EscalationType.L4)

								|| x.getEscalationType().equals(EscalationType.L5))

						.count() > 0) {

					authUserTicketCount = ticketRepository.selectAllAuthUserTicketCount(Optional.of(false));

				}

			}

			if (Arrays.asList("amit.gupta@smartdukaan.com", "tejbeer.kaur@smartdukaan.com").contains(email)) {

				menus = menuRepository.selectAll();

			} else if (positions.size() > 0) {

				if (positions.stream().filter(x -> x.getEscalationType().equals(EscalationType.L5)).count() > 0) {

					menus = menuRepository.selectAll();

				} else {

					List<Integer> menuIds = menuCategoryRepository.selectAllByPositions(positions).stream()

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

					if (menuIds.size() > 0) {

						menus = menuRepository.selectAllByIds(menuIds);

					}

				}

			}

			model.addAttribute("authId", authUser.getId());

			model.addAttribute("warehousePartnerDetailMap", warehousePartnerDetailMap);

			model.addAttribute("warehouseMap", wm);

			model.addAttribute("authUserTicketCount", authUserTicketCount);

			model.addAttribute("warehouseStockMap", warehouseStockSortedMap);

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

			model.addAttribute("date", curDate.withDayOfMonth(1).minusMonths(6).toLocalDate());

		} catch (ProfitMandiBusinessException e) {

		}

		List<Menu> menuList = (menus != null) ? this.prepareMenu(menus) : new ArrayList<>();

		LOGGER.info("menu" + menuList);

		model.addAttribute("menu", menuList);

		return "admin";

	}

	private List<Menu> prepareMenu(List<Menu> menus) {

		List<Menu> returnMenu = new ArrayList<>();

		Map<Menu, List<Menu>> subMenuMap = new HashMap<>();

		for (Menu menu : menus) {

			if (menu.get_parent() == null) {

				if (!subMenuMap.containsKey(menu)) {

					subMenuMap.put(menu, new ArrayList<>());

				}

			} else {

				Menu parentMenu = menu.get_parent();

				if (!subMenuMap.containsKey(parentMenu)) {

					subMenuMap.put(parentMenu, new ArrayList<>());

				}

				subMenuMap.get(parentMenu).add(menu);

			}

		}

		subMenuMap.entrySet().stream().forEach(entry -> {

			entry.getKey().setSubMenus(entry.getValue());

			returnMenu.add(entry.getKey());

		});

		return returnMenu;

	}

	public Map<Integer, PartnerDetailModel> getWarehousePartnerDetail(Map<Integer, List<Integer>> warehousePartnerMap)

			throws Exception {

		Map<Integer, PartnerDetailModel> warehouseIdAndallValues = new LinkedHashMap<>();

		// Map<Integer, List<FofoStore>> warehousePartnerMap =

		// fofoStoreRepository.getWarehousePartnerMap();

		Map<Integer, PartnerDetailModel> partnerStats = this.getPartnersStatDataFromFile();

		List<Integer> allfofoIds = new ArrayList<>();

		if (partnerStats != null) {

			for (Entry<Integer, List<Integer>> warehouse : warehousePartnerMap.entrySet()) {

				List<Integer> fofoIds = warehouse.getValue().stream().collect(Collectors.toList());

				allfofoIds.addAll(fofoIds);

				List<PartnerDetailModel> partnerDetails = fofoIds.stream().map(x -> partnerStats.get(x))

						.collect(Collectors.toList());

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

					PartnerDetailModel partnerDetailModel = partnerStatsService.getAggregateStats(partnerDetails);

					warehouseIdAndallValues.put(warehouse.getKey(), partnerDetailModel);

				}

			}

			List<PartnerDetailModel> allPartnerDetails = allfofoIds.stream().map(x -> partnerStats.get(x))

					.collect(Collectors.toList());

			LOGGER.info("allPartnerDetails" + allPartnerDetails);

			PartnerDetailModel partnerDetailModel = partnerStatsService

					.getAggregateStats(new ArrayList<>(allPartnerDetails));

			warehouseIdAndallValues.put(0, partnerDetailModel);

		}

		return warehouseIdAndallValues;

	}

	public Map<Integer, PartnerDetailModel> getPartnersStatDataFromFile() throws Exception {

		ObjectInputStream objectinputstream = null;

		Map<Integer, PartnerDetailModel> partnerStat = null;

		try {

			FileInputStream streamIn = new FileInputStream("/tmp/partnerStat.tmp");

			objectinputstream = new ObjectInputStream(streamIn);

			partnerStat = (Map<Integer, PartnerDetailModel>) objectinputstream.readObject();

			LOGGER.info("partnerStat" + partnerStat);

			objectinputstream.close();

		} catch (Exception e) {

			LOGGER.info("exceptionddd" + e);

			e.printStackTrace();

		} finally {

			if (objectinputstream != null) {

				objectinputstream.close();

				LOGGER.info("clofddd" + partnerStat);

			}

		}

		return partnerStat;

	}

	private String getWarehouses(Set<CustomRetailer> positionRetailers) {

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

		positionRetailers.stream().forEach(x -> {

			if (x.getWarehouseId() != 0) {

				warehouses.put(x.getWarehouseId(), ProfitMandiConstants.WAREHOUSE_MAP.get(x.getWarehouseId()));

			}

		});

		return gson.toJson(warehouses);

	}

}