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@shop2020.in",
                        "tejbeer.kaur@shop2020.in");

        List<String> colorList = Arrays.asList("mediumseagreen", "dodgerblue", "darkblue", "gold", "coral", "steelblue",
                        "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@shop2020.in", "tejbeer.kaur@shop2020.in", "manish.tiwari@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);

        }

}