Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.ObjectOutputStream;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.LocalTime;

import java.time.YearMonth;

import java.time.format.DateTimeFormatter;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import java.util.NoSuchElementException;

import java.util.Optional;

import java.util.Set;

import java.util.TreeMap;

import java.util.stream.Collectors;

import javax.servlet.http.HttpServletRequest;

import javax.transaction.Transactional;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.authentication.RoleManager;

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

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

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;

@Controller

@Transactional(rollbackOn = Throwable.class)

public class DashboardController {

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

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

			"tejbeer.kaur@shop2020.in");

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

	private String webApiHost;

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

	private String webApiScheme;

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

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

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

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

			model.addAttribute("monthValueMap", monthValueMap);

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

			model.addAttribute("isInvestmentOk",

					partnerInvestmentService.isInvestmentOk(fofoId, 10, 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();

		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.getTypeOnDate(fofoId, startOfMonth.toLocalDate());

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

	}

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

		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(in.shop2020.model.v1.order.OrderStatus.SUBMITTED_FOR_PROCESSING);

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

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

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

		List<Integer> billedOrderIds = order.stream()

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

				.collect(Collectors.toList());

		List<Integer> shippedOrderIds = order.stream()

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

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

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

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

		List<Order> grnPendingOrder = orderRepository.selectPendingGrnOrders(fofoId);

		List<Integer> grnOrderIds = grnPendingOrder.stream().map(x -> x.getId()).collect(Collectors.toList());

		model.addAttribute("grnOrderIds", grnOrderIds);

		if (!grnOrderIds.isEmpty()) {

			List<LineItem> grnPendingLineItem = lineItemRepository.selectLineItem(grnOrderIds);

			Map<Integer, LineItem> grnPendingLineMap = grnPendingLineItem.stream()

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

			long grnPendingCount = grnPendingLineMap.entrySet().stream().filter(x -> x.getKey() > 0).count();

			long grnPendingValue = grnPendingLineMap.entrySet().stream()

					.mapToLong(x -> x.getValue().getTotalPrice().longValue()).sum();

			model.addAttribute("grnPendingCount", grnPendingCount);

			model.addAttribute("grnPendingValue", grnPendingValue);

		}

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

			long submittedCount = submittedLineItemMap.entrySet().stream().filter(x -> x.getKey() > 0).count();

			long submittedValue = submittedLineItemMap.entrySet().stream()

					.mapToLong(x -> x.getValue().getTotalPrice().longValue()).sum();

			model.addAttribute("submittedCount", submittedCount);

			model.addAttribute("submittedValue", submittedValue);

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

		}

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

			long billedCount = billedLineItemMap.entrySet().stream().filter(x -> x.getKey() > 0).count();

			model.addAttribute("billedCount", billedCount);

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

			long billedValue = billedLineItemMap.entrySet().stream()

					.mapToLong(x -> x.getValue().getTotalPrice().longValue()).sum();

			model.addAttribute("billedValue", billedValue);

		}

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

			long shippedCount = shippedLineItemMap.entrySet().stream().filter(x -> x.getKey() > 0).count();

			model.addAttribute("shippedCount", shippedCount);

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

			long shippedValue = shippedLineItemMap.entrySet().stream()

					.mapToLong(x -> x.getValue().getTotalPrice().longValue()).sum();

			model.addAttribute("shippedValue", shippedValue);

		}

		model.addAttribute("countOrder", countOrder);

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

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

		if (isAdmin) {

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

		} else {

			FofoStore fofoStore = null;

			try {

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

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

				model.addAttribute("partnerType", partnerType);

				model.addAttribute("maa", loginDetails.getFofoId() == 175138885);

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

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

				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("brandStockPrices", fofoUser.getBrandStockPrices(loginDetails.getFofoId()));

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

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

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

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

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

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

				model.addAttribute("publishedOffers", publishedOffers);

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

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

						10, ProfitMandiConstants.CUTOFF_INVESTMENT));

			} catch (ProfitMandiBusinessException e) {

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

			}

		}

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

		LocalDateTime lastMonthStart = currentMonthStart.minusMonths(1);

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

		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;

		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 <= 5; i++) {

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

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

		}

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

		/*

		 * if (loginDetails.isReadOnly()) { return "dashboard-readonly"; } else { }

		 */

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

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

		List<Order> order = orderRepository.selectPendingGrnOrders(fofoId);

		List<Integer> orderIds = order.stream().map(x -> x.getId()).collect(Collectors.toList());

		model.addAttribute("grnOrderIds", orderIds);

		if (!orderIds.isEmpty()) {

			List<LineItem> grnPendingLineItem = lineItemRepository.selectLineItem(orderIds);

			Map<Integer, LineItem> grnPendingLineMap = grnPendingLineItem.stream()

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

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

			model.addAttribute("grnPendingLineMap", grnPendingLineMap);

			Map<Integer, Order> orderMap = order.stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

			model.addAttribute("orderMap", orderMap);

		}

		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(in.shop2020.model.v1.order.OrderStatus.SHIPPED_FROM_WH);

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

		List<Integer> shippedOrderIds = order.stream()

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

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

	}

	@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(), currentMonthStart,

				currentMonthEnd) / 2;

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

				currentMonthStart) / 2;

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

				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) throws Exception {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		int fofoId = loginDetails.getFofoId();

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

		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) throws Exception {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		int 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, Model model) throws Exception {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		int fofoId = loginDetails.getFofoId();

		ChartModel cm = fofoUser.getBrandChart(fofoId);

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

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

		return "bar_chart";

	}

	@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) throws Exception {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

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

				}

			}

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

			brandMonthValue.put(brand, sortedMonthBrandValue);

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

		}

		LOGGER.info("sortedBrandValue" + sortedBrandValue);

		model.addAttribute("fofoId", fofoId);

		model.addAttribute("sortedBrandValue", sortedBrandValue);

		return "price-drop-tabular";

	}

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

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

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		int fofoId = loginDetails.getFofoId();

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

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

		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<ActivationYearMonthModel> pendingActivationModels = schemeInOutRepository

				.selectPendingActivationGroupByBrandYearMonth(fofoId, startOfMonth);

		List<ActivationBrandModel> pendingActivationBeforeSixMonth = schemeInOutRepository

				.selectByYearMonthActivationGroupByBrand(fofoId, startOfMonth);

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

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

		model.addAttribute("pendingActivationBeforeSixMonthMap", pendingActivationBeforeSixMonthMap);

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

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

		for (ActivationYearMonthModel pam : pendingActivationModels) {

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

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

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

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

			} else {

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

			}