Subversion Repositories SmartDukaan

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.InputStream;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.LocalTime;

import java.time.Month;

import java.time.YearMonth;

import java.time.format.DateTimeFormatter;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.stream.Collectors;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import javax.transaction.Transactional;

import org.apache.commons.csv.CSVRecord;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

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

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

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

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

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

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

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

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

import org.springframework.web.multipart.MultipartFile;

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

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

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

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

import com.spice.profitmandi.common.util.ExcelUtils;

import com.spice.profitmandi.common.util.FileUtil;

import com.spice.profitmandi.common.util.FormattingUtils;

import com.spice.profitmandi.common.util.StringUtils;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		String status = "CREDITED";

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		LocalDateTime currentStartMonth = LocalDate.now().atStartOfDay().withDayOfMonth(1);

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

		YearMonth yearMonth = YearMonth.now();

		LOGGER.info("yearMonth" + yearMonth);

		boolean partnerType = partnerTypeChangeService.isPartnerTypeUpgraded(loginDetails.getFofoId(), yearMonth);

		LOGGER.info("partnerType" + partnerType);

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

		if (partnerType) {

			lastMonthCategoryUpgradeMarginMap = schemeInOutRepository

					.selectLastMonthCategoryUpgradeMarginByBrand(loginDetails.getFofoId(), currentStartMonth,

							currentDate)

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

		}

		List<LastMonthCreditedIncomeModel> lastMonthCreditedIncomeModels = schemeInOutRepository

				.selectLastMonthCreditedIncomeByFofoId(loginDetails.getFofoId(), currentStartMonth, currentDate);

		List<LastMonthCreditedIncomeModel> lastMonthPurchaseInMargins = schemeInOutRepository

				.selectLastMonthPurchaseInMarginByFofoId(loginDetails.getFofoId(), currentStartMonth, currentDate);

		List<LastMonthCreditedIncomeModel> lastMonthFrontEndIncomes = schemeInOutRepository

				.selectFrontIncomeByBrand(loginDetails.getFofoId(), currentStartMonth, currentDate);

		LOGGER.info("lastMonthCreditedIncomeModels" + lastMonthCreditedIncomeModels);

		LOGGER.info("lastMonthFrontEndIncomes" + lastMonthFrontEndIncomes);

		LOGGER.info("lastMonthPurchaseInMargins" + lastMonthPurchaseInMargins);

		LOGGER.info("lastMonthCategoryUpgradeMarginMap" + lastMonthCategoryUpgradeMarginMap);

		Map<String, LastMonthCreditedIncomeModel> lastMonthPurchaseInMarginMap = new HashMap<>();

		lastMonthPurchaseInMarginMap = lastMonthPurchaseInMargins.stream()

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

		Map<String, LastMonthCreditedIncomeModel> lastMonthSaleMarginMap = lastMonthCreditedIncomeModels.stream()

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

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

			if (lastMonthSaleMarginMap.containsKey(x.getBrand())) {

				x.setAmount(lastMonthSaleMarginMap.get(x.getBrand()).getAmount() + x.getAmount());

				lastMonthSaleMarginMap.put(x.getBrand(), x);

			} else {

				lastMonthSaleMarginMap.put(x.getBrand(), x);

			}

		});

		Map<String, Float> totalAmountMap = lastMonthSaleMarginMap.entrySet().stream()

				.collect(Collectors.toMap(x -> x.getKey(), x -> x.getValue().getAmount()));

		Set<String> keySet = new HashSet<String>();

		keySet.addAll(lastMonthPurchaseInMarginMap.keySet());

		keySet.addAll(lastMonthSaleMarginMap.keySet());

		lastMonthPurchaseInMarginMap.entrySet().stream().forEach(x -> {

			String brand = x.getKey();

			float amount = x.getValue().getAmount();

			if (!totalAmountMap.containsKey(brand)) {

				totalAmountMap.put(brand, 0f);

			}

			totalAmountMap.put(brand, totalAmountMap.get(brand) + amount);

		});

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

		model.addAttribute("monthValueMap", monthValueMap);

		model.addAttribute("keySet", keySet);

		model.addAttribute("lastMonthCategoryUpgradeMarginMap", lastMonthCategoryUpgradeMarginMap);

		model.addAttribute("lastMonthPurchaseInMarginMap", lastMonthPurchaseInMarginMap);

		model.addAttribute("lastMonthSaleMarginMap", lastMonthSaleMarginMap);

		model.addAttribute("status", status);

		model.addAttribute("totalAmountMap", totalAmountMap);

		return "last-month-credited-income";

	}

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

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

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		LocalDateTime currentStartMonth = LocalDate.now().atStartOfDay().withDayOfMonth(1);

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

		String status = "PENDING";

		LOGGER.info("currentStartMonth" + currentStartMonth);

		LOGGER.info("currentDate" + currentDate);

		List<LastMonthCreditedIncomeModel> lastMonthPendingIncomeModels = schemeInOutRepository

				.selectLastMonthPendingIncomeByFofoId(loginDetails.getFofoId(), currentStartMonth, currentDate);

		Map<String, LastMonthCreditedIncomeModel> lastMonthMarginMap = new HashMap<>();

		for (LastMonthCreditedIncomeModel lastMonthPendingIncomeModel : lastMonthPendingIncomeModels) {

			lastMonthMarginMap.put(lastMonthPendingIncomeModel.getBrand(), lastMonthPendingIncomeModel);

		}

		LOGGER.info("lastMonthPendingIncomeModel" + lastMonthPendingIncomeModels);

		LOGGER.info("lastMonthMarginMap" + lastMonthMarginMap);

		model.addAttribute("lastMonthCreditedIncomeModels", lastMonthPendingIncomeModels);

		model.addAttribute("lastMonthMarginMap", lastMonthMarginMap);

		model.addAttribute("status", status);

		return "last-month-credited-income";

	}

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

	public String getLastMonthImeiWiseIncome(HttpServletRequest request,

			@RequestParam(name = "catalogItemId", required = false, defaultValue = "") int catalogItemId,

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

			throws Exception {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		LocalDateTime lastMonthStart = LocalDate.now().minusMonths(month).withDayOfMonth(1).atStartOfDay();

		LocalDateTime currentMonthEnd = lastMonthStart.plusMonths(1).withDayOfMonth(1).toLocalDate().atStartOfDay();

		HashSet<String> allImeiSet = new LinkedHashSet<>();

		HashSet<String> purchaseSet = new LinkedHashSet<>();

		HashSet<String> saleSet = new LinkedHashSet<>();

		List<LastMonthFrontEndImeiModel> lmfi = schemeInOutRepository

				.selectLastMonthFrontEndImei(loginDetails.getFofoId(), catalogItemId, lastMonthStart, currentMonthEnd);

		List<LastMonthImeiModel> lmpi = schemeInOutRepository.selectLastMonthPurchaseInImei(loginDetails.getFofoId(),

				catalogItemId, lastMonthStart, currentMonthEnd);

		List<LastMonthImeiModel> lmci = schemeInOutRepository.selectLastMonthCreditedImei(loginDetails.getFofoId(),

				catalogItemId, lastMonthStart, currentMonthEnd);

		Map<String, Double> lastmonthCategoryUpgradeMargin = schemeInOutRepository

				.selectLastMonthCategoryUpgradeMarginByImei(loginDetails.getFofoId(), catalogItemId, lastMonthStart,

						currentMonthEnd)

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

		allImeiSet.addAll(lmpi.stream().map(x -> x.getImei()).collect(Collectors.toList()));

		allImeiSet.addAll(lmci.stream().map(x -> x.getImei()).collect(Collectors.toList()));

		allImeiSet.addAll(lmfi.stream().map(x -> x.getImei()).collect(Collectors.toList()));

		List<String> allImeiList = new ArrayList<>(allImeiSet);

		LOGGER.info("allImeiList" + allImeiList);

		LOGGER.info("lmcm" + lastmonthCategoryUpgradeMargin);

		List<LastMonthFrontEndImeiModel> lastMonthFrontEndImeis = schemeInOutRepository

				.selectLastMonthFrontEndByImei(loginDetails.getFofoId(), allImeiList);

		List<LastMonthImeiModel> lastMonthPurchaseInImeis = schemeInOutRepository

				.selectLastMonthPurchaseInByImei(loginDetails.getFofoId(), allImeiList);

		List<LastMonthImeiModel> lastMonthCreditedImeis = schemeInOutRepository

				.selectLastMonthCreditedByImei(loginDetails.getFofoId(), allImeiList);

		LOGGER.info("lastMonthFrontEndImei {}", lastMonthFrontEndImeis);

		LOGGER.info("lastMonthPurchaseInImei {}", lastMonthPurchaseInImeis);

		LOGGER.info("lastMonthCreditedImei {}", lastMonthCreditedImeis);

		Map<IncomeImeiDate, Map<String, Double>> lastMonthPurchaseInMapPairMap = lastMonthPurchaseInImeis.stream()

				.collect(Collectors.groupingBy(x -> new IncomeImeiDate(x.getImei(), x.getCreateTimeStamp()),

						Collectors.groupingBy(x -> x.getDescription(), Collectors.summingDouble(x -> x.getAmount()))));

		Map<IncomeImeiDate, Map<String, Double>> lastMonthCreditedMapPairMap = lastMonthCreditedImeis.stream()

				.collect(Collectors.groupingBy(x -> new IncomeImeiDate(x.getImei(), x.getCreateTimeStamp()),

						Collectors.groupingBy(x -> x.getDescription(), Collectors.summingDouble(x -> x.getAmount()))));

		// descriptionSet.add("")

		purchaseSet.addAll(lastMonthPurchaseInImeis.stream().map(x -> x.getDescription()).collect(Collectors.toList()));

		saleSet.addAll(lastMonthCreditedImeis.stream().map(x -> x.getDescription()).collect(Collectors.toList()));

		List<String> purchaseList = new ArrayList<>(purchaseSet);

		List<String> saleList = new ArrayList<>(saleSet);

		Map<IncomeImeiDate, ImeiWiseIncomePairAndMapModel> imeiWiseIncomeMapOfMap = new HashMap<>();

		for (Map.Entry<IncomeImeiDate, Map<String, Double>> entry : lastMonthPurchaseInMapPairMap.entrySet()) {

			IncomeImeiDate imeiDate = entry.getKey();

			Map<String, Double> descriptionAmountMap = entry.getValue();

			ImeiWiseIncomePairAndMapModel modelImeiMap = new ImeiWiseIncomePairAndMapModel(imeiDate.getImei(),

					imeiDate.getLocalDateTime(), null, descriptionAmountMap);

			imeiWiseIncomeMapOfMap.put(imeiDate, modelImeiMap);

			double totalAmount = imeiWiseIncomeMapOfMap.get(imeiDate).getDescriptionAmountMap().entrySet().stream()

					.collect(Collectors.summingDouble(x -> x.getValue()));

			imeiWiseIncomeMapOfMap.get(imeiDate).setTotalIncome(totalAmount);

		}

		for (Map.Entry<IncomeImeiDate, Map<String, Double>> entry : lastMonthCreditedMapPairMap.entrySet()) {

			IncomeImeiDate imeiDate = entry.getKey();

			Map<String, Double> descriptionAmountMap = entry.getValue();

			if (!imeiWiseIncomeMapOfMap.containsKey(imeiDate)) {

				ImeiWiseIncomePairAndMapModel modelImeiMap = new ImeiWiseIncomePairAndMapModel(imeiDate.getImei(), null,

						imeiDate.getLocalDateTime(), descriptionAmountMap);

				imeiWiseIncomeMapOfMap.put(imeiDate, modelImeiMap);

			} else {

				ImeiWiseIncomePairAndMapModel modelImeiMap = imeiWiseIncomeMapOfMap.get(imeiDate);

				modelImeiMap.setSaleDate(imeiDate.getLocalDateTime());

				modelImeiMap.getDescriptionAmountMap().putAll(descriptionAmountMap);

			}

			double totalAmount = descriptionAmountMap.entrySet().stream()

					.collect(Collectors.summingDouble(x -> x.getValue()));

			imeiWiseIncomeMapOfMap.get(imeiDate)

					.setTotalIncome(totalAmount + imeiWiseIncomeMapOfMap.get(imeiDate).getTotalIncome());

		}

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

			IncomeImeiDate incomeImeiDate = new IncomeImeiDate(x.getImei(), null);

			if (imeiWiseIncomeMapOfMap.containsKey(incomeImeiDate)) {

				ImeiWiseIncomePairAndMapModel imeiWiseIncomePairAndMapModel = imeiWiseIncomeMapOfMap

						.get(incomeImeiDate);

				double totalAmount = imeiWiseIncomePairAndMapModel.getTotalIncome() + x.getAmount();

				imeiWiseIncomePairAndMapModel.setTotalIncome(totalAmount);

				imeiWiseIncomePairAndMapModel.setFrontMargin(x.getAmount());

			}

		});

		model.addAttribute("month", month);

		model.addAttribute("purchaseList", purchaseList);

		model.addAttribute("saleList", saleList);

		model.addAttribute("lastMonthPurchaseInMapPairMap", lastMonthPurchaseInMapPairMap);

		model.addAttribute("lastMonthCreditedMapPairMap", lastMonthCreditedMapPairMap);

		model.addAttribute("imeiWiseIncomeMapOfMap", imeiWiseIncomeMapOfMap);

		model.addAttribute("lastmonthCategoryUpgradeMargin", lastmonthCategoryUpgradeMargin);

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

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

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

		return "last-month-imei-wise-income";

	}

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

	public String getBrandWiseIncome(HttpServletRequest request,

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

			@RequestParam(name = "status", required = false, defaultValue = "") String status,

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

			throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

		LOGGER.info("brand" + brand);

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

		model.addAttribute("month", month);

		LocalDateTime lastMonthStart = LocalDate.now().minusMonths(month).withDayOfMonth(1).atStartOfDay();

		LocalDateTime currentMonthEnd = lastMonthStart.plusMonths(1).withDayOfMonth(1).toLocalDate().atStartOfDay();

		List<LastMonthBrandWiseIncomeModel> lastMonthModelWiseIncomes = null;

		List<LastMonthBrandWiseIncomeModel> modelWiseFrontIncomes = null;

		List<LastMonthBrandWiseIncomeModel> purchaseInModelWiseIncomes = null;

		boolean partnerType = partnerTypeChangeService.isPartnerTypeUpgraded(loginDetails.getFofoId(), YearMonth.now());

		LOGGER.info("partnerType" + partnerType);

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

		if (partnerType) {

			categoryUpradeBrandModelMap = schemeInOutRepository

					.selectLastMonthCategoryUpgradeMarginByBrandModel(loginDetails.getFofoId(), brand, lastMonthStart,

							currentMonthEnd)

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

		}

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

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

		if (status.equals("PENDING")) {

		}

		if (status.equals("CREDITED")) {

			lastMonthModelWiseIncomes = schemeInOutRepository.selectLastMonthBrandWiseIncome(loginDetails.getFofoId(),

					brand, lastMonthStart, currentMonthEnd);

			modelWiseFrontIncomes = schemeInOutRepository.selectFrontIncomeBrandWise(loginDetails.getFofoId(), brand,

					lastMonthStart, currentMonthEnd);

			purchaseInModelWiseIncomes = schemeInOutRepository.selectLastMonthPurchaseBrandWiseIncome(

					loginDetails.getFofoId(), brand, lastMonthStart, currentMonthEnd);

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

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

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

			Map<String, LastMonthBrandWiseIncomeModel> modelWiseMap = lastMonthModelWiseIncomes.stream()

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

			Map<String, LastMonthBrandWiseIncomeModel> purchaseWiseMap = purchaseInModelWiseIncomes.stream()

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

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

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

				if (modelWiseMap.containsKey(x.getModelNumber())) {

					x.setAmount(x.getAmount() + modelWiseMap.get(x.getModelNumber()).getAmount());

					modelWiseMap.put(x.getModelNumber(), x);

				} else {

					modelWiseMap.put(x.getModelNumber(), x);

				}

				if (modelWiseTotalAmount.containsKey(x.getModelNumber())) {

					double amount = x.getAmount() + modelWiseTotalAmount.get(x.getModelNumber());

					modelWiseTotalAmount.put(x.getModelNumber(), amount);

				} else {

					modelWiseTotalAmount.put(x.getModelNumber(), x.getAmount());

				}

			});

			for (LastMonthBrandWiseIncomeModel pmi : purchaseInModelWiseIncomes) {

				if (!modelWiseMap.containsKey(pmi.getModelNumber())) {

					modelWiseMap.put(pmi.getModelNumber(), null);

				}

				if (modelWiseTotalAmount.containsKey(pmi.getModelNumber())) {

					double amount = pmi.getAmount() + modelWiseTotalAmount.get(pmi.getModelNumber());

					modelWiseTotalAmount.put(pmi.getModelNumber(), amount);

				} else {

					modelWiseTotalAmount.put(pmi.getModelNumber(), pmi.getAmount());

				}

			}

			model.addAttribute("purchaseWiseMap", purchaseWiseMap);

			model.addAttribute("categoryUpradeBrandModelMap", categoryUpradeBrandModelMap);

			model.addAttribute("modelWiseMap", modelWiseMap);

			model.addAttribute("modelWiseTotalAmount", modelWiseTotalAmount);

		}

		return "montly-brand-wise-income";

	}

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

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

			throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

		LocalDateTime currentMonthEnd = lastMonthStart.plusMonths(1).withDayOfMonth(1).toLocalDate().atStartOfDay();

		YearMonth monthYear = YearMonth.now();

		boolean partnerType = partnerTypeChangeService.isPartnerTypeUpgraded(loginDetails.getFofoId(), monthYear);

		LOGGER.info("partnerType" + partnerType);

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

		if (partnerType) {

			lastMonthCategoryUpgradeMarginMap = schemeInOutRepository

					.selectLastMonthCategoryUpgradeMarginByBrand(loginDetails.getFofoId(), lastMonthStart,

							currentMonthEnd)

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

		}

		String status = "CREDITED";

		LOGGER.info("lastMonthStart" + lastMonthStart);

		LOGGER.info("currentMonthEnd" + currentMonthEnd);

		List<LastMonthCreditedIncomeModel> lastMonthCreditedIncomeModels = schemeInOutRepository

				.selectLastMonthCreditedIncomeByFofoId(loginDetails.getFofoId(), lastMonthStart, currentMonthEnd);

		List<LastMonthCreditedIncomeModel> lastMonthPurchaseInMargins = schemeInOutRepository

				.selectLastMonthPurchaseInMarginByFofoId(loginDetails.getFofoId(), lastMonthStart, currentMonthEnd);

		List<LastMonthCreditedIncomeModel> lastMonthFrontEndIncomes = schemeInOutRepository

				.selectFrontIncomeByBrand(loginDetails.getFofoId(), lastMonthStart, currentMonthEnd);

		LOGGER.info("lastMonthCreditedIncomeModels" + lastMonthCreditedIncomeModels);

		LOGGER.info("lastMonthFrontEndIncomes" + lastMonthFrontEndIncomes);

		LOGGER.info("lastMonthPurchaseInMargins" + lastMonthPurchaseInMargins);

		Map<String, LastMonthCreditedIncomeModel> lastMonthPurchaseInMarginMap = new HashMap<>();

		lastMonthPurchaseInMarginMap = lastMonthPurchaseInMargins.stream()

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

		Map<String, LastMonthCreditedIncomeModel> lastMonthSaleMarginMap = lastMonthCreditedIncomeModels.stream()

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

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

			if (lastMonthSaleMarginMap.containsKey(x.getBrand())) {

				x.setAmount(lastMonthSaleMarginMap.get(x.getBrand()).getAmount() + x.getAmount());

				lastMonthSaleMarginMap.put(x.getBrand(), x);

			} else {

				lastMonthSaleMarginMap.put(x.getBrand(), x);

			}

		});

		Map<String, Float> totalAmountMap = lastMonthSaleMarginMap.entrySet().stream()

				.collect(Collectors.toMap(x -> x.getKey(), x -> x.getValue().getAmount()));

		Set<String> keySet = new HashSet<String>();

		keySet.addAll(lastMonthPurchaseInMarginMap.keySet());

		keySet.addAll(lastMonthSaleMarginMap.keySet());

		lastMonthPurchaseInMarginMap.entrySet().stream().forEach(x -> {

			String brand = x.getKey();

			float amount = x.getValue().getAmount();

			if (!totalAmountMap.containsKey(brand)) {

				totalAmountMap.put(brand, 0f);

			}

			totalAmountMap.put(brand, totalAmountMap.get(brand) + amount);

		});

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

		model.addAttribute("lastMonthPurchaseInMarginMap", lastMonthPurchaseInMarginMap);

		model.addAttribute("lastMonthSaleMarginMap", lastMonthSaleMarginMap);

		model.addAttribute("totalAmountMap", totalAmountMap);

		model.addAttribute("status", status);

		model.addAttribute("month", yearMonth);

		model.addAttribute("lastMonthCategoryUpgradeMarginMap", lastMonthCategoryUpgradeMarginMap);

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

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

		return "last-month-credited-income";

	}