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

import java.io.ObjectOutputStream;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.LocalTime;

import java.time.YearMonth;

import java.time.ZoneOffset;

import java.time.format.DateTimeFormatter;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Comparator;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Optional;

import java.util.Set;

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.enumuration.ReporticoProject;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import com.spice.profitmandi.dao.Interface.Campaign;

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

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

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

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

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

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

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

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

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

import com.spice.profitmandi.dao.entity.user.Lead;

import com.spice.profitmandi.dao.enumuration.cs.EscalationType;

import com.spice.profitmandi.dao.enumuration.dtr.LeadStatus;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.dtr.UserCampaignRepository;

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

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

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

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

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

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

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

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

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

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 {

	private static final double ONE_LAC = 1 * 1000 * 100;

	private static final double TWO_LAC = 2 * 1000 * 100;

	private static final double FOUR_LAC = 4 * 1000 * 100;

	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 CookiesProcessor cookiesProcessor;

	@Autowired

	private PartnerStatsService partnerStatsService;

	@Autowired

	private MenuRepository menuRepository;

	@Autowired

	private MenuCategoryRepository menuCategoryRepository;

	@Autowired

	private CsService csService;

	@Autowired

	private PartnerTargetRepository partnerTargetRepository;

	@Autowired

	private ResponseSender<?> responseSender;

	@Autowired

	RetailerService retailerService;

	@Autowired

	private RoleManager roleManager;

	@Autowired

	private FofoStoreRepository fofoStoreRepository;

	@Autowired

	private PartnerDailyInvestmentRepository partnerDailyInvestmentRepository;

	@Autowired

	private PartnerInvestmentService partnerInvestmentService;

	@Autowired

	DocumentRepository documentRepository;

	@Autowired

	InventoryItemRepository inventoryItemRepository;

	@Autowired

	InventoryService inventoryService;

	@Autowired

	private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

	@Autowired

	private FofoOrderItemRepository fofoOrderItemRepository;

	@Autowired

	private TicketCategoryRepository ticketCategoryRepository;

	@Autowired

	private PartnerTypeChangeService partnerTypeChangeService;

	@Autowired

	private HygieneDataRepository hygieneDataRepository;

	@Autowired

	private UserCampaignRepository userCampaignRepository;

	@Autowired

	private PositionRepository positionRepository;

	@Autowired

	private PartnerTypeChangeRepository partnerTypeChangeRepository;

	@Autowired

	private PartnersPositionRepository partnerPositionRepository;

	@Autowired

	private UserAccountRepository userAccountRepository;

	@Autowired

	private NotificationCampaignRepository notificationCampaignRepository;

	@Autowired

	private Mongo mongoClient;

	@Autowired

	private AuthRepository authRepository;

	@Autowired

	private FofoOrderRepository fofoOrderRepository;

	@Autowired

	private Gson gson;

	@Autowired

	TicketRepository ticketRepository;

	@Autowired

	private LeadRepository leadRepository;

	@Autowired

	private OfferRepository offerRepository;

	@Autowired

	private OfferPartnerRepository offerPartnerRepository;

	@Autowired

	private OfferService offerService;

	@Autowired

	private OfferMarginRepository offerMarginRepository;

	@Autowired

	private ItemRepository itemRepository;

	@Autowired

	private SaholicInventorySnapshotRepository saholicInventorySnapshotRepository;

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

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

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

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

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

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

			// this.setInvestments

			//

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

			model.addAttribute("isInvestmentOk",

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

		} catch (ProfitMandiBusinessException e) {

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

		}

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

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

		double currentMonthRating = hygieneDataRepository.selectRatingAvg(fofoId, currentMonthStart, currentMonthEnd)

				/ 2;

		double lastMonthRating = hygieneDataRepository.selectRatingAvg(fofoId, currentMonthStart, currentMonthEnd) / 2;

		double ratingTillDate = hygieneDataRepository.selectRatingAvg(fofoId, currentMonthStart, 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(fofoId, true, currentMonthStart, currentMonthEnd);

		long invalidHygieneCount = hygieneDataRepository.selectHygieneCount(fofoId, false, currentMonthStart,

				currentMonthEnd);

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

			invalidHygieneCount = 1;

		}

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

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

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

		return "12dashboard34";

	}

	private Map<String, Object> getInvestments(int fofoId) throws Exception {

		Map<String, Object> investments = new LinkedHashMap<>();

		PartnerDailyInvestment investment = partnerInvestmentService.getInvestment(fofoId, 0);

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

		LocalDate yesterDate = LocalDate.now().minusDays(1);

		PartnerDailyInvestment yesterdayInvestment = partnerDailyInvestmentRepository.select(fofoId, yesterDate);

		if (yesterdayInvestment == null) {

			yesterdayInvestment = new PartnerDailyInvestment();

		}

		List<PartnerDailyInvestment> currentMonthInvestments = partnerDailyInvestmentRepository.selectAll(fofoId,

				currentMonthStart, currentMonthStart.withDayOfMonth(currentMonthStart.lengthOfMonth()));

		long okInvestmentDays = currentMonthInvestments.stream().filter(x -> x.getShortPercentage() <= 10)

				.collect(Collectors.counting());

		investments.put("today", investment.getTotalInvestment());

		investments.put("investment", investment);

		investments.put("inStock", investment.getInStockAmount());

		investments.put("minimum", investment.getMinInvestmentString());

		investments.put("short", investment.getShortPercentage());

		investments.put("activated_stock", investment.getActivatedStockAmount());

		investments.put("okDays", okInvestmentDays);

		return investments;

	}

	private Map<String, Object> getSales(int fofoId) {

		Map<String, Object> salesMap = new LinkedHashMap<>();

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

		int monthLength = LocalDate.now().lengthOfMonth();

		Double todaySale = fofoOrderItemRepository

				.selectSumMopGroupByRetailer(curDate, curDate.with(LocalTime.MAX), fofoId, false).get(fofoId);

		Double mtdSale = fofoOrderItemRepository

				.selectSumMopGroupByRetailer(curDate.withDayOfMonth(1), curDate.with(LocalTime.MAX), fofoId, false)

				.get(fofoId);

		Double lmtdSale = fofoOrderItemRepository.selectSumMopGroupByRetailer(curDate.withDayOfMonth(1).minusMonths(1),

				curDate.with(LocalTime.MAX).minusMonths(1), fofoId, false).get(fofoId);

		List<PartnerTargetDetails> partnerTargetDetails = partnerTargetRepository

				.selectAllGeEqAndLeEqStartDateAndEndDate(LocalDateTime.now());

		if (partnerTargetDetails.isEmpty()) {

			partnerTargetDetails = partnerTargetRepository

					.selectAllGeEqAndLeEqStartDateAndEndDate(LocalDateTime.now().minusMonths(3));

		}

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

		int currentRate = (int) (mtdSale / curDate.getDayOfMonth());

		salesMap.put("requiredType", partnerType.next());

		float reqdAmount = partnerTypeChangeService.getMinimumAmount(partnerType.next());

		int requiredRate = (int) ((reqdAmount - mtdSale) / (monthLength - curDate.getDayOfMonth()));

		if (partnerType.equals(PartnerType.PLATINUM) && requiredRate < currentRate) {

			requiredRate = currentRate;

		}

		salesMap.put("requiredRate", requiredRate);

		salesMap.put("requiredTypeImage", PartnerType.imageMap.get(partnerType.next()));

		salesMap.put("todaySale", todaySale == null ? 0 : todaySale);

		salesMap.put("mtdSale", mtdSale == null ? 0 : mtdSale);

		salesMap.put("lmtdSale", lmtdSale == null ? 0 : lmtdSale);

		PartnerType currentType = partnerTypeChangeService.getPartnerTypeByAmount(currentRate * monthLength);

		salesMap.put("currentRate", currentRate);

		salesMap.put("currentType", currentType);

		salesMap.put("currentTypeImage", PartnerType.imageMap.get(currentType));

		return salesMap;

	}

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

			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(this.format((long) mtdSales));

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

			ms.setPartnerType(partnerType);

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

			monthSaleMap.put(i, ms);

		}

		model.addAttribute("monthSales", monthSaleMap);

		return "monthSales";

	}

	private String format(long value) {

		String finalval = null;

		if (value >= 100000 && value < 10000000) {

			long reminder = value / 100000;

			long quitonent = value % 100000;

			finalval = reminder + "." + quitonent;

			String secondval = String.valueOf(quitonent);

			if (secondval.length() >= 2) {

				secondval = secondval.substring(0, 2);

				finalval = reminder + "." + secondval;

			}

			return String.valueOf(finalval) + " Lacs";

		} else if (value >= 1000 && value < 100000) {

			long reminder = value / 1000;

			long quitonent = value % 1000;

			finalval = reminder + "." + quitonent;

			String secondval = String.valueOf(quitonent);

			if (secondval.length() >= 2) {

				secondval = secondval.substring(0, 2);

				finalval = reminder + "." + secondval;

			}

			return String.valueOf(finalval) + " K";

		} else if (value >= 10000000 && value < 1000000000) {

			long reminder = value / 10000000;

			long quitonent = value % 10000000;

			finalval = reminder + "." + quitonent;

			String secondval = String.valueOf(quitonent);

			if (secondval.length() >= 2) {

				secondval = secondval.substring(0, 2);

				finalval = reminder + "." + secondval;

			}

			return String.valueOf(finalval) + " Cr";

		}

		return String.valueOf(finalval);

	}

	private List<BrandStockPrice> getBrandStockPrices(int fofoId) throws Exception {

		Map<String, BrandStockPrice> brandStockPricesMap = inventoryService.getBrandWiseStockValue(fofoId);

		List<DBObject> mobileBrands = mongoClient.getAllBrandsToDisplay(3);

		List<BrandStockPrice> brandStockPrices = new ArrayList<>();

		mobileBrands.stream().forEach(x -> {

			String brand = (String) x.get("name");

			if (brandStockPricesMap.containsKey(brand)) {

				BrandStockPrice brandStockPrice = brandStockPricesMap.get(brand);

				brandStockPrice.setBrandUrl((String) x.get("url"));

				brandStockPrice.setRank(((Double) x.get("rank")).intValue());

				brandStockPrices.add(brandStockPrice);

			}

		});

		return brandStockPrices.stream().filter(x -> x.getTotalQty() > 0).sorted((x, y) -> x.getRank() - y.getRank())

				.collect(Collectors.toList());

	}

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

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

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		String email = loginDetails.getEmailId();

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

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

				ChartModel cm = this.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", this.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;

		}

		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 = "/investmentDetails", method = RequestMethod.GET)

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

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		int fofoId = loginDetails.getFofoId();

		ChartInvestmentModel cm = this.getInvestmentChart(fofoId);

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

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

		LOGGER.info("InvestmentChart" + cm);

		return "investmentdetails";

	}

	private ChartInvestmentModel getInvestmentChart(int fofoId) throws ProfitMandiBusinessException {

		PartnerDailyInvestment investment = partnerInvestmentService.getInvestment(fofoId, 0);

		Map<String, Float> investmentWalletAmount = new HashMap<>();

		investmentWalletAmount.put("Wallet", investment.getWalletAmount());

		investmentWalletAmount.put("InStock", investment.getInStockAmount());

		investmentWalletAmount.put("Unbilled Order", investment.getUnbilledAmount());

		investmentWalletAmount.put("GrnPending", investment.getGrnPendingAmount());

		investmentWalletAmount.put("ReturnInTransit", investment.getReturnInTransitAmount());

		if (investment.getShortInvestment() > 0) {

			investmentWalletAmount.put("Short Investment", investment.getShortInvestment());

		}

		ChartInvestmentModel cm = new ChartInvestmentModel();

		HashSet<String> labels = new HashSet<String>();

		labels.addAll(investmentWalletAmount.keySet());

		List<String> labelList = new ArrayList<>(labels);

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

		List<Float> labelsValue = new ArrayList<>();

		List<Float> values = new ArrayList<>();

		for (String label : labelList) {

			values.add(investmentWalletAmount.get(label));

			if (label.equals("Wallet")) {

				backgroundColor.add("pink");

			}

			if (label.equals("Short Investment")) {

				backgroundColor.add("red");

			}

			if (label.equals("InStock")) {

				backgroundColor.add("#9ACD32");

			}

			if (label.equals("Unbilled Order")) {

				backgroundColor.add("blue");

			}

			if (label.equals("ReturnInTransit")) {

				backgroundColor.add("orange");

			}

			if (label.equals("GrnPending")) {

				backgroundColor.add("yellow");

			}

		}

		Data data = new Data();

		data.setData(values);

		data.setBackgroundColor(backgroundColor);

		data.setLabel("DataSet 1");

		PieLables label = new PieLables();

		label.setFontColor("White");

		label.setFontSize(15);

		Legend legend = new Legend();

		legend.setLabels(label);

		legend.setPosition("left");

		List<Data> dataList = new ArrayList<>();

		dataList.add(data);

		DataInvestmentModel datasets = new DataInvestmentModel();

		datasets.setDatasets(dataList);

		datasets.setLabels(labels);

		OptionModel om = new OptionModel();

		om.setLegend(legend);

		cm.setType("pie");

		cm.setData(datasets);

		cm.setOptions(om);

		return cm;

	}

	private ChartModel getBrandChart(int fofoId) {

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

		LOGGER.info("cur Date" + curDate.withDayOfMonth(1));

		LOGGER.info("curDateYear" + curDate.with(LocalTime.MAX));

		Map<String, Double> brandwisesale = fofoOrderItemRepository

				.selectSumAmountGroupByBrand(curDate.withDayOfMonth(1), curDate.with(LocalTime.MAX), fofoId);

		LOGGER.info("brandwisesale" + brandwisesale);

		Map<Integer, Double> accesoriesmtdsale = fofoOrderRepository.selectSumSaleGroupByFofoIdsForMobileOrAccessories(

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

		brandwisesale.put("Accessories", accesoriesmtdsale.get(fofoId));

		Map<String, Double> activatedImeisWithSellingPriceMTD = fofoOrderRepository

				.selectValueOfActivatedImeis(curDate.withDayOfMonth(1), curDate.with(LocalTime.MAX), fofoId).stream()

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

		Map<String, Double> activatedImeisWithSellingPriceLMTD = fofoOrderRepository

				.selectValueOfActivatedImeis(curDate.withDayOfMonth(1).minusMonths(1),

						curDate.with(LocalTime.MAX).minusMonths(1), fofoId)

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

		Map<String, Double> lmtdBrandWiseSale = fofoOrderItemRepository.selectSumAmountGroupByBrand(

				curDate.withDayOfMonth(1).minusMonths(1), curDate.with(LocalTime.MAX).minusMonths(1), fofoId);

		Map<Integer, Double> accesorieslmtdsale = fofoOrderRepository.selectSumSaleGroupByFofoIdsForMobileOrAccessories(

				fofoId, curDate.withDayOfMonth(1).minusMonths(1), curDate.with(LocalTime.MAX).minusMonths(1),

				Optional.of(false));

		lmtdBrandWiseSale.put("Accessories", accesorieslmtdsale.get(fofoId));

		ChartModel cm = new ChartModel();

		HashSet<String> labels = new HashSet<String>();

		labels.addAll(brandwisesale.keySet());

		labels.addAll(lmtdBrandWiseSale.keySet());

		List<String> labelList = new ArrayList<>(labels);

		List<Double> mtdActivatedImeisValues = new ArrayList<>();

		List<Double> mtdValues = new ArrayList<>();

		List<Double> lmtdUnActivatedImeisValues = new ArrayList<>();

		List<Double> lmtdActivatedImeisValues = new ArrayList<>();

		List<Double> mtdUnActivatedImeisValues = new ArrayList<>();

		List<Double> lmtdValues = new ArrayList<>();

		for (String label : labelList) {

			mtdActivatedImeisValues.add(activatedImeisWithSellingPriceMTD.get(label) == null ? 0

					: activatedImeisWithSellingPriceMTD.get(label));

			lmtdActivatedImeisValues.add(activatedImeisWithSellingPriceLMTD.get(label) == null ? 0

					: activatedImeisWithSellingPriceLMTD.get(label));

			mtdValues.add(brandwisesale.get(label) == null ? 0 : brandwisesale.get(label));

			if (brandwisesale.get(label) != null) {

				mtdUnActivatedImeisValues

						.add(brandwisesale.get(label) - (activatedImeisWithSellingPriceMTD.get(label) == null ? 0

								: activatedImeisWithSellingPriceMTD.get(label)));

			} else {

				mtdUnActivatedImeisValues.add(0.0);

			}

			if (lmtdBrandWiseSale.get(label) != null) {

				lmtdUnActivatedImeisValues

						.add(lmtdBrandWiseSale.get(label) - (activatedImeisWithSellingPriceLMTD.get(label) == null ? 0

								: activatedImeisWithSellingPriceLMTD.get(label)));

			} else {

				lmtdUnActivatedImeisValues.add(0.0);

			}

			lmtdValues.add(lmtdBrandWiseSale.get(label) == null ? 0 : lmtdBrandWiseSale.get(label));

		}

		DatasetModel dsmtotal = new DatasetModel();

		dsmtotal.setLabel("MTD");

		dsmtotal.setBackgroundColor("blue");

		dsmtotal.setData(mtdValues);

		dsmtotal.setStack("stack0");

		dsmtotal.setOrder(1);

		DatasetModel dsmUnactivated = new DatasetModel();

		dsmUnactivated.setLabel("MTD Unactivated");

		dsmUnactivated.setBackgroundColor("red");

		dsmUnactivated.setData(mtdUnActivatedImeisValues);

		dsmUnactivated.setStack("stack0");

		dsmUnactivated.setOrder(1);

		LOGGER.info("mtdValuesMoney" + mtdValues);

		DatasetModel mtdActivatedImeis = new DatasetModel();

		mtdActivatedImeis.setLabel("MTD Activation");

		mtdActivatedImeis.setData(mtdActivatedImeisValues);

		mtdActivatedImeis.setBackgroundColor("#00008b");

		mtdActivatedImeis.setStack("stack0");

		mtdActivatedImeis.setOrder(1);

		DatasetModel lmtddsmtotal = new DatasetModel();

		lmtddsmtotal.setLabel("LMTD");

		lmtddsmtotal.setBackgroundColor("blue");

		lmtddsmtotal.setData(lmtdValues);

		lmtddsmtotal.setStack("stack1");

		lmtddsmtotal.setOrder(1);

		DatasetModel lmtdUnActivated = new DatasetModel();

		lmtdUnActivated.setLabel("LMTD Unactivation");

		lmtdUnActivated.setBackgroundColor("red");

		lmtdUnActivated.setData(lmtdUnActivatedImeisValues);

		lmtdUnActivated.setStack("stack1");

		lmtdUnActivated.setOrder(1);

		DatasetModel LmtdActivatedImeis = new DatasetModel();

		LmtdActivatedImeis.setLabel("LMTD Activation");

		LmtdActivatedImeis.setBackgroundColor("#87ceeb");

		LmtdActivatedImeis.setData(lmtdActivatedImeisValues);

		LmtdActivatedImeis.setStack("stack1");

		LmtdActivatedImeis.setOrder(1);

		DatasetModel linemtdChart = new DatasetModel();

		linemtdChart.setLabel("MTD");

		linemtdChart.setBackgroundColor("#006400");

		linemtdChart.setData(mtdValues);

		linemtdChart.setType("line");

		linemtdChart.setOrder(2);

		linemtdChart.setFill("false");

		DatasetModel lineLmtdChart = new DatasetModel();

		lineLmtdChart.setLabel("LMTD");

		lineLmtdChart.setBackgroundColor("#006400");

		lineLmtdChart.setData(lmtdValues);

		lineLmtdChart.setType("line");

		lineLmtdChart.setOrder(3);

		lineLmtdChart.setFill("false");

		List<DatasetModel> datasets = new ArrayList<>();

		datasets.add(lmtdUnActivated);

		datasets.add(LmtdActivatedImeis);

		datasets.add(dsmUnactivated);

		datasets.add(mtdActivatedImeis);

		datasets.add(linemtdChart);

		datasets.add(lineLmtdChart);

		DataModel dm = new DataModel();

		dm.setDatasets(datasets);

		dm.setLabels(labels);

		LegendModel lm = new LegendModel();

		lm.setPosition("top");

		TitleModel tm = new TitleModel();

		tm.setText("Brand Wise Sales");

		tm.setDisplay(true);

		List<Axis> xAxes = new ArrayList<>();

		Axis xAxis = new Axis();

		xAxis.setStacked(true);

		xAxes.add(xAxis);

		List<Axis> yAxes = new ArrayList<>();

		Axis yAxis = new Axis();

		yAxis.setStacked(false);

		yAxes.add(yAxis);

		ScalesModel sm = new ScalesModel();

		sm.setxAxes(xAxes);

		OptionsModel om = new OptionsModel();

		om.setLegend(lm);

		om.setTitle(tm);

		om.setScales(sm);

		cm.setType("bar");

		cm.setData(dm);

		cm.setOptions(om);

		LOGGER.info("cm" + cm);

		return cm;

	}

	private String adminPanel(int fofoId, String email, Model model) throws Exception {

		List<Menu> menus = null;

		try {

			AuthUser authUser = authRepository.selectByEmailOrMobile(email);

			List<Position> positions = positionRepository.selectAll(authUser.getId());

			Map<Integer, PartnerDetailModel> warehousePartnerDetailMap = null;

			ReporticoCacheTable rctSaholic = null;

			ReporticoCacheTable rctPartneStat = null;

			Map<Integer, WarehouseWiseStockModel> warehouseStockMap = new HashMap<>();

			LinkedHashMap<Integer, WarehouseWiseStockModel> warehouseStockSortedMap = new LinkedHashMap<>();

			Map<Integer, String> warehouseMap = ProfitMandiConstants.WAREHOUSE_MAP;

			LinkedHashMap<Integer, String> wm = new LinkedHashMap<Integer, String>();

			Map<String, BrandWisePartnerSaleModel> partnersBrandSaleMap = null;

			List<BrandWisePartnerSaleModel> accessoriesBrandSales = null;

			Map<AuthUser, Long> authUserTicketCount = null;

			for (Map.Entry<Integer, String> entry : warehouseMap.entrySet()) {

				wm.put(entry.getKey(), entry.getValue());

			}

			wm.put(0, "Total Values");

			long stockValue = 0;

			long stockQty = 0;

			long pendingIndent = 0;

			long tertiary = 0;

			Map<String, Set<Integer>> storeGuyMap = csService.getAuthUserPartnerIdMapping();

			Set<Integer> fofoIds = storeGuyMap.get(authUser.getEmailId());

			if (emails.contains(authUser.getEmailId())) {

				fofoIds = storeGuyMap.get("tarun.verma@smartdukaan.com");

			}

			LOGGER.info("fofoIds" + fofoIds);

			if (fofoIds != null) {

				Map<Integer, List<Integer>> warehouseIdFofoIdMap = fofoStoreRepository

						.selectActivePartnersByRetailerIds(new ArrayList<>(fofoIds)).stream()

						.collect(Collectors.groupingBy(FofoStore::getWarehouseId,

								Collectors.mapping(FofoStore::getId, Collectors.toList())));

				// warehouseStock

				List<WarehouseWiseStockModel> warehouseStocks = saholicInventoryCISRepository