Subversion Repositories SmartDukaan

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

    List<String> emails = Arrays.asList("kamini.sharma@smartdukaan.com", "neeraj.gupta@smartdukaan.com", "amit.gupta@smartdukaan.com", "tejbeer.kaur@smartdukaan.com", "kanan.choudhary@smartdukaan.com");

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

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

	private String webApiHost;

    private String webApiHost;

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

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

	private String webApiScheme;

    private String webApiScheme;

	@Autowired

    @Autowired

	private CsService1 csService1;

    private CsService1 csService1;

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

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

	private String webApiRoot;

    private String webApiRoot;

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

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

	private int webApiPort;

    private int webApiPort;

	@Autowired

    @Autowired

	private PriceDropRepository priceDropRepository;

    private PriceDropRepository priceDropRepository;

	@Autowired

    @Autowired

	private CookiesProcessor cookiesProcessor;

    private CookiesProcessor cookiesProcessor;

	@Autowired

    @Autowired

	private PendingOrderRepository pendingOrderRepository;

    private PendingOrderRepository pendingOrderRepository;

	@Autowired

    @Autowired

	private PartnerStatsService partnerStatsService;

    private PartnerStatsService partnerStatsService;

	@Autowired

    @Autowired

	private CsService csService;

    private CsService csService;

	@Autowired

    @Autowired

	private ResponseSender<?> responseSender;

    private ResponseSender<?> responseSender;

	@Autowired

    @Autowired

	RetailerService retailerService;

    RetailerService retailerService;

	@Autowired

    @Autowired

	private AdminUser adminUser;

    private AdminUser adminUser;

	@Autowired

    @Autowired

	private RoleManager roleManager;

    private RoleManager roleManager;

	@Autowired

    @Autowired

	private FofoStoreRepository fofoStoreRepository;

    private FofoStoreRepository fofoStoreRepository;

	@Autowired

    @Autowired

	private PartnerInvestmentService partnerInvestmentService;

    private PartnerInvestmentService partnerInvestmentService;

	@Autowired

    @Autowired

	DocumentRepository documentRepository;

    DocumentRepository documentRepository;

	@Autowired

    @Autowired

	InventoryItemRepository inventoryItemRepository;

    InventoryItemRepository inventoryItemRepository;

	@Autowired

    @Autowired

	InventoryService inventoryService;

    InventoryService inventoryService;

	@Autowired

    @Autowired

	private PendingOrderItemRepository pendingOrderItemRepository;

    private PendingOrderItemRepository pendingOrderItemRepository;

	@Autowired

    @Autowired

	private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

    private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

	@Autowired

    @Autowired

	private FofoOrderItemRepository fofoOrderItemRepository;

    private FofoOrderItemRepository fofoOrderItemRepository;

	@Autowired

    @Autowired

	private PartnerTypeChangeService partnerTypeChangeService;

    private PartnerTypeChangeService partnerTypeChangeService;

	@Autowired

    @Autowired

	private HygieneDataRepository hygieneDataRepository;

    private HygieneDataRepository hygieneDataRepository;

	@Autowired

    @Autowired

	private UserAccountRepository userAccountRepository;

    private UserAccountRepository userAccountRepository;

	@Autowired

    @Autowired

	private NotificationCampaignRepository notificationCampaignRepository;

    private NotificationCampaignRepository notificationCampaignRepository;

	@Autowired

    @Autowired

	private AuthRepository authRepository;

    private AuthRepository authRepository;

	@Autowired

    @Autowired

	private FofoOrderRepository fofoOrderRepository;

    private FofoOrderRepository fofoOrderRepository;

	@Autowired

    @Autowired

	private Gson gson;

    private Gson gson;

	@Autowired

    @Autowired

	TicketRepository ticketRepository;

    TicketRepository ticketRepository;

	@Autowired

    @Autowired

	private OfferService offerService;

    private OfferService offerService;

	@Autowired

    @Autowired

	private ItemRepository itemRepository;

    private ItemRepository itemRepository;

	@Autowired

    @Autowired

	private SaholicInventoryCISRepository saholicInventoryCISRepository;

    private SaholicInventoryCISRepository saholicInventoryCISRepository;

	@Autowired

    @Autowired

	private MVCResponseSender mvcResponseSender;

    private MVCResponseSender mvcResponseSender;

	@Autowired

    @Autowired

	private ReporticoCacheTableRepository reporticoCacheTableRepository;

    private ReporticoCacheTableRepository reporticoCacheTableRepository;

	@Autowired

    @Autowired

	private TransactionService transactionService;

    private TransactionService transactionService;

	@Autowired

    @Autowired

	private TagListingRepository tagListingRepository;

    private TagListingRepository tagListingRepository;

	@Autowired

    @Autowired

	private TicketAssignedRepository ticketAssignedRepository;

    private TicketAssignedRepository ticketAssignedRepository;

	@Autowired

    @Autowired

	private OrderRepository orderRepository;

    private OrderRepository orderRepository;

	@Autowired

    @Autowired

	private FofoUser fofoUser;

    private FofoUser fofoUser;

	@Autowired

    @Autowired

	private ActivatedImeiRepository activatedImeiRepository;

    private ActivatedImeiRepository activatedImeiRepository;

	@Autowired

    @Autowired

	private Mongo mongoClient;

    private Mongo mongoClient;

	@Autowired

    @Autowired

	private SchemeInOutRepository schemeInOutRepository;

    private SchemeInOutRepository schemeInOutRepository;

	@Autowired

    @Autowired

	private LineItemRepository lineItemRepository;

    private LineItemRepository lineItemRepository;

	@Autowired

    @Autowired

	private FofoLineItemRepository fofoLineItemRepository;

    private FofoLineItemRepository fofoLineItemRepository;

	@Autowired

    @Autowired

	private PositionRepository positionRepository;

    private PositionRepository positionRepository;

	@Autowired

    @Autowired

	private MonthlyTargetRepository monthlyTargetRepository;

    private MonthlyTargetRepository monthlyTargetRepository;

	@Autowired

    @Autowired

	private SamsungUpgradeOfferRepository samsungUpgradeOfferRepository;

    private SamsungUpgradeOfferRepository samsungUpgradeOfferRepository;

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

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

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

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

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

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

		boolean isAdmin = false;

        boolean isAdmin = false;

		model.addAttribute("isAdmin", isAdmin);

        model.addAttribute("isAdmin", isAdmin);

		model.addAttribute("webApiHost", webApiHost);

        model.addAttribute("webApiHost", webApiHost);

		model.addAttribute("webApiPort", webApiPort);

        model.addAttribute("webApiPort", webApiPort);

		model.addAttribute("webApiScheme", webApiScheme);

        model.addAttribute("webApiScheme", webApiScheme);

		model.addAttribute("webApiRoot", webApiRoot);

        model.addAttribute("webApiRoot", webApiRoot);

		if (isAdmin) {

        if (isAdmin) {

			return "dashboard1";

            return "dashboard1";

		}

        }

		FofoStore fofoStore = null;

        FofoStore fofoStore = null;

		try {

        try {

			CustomRetailer customRetailer = retailerService.getFofoRetailer(fofoId);

            CustomRetailer customRetailer = retailerService.getFofoRetailer(fofoId);

			fofoStore = fofoStoreRepository.selectByRetailerId(fofoId);

            fofoStore = fofoStoreRepository.selectByRetailerId(fofoId);

			if (!fofoStore.isActive()) {

            if (!fofoStore.isActive()) {

				return "redirect:/login";

                return "redirect:/login";

			}

            }

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

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

			model.addAttribute("partnerType", partnerType);

            model.addAttribute("partnerType", partnerType);

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

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

			model.addAttribute("fofoStore", customRetailer);

            model.addAttribute("fofoStore", customRetailer);

			model.addAttribute("partnerType", partnerType);

            model.addAttribute("partnerType", partnerType);

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

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

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

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

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

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

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

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

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

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

			// this.setInvestments

            // this.setInvestments

			//

            //

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

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

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

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

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

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

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

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

			}

            }

			LOGGER.info("monthValueMap" + monthValueMap);

            LOGGER.info("monthValueMap" + monthValueMap);

			model.addAttribute("monthValueMap", monthValueMap);

            model.addAttribute("monthValueMap", monthValueMap);

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

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

			model.addAttribute("isInvestmentOk",

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

					partnerInvestmentService.isInvestmentOk(fofoId, ProfitMandiConstants.MIN_INVESTMENT_PERCENTAGE, ProfitMandiConstants.CUTOFF_INVESTMENT));

        } catch (ProfitMandiBusinessException e) {

		} catch (ProfitMandiBusinessException e) {

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

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

        }

		}

        return "12dashboard34";

		return "12dashboard34";

    }

	}

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

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

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

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        int fofoId = loginDetails.getFofoId();

		int fofoId = loginDetails.getFofoId();

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

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

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

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

        int dayOfMonth = curDate.getDayOfMonth();

		int dayOfMonth = curDate.getDayOfMonth();

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

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

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

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

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

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

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

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

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

					startOfMonth.plusMonths(1));

			double monthSales = fofoOrderItemRepository.selectSumMopGroupByRetailer(startOfMonth,

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

					startOfMonth.plusMonths(1), loginDetails.getFofoId(), false).get(fofoId);

            PartnerType partnerType = partnerTypeChangeService.getTypeOnDate(fofoId, startOfMonth.toLocalDate());

			double mtdSales = fofoOrderItemRepository

					.selectSumMopGroupByRetailer(startOfMonth,

            MonthSaleModel ms = new MonthSaleModel();

							startOfMonth.plusDays(Math.min(dayOfMonth, lengthOfMonth)), loginDetails.getFofoId(), false)

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

					.get(fofoId);

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

            ms.setPartnerType(partnerType);

			PartnerType partnerType = partnerTypeChangeService.getTypeOnDate(fofoId, startOfMonth.toLocalDate());

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

            monthSaleMap.put(i, ms);

			MonthSaleModel ms = new MonthSaleModel();

        }

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

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

        model.addAttribute("monthSales", monthSaleMap);

			ms.setPartnerType(partnerType);

        return "monthSales";

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

    }

			monthSaleMap.put(i, ms);

		}

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

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

		model.addAttribute("monthSales", monthSaleMap);

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		return "monthSales";

        String email = loginDetails.getEmailId();

	}

        int fofoId = loginDetails.getFofoId();

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

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

        model.addAttribute("isAdmin", isAdmin);

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

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        model.addAttribute("webApiHost", webApiHost);

		String email = loginDetails.getEmailId();

        model.addAttribute("webApiPort", webApiPort);

		int fofoId = loginDetails.getFofoId();

        model.addAttribute("webApiScheme", webApiScheme);

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

        model.addAttribute("webApiRoot", webApiRoot);

		model.addAttribute("isAdmin", isAdmin);

        if (isAdmin) {

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

		model.addAttribute("webApiHost", webApiHost);

        } else {

		model.addAttribute("webApiPort", webApiPort);

            FofoStore fofoStore = null;

		model.addAttribute("webApiScheme", webApiScheme);

            try {

		model.addAttribute("webApiRoot", webApiRoot);

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

		if (isAdmin) {

                if (!fofoStore.isActive()) {

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

                    return "redirect:/login";

		} else {

                }

			FofoStore fofoStore = null;

			try {

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

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

                LocalDateTime endtDate = LocalDateTime.now();

				if (!fofoStore.isActive()) {

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

					return "redirect:/login";

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

				}

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

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

                LOGGER.info("countOrder" + countOrder);

				LocalDateTime endtDate = LocalDateTime.now();

				OnlineDeliveredOrderSum onlineDeliveredOrderSum = pendingOrderItemRepository

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

						.selectSumSellingPriceOnlineOrder(fofoId, startDate, endtDate);

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

                orderStatus.add(SUBMITTED_FOR_PROCESSING);

                orderStatus.add(BILLED);

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

                orderStatus.add(SHIPPED_FROM_WH);

				LOGGER.info("countOrder" + countOrder);

                orderStatus.add(DELIVERY_SUCCESS);

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

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

				orderStatus.add(SUBMITTED_FOR_PROCESSING);

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

				orderStatus.add(BILLED);

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

				orderStatus.add(SHIPPED_FROM_WH);

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

				orderStatus.add(DELIVERY_SUCCESS);

                long imeiActivationPendingCount = 0;

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

                long imeiActivationPendingValue = 0;

				List<LineItem> submittedLineItemIds = openOrders.stream()

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

						.filter(x -> x.getStatus().equals(SUBMITTED_FOR_PROCESSING)).map(x -> x.getLineItem())

                if (grnPendingOrderIds.size() > 0) {

						.collect(Collectors.toList());

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

				List<LineItem> billedOrderIds = openOrders.stream().filter(x -> x.getStatus().equals(BILLED))

                    imeiActivationPendingCount = imeiActivationTimestampModels.size();

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

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

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

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

						.filter(x -> x.getStatus().equals(DELIVERY_SUCCESS)).map(x -> x.getLineItem())

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

						.collect(Collectors.toList());

                model.addAttribute("grnPendingCount", grnPendingCount);

                model.addAttribute("grnPendingValue", grnPendingValue);

				long imeiActivationPendingCount = 0;

				long imeiActivationPendingValue = 0;

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

				List<Integer> grnPendingOrderIds = openOrders.stream()

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

						.filter(x -> x.getStatus().equals(SHIPPED_FROM_WH) || x.getStatus().equals(DELIVERY_SUCCESS))

                model.addAttribute("submittedCount", submittedCount);

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

                model.addAttribute("submittedValue", submittedValue);

				if (grnPendingOrderIds.size() > 0) {

					List<ImeiActivationTimestampModel> imeiActivationTimestampModels = activatedImeiRepository

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

							.selectActivatedImeisByOrders(grnPendingOrderIds);

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

					imeiActivationPendingCount = imeiActivationTimestampModels.size();

                model.addAttribute("billedValue", billedValue);

					imeiActivationPendingValue = imeiActivationTimestampModels.stream()

                model.addAttribute("billedCount", billedCount);

							.collect(Collectors.summingDouble(x -> x.getSellingPrice())).longValue();

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

				}

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

				long grnPendingCount = grnPendingLineItemIds.stream()

                model.addAttribute("shippedCount", shippedCount);

						.collect(Collectors.summingLong(LineItem::getQuantity));

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

				long grnPendingValue = grnPendingLineItemIds.stream()

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

						.collect(Collectors.summingLong(x -> x.getTotalPrice().longValue()));

                model.addAttribute("shippedValue", shippedValue);

				model.addAttribute("grnPendingCount", grnPendingCount);

				model.addAttribute("grnPendingValue", grnPendingValue);

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

				long submittedCount = submittedLineItemIds.stream()

                LocalDateTime currentMonthStart = curDate.withDayOfMonth(1);

						.collect(Collectors.summingLong(LineItem::getQuantity));

                LocalDateTime lastMonthStart = currentMonthStart.minusMonths(1);

				long submittedValue = submittedLineItemIds.stream()

                LocalDateTime currentMonthEnd = currentMonthStart.withDayOfMonth(1);

						.collect(Collectors.summingLong(x -> x.getTotalPrice().longValue()));

				model.addAttribute("submittedCount", submittedCount);

                LOGGER.info("lastMonthStart" + lastMonthStart);

				model.addAttribute("submittedValue", submittedValue);

                LOGGER.info("currentMonthEnd" + currentMonthEnd);

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

                model.addAttribute("countOrder", countOrder);

				long billedValue = billedOrderIds.stream()

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

						.collect(Collectors.summingLong(x -> x.getTotalPrice().longValue()));

				model.addAttribute("billedValue", billedValue);

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

				model.addAttribute("billedCount", billedCount);

                model.addAttribute("partnerType", partnerType);

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

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

                model.addAttribute("fofoStore", fofoStore);

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

                model.addAttribute("partnerType", partnerType);

				model.addAttribute("shippedCount", shippedCount);

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

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

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

				long shippedValue = shippedOrderIds.stream()

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

						.collect(Collectors.summingLong(x -> x.getTotalPrice().longValue()));

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

				model.addAttribute("shippedValue", shippedValue);

                model.addAttribute("imeiActivationPendingCount", imeiActivationPendingCount);

                model.addAttribute("imeiActivationPendingValue", imeiActivationPendingValue);

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

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

				LocalDateTime currentMonthStart = curDate.withDayOfMonth(1);

				LocalDateTime lastMonthStart = currentMonthStart.minusMonths(1);

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

				LocalDateTime currentMonthEnd = currentMonthStart.withDayOfMonth(1);

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

				LOGGER.info("lastMonthStart" + lastMonthStart);

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

				LOGGER.info("currentMonthEnd" + currentMonthEnd);

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

                ChartModel cm = fofoUser.getBrandChart(loginDetails.getFofoId());

				model.addAttribute("countOrder", countOrder);

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

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

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

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

				model.addAttribute("partnerType", partnerType);

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

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

                model.addAttribute("publishedOffers", publishedOffers);

				model.addAttribute("fofoStore", fofoStore);

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

				model.addAttribute("partnerType", partnerType);

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

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

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

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

				model.addAttribute("retailers", new JSONObject().append("code", fofoStore.getCode())

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

						.append("partnerId", fofoStore.getId()).toString());

                double ratingTillDate = hygieneDataRepository.selectRatingAvg(loginDetails.getFofoId(), LocalDateTime.MIN, currentMonthEnd) / 2;

				model.addAttribute("activatedImeis",

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

						inventoryItemRepository.selectCountByActivatedNotSold(loginDetails.getFofoId()));

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

				model.addAttribute("imeiActivationPendingCount", imeiActivationPendingCount);

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

				model.addAttribute("imeiActivationPendingValue", imeiActivationPendingValue);

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

				Map<Integer, Double> accesoriesmtdsale = fofoOrderRepository

						.selectSumSaleGroupByFofoIdsForMobileOrAccessories(loginDetails.getFofoId(),

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

								curDate.withDayOfMonth(1), curDate.with(LocalTime.MAX), Optional.of(false));

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

                    invalidHygieneCount = 1;

				Double accesoriesStock = currentInventorySnapshotRepository

                }

						.selectSumStockGroupByFofoIdsForMobileOrAccessories(loginDetails.getFofoId(),

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

								Optional.of(false))

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

						.get(loginDetails.getFofoId());

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

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

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

                }

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

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

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

				ChartModel cm = fofoUser.getBrandChart(loginDetails.getFofoId());

                model.addAttribute("monthlyTarget", monthlyTarget);

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

                model.addAttribute("monthValueMap", monthValueMap);

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

                model.addAttribute("month", 0);

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

				List<CreateOfferRequest> publishedOffers = offerService.getPublishedOffers(loginDetails.getFofoId(),

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

						YearMonth.from(LocalDateTime.now()));

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

				model.addAttribute("publishedOffers", publishedOffers);

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

            } catch (ProfitMandiBusinessException e) {

				model.addAttribute("isInvestmentOk", partnerInvestmentService.isInvestmentOk(loginDetails.getFofoId(),

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

						ProfitMandiConstants.MIN_INVESTMENT_PERCENTAGE, ProfitMandiConstants.CUTOFF_INVESTMENT));

            }

				double currentMonthRating = hygieneDataRepository.selectRatingAvg(loginDetails.getFofoId(),

            return "dashboard1";

						currentMonthStart, currentMonthEnd) / 2;

        }

				double lastMonthRating = hygieneDataRepository.selectRatingAvg(loginDetails.getFofoId(), lastMonthStart,

						currentMonthStart) / 2;

    }

				double ratingTillDate = hygieneDataRepository.selectRatingAvg(loginDetails.getFofoId(),

						LocalDateTime.MIN, currentMonthEnd) / 2;

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

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

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

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

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        int fofoId = loginDetails.getFofoId();

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

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

						currentMonthStart, currentMonthEnd);

        model.addAttribute("grnPendingOrders", grnPendingOrders);

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

        return "purchase-grn-order-status";

						currentMonthStart, currentMonthEnd);

    }

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

					invalidHygieneCount = 1;

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

				}

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

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

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

        int fofoId = loginDetails.getFofoId();

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

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

				}

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

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

				model.addAttribute("monthlyTarget", monthlyTarget);

        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("monthValueMap", monthValueMap);

        model.addAttribute("submittedOrderIds", submittedOrderIds);

				model.addAttribute("month", 0);

        if (!submittedOrderIds.isEmpty()) {

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

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

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

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

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

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

			} catch (ProfitMandiBusinessException e) {

            model.addAttribute("submittedLineItemMap", submittedLineItemMap);

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

        }

			}

        return "purchase-pending-order-status";

			return "dashboard1";

    }

		}

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

	}

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

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

        int fofoId = loginDetails.getFofoId();

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

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

		int fofoId = loginDetails.getFofoId();

		List<Order> grnPendingOrders = orderRepository.selectGrnTimestampNull(fofoId,

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

				Arrays.asList(in.shop2020.model.v1.order.OrderStatus.DELIVERY_SUCCESS));

        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("grnPendingOrders", grnPendingOrders);

        model.addAttribute("billedOrderIds", billedOrderIds);

		return "purchase-grn-order-status";

	}

        if (!billedOrderIds.isEmpty()) {

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

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

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

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

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

            model.addAttribute("billedLineItemMap", billedLineItemMap);

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        }

		int fofoId = loginDetails.getFofoId();

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

        return "purchase-billed-order-status";

    }

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

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

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

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

		List<Integer> submittedOrderIds = order.stream()

				.filter(x -> x.getStatus() == in.shop2020.model.v1.order.OrderStatus.SUBMITTED_FOR_PROCESSING)

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

        int fofoId = loginDetails.getFofoId();

		model.addAttribute("submittedOrderIds", submittedOrderIds);

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

		if (!submittedOrderIds.isEmpty()) {

        orderStatus.add(SHIPPED_FROM_WH);

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

			Map<Integer, LineItem> submittedLineItemMap = submittedLineItem.stream()

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

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

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

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

        model.addAttribute("shippedOrderIds", shippedOrderIds);

			model.addAttribute("submittedLineItemMap", submittedLineItemMap);

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

		}

        if (!shippedOrderIds.isEmpty()) {

		return "purchase-pending-order-status";

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

	}

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

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

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

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

            model.addAttribute("shippedLineItemMap", shippedLineItemMap);

        }

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        return "purchase-shipped-order-status";

		int fofoId = loginDetails.getFofoId();

    }

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

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

    @Autowired

    OfferRepository offerRepository;

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

		List<Integer> billedOrderIds = order.stream()

    @Autowired

				.filter(x -> x.getStatus() == in.shop2020.model.v1.order.OrderStatus.BILLED).map(x -> x.getId())

    OfferPayoutRepository offerPayoutRepository;

				.collect(Collectors.toList());

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

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

		model.addAttribute("billedOrderIds", billedOrderIds);

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

		if (!billedOrderIds.isEmpty()) {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

        long pendingIncome = 0;

			Map<Integer, LineItem> billedLineItemMap = billedLineItem.stream()

        long partnerPurchaseIn = 0;

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

        long partnerCreditedSale = 0;

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

        long partnerFrontIncome = 0;

			model.addAttribute("billedLineItemMap", billedLineItemMap);

		}

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

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

		return "purchase-billed-order-status";

	}

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

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

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

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

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

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

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		int fofoId = loginDetails.getFofoId();

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

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

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

		orderStatus.add(SHIPPED_FROM_WH);

        // AllPurchaseInventoryModel partnerAdditionalIncome =

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

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

        // endOfMonth);

		List<Integer> shippedOrderIds = order.stream().filter(x -> x.getPartnerGrnTimestamp() == null)

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

        LOGGER.info("partnerfrontIncomes" + partnerFrontIncomes);

		model.addAttribute("shippedOrderIds", shippedOrderIds);

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

        LOGGER.info("partnerCreditedSaleAmount" + partnerCreditedSaleAmount);

        LOGGER.info("partnerPurchaseInAmount" + partnerPurchaseInAmount);

		if (!shippedOrderIds.isEmpty()) {

        LOGGER.info("partnerlPendingSaleAmount" + partnerlPendingSaleAmount);

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

			Map<Integer, LineItem> shippedLineItemMap = shippedLineItem.stream()

        if (partnerlPendingSaleAmount != null) {

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

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

            pendingIncome = partnerlPendingSaleAmount.getAmount();

			model.addAttribute("shippedLineItemMap", shippedLineItemMap);

            LOGGER.info("pendingIncome" + pendingIncome);

		}

		return "purchase-shipped-order-status";

        }

	}

        if (partnerCreditedSaleAmount != null) {

	@Autowired

	OfferRepository offerRepository;

            partnerCreditedSale = partnerCreditedSaleAmount.getAmount();

	@Autowired

            LOGGER.info("partnerCreditedSale" + partnerCreditedSale);

	OfferPayoutRepository offerPayoutRepository;

        }

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

        if (partnerFrontIncomes != null) {

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

			throws Exception {

            partnerFrontIncome = partnerFrontIncomes.getAmount();

            LOGGER.info("partnerPurchaseIn" + partnerPurchaseIn);

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		long pendingIncome = 0;

        }

		long partnerPurchaseIn = 0;

        if (partnerPurchaseInAmount != null) {

		long partnerCreditedSale = 0;

		long partnerFrontIncome = 0;

            partnerPurchaseIn = partnerPurchaseInAmount.getAmount();

            LOGGER.info("partnerPurchaseIn" + partnerPurchaseIn);

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

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

        }

		AllPurchaseInventoryModel partnerlPendingSaleAmount = schemeInOutRepository

        LOGGER.info("partnerPurchaseInTT" + partnerPurchaseIn);

				.selectAllPendingSaleInventoryByFofoId(loginDetails.getFofoId(), startOfMonth, endOfMonth);

        LOGGER.info("partnerCreditedSaleTT" + partnerCreditedSale);

		AllPurchaseInventoryModel partnerCreditedSaleAmount = schemeInOutRepository

        LOGGER.info("pendingIncomeTT" + pendingIncome);

				.selectAllCreditedSaleInventoryByFofoId(loginDetails.getFofoId(), startOfMonth, endOfMonth);

		AllPurchaseInventoryModel partnerPurchaseInAmount = schemeInOutRepository

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

				.selectAllPurchaseInventoryByFofoId(loginDetails.getFofoId(), startOfMonth, endOfMonth);

        long creditedIncome = partnerCreditedSale + partnerPurchaseIn + partnerFrontIncome + additionalIncome;

		AllPurchaseInventoryModel partnerFrontIncomes = schemeInOutRepository

				.selectFrontIncomeByFofoId(loginDetails.getFofoId(), startOfMonth, endOfMonth);

        long pendingTotalIncome = pendingIncome;

        LOGGER.info("totalIncome" + totalIncome);

		List<OfferPayoutImeiIncomeModel> offerPayoutImeiIncomeModels = offerPayoutRepository

        LOGGER.info("creditedIncome" + creditedIncome);

				.getTotalPayoutsByPartnerPeriod(YearMonth.of(startOfMonth.getYear(), startOfMonth.getMonth()),

        LOGGER.info("pendingTotalIncome" + pendingTotalIncome);

						loginDetails.getFofoId(), null, null);

        model.addAttribute("totalIncome", totalIncome);

		long additionalIncome = offerPayoutImeiIncomeModels.stream()

        model.addAttribute("creditedIncome", creditedIncome);

				.collect(Collectors.summingDouble(x -> x.getSalePayout() + x.getPurchasePayout())).longValue();

        model.addAttribute("pendingTotalIncome", pendingTotalIncome);

		// AllPurchaseInventoryModel partnerAdditionalIncome =

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

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

		// endOfMonth);

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

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

		LOGGER.info("partnerfrontIncomes" + partnerFrontIncomes);

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

        }

		LOGGER.info("partnerCreditedSaleAmount" + partnerCreditedSaleAmount);

		LOGGER.info("partnerPurchaseInAmount" + partnerPurchaseInAmount);

        model.addAttribute("month", yearMonth);

		LOGGER.info("partnerlPendingSaleAmount" + partnerlPendingSaleAmount);

        model.addAttribute("monthValueMap", monthValueMap);

		if (partnerlPendingSaleAmount != null) {

        return "partner-total-income";

    }

			pendingIncome = partnerlPendingSaleAmount.getAmount();

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

			LOGGER.info("pendingIncome" + pendingIncome);

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

		if (partnerCreditedSaleAmount != null) {

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

			partnerCreditedSale = partnerCreditedSaleAmount.getAmount();

        LocalDateTime lastMonthStart = currentMonthStart.minusMonths(1);

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

			LOGGER.info("partnerCreditedSale" + partnerCreditedSale);

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

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

		}

        double ratingTillDate = hygieneDataRepository.selectRatingAvg(loginDetails.getFofoId(), LocalDateTime.MIN, currentMonthEnd) / 2;

		if (partnerFrontIncomes != null) {

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

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

			partnerFrontIncome = partnerFrontIncomes.getAmount();

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

			LOGGER.info("partnerPurchaseIn" + partnerPurchaseIn);

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

		}

		if (partnerPurchaseInAmount != null) {

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

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

			partnerPurchaseIn = partnerPurchaseInAmount.getAmount();

            invalidHygieneCount = 1;

			LOGGER.info("partnerPurchaseIn" + partnerPurchaseIn);

        }

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

		}

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

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

		LOGGER.info("partnerPurchaseInTT" + partnerPurchaseIn);

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

		LOGGER.info("partnerCreditedSaleTT" + partnerCreditedSale);

        }

		LOGGER.info("pendingIncomeTT" + pendingIncome);

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

        model.addAttribute("monthValueMap", monthValueMap);

		long totalIncome = partnerCreditedSale + partnerPurchaseIn + pendingIncome + partnerFrontIncome

        model.addAttribute("investments", investment);

				+ additionalIncome;

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

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

		long creditedIncome = partnerCreditedSale + partnerPurchaseIn + partnerFrontIncome + additionalIncome;

        model.addAttribute("month", month);

        return "performance";

		long pendingTotalIncome = pendingIncome;

    }

		LOGGER.info("totalIncome" + totalIncome);

		LOGGER.info("creditedIncome" + creditedIncome);

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

		LOGGER.info("pendingTotalIncome" + pendingTotalIncome);

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		model.addAttribute("totalIncome", totalIncome);

        int fofoId = loginDetails.getFofoId();

		model.addAttribute("creditedIncome", creditedIncome);

        ChartInvestmentModel cm = fofoUser.getInvestmentChart(fofoId);

		model.addAttribute("pendingTotalIncome", pendingTotalIncome);

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

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

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

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

        LOGGER.info("InvestmentChart" + cm);

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

        return "investmentdetails";

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

    }

		}

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

		model.addAttribute("month", yearMonth);

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

		model.addAttribute("monthValueMap", monthValueMap);

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        int fofoId = loginDetails.getFofoId();

		return "partner-total-income";

        ChartModel cm = fofoUser.getLmsLineChart(loginDetails.getFofoId());

	}

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

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

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

	public String getMonthsInvestment(HttpServletRequest request,

        return "lmsLineChart";

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

    }

			throws Exception {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

		int fofoId = loginDetails.getFofoId();

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

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        int fofoId = loginDetails.getFofoId();

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

        ChartModel cm = fofoUser.getPurchaseOrderChart(fofoId);

		LocalDateTime lastMonthStart = currentMonthStart.minusMonths(1);

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

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

		double currentMonthRating = hygieneDataRepository.selectRatingAvg(loginDetails.getFofoId(), currentMonthStart,

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

				currentMonthEnd) / 2;

		double lastMonthRating = hygieneDataRepository.selectRatingAvg(loginDetails.getFofoId(), lastMonthStart,

        return "purchase_chart";

				currentMonthStart) / 2;

    }

		double ratingTillDate = hygieneDataRepository.selectRatingAvg(loginDetails.getFofoId(), LocalDateTime.MIN,

				currentMonthEnd) / 2;

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

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

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

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

        int fofoId = loginDetails.getFofoId();

        ChartModel cm = fofoUser.getBrandChart(fofoId);

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

				currentMonthStart.minusMonths(month), currentMonthEnd.minusMonths(month));

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

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

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

				currentMonthStart.minusMonths(month), currentMonthEnd.minusMonths(month));

        return "bar_chart";

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

    }

			invalidHygieneCount = 1;

		}

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

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

    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 {

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

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

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

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

		}

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

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

		model.addAttribute("monthValueMap", monthValueMap);

        LOGGER.info("priceDropdetailsList" + priceDropdetailsList);

		model.addAttribute("investments", investment);

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

        model.addAttribute("priceDropdetailsList", priceDropdetailsList);

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

		model.addAttribute("month", month);

        return "price-drop-details";

		return "performance";

    }

	}

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

	@RequestMapping(value = "/investmentDetails", 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 {

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

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

		int fofoId = loginDetails.getFofoId();

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

		ChartInvestmentModel cm = fofoUser.getInvestmentChart(fofoId);

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

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

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

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

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

		LOGGER.info("InvestmentChart" + cm);

		return "investmentdetails";

        LOGGER.info("priceDropdetailsList" + priceDropdetailsList);

	}

        model.addAttribute("priceDropdetailsList", priceDropdetailsList);

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

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

        return "price-drop-details";

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

    }

		int fofoId = loginDetails.getFofoId();

		ChartModel cm = fofoUser.getLmsLineChart(loginDetails.getFofoId());

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

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

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

        int fofoId = loginDetails.getFofoId();

		return "lmsLineChart";

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

	}

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

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

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

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

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

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		int fofoId = loginDetails.getFofoId();

        LOGGER.info("startfMonthTotal" + startfMonthTotal);

		ChartModel cm = fofoUser.getPurchaseOrderChart(fofoId);

        LOGGER.info("endMonthTotal" + endMonthTotal);

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

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

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

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

		return "purchase_chart";

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

	}

        }

        Collections.reverse(yms);

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

        model.addAttribute("yms", yms);

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

        LOGGER.info("ym" + yms);

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		int fofoId = loginDetails.getFofoId();

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

		ChartModel cm = fofoUser.getBrandChart(fofoId);

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

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

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

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

		return "bar_chart";

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

	}

        LOGGER.info("priceDropBrandSixMonthTotals" + priceDropBrandSixMonthTotals);

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

	public String getPriceDropDetails(HttpServletRequest request,

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

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

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

        model.addAttribute("priceDropBrandSixMonthMap", priceDropBrandSixMonthMap);

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

        LOGGER.info("priceDropYearMonthModels" + priceDropYearMonthModels);

			throws Exception {

        for (PriceDropYearMonthModel pdm : priceDropYearMonthModels) {

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

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

		List<PriceDropWithDetailsByYearMonthModel> priceDropdetailsList = priceDropRepository

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

				.selectBrandPendingPriceDropWithDetailsByYearMonth(fofoId, brand, yearMonth);

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

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

		LOGGER.info("priceDropdetailsList" + priceDropdetailsList);

            } else {

		model.addAttribute("priceDropdetailsList", priceDropdetailsList);

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

		return "price-drop-details";

            }

	}

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

        }

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

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

	public String getPriceDropDetailSixMonths(HttpServletRequest request,

        brands.add("Accessories");

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

        brands.add("Oppo");

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

        brands.add("Vivo");

			throws Exception {

        brands.add("Samsung");

        brands.add("Realme");

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

        brands.add("MI");

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

        brands.add("Tecno");

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

        brands.add("Itel");

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

        brands.add("Nokia");

		List<PriceDropWithDetailsByYearMonthModel> priceDropdetailsList = priceDropRepository

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

				.selectBrandPendingPriceDropWithDetailsAndSixMonth(fofoId, brand, startfMonthSixMonth, endMonthTotal);

        model.addAttribute("brands", brands);

		LOGGER.info("priceDropdetailsList" + priceDropdetailsList);

        for (String brand : brands) {

		model.addAttribute("priceDropdetailsList", priceDropdetailsList);

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

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

		return "price-drop-details";

	}

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

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

                if (yearMonthValue != null) {

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

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

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

		int fofoId = loginDetails.getFofoId();

                    }

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

                } else {

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

                    yearMonthValue = new HashMap<>();

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

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

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

                }

            }

		LOGGER.info("startfMonthTotal" + startfMonthTotal);

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

		LOGGER.info("endMonthTotal" + endMonthTotal);

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

            brandMonthValue.put(brand, sortedMonthBrandValue);

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

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

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

		}

        }

		Collections.reverse(yms);

		model.addAttribute("yms", yms);

        LOGGER.info("sortedBrandValue" + sortedBrandValue);

		LOGGER.info("ym" + yms);

        model.addAttribute("fofoId", fofoId);

		List<PriceDropYearMonthModel> priceDropYearMonthModels = priceDropRepository

        model.addAttribute("sortedBrandValue", sortedBrandValue);

				.selectBrandPendingPriceDropByYearMonth(fofoId, startOfMonth);

        return "price-drop-tabular";

		List<PriceDropBrandModel> priceDropBrandSixMonthTotals = priceDropRepository

    }

				.selectSixMonthBrandPriceDropByYearMonth(fofoId, startfMonthTotal, endMonthTotal);

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

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

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

        int fofoId = loginDetails.getFofoId();

		LOGGER.info("priceDropBrandSixMonthTotals" + priceDropBrandSixMonthTotals);

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

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

		Map<String, Double> priceDropBrandSixMonthMap = priceDropBrandSixMonthTotals.stream()

				.collect(Collectors.toMap(x -> x.getBrand(), x -> (double) x.getAmount()));

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

		model.addAttribute("priceDropBrandSixMonthMap", priceDropBrandSixMonthMap);

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

		LOGGER.info("priceDropYearMonthModels" + priceDropYearMonthModels);

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

        }

		for (PriceDropYearMonthModel pdm : priceDropYearMonthModels) {

        Collections.reverse(yms);

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

        model.addAttribute("yms", yms);

        LOGGER.info("ym" + yms);

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

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

        List<ActivationYearMonthModel> pendingActivationModels = schemeInOutRepository.selectPendingActivationGroupByBrandYearMonth(fofoId, startOfMonth);

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

			} else {

        List<ActivationBrandModel> pendingActivationBeforeSixMonth = schemeInOutRepository.selectByYearMonthActivationGroupByBrand(fofoId, startOfMonth);

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

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

			}

        model.addAttribute("pendingActivationBeforeSixMonthMap", pendingActivationBeforeSixMonthMap);

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

		}

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

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

		brands.add("Accessories");

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

		brands.add("Oppo");

		brands.add("Vivo");

        for (ActivationYearMonthModel pam : pendingActivationModels) {

		brands.add("Samsung");

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

		brands.add("Realme");

		brands.add("MI");

            if (activationBrandMonthMap.containsKey(pam.getBrand())) {

		brands.add("Tecno");

                brandValue = activationBrandMonthMap.get(pam.getBrand());

		brands.add("Itel");

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

		brands.add("Nokia");

            } else {

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

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

		model.addAttribute("brands", brands);

            }

            activationBrandMonthMap.put(pam.getBrand(), brandValue);

		for (String brand : brands) {

        }

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

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

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

        brands.add("Oppo");

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

        brands.add("Vivo");

        brands.add("Samsung");

				if (yearMonthValue != null) {

        brands.add("Realme");

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

        brands.add("MI");

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

        brands.add("Tecno");

					}

        brands.add("Itel");

        brands.add("Nokia");

				} else {

        brands.add("Lava");

					yearMonthValue = new HashMap<>();

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

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

				}

        model.addAttribute("brands", brands);

			}

        for (String brand : brands) {

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

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

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

			brandMonthValue.put(brand, sortedMonthBrandValue);

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

                if (yearMonthValue != null) {

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

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

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

		}

                    }

		LOGGER.info("sortedBrandValue" + sortedBrandValue);

                } else {

		model.addAttribute("fofoId", fofoId);

                    yearMonthValue = new HashMap<>();

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

		model.addAttribute("sortedBrandValue", sortedBrandValue);

                }

            }

		return "price-drop-tabular";

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

	}

            activationBrandMonthMap.put(brand, sortedMonthBrandValue);

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

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

        }

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

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        LOGGER.info("sortedBrandValue" + sortedBrandValue);

		int fofoId = loginDetails.getFofoId();

        model.addAttribute("sortedBrandValue", sortedBrandValue);

        model.addAttribute("fofoId", fofoId);

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

        return "activation-tabular";

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

    }

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

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

    public String getMonthlyActivationItemDetail(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 {

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

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

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

		}

		Collections.reverse(yms);

        List<ActivationItemDetailModel> activationItemDetails = schemeInOutRepository.selectBrandPendingActivationItemDetails(fofoId, brand, yearMonth);

		model.addAttribute("yms", yms);

		LOGGER.info("ym" + yms);

        for (ActivationItemDetailModel activationItemDetail : activationItemDetails) {

		List<ActivationYearMonthModel> pendingActivationModels = schemeInOutRepository

            List<FofoLineItem> flis = fofoLineItemRepository.selectByInventoryItemId(activationItemDetail.getInventoryItemId());

				.selectPendingActivationGroupByBrandYearMonth(fofoId, startOfMonth);

            LOGGER.info("flis" + flis);

		List<ActivationBrandModel> pendingActivationBeforeSixMonth = schemeInOutRepository

				.selectByYearMonthActivationGroupByBrand(fofoId, startOfMonth);

            int maxFofoOrderItemId = flis.stream().mapToInt(x -> x.getFofoOrderItemId()).max().orElseThrow(NoSuchElementException::new);

            LOGGER.info("maxFofoOrderItemId" + maxFofoOrderItemId);

		Map<String, Double> pendingActivationBeforeSixMonthMap = pendingActivationBeforeSixMonth.stream()

				.collect(Collectors.toMap(x -> x.getBrand(), x -> (double) x.getAmount()));

            FofoOrderItem foi = fofoOrderItemRepository.selectById(maxFofoOrderItemId);

		model.addAttribute("pendingActivationBeforeSixMonthMap", pendingActivationBeforeSixMonthMap);

            FofoOrder fo = fofoOrderRepository.selectByOrderId(foi.getOrderId());

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

            activationItemDetail.setInvoiceNumber(fo.getInvoiceNumber());

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

        }