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.entity.transaction.LoanSummary;

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.CsService1;

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.transaction.SDCreditService;

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

    CsService1 csService1;

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

    @Autowired

    private SDCreditService sdCreditService;

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

            "#63C5DA", "red", "deeppink", "midnightblue", "cornsilk");

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

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

    List<String> brands = Arrays.asList("Oppo", "Vivo", "Samsung", "Realme", "OnePlus", "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<Integer, String> warehouseMap = ProfitMandiConstants.WAREHOUSE_MAP;

        Set<Integer> fofoIds = csService1.getAuthFofoIds(email, true);

        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;

            LoanSummary loanSummary = sdCreditService.getLoanSummary();

            model.addAttribute("loanSummary", loanSummary);

            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;

            Set<Integer> fofoIds = csService1.getAuthFofoIds(email, true);

            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", "ranu.rajput@smartdukaan.com",

                    "shampa.banerjee@smartdukaan.com", "tejus.lohani@smartdukaan.com").contains(email)) {

                menus = menuRepository.selectAllBySequence();

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

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

                    menus = menuRepository.selectAllBySequence();

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

            objectinputstream.close();

        } catch (Exception e) {

            LOGGER.info("exceptionddd" + e);

            e.printStackTrace();

        } finally {

            if (objectinputstream != null) {

                objectinputstream.close();

            }

        }

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

    }

}