Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import com.google.gson.Gson;

import com.mongodb.DBObject;

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

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

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

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

import com.spice.profitmandi.common.web.util.ResponseSender;

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

import com.spice.profitmandi.dao.entity.catalog.Item;

import com.spice.profitmandi.dao.entity.catalog.Scheme;

import com.spice.profitmandi.dao.entity.catalog.TagListing;

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

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

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

import com.spice.profitmandi.dao.entity.dtr.Document;

import com.spice.profitmandi.dao.entity.dtr.NotificationCampaign;

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

import com.spice.profitmandi.dao.entity.transaction.LineItem;

import com.spice.profitmandi.dao.entity.transaction.Order;

import com.spice.profitmandi.dao.enumuration.catalog.UpgradeOfferStatus;

import com.spice.profitmandi.dao.enumuration.fofo.Milestone;

import com.spice.profitmandi.dao.enumuration.transaction.OrderStatus;

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

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

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

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

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

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

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

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

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

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

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

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

import com.spice.profitmandi.service.AdminUser;

import com.spice.profitmandi.service.FofoUser;

import com.spice.profitmandi.service.PartnerInvestmentService;

import com.spice.profitmandi.service.PartnerStatsService;

import com.spice.profitmandi.service.SshServer.SSHService;

import com.spice.profitmandi.service.authentication.RoleManager;

import com.spice.profitmandi.service.catalog.BrandsService;

import com.spice.profitmandi.service.integrations.psismart.PsiSmartService;

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

import com.spice.profitmandi.service.offers.ItemCriteria;

import com.spice.profitmandi.service.offers.OfferService;

import com.spice.profitmandi.service.scheme.SchemeService;

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

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

import com.spice.profitmandi.web.model.LoginDetails;

import com.spice.profitmandi.web.util.CookiesProcessor;

import com.spice.profitmandi.web.util.MVCResponseSender;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.json.JSONObject;

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

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

import org.springframework.core.io.InputStreamResource;

import org.springframework.http.HttpHeaders;

import org.springframework.http.HttpStatus;

import org.springframework.http.ResponseEntity;

import org.springframework.stereotype.Controller;

import org.springframework.ui.Model;

import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;

import javax.transaction.Transactional;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.LocalTime;

import java.time.YearMonth;

import java.time.format.DateTimeFormatter;

import java.util.*;

import java.util.Map.Entry;

import java.util.stream.Collectors;

import static in.shop2020.model.v1.order.OrderStatus.*;

@Controller

@Transactional(rollbackOn = Throwable.class)

public class DashboardController {

    List<String> emails = Arrays.asList("kamini.sharma@smartdukaan.com", "neeraj.gupta@smartdukaan.com", "amit.gupta@smartdukaan.com", "ranu.rajput@smartdukaan.com", "vikas.jangra@smartdukaan.com", "tejus.lohani@smartdukaan.com", "aman.gupta@smartdukaan.com");

    @Value("${web.api.host}")

    private String webApiHost;

    @Value("${web.api.scheme}")

    private String webApiScheme;

    @Autowired

    private CsService1 csService1;

    @Value("${web.api.root}")

    private String webApiRoot;

    @Value("${web.api.port}")

    private int webApiPort;

    @Autowired

    private PriceDropRepository priceDropRepository;

    @Autowired

    private CookiesProcessor cookiesProcessor;

    @Autowired

    private PendingOrderRepository pendingOrderRepository;

    @Autowired

    private PartnerStatsService partnerStatsService;

    @Autowired

    private CsService csService;

    @Autowired

    private ResponseSender<?> responseSender;

    @Autowired

    RetailerService retailerService;

    @Autowired

    private AdminUser adminUser;

    @Autowired

    private RoleManager roleManager;

    @Autowired

    private FofoStoreRepository fofoStoreRepository;

    @Autowired

    private PartnerInvestmentService partnerInvestmentService;

    @Autowired

    DocumentRepository documentRepository;

    @Autowired

    InventoryItemRepository inventoryItemRepository;

    @Autowired

    InventoryService inventoryService;

    @Autowired

    private PendingOrderItemRepository pendingOrderItemRepository;

    @Autowired

    private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

    @Autowired

    private FofoOrderItemRepository fofoOrderItemRepository;

    @Autowired

    private PartnerTypeChangeService partnerTypeChangeService;

    @Autowired

    private HygieneDataRepository hygieneDataRepository;

    @Autowired

    private UserAccountRepository userAccountRepository;

    @Autowired

    private NotificationCampaignRepository notificationCampaignRepository;

    @Autowired

    private AuthRepository authRepository;

    @Autowired

    private FofoOrderRepository fofoOrderRepository;

    @Autowired

    private Gson gson;

    @Autowired

    TicketRepository ticketRepository;

    @Autowired

    private OfferService offerService;

    @Autowired

    private ItemRepository itemRepository;

    @Autowired

    private SaholicInventoryCISRepository saholicInventoryCISRepository;

    @Autowired

    private MVCResponseSender mvcResponseSender;

    @Autowired

    private ReporticoCacheTableRepository reporticoCacheTableRepository;

    @Autowired

    private TransactionService transactionService;

    @Autowired

    private TagListingRepository tagListingRepository;

    @Autowired

    private TicketAssignedRepository ticketAssignedRepository;

    @Autowired

    private OrderRepository orderRepository;

    @Autowired

    private FofoUser fofoUser;

    @Autowired

    private ActivatedImeiRepository activatedImeiRepository;

    @Autowired

    private Mongo mongoClient;

    @Autowired

    private SchemeInOutRepository schemeInOutRepository;

    @Autowired

    private LineItemRepository lineItemRepository;

    @Autowired

    private FofoLineItemRepository fofoLineItemRepository;

    @Autowired

    private PositionRepository positionRepository;

    @Autowired

    private MonthlyTargetRepository monthlyTargetRepository;

    @Autowired

    private SamsungUpgradeOfferRepository samsungUpgradeOfferRepository;

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

    @Autowired

    private SSHService sshService;

    @Autowired

    BrandsService brandsService;

    @RequestMapping(value = "/12dashboard34", method = RequestMethod.GET)

    public String dashboard1(HttpServletRequest request, Model model, @RequestParam int fofoId) throws Exception {

        boolean isAdmin = false;

        model.addAttribute("isAdmin", isAdmin);

        model.addAttribute("webApiHost", webApiHost);

        model.addAttribute("webApiPort", webApiPort);

        model.addAttribute("webApiScheme", webApiScheme);

        model.addAttribute("webApiRoot", webApiRoot);

        if (isAdmin) {

            return "dashboard1";

        }

        FofoStore fofoStore = null;

        try {

            CustomRetailer customRetailer = retailerService.getFofoRetailer(fofoId);

            fofoStore = fofoStoreRepository.selectByRetailerId(fofoId);

            if (!fofoStore.isActive()) {

                return "redirect:/login";

            }

            PartnerType partnerType = partnerTypeChangeService.getTypeOnDate(fofoStore.getId(), LocalDate.now());

            model.addAttribute("partnerType", partnerType);

            model.addAttribute("partnerTypeImage", PartnerType.imageMap.get(partnerType));

            model.addAttribute("fofoStore", customRetailer);

            model.addAttribute("partnerType", partnerType);

            model.addAttribute("hasGift", fofoUser.hasGift(fofoId));

            model.addAttribute("giftItemId", ProfitMandiConstants.GIFT_ID);

            model.addAttribute("brandStockPrices", fofoUser.getBrandStockPrices(fofoId, false));

            model.addAttribute("salesMap", fofoUser.getSales(fofoId));

            model.addAttribute("activatedImeis", inventoryItemRepository.selectCountByActivatedNotSold(fofoId));

            // this.setInvestments

            //

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

            for (int i = 0; i <= 5; i++) {

                LocalDateTime startOfMonth = LocalDateTime.now().withDayOfMonth(1).minusMonths(i);

                monthValueMap.put(i, startOfMonth.format(DateTimeFormatter.ofPattern("MMM''uu")));

            }

            LOGGER.info("monthValueMap" + monthValueMap);

            Set<String> brands = brandsService.getBrandsToDisplay(3).stream().map(x -> x.getName()).collect(Collectors.toSet());

            brands.addAll(itemRepository.selectAllBrands(ProfitMandiConstants.LED_CATEGORY_ID));

            brands.addAll(itemRepository.selectAllBrands(ProfitMandiConstants.SMART_WATCH_CATEGORY_ID));

            brands.add("Live Demo");

            model.addAttribute("brands", brands);

            model.addAttribute("monthValueMap", monthValueMap);

            model.addAttribute("investments", fofoUser.getInvestments(fofoId));

            model.addAttribute("isInvestmentOk", partnerInvestmentService.isInvestmentOk(fofoId, ProfitMandiConstants.MIN_INVESTMENT_PERCENTAGE, ProfitMandiConstants.CUTOFF_INVESTMENT));

        } catch (ProfitMandiBusinessException e) {

            LOGGER.error("FofoStore Code not found of fofoId {}", fofoId);

        }

        return "12dashboard34";

    }

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

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        int fofoId = loginDetails.getFofoId();

        Map<Integer, MonthSaleModel> monthSaleMap = new HashMap<>();

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

        int dayOfMonth = curDate.getDayOfMonth();

        YearMonth yearMonth = YearMonth.now();

        for (int i = 1; i <= 6; i++) {

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

            int lengthOfMonth = YearMonth.from(startOfMonth).lengthOfMonth();

            LOGGER.info("Start of previous Month {}, start of next month Month {}", startOfMonth, startOfMonth.plusMonths(1));

            double monthSales = fofoOrderItemRepository.selectSumMopGroupByRetailer(startOfMonth, startOfMonth.plusMonths(1), loginDetails.getFofoId(), false).get(fofoId);

            double mtdSales = fofoOrderItemRepository.selectSumMopGroupByRetailer(startOfMonth, startOfMonth.plusDays(Math.min(dayOfMonth, lengthOfMonth)), loginDetails.getFofoId(), false).get(fofoId);

            PartnerType partnerType = partnerTypeChangeService.getTypeOnMonth(fofoId, yearMonth.minusMonths(i));

            MonthSaleModel ms = new MonthSaleModel();

            ms.setMtdSales(fofoUser.format((long) mtdSales));

            ms.setMonthlySales(fofoUser.format(((long) monthSales)));

            ms.setPartnerType(partnerType);

            ms.setMonth(startOfMonth.format(DateTimeFormatter.ofPattern("MMM''uu")));

            monthSaleMap.put(i, ms);

        }

        model.addAttribute("monthSales", monthSaleMap);

        return "monthSales";

    }

    @Autowired

    SchemeService schemeService;

    @Value("${google.api.key}")

    private String googleApiKey;

    @Autowired

    PrintResourceRegionRepository printResourceRegionRepository;

    @Autowired

    PartnerRegionRepository partnerRegionRepository;

    @Autowired

    PrintResourceRepository printResourceRepository;

    @Autowired

    CatalogRepository catalogRepository;

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

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        String email = loginDetails.getEmailId();

        int fofoId = loginDetails.getFofoId();

        boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());

        model.addAttribute("isAdmin", isAdmin);

        model.addAttribute("webApiHost", webApiHost);

        model.addAttribute("webApiPort", webApiPort);

        model.addAttribute("webApiScheme", webApiScheme);

        model.addAttribute("webApiRoot", webApiRoot);

        model.addAttribute("googleApiKey", googleApiKey);

        if (isAdmin) {

            return adminUser.adminPanel(loginDetails.getFofoId(), email, model);

        } else {

            FofoStore fofoStore;

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

            LocalDateTime currentDate = LocalDateTime.now();

            List<PrintResource> printResources = printResourceRepository.selectPrintResourcesByFofoRegion(partnerRegion.get(0).getRegionId(), currentDate);

            LOGGER.info("printresourcesList {}", printResources);

            model.addAttribute("printResources", printResources);

            try {

                fofoStore = fofoStoreRepository.selectByRetailerId(loginDetails.getFofoId());

                if (!fofoStore.isActive()) {

                    return "redirect:/login";

                }

                LocalDateTime startDate = LocalDate.now().withDayOfYear(1).atStartOfDay();

                LocalDateTime endtDate = LocalDateTime.now();

                OnlineDeliveredOrderSum onlineDeliveredOrderSum = pendingOrderItemRepository.selectSumSellingPriceOnlineOrder(fofoId, startDate, endtDate);

                LOGGER.info("onlineDeliveredOrderSum" + onlineDeliveredOrderSum.getSellingPrice());

                long countOrder = pendingOrderRepository.pendingOrderCount(fofoId, OrderStatus.PROCESSING);

                LOGGER.info("countOrder" + countOrder);

                ArrayList<in.shop2020.model.v1.order.OrderStatus> orderStatus = new ArrayList<>();

                orderStatus.add(SUBMITTED_FOR_PROCESSING);

                orderStatus.add(BILLED);

                orderStatus.add(SHIPPED_FROM_WH);

                orderStatus.add(DELIVERY_SUCCESS);

                List<Order> openOrders = orderRepository.selectGrnTimestampNull(fofoId, orderStatus);

                List<LineItem> submittedLineItemIds = openOrders.stream().filter(x -> x.getStatus().equals(SUBMITTED_FOR_PROCESSING)).map(x -> x.getLineItem()).collect(Collectors.toList());

                List<LineItem> billedOrderIds = openOrders.stream().filter(x -> x.getStatus().equals(BILLED)).map(x -> x.getLineItem()).collect(Collectors.toList());

                List<LineItem> shippedOrderIds = openOrders.stream().filter(x -> x.getStatus().equals(SHIPPED_FROM_WH)).map(x -> x.getLineItem()).collect(Collectors.toList());

                List<LineItem> grnPendingLineItemIds = openOrders.stream().filter(x -> x.getStatus().equals(DELIVERY_SUCCESS)).map(x -> x.getLineItem()).collect(Collectors.toList());

                long imeiActivationPendingCount = 0;

                long imeiActivationPendingValue = 0;

                //Only delivered orders should be visible

                List<Integer> grnPendingOrderIds = openOrders.stream().filter(x -> x.getStatus().equals(DELIVERY_SUCCESS)).map(x -> x.getId()).collect(Collectors.toList());

                if (grnPendingOrderIds.size() > 0) {

                    List<ImeiActivationTimestampModel> imeiActivationTimestampModels = activatedImeiRepository.selectActivatedImeisByOrders(grnPendingOrderIds);

                    imeiActivationPendingCount = imeiActivationTimestampModels.size();

                    imeiActivationPendingValue = imeiActivationTimestampModels.stream().collect(Collectors.summingDouble(x -> x.getSellingPrice())).longValue();

                }

                long grnPendingCount = grnPendingLineItemIds.stream().collect(Collectors.summingLong(LineItem::getQuantity));

                long grnPendingValue = grnPendingLineItemIds.stream().collect(Collectors.summingLong(x -> x.getTotalPrice().longValue()));

                model.addAttribute("grnPendingCount", grnPendingCount);

                model.addAttribute("grnPendingValue", grnPendingValue);

                long submittedCount = submittedLineItemIds.stream().collect(Collectors.summingLong(LineItem::getQuantity));

                long submittedValue = submittedLineItemIds.stream().collect(Collectors.summingLong(x -> x.getTotalPrice().longValue()));

                model.addAttribute("submittedCount", submittedCount);

                model.addAttribute("submittedValue", submittedValue);

                long billedCount = billedOrderIds.stream().collect(Collectors.summingLong(LineItem::getQuantity));

                long billedValue = billedOrderIds.stream().collect(Collectors.summingLong(x -> x.getTotalPrice().longValue()));

                model.addAttribute("billedValue", billedValue);

                model.addAttribute("billedCount", billedCount);

                LOGGER.info("billedCount {}", billedCount);

                long shippedCount = shippedOrderIds.stream().collect(Collectors.summingLong(LineItem::getQuantity));

                model.addAttribute("shippedCount", shippedCount);

                LOGGER.info("shippedCount {}", shippedCount);

                long shippedValue = shippedOrderIds.stream().collect(Collectors.summingLong(x -> x.getTotalPrice().longValue()));

                model.addAttribute("shippedValue", shippedValue);

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

                LocalDateTime currentMonthStart = curDate.withDayOfMonth(1);

                LocalDateTime lastMonthStart = currentMonthStart.minusMonths(1);

                LocalDateTime currentMonthEnd = currentMonthStart.withDayOfMonth(1);

                LOGGER.info("lastMonthStart" + lastMonthStart);

                LOGGER.info("currentMonthEnd" + currentMonthEnd);

                Scheme staticScheme = schemeService.getStaticScheme(fofoId);

                double schemeAchievement = 0;

                String schemeCategory = null;

                if (staticScheme != null) {

                    Map<Integer, Double> schemeAchievementMap = orderRepository.selectBillingDatesBetweenSumGroupByRetailerId(staticScheme.getStartDateTime(), staticScheme.getEndDateTime());

                    if (schemeAchievementMap.get(fofoId) != null) {

                        schemeAchievement = schemeAchievementMap.get(fofoId);

                        if (staticScheme.getTarget() >= 120000 && staticScheme.getTarget() < 2000000) {

                            schemeCategory = "Bronze Club";

                        } else if (staticScheme.getTarget() < 3000000) {

                            schemeCategory = "Silver Club";

                        } else if (staticScheme.getTarget() < 4000000) {

                            schemeCategory = "Gold Club";

                        } else if (staticScheme.getTarget() < 6000000) {

                            schemeCategory = "Rising Star Club";

                        } else if (staticScheme.getTarget() < 8000000) {

                            schemeCategory = "Super Star Club";

                        } else if (staticScheme.getTarget() < 12500000) {

                            schemeCategory = "Diamond Club";

                        } else if (staticScheme.getTarget() < 28000000) {

                            schemeCategory = "Platinum Club";

                        } else {

                            schemeCategory = "Premium Club";

                        }

                    }

                }

                model.addAttribute("countOrder", countOrder);

                model.addAttribute("onlineDeliveredOrderSum", onlineDeliveredOrderSum.getSellingPrice());

                PartnerType partnerType = partnerTypeChangeService.getTypeOnDate(fofoStore.getId(), LocalDate.now());

                model.addAttribute("partnerType", partnerType);

                model.addAttribute("partnerTypeImage", PartnerType.imageMap.get(partnerType));

                model.addAttribute("fofoStore", fofoStore);

                model.addAttribute("partnerType", partnerType);

                model.addAttribute("hasGift", fofoUser.hasGift(loginDetails.getFofoId()));

                model.addAttribute("giftItemId", ProfitMandiConstants.GIFT_ID);

                model.addAttribute("retailers", new JSONObject().append("code", fofoStore.getCode()).append("partnerId", fofoStore.getId()).toString());

                model.addAttribute("activatedImeis", inventoryItemRepository.selectCountByActivatedNotSold(loginDetails.getFofoId()));

                model.addAttribute("imeiActivationPendingCount", imeiActivationPendingCount);

                model.addAttribute("imeiActivationPendingValue", imeiActivationPendingValue);

                Map<Integer, Double> accesoriesmtdsale = fofoOrderRepository.selectSumSaleGroupByFofoIdsForMobileOrAccessories(loginDetails.getFofoId(), curDate.withDayOfMonth(1), curDate.with(LocalTime.MAX), Optional.of(false));

                Double accesoriesStock = currentInventorySnapshotRepository.selectSumStockGroupByFofoIdsForMobileOrAccessories(loginDetails.getFofoId(), Optional.of(false)).get(loginDetails.getFofoId());

                model.addAttribute("accesoriesStock", String.format("%.0f", accesoriesStock));

                model.addAttribute("staticScheme", staticScheme);

                model.addAttribute("schemeCategory", schemeCategory);

                model.addAttribute("schemeAchievement", schemeAchievement);

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

                model.addAttribute("salesMap", fofoUser.getSales(loginDetails.getFofoId()));

                ChartModel cm = fofoUser.getBrandChart(loginDetails.getFofoId(),null,null,false);

                LOGGER.info("chartMap" + gson.toJson(cm));

                model.addAttribute("chartMap", gson.toJson(cm));

                List<CreateOfferRequest> createOffers = offerService.getPublishedOffers(loginDetails.getFofoId(), YearMonth.from(LocalDateTime.now()));

                List<CreateOfferRequest> publishedOffers = null;

                publishedOffers = createOffers.stream().filter(createOffer -> createOffer.getTargetSlabs().stream()

                        .map(x -> x.getItemCriteriaPayouts())

                        .flatMap(List::stream)

                        .map(ItemCriteriaPayout::getItemCriteria)

                        .map(ItemCriteria::getCatalogIds)

                        .flatMap(List::stream)

                        .noneMatch(catalogId -> catalogRepository.selectCatalogById(catalogId).getBrand().equals("Live Demo"))).collect(Collectors.toList());

                model.addAttribute("publishedOffers", publishedOffers);

                model.addAttribute("investments", fofoUser.getInvestments(loginDetails.getFofoId()));

                model.addAttribute("isInvestmentOk", partnerInvestmentService.isInvestmentOk(loginDetails.getFofoId(), ProfitMandiConstants.MIN_INVESTMENT_PERCENTAGE, ProfitMandiConstants.CUTOFF_INVESTMENT));

                double currentMonthRating = hygieneDataRepository.selectRatingAvg(loginDetails.getFofoId(), DateRangeModel.of(currentMonthStart, currentMonthEnd)) / 2;

                double lastMonthRating = hygieneDataRepository.selectRatingAvg(loginDetails.getFofoId(), DateRangeModel.of(lastMonthStart, currentMonthStart)) / 2;

                double ratingTillDate = hygieneDataRepository.selectRatingAvg(loginDetails.getFofoId(), DateRangeModel.withEndDate(currentMonthEnd)) / 2;

                model.addAttribute("currentMonthRating", (float) Math.round(currentMonthRating * 10) / 10);

                model.addAttribute("lastMonthRating", (float) Math.round(lastMonthRating * 10) / 10);

                model.addAttribute("ratingTillDate", (float) Math.round(ratingTillDate * 10) / 10);

                long hygieneCount = hygieneDataRepository.selectHygieneCount(loginDetails.getFofoId(), true, currentMonthStart, currentMonthEnd);

                long invalidHygieneCount = hygieneDataRepository.selectHygieneCount(loginDetails.getFofoId(), false, currentMonthStart, currentMonthEnd);

                if (hygieneCount == 0 && invalidHygieneCount == 0) {

                    invalidHygieneCount = 1;

                }

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

                for (int i = 0; i <= 12; i++) {

                    LocalDateTime startOfMonth = LocalDateTime.now().withDayOfMonth(1).minusMonths(i);

                    monthValueMap.put(i, startOfMonth.format(DateTimeFormatter.ofPattern("MMM''uu")));

                }

                MonthlyTarget monthlyTarget = monthlyTargetRepository.selectByDateAndFofoId(YearMonth.now(), fofoId);

                model.addAttribute("monthlyTarget", monthlyTarget);

                Set<String> brands = brandsService.getBrandsToDisplay(3).stream().map(x -> x.getName()).collect(Collectors.toSet());

                model.addAttribute("brands", brands);

                model.addAttribute("monthValueMap", monthValueMap);

                model.addAttribute("month", 0);

                model.addAttribute("hygienePercentage", (hygieneCount * 100) / (invalidHygieneCount + hygieneCount));

                model.addAttribute("monthDays", LocalDate.now().minusDays(1).lengthOfMonth());

                model.addAttribute("dayOfMonth", LocalDate.now().minusDays(1).getDayOfMonth());

            } catch (

                    ProfitMandiBusinessException e) {

                LOGGER.error("FofoStore Code not found of fofoId {}", loginDetails.getFofoId());

            }

            return "dashboard1";

        }

    }

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

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        int fofoId = loginDetails.getFofoId();

        List<Order> grnPendingOrders = orderRepository.selectGrnTimestampNull(fofoId, Arrays.asList(in.shop2020.model.v1.order.OrderStatus.DELIVERY_SUCCESS));

        model.addAttribute("grnPendingOrders", grnPendingOrders);

        return "purchase-grn-order-status";

    }

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

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        int fofoId = loginDetails.getFofoId();

        ArrayList<in.shop2020.model.v1.order.OrderStatus> orderStatus = new ArrayList<>();

        orderStatus.add(in.shop2020.model.v1.order.OrderStatus.SUBMITTED_FOR_PROCESSING);

        List<Order> order = orderRepository.selectOrders(fofoId, orderStatus);

        List<Integer> submittedOrderIds = order.stream().filter(x -> x.getStatus() == in.shop2020.model.v1.order.OrderStatus.SUBMITTED_FOR_PROCESSING).map(x -> x.getId()).collect(Collectors.toList());

        model.addAttribute("submittedOrderIds", submittedOrderIds);

        if (!submittedOrderIds.isEmpty()) {

            List<LineItem> submittedLineItem = lineItemRepository.selectLineItem(submittedOrderIds);

            Map<Integer, LineItem> submittedLineItemMap = submittedLineItem.stream().collect(Collectors.toMap(x -> x.getOrderId(), x -> x));

            //LOGGER.info("submittedLineItemMap {}", submittedLineItemMap);

            model.addAttribute("submittedLineItemMap", submittedLineItemMap);

        }

        return "purchase-pending-order-status";

    }

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

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        int fofoId = loginDetails.getFofoId();

        ArrayList<in.shop2020.model.v1.order.OrderStatus> orderStatus = new ArrayList<>();

        orderStatus.add(in.shop2020.model.v1.order.OrderStatus.BILLED);

        List<Order> order = orderRepository.selectOrders(fofoId, orderStatus);

        List<Integer> billedOrderIds = order.stream().filter(x -> x.getStatus() == in.shop2020.model.v1.order.OrderStatus.BILLED).map(x -> x.getId()).collect(Collectors.toList());

        LOGGER.info("billedOrderIds {}", billedOrderIds);

        model.addAttribute("billedOrderIds", billedOrderIds);

        if (!billedOrderIds.isEmpty()) {

            List<LineItem> billedLineItem = lineItemRepository.selectLineItem(billedOrderIds);

            Map<Integer, LineItem> billedLineItemMap = billedLineItem.stream().collect(Collectors.toMap(x -> x.getOrderId(), x -> x));

            LOGGER.info("billedLineItemMap {}", billedLineItemMap);

            model.addAttribute("billedLineItemMap", billedLineItemMap);

        }

        return "purchase-billed-order-status";

    }

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

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        int fofoId = loginDetails.getFofoId();

        ArrayList<in.shop2020.model.v1.order.OrderStatus> orderStatus = new ArrayList<>();

        orderStatus.add(SHIPPED_FROM_WH);

        List<Order> order = orderRepository.selectOrders(fofoId, orderStatus);

        List<Integer> shippedOrderIds = order.stream().filter(x -> x.getPartnerGrnTimestamp() == null).map(x -> x.getId()).collect(Collectors.toList());

        model.addAttribute("shippedOrderIds", shippedOrderIds);

        LOGGER.info("shippedOrderIds {}", shippedOrderIds);

        if (!shippedOrderIds.isEmpty()) {

            List<LineItem> shippedLineItem = lineItemRepository.selectLineItem(shippedOrderIds);

            Map<Integer, LineItem> shippedLineItemMap = shippedLineItem.stream().collect(Collectors.toMap(x -> x.getOrderId(), x -> x));

            LOGGER.info("shippedLineItemMap {}", shippedLineItemMap);

            model.addAttribute("shippedLineItemMap", shippedLineItemMap);

        }

        return "purchase-shipped-order-status";

    }

    @Autowired

    OfferRepository offerRepository;

    @Autowired

    OfferPayoutRepository offerPayoutRepository;

    @RequestMapping(value = "/partnerTotalIncomeByMonth/{yearMonth}", method = RequestMethod.GET)

    public String getPartnerTotalIncomeByMonth(HttpServletRequest request, @PathVariable int yearMonth, Model model) throws

            Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        long pendingIncome = 0;

        long partnerPurchaseIn = 0;

        long partnerCreditedSale = 0;

        long partnerFrontIncome = 0;

        LocalDateTime startOfMonth = LocalDate.now().minusMonths(yearMonth).withDayOfMonth(1).atStartOfDay();

        LocalDateTime endOfMonth = startOfMonth.plusMonths(1).toLocalDate().atStartOfDay();

        AllPurchaseInventoryModel partnerlPendingSaleAmount = schemeInOutRepository.selectAllPendingSaleInventoryByFofoId(loginDetails.getFofoId(), startOfMonth, endOfMonth);

        AllPurchaseInventoryModel partnerCreditedSaleAmount = schemeInOutRepository.selectAllCreditedSaleInventoryByFofoId(loginDetails.getFofoId(), startOfMonth, endOfMonth);

        AllPurchaseInventoryModel partnerPurchaseInAmount = schemeInOutRepository.selectAllPurchaseInventoryByFofoId(loginDetails.getFofoId(), startOfMonth, endOfMonth);

        AllPurchaseInventoryModel partnerFrontIncomes = schemeInOutRepository.selectFrontIncomeByFofoId(loginDetails.getFofoId(), startOfMonth, endOfMonth);

        List<OfferPayoutImeiIncomeModel> offerPayoutImeiIncomeModels = offerPayoutRepository.getTotalPayoutsByPartnerPeriod(YearMonth.of(startOfMonth.getYear(), startOfMonth.getMonth()), loginDetails.getFofoId(), null, null);

        long additionalIncome = offerPayoutImeiIncomeModels.stream().collect(Collectors.summingDouble(x -> x.getSalePayout() + x.getPurchasePayout())).longValue();

        // AllPurchaseInventoryModel partnerAdditionalIncome =

        // offerRepository.selectPurchaseIncome(loginDetails.getFofoId(), startOfMonth,

        // endOfMonth);

        LOGGER.info("partnerfrontIncomes" + partnerFrontIncomes);

        LOGGER.info("partnerCreditedSaleAmount" + partnerCreditedSaleAmount);

        LOGGER.info("partnerPurchaseInAmount" + partnerPurchaseInAmount);

        LOGGER.info("partnerlPendingSaleAmount" + partnerlPendingSaleAmount);

        if (partnerlPendingSaleAmount != null) {

            pendingIncome = partnerlPendingSaleAmount.getAmount();

            LOGGER.info("pendingIncome" + pendingIncome);

        }

        if (partnerCreditedSaleAmount != null) {

            partnerCreditedSale = partnerCreditedSaleAmount.getAmount();

            LOGGER.info("partnerCreditedSale" + partnerCreditedSale);

        }

        if (partnerFrontIncomes != null) {

            partnerFrontIncome = partnerFrontIncomes.getAmount();

            LOGGER.info("partnerPurchaseIn" + partnerPurchaseIn);

        }

        if (partnerPurchaseInAmount != null) {

            partnerPurchaseIn = partnerPurchaseInAmount.getAmount();

            LOGGER.info("partnerPurchaseIn" + partnerPurchaseIn);

        }

        LOGGER.info("partnerPurchaseInTT" + partnerPurchaseIn);

        LOGGER.info("partnerCreditedSaleTT" + partnerCreditedSale);

        LOGGER.info("pendingIncomeTT" + pendingIncome);

        long totalIncome = partnerCreditedSale + partnerPurchaseIn + pendingIncome + partnerFrontIncome + additionalIncome;

        long creditedIncome = partnerCreditedSale + partnerPurchaseIn + partnerFrontIncome + additionalIncome;

        long pendingTotalIncome = pendingIncome;

        LOGGER.info("totalIncome" + totalIncome);

        LOGGER.info("creditedIncome" + creditedIncome);

        LOGGER.info("pendingTotalIncome" + pendingTotalIncome);

        model.addAttribute("totalIncome", totalIncome);

        model.addAttribute("creditedIncome", creditedIncome);

        model.addAttribute("pendingTotalIncome", pendingTotalIncome);

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

        for (int i = 0; i <= 5; i++) {

            LocalDateTime monthStart = LocalDateTime.now().withDayOfMonth(1).minusMonths(i);

            monthValueMap.put(i, monthStart.format(DateTimeFormatter.ofPattern("MMM''uu")));

        }

        model.addAttribute("month", yearMonth);

        model.addAttribute("monthValueMap", monthValueMap);

        return "partner-total-income";

    }

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

    public String getMonthsInvestment(HttpServletRequest request,

                                      @RequestParam(name = "month", required = true, defaultValue = "0") int month, Model model) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        int fofoId = loginDetails.getFofoId();

        Map<String, Object> investment = fofoUser.getInvestmentsMonths(fofoId, month);

        LocalDateTime currentMonthStart = LocalDateTime.now().withDayOfMonth(1);

        LocalDateTime lastMonthStart = currentMonthStart.minusMonths(1);

        LocalDateTime currentMonthEnd = currentMonthStart.plusMonths(1).withDayOfMonth(1);

        double currentMonthRating = hygieneDataRepository.selectRatingAvg(loginDetails.getFofoId(), DateRangeModel.of(currentMonthStart, currentMonthEnd)) / 2;

        double lastMonthRating = hygieneDataRepository.selectRatingAvg(loginDetails.getFofoId(), DateRangeModel.of(lastMonthStart, currentMonthStart)) / 2;

        double ratingTillDate = hygieneDataRepository.selectRatingAvg(loginDetails.getFofoId(), DateRangeModel.withEndDate(currentMonthEnd)) / 2;

        model.addAttribute("currentMonthRating", (float) Math.round(currentMonthRating * 10) / 10);

        model.addAttribute("lastMonthRating", (float) Math.round(lastMonthRating * 10) / 10);

        model.addAttribute("ratingTillDate", (float) Math.round(ratingTillDate * 10) / 10);

        long hygieneCount = hygieneDataRepository.selectHygieneCount(loginDetails.getFofoId(), true, currentMonthStart.minusMonths(month), currentMonthEnd.minusMonths(month));

        long invalidHygieneCount = hygieneDataRepository.selectHygieneCount(loginDetails.getFofoId(), false, currentMonthStart.minusMonths(month), currentMonthEnd.minusMonths(month));

        if (hygieneCount == 0 && invalidHygieneCount == 0) {

            invalidHygieneCount = 1;

        }

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

        for (int i = 0; i <= 5; i++) {

            LocalDateTime startOfMonth = LocalDateTime.now().withDayOfMonth(1).minusMonths(i);

            monthValueMap.put(i, startOfMonth.format(DateTimeFormatter.ofPattern("MMM''uu")));

        }

        model.addAttribute("hygienePercentage", (hygieneCount * 100) / (invalidHygieneCount + hygieneCount));

        model.addAttribute("monthValueMap", monthValueMap);

        model.addAttribute("investments", investment);

        model.addAttribute("monthDays", LocalDate.now().minusMonths(month).lengthOfMonth());

        model.addAttribute("dayOfMonth", LocalDate.now().minusMonths(month).lengthOfMonth());

        model.addAttribute("month", month);

        return "performance";

    }

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

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        int fofoId = loginDetails.getFofoId();

        ChartInvestmentModel cm = fofoUser.getInvestmentChart(fofoId);

        model.addAttribute("chartPieMap", gson.toJson(cm));

        LOGGER.info("InvestmentChart" + gson.toJson(cm));

        LOGGER.info("InvestmentChart" + cm);

        return "investmentdetails";

    }

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

    public String getlmsLineChart(HttpServletRequest request, Model model, @RequestParam(name = "fofoId", defaultValue = "0") int fofoId) throws Exception {

        if (fofoId == 0) {

            LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

            fofoId = loginDetails.getFofoId();

        }

        ChartModel cm = fofoUser.getLmsLineChart(fofoId);

        LOGGER.info("linechartMap" + gson.toJson(cm));

        model.addAttribute("linechartMap", gson.toJson(cm));

        return "lmsLineChart";

    }

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

    public String getMonthlyPurchaseLineChart(HttpServletRequest request, Model model, @RequestParam(name = "fofoId", defaultValue = "0") int fofoId) throws Exception {

        if (fofoId == 0) {

            LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

            fofoId = loginDetails.getFofoId();

        }

        ChartModel cm = fofoUser.getPurchaseOrderChart(fofoId);

        LOGGER.info("chartMap" + gson.toJson(cm));

        model.addAttribute("chartMap", gson.toJson(cm));

        return "purchase_chart";

    }

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

    public String getBarChart(HttpServletRequest request, @RequestParam(required = false) LocalDate from, @RequestParam(required = false) LocalDate to,@RequestParam(required = false) Boolean isQuantity ,Model model) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        int fofoId = loginDetails.getFofoId();

        LocalDateTime curDate = from == null ? LocalDate.now().atStartOfDay().withDayOfMonth(1) : from.atStartOfDay();

        LocalDateTime lastDate = to == null ? LocalDate.now().atStartOfDay().with(LocalTime.MAX) : to.atStartOfDay();

        isQuantity = isQuantity==null?false:isQuantity;

        ChartModel cm = fofoUser.getBrandChart(fofoId, from, to,isQuantity);

        LOGGER.info("from" + curDate);

        LOGGER.info("to" + lastDate);

        LOGGER.info("chartMap" + gson.toJson(cm));

        model.addAttribute("chartMap", gson.toJson(cm));

        model.addAttribute("from", curDate.toLocalDate());

        model.addAttribute("to", lastDate.toLocalDate());

        model.addAttribute("fofoId", fofoId);

        model.addAttribute("isQuantity",isQuantity);

        return "bar_chart";

    }

    @GetMapping(value = "/brandWiseFofoSaleData")

    public String getBarChartModelWise(HttpServletRequest request,

                                       @RequestParam LocalDate from,

                                       @RequestParam LocalDate to,

                                       @RequestParam String brand,

                                       @RequestParam boolean isQuantity,

                                       @RequestParam int fofoId, Model model) throws Exception {

        ChartModel cm = fofoUser.getModelBrandChart(fofoId, brand, from, to,isQuantity);

        LOGGER.info("chartMap" + gson.toJson(cm));

        model.addAttribute("chartMap", gson.toJson(cm));

        return "bar_chart_model_wise";

    }

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

    public String getPriceDropDetails(HttpServletRequest request,

                                      @RequestParam(name = "fofoId", required = true, defaultValue = "0") int fofoId,

                                      @RequestParam(name = "brand", required = true, defaultValue = "0") String brand,

                                      @RequestParam(name = "yearMonth", required = false, defaultValue = "0") String yearMonth, Model model) throws

            Exception {

        LOGGER.info("params" + fofoId + brand + yearMonth);

        List<PriceDropWithDetailsByYearMonthModel> priceDropdetailsList = priceDropRepository.selectBrandPendingPriceDropWithDetailsByYearMonth(fofoId, brand, yearMonth);

        LOGGER.info("priceDropdetailsList" + priceDropdetailsList);

        model.addAttribute("priceDropdetailsList", priceDropdetailsList);

        return "price-drop-details";

    }

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

    public String getPriceDropDetailSixMonths(HttpServletRequest request,

                                              @RequestParam(name = "fofoId", required = true, defaultValue = "0") int fofoId,

                                              @RequestParam(name = "brand", required = true, defaultValue = "0") String brand, Model model) throws Exception {

        LOGGER.info("params" + fofoId + brand);

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

        LocalDateTime startfMonthSixMonth = curDate.withDayOfMonth(1).minusMonths(12);

        LocalDateTime endMonthTotal = curDate.withDayOfMonth(1).minusMonths(6);

        List<PriceDropWithDetailsByYearMonthModel> priceDropdetailsList = priceDropRepository.selectBrandPendingPriceDropWithDetailsAndSixMonth(fofoId, brand, startfMonthSixMonth, endMonthTotal);

        LOGGER.info("priceDropdetailsList" + priceDropdetailsList);

        model.addAttribute("priceDropdetailsList", priceDropdetailsList);

        return "price-drop-details";

    }

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

    public String getMonthlyPriceDropTabular(HttpServletRequest request, Model model, @RequestParam(name = "fofoId", defaultValue = "0") int fofoId) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        if (fofoId == 0) {

            fofoId = loginDetails.getFofoId();

        }

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

        LocalDateTime startOfMonth = curDate.withDayOfMonth(1).minusMonths(6);

        LocalDateTime startfMonthTotal = curDate.withDayOfMonth(1).minusMonths(12);

        LocalDateTime endMonthTotal = curDate.withDayOfMonth(1).minusMonths(5);

        LOGGER.info("startfMonthTotal" + startfMonthTotal);

        LOGGER.info("endMonthTotal" + endMonthTotal);

        List<YearMonth> yms = new ArrayList<YearMonth>();

        for (int i = 0; i <= 5; i++) {

            yms.add(YearMonth.from(curDate.withDayOfMonth(1).minusMonths(i)));

        }

        Collections.reverse(yms);

        model.addAttribute("yms", yms);

        LOGGER.info("ym" + yms);

        List<PriceDropYearMonthModel> priceDropYearMonthModels = priceDropRepository.selectBrandPendingPriceDropByYearMonth(fofoId, startOfMonth);

        List<PriceDropBrandModel> priceDropBrandSixMonthTotals = priceDropRepository.selectSixMonthBrandPriceDropByYearMonth(fofoId, startfMonthTotal, endMonthTotal);

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

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

        LOGGER.info("priceDropBrandSixMonthTotals" + priceDropBrandSixMonthTotals);

        Map<String, Double> priceDropBrandSixMonthMap = priceDropBrandSixMonthTotals.stream().collect(Collectors.toMap(x -> x.getBrand(), x -> (double) x.getAmount()));

        model.addAttribute("priceDropBrandSixMonthMap", priceDropBrandSixMonthMap);

        LOGGER.info("priceDropYearMonthModels" + priceDropYearMonthModels);

        for (PriceDropYearMonthModel pdm : priceDropYearMonthModels) {

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

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

                brandValue = brandMonthValue.get(pdm.getBrand());

                brandValue.put(YearMonth.parse(pdm.getYearMonth(), dateTimeFormatter), (double) pdm.getAmount());

            } else {

                brandValue.put(YearMonth.parse(pdm.getYearMonth(), dateTimeFormatter), (double) pdm.getAmount());

            }

            brandMonthValue.put(pdm.getBrand(), brandValue);

        }

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

        brands.add("Accessories");

        brands.add("Oppo");

        brands.add("Vivo");

        brands.add("Samsung");

        brands.add("Realme");

        brands.add("MI");

        brands.add("Tecno");

        brands.add("Itel");

        brands.add("Nokia");

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

        model.addAttribute("brands", brands);

        for (String brand : brands) {

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

            for (int i = 5; 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<>();