Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

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

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

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

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

import com.spice.profitmandi.common.services.ReporticoService;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.scheme.SchemeService;

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

import com.spice.profitmandi.service.wallet.WalletService;

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

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

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

import in.shop2020.model.v1.order.WalletReferenceType;

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

import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import javax.transaction.Transactional;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.InputStream;

import java.time.*;

import java.time.format.DateTimeFormatter;

import java.util.*;

import java.util.stream.Collectors;

@Controller

@Transactional(rollbackOn = Throwable.class)

public class SchemeController {

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

	@Autowired

	private SchemeService schemeService;

	@Autowired

	private OfferService offerService;

	@Autowired

	private StateGstRateRepository stateGstRateRepository;

	@Autowired

	private ItemRepository itemRepository;

	@Autowired

	private ReporticoService reporticoService;

	@Autowired

	private SchemeRepository schemeRepository;

	@Autowired

	private SchemeItemRepository schemeItemRepository;

	@Autowired

	private MVCResponseSender mvcResponseSender;

	@Autowired

	private CookiesProcessor cookiesProcessor;

	@Autowired

	@Qualifier("fofoInventoryService")

	private InventoryService inventoryService;

	@Autowired

	private TagListingRepository tagListingRepository;

	@Autowired

	private RoleManager roleManager;

	@Autowired

	private ResponseSender<?> responseSender;

	@Autowired

	private FofoStoreRepository fofoStoreRepository;

	@Autowired

	private RetailerService retailerService;

	@Autowired

	private Mongo mongoClient;

	@Autowired

	WalletService walletService;

	@Autowired

	PartnerDailyInvestmentRepository partnerDailyInvestmentRepository;

	@Autowired

	private PartnerTypeChangeService partnerTypeChangeService;

	@Autowired

	InventoryItemRepository inventoryItemRepository;

	@Autowired

	PriceDropIMEIRepository priceDropIMEIRepository;

	@Autowired

	PriceDropRepository priceDropRepository;

	@Autowired

	SchemeInOutRepository schemeInOutRepository;

	@Autowired

	private CustomerOfferRepository customerOfferRepository;

	@Autowired

	private CustomerOfferItemRepository customerOfferItemRepository;

	@Autowired

	private SamsungUpgradeOfferRepository samsungUpgradeOfferRepository;

	@Autowired

	private CsService csService;

	List<String> adminEmail = Arrays.asList("tarun.verma@smartdukaan.com", "neeraj.gupta@smartdukaan.com",

			"amit.gupta@shop2020.in", "manish.tiwari@smartdukaan.com", "tejbeer.kaur@shop2020.in");

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

	public String createScheme(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		LocalDate currentdate = LocalDate.now();

		Month month = currentdate.getMonth().minus(1);

		model.addAttribute("month", month);

		// Map<Integer, String> itemIdItemDescriptionMap =

		// inventoryService.getAllItemIdItemDescriptionMap();

		// model.addAttribute("itemIdItemDescriptionMap", itemIdItemDescriptionMap);

		Set<String> brands = inventoryService.getAllTagListingBrands(ProfitMandiConstants.MOBILE_CATEGORY_ID);

		brands.addAll(inventoryService.getAllTagListingBrands(14206));

		boolean fullAccesss = this.getAccess(loginDetails.getEmailId());

		model.addAttribute("fullAccesss", fullAccesss);

		model.addAttribute("brands", brands);

		model.addAttribute("retailerTypes", PartnerType.values());

		return "create-scheme";

	}

	private boolean getAccess(String emailId) {

		boolean fullAccesss = false;

		List<String> emails = csService

				.getAuthUserByCategoryId(ProfitMandiConstants.TICKET_CATEGORY_CATEGORY, EscalationType.L3).stream()

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

		emails.addAll(

				csService.getAuthUserByCategoryId(ProfitMandiConstants.TICKET_CATEGORY_CATEGORY, EscalationType.L2)

						.stream().map(x -> x.getEmailId()).collect(Collectors.toList()));

		if (adminEmail.contains(emailId)) {

			fullAccesss = true;

		}

		if (emails.contains(emailId)) {

			fullAccesss = false;

		}

		return fullAccesss;

	}

	@RequestMapping(value = "/getTagListingItemsByBrand", method = RequestMethod.POST)

	public String getTagListingItemsByBrand(HttpServletRequest request, @RequestBody List<String> brands, Model model) {

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

		LOGGER.info("brands" + brands);

		List<MapWrapper<Integer, String>> itemIdItemDescriptionMaplist = inventoryService

				.getAllTagListingItemIdItemDescriptionMap(new HashSet<>(brands));

		for (MapWrapper<Integer, String> mapWrapper : itemIdItemDescriptionMaplist) {

			itemIdItemDescriptionMap.put(mapWrapper.getKey(), mapWrapper.getValue());

		}

		model.addAttribute("itemIdItemDescriptionMap", itemIdItemDescriptionMap);

		// model.addAttribute("brands", inventoryService.getAllBrands());

		return "tag-listing-items-description";

	}

	@RequestMapping(value = "/schemes/update-schemes-page", method = RequestMethod.GET)

	public String updateShcemes(HttpServletRequest request) throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		if (!roleManager.isAdmin(loginDetails.getRoleIds())) {

			throw new ProfitMandiBusinessException("User", loginDetails.getEmailId(), "Unauthorised access");

		}

		return "update-schemes-page";

	}

	@RequestMapping(value = "/payMonthlyInvestment", method = RequestMethod.POST)

	public void payMonthlyInvestment(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {

		LocalDate firstDateOfCurrentMonth = LocalDateTime.now().withDayOfMonth(1).toLocalDate();

		LocalDate startOfPreviousMonth = firstDateOfCurrentMonth.minusMonths(1);

		int referenceId = Integer.parseInt(FormattingUtils.getYearMonth(startOfPreviousMonth.atStartOfDay()));

		LocalDate lastOfPreviousMonth = firstDateOfCurrentMonth.minusDays(1);

		List<PartnerDailyInvestment> partnerDailyInvestments = partnerDailyInvestmentRepository

				.selectAll(startOfPreviousMonth, lastOfPreviousMonth);

		Map<Integer, Long> investmentMaintainedDaysMap = partnerDailyInvestments.stream()

				.filter(x -> x.getShortPercentage() <= 10)

				.collect(Collectors.groupingBy(x -> x.getFofoId(), Collectors.counting()));

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

		List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectAllPending(SchemeType.INVESTMENT,

				startOfPreviousMonth.atStartOfDay(), firstDateOfCurrentMonth.atStartOfDay());

		if (schemeInOuts.isEmpty()) {

			throw new ProfitMandiBusinessException("Investment Payout", "", "No data Found");

		}

		Map<Integer, List<SchemeInOut>> inventoryItemIdSchemeMap = schemeInOuts.stream()

				.collect(Collectors.groupingBy(x -> x.getInventoryItemId()));

		List<InventoryItem> inventoryItems = inventoryItemRepository.selectByIds(inventoryItemIdSchemeMap.keySet());

		Map<Integer, List<Integer>> retailerInventoryItemIdMap = inventoryItems.stream().collect(

				Collectors.groupingBy(x -> x.getFofoId(), Collectors.mapping(x -> x.getId(), Collectors.toList())));

		System.out.println("Fofo Id\tInvestment Maintained Days\tEligible payout");

		for (Map.Entry<Integer, List<Integer>> retailerEntry : retailerInventoryItemIdMap.entrySet()) {

			int fofoId = retailerEntry.getKey();

			long investmentMaintainedDays = investmentMaintainedDaysMap.get(fofoId) == null ? 0

					: investmentMaintainedDaysMap.get(fofoId);

			List<SchemeInOut> schemeInouts = retailerEntry.getValue().stream().map(x -> inventoryItemIdSchemeMap.get(x))

					.flatMap(List::stream).filter(x -> x.getRolledBackTimestamp() == null).collect(Collectors.toList());

			float totalAmount = 0;

			for (SchemeInOut sio : schemeInouts) {

				if (investmentMaintainedDays < 8) {

					sio.setStatus(SchemePayoutStatus.REJECTED);

					// sio.setRolledBackTimestamp(LocalDateTime.now());

					sio.setStatusDescription("Investment maintained for " + investmentMaintainedDays + "(< 8) days");

				} else if (investmentMaintainedDays < 12) {

					sio.setStatus(SchemePayoutStatus.CREDITED);

					sio.setAmount(sio.getAmount() / 2);

					sio.setCreditTimestamp(LocalDateTime.now());

					sio.setStatusDescription("Investment maintained for " + investmentMaintainedDays + "(< 12) days");

					totalAmount += sio.getAmount();

				} else {

					sio.setStatus(SchemePayoutStatus.CREDITED);

					sio.setCreditTimestamp(LocalDateTime.now());

					totalAmount += sio.getAmount();

				}

			}

			if (totalAmount > 0) {

				String description = "Investment margin paid for "

						+ FormattingUtils.formatYearMonth(startOfPreviousMonth.atStartOfDay());

				if (investmentMaintainedDays < 12) {

					description += ", as maintained for " + investmentMaintainedDays + "(< 12) days";

				}

				walletService.addAmountToWallet(fofoId, referenceId, WalletReferenceType.INVESTMENT_PAYOUT, description,

						totalAmount, lastOfPreviousMonth.atTime(LocalTime.MAX));

			}

			System.out.printf("%d\t%d\t%f%n", fofoId, investmentMaintainedDays, totalAmount);

		}

	}

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

	public ResponseEntity<?> evaluateActualInvestmentPayout(HttpServletRequest request, Model model) throws Exception {

		List<List<?>> rows = new ArrayList<>();

		LocalDate firstDateOfCurrentMonth = LocalDateTime.now().withDayOfMonth(1).toLocalDate();

		LocalDate startOfPreviousMonth = firstDateOfCurrentMonth.minusMonths(1);

		LocalDate lastOfPreviousMonth = firstDateOfCurrentMonth.minusDays(1);

		List<PartnerDailyInvestment> partnerDailyInvestments = partnerDailyInvestmentRepository

				.selectAll(startOfPreviousMonth, lastOfPreviousMonth);

		Map<Integer, Long> investmentMaintainedDaysMap = partnerDailyInvestments.stream()

				.filter(x -> x.getShortPercentage() <= 10)

				.collect(Collectors.groupingBy(x -> x.getFofoId(), Collectors.counting()));

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

		List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectAllPending(SchemeType.INVESTMENT,

				startOfPreviousMonth.atStartOfDay(), firstDateOfCurrentMonth.atStartOfDay());

		Map<Integer, List<SchemeInOut>> inventoryItemIdSchemeMap = schemeInOuts.stream()

				.collect(Collectors.groupingBy(x -> x.getInventoryItemId()));

		List<InventoryItem> inventoryItems = inventoryItemRepository.selectByIds(inventoryItemIdSchemeMap.keySet());

		Map<Integer, List<Integer>> retailerInventoryItemIdMap = inventoryItems.stream().collect(

				Collectors.groupingBy(x -> x.getFofoId(), Collectors.mapping(x -> x.getId(), Collectors.toList())));

		System.out.println("Fofo Id\tInvestment Maintained Days\tEligible payout");

		for (Map.Entry<Integer, List<Integer>> retailerEntry : retailerInventoryItemIdMap.entrySet()) {

			int fofoId = retailerEntry.getKey();

			List<SchemeInOut> schemeInouts = retailerEntry.getValue().stream().map(x -> inventoryItemIdSchemeMap.get(x))

					.flatMap(List::stream).collect(Collectors.toList());

			double totalAmount = schemeInouts.stream().filter(x -> x.getRolledBackTimestamp() == null)

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

			long investmentMaintainedDays = investmentMaintainedDaysMap.get(fofoId) == null ? 0

					: investmentMaintainedDaysMap.get(fofoId);

			if (investmentMaintainedDays < 8) {

				totalAmount = 0;

			} else if (investmentMaintainedDays < 12) {

				totalAmount = totalAmount / 2;

			}

			System.out.printf("%d\t%d\t%f%n", fofoId, investmentMaintainedDays, totalAmount);

			CustomRetailer customRetailer = retailerService.getFofoRetailer(fofoId);

			rows.add(Arrays.asList(fofoId, customRetailer.getBusinessName(), customRetailer.getCode(),

					investmentMaintainedDays, totalAmount));

		}

		org.apache.commons.io.output.ByteArrayOutputStream baos = FileUtil.getCSVByteStream(

				Arrays.asList("fofoId", "Name", "Code", "investmentMaintainedDays", "totalAmount"), rows);

		final HttpHeaders headers = new HttpHeaders();

		headers.set("Content-Type", "text/csv");

		headers.set("Content-disposition", "inline; filename=investmentMaintainedDays.csv");

		headers.setContentLength(baos.toByteArray().length);

		final InputStream inputStream = new ByteArrayInputStream(baos.toByteArray());

		final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

		return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);

	}

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

	public ResponseEntity<?> processInvestmentDryRun(HttpServletRequest request, Model model) throws Exception {

		LocalDate firstDateOfCurrentMonth = LocalDateTime.now().withDayOfMonth(1).toLocalDate();

		LocalDate startOfPreviousMonth = firstDateOfCurrentMonth.minusMonths(1);

		LocalDate lastOfPreviousMonth = firstDateOfCurrentMonth.minusDays(1);

		List<List<?>> rows = new ArrayList<>();

		Map<String, String> params = new HashMap<>();

		params.put("MANUAL_datesBetween_FROMDATE", firstDateOfCurrentMonth.toString());

		params.put("MANUAL_datesBetween_TODATE", firstDateOfCurrentMonth.plusDays(9).toString());

		params.put("type", "INVESTMENT");

		List<EvaluateSchemeInvestmentPayoutModel> evaluateSchemeInvestmentPayouts = reporticoService.getReports(

				EvaluateSchemeInvestmentPayoutModel.class, ReporticoProject.FOCO, "schemepayout.xml", params);

		LOGGER.info("reportResponse {}", evaluateSchemeInvestmentPayouts);

		int referenceId = Integer.parseInt(FormattingUtils.getYearMonth(startOfPreviousMonth.atStartOfDay()));

		List<PartnerDailyInvestment> partnerDailyInvestments = partnerDailyInvestmentRepository

				.selectAll(startOfPreviousMonth, lastOfPreviousMonth);

		Map<Integer, Long> investmentMaintainedDaysMap = partnerDailyInvestments.stream()

				.filter(x -> x.getShortPercentage() <= 10)

				.collect(Collectors.groupingBy(x -> x.getFofoId(), Collectors.counting()));

		for (EvaluateSchemeInvestmentPayoutModel esip : evaluateSchemeInvestmentPayouts) {

			long investmentMaintainedDays = investmentMaintainedDaysMap.get(esip.getFofoId()) == null ? 0

					: investmentMaintainedDaysMap.get(esip.getFofoId());

			esip.setInvestmentDays(investmentMaintainedDays);

			float processAmount = esip.getPaidAmount() / 2;

			esip.setProcessAmount(processAmount);

			rows.add(Arrays.asList(esip.getCode(), esip.getStoreName(), esip.getFofoId(), esip.getItemId(),

					esip.getBrand(), esip.getModelName(), esip.getModelNumber(), esip.getColor(), esip.getSchemeInDp(),

					esip.getSchemeOutDp(), esip.getSchemeId(), esip.getName(), esip.getType(), esip.getPartnerType(),

					esip.getAmountType(), esip.getAmount(), esip.getPurchaseInvoice(), esip.getSaleInovoice(),

					esip.getPaidAmount(), esip.getCreateTimestamp(), esip.getRolledBackTimestamp(),

					esip.getSerialNumber(), esip.getInRef(), esip.getOutRef(), esip.getBusinessDate(), esip.getStatus(),

					esip.getDescription(), esip.getProcessAmount(), esip.getInvestmentDays()));

		}

		org.apache.commons.io.output.ByteArrayOutputStream baos = FileUtil

				.getCSVByteStream(Arrays.asList("Code", "Store Name", "Fofo Id", "Item Id", "Brand", "Model Name",

						"Model Number", "Color", "Scheme In Dp", "Scheme Out Dp", "Scheme Id", "Name", "Type",

						"Partner Type", "Amount Type", "Amount", "Purchase Invoice", "Sale Inovoice", "Paid Amount",

						"Create Timestamp", "Rolled Back Timestamp", "Serial Number", "In Ref", "Out Ref",

						"Business Date", "Status", "Description", "Process Amount", "Investment Days"), rows);

		final HttpHeaders headers = new HttpHeaders();

		headers.set("Content-Type", "text/csv");

		headers.set("Content-disposition", "inline; filename=schemePayout.csv");

		headers.setContentLength(baos.toByteArray().length);

		final InputStream inputStream = new ByteArrayInputStream(baos.toByteArray());

		final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

		return new ResponseEntity<InputStreamResource>(inputStreamResource, headers, HttpStatus.OK);

	}

	@RequestMapping(value = "/schemes/update", method = RequestMethod.POST)

	public String updateShcemes(HttpServletRequest request, @RequestBody SchemeItems schemeItems, Model model)

			throws Exception {

		for (int schemeId : schemeItems.getSchemeIds()) {

			if (schemeRepository.selectById(schemeId) != null)

				for (int catalogId : schemeItems.getCatalogIds()) {

					if (tagListingRepository.selectByItemIdsAndTagIds(new HashSet<>(Arrays.asList(catalogId)),

							new HashSet<>(Arrays.asList(4, 7))).size() > 0) {

						SchemeItem si = new SchemeItem();

						si.setCatalogId(catalogId);

						si.setSchemeId(schemeId);

						si.setCreateTimestamp(LocalDateTime.now());

						try {

							schemeItemRepository.persist(si);

						} catch (Exception e) {

							LOGGER.info("Scheme aleady exist");

						}

						model.addAttribute("response", mvcResponseSender.createResponseString(true));

					} else {

						model.addAttribute("response", mvcResponseSender.createResponseString(false));

						throw new ProfitMandiBusinessException("Catalog Id ", catalogId, "Invalid Catalog Id");

					}

				}

		}

		return "response";

	}

	@RequestMapping(value = "/addItemToScheme", method = RequestMethod.POST)

	public String updateScheme(HttpServletRequest request, @RequestBody SchemeItems schemeItems, Model model)

			throws Exception {

		for (int schemeId : schemeItems.getSchemeIds()) {

			List<Integer> catalogIds = schemeItemRepository.selectCatalogIdsBySchemeId(schemeId);

			if (schemeRepository.selectById(schemeId) != null)

				for (int catalogId : schemeItems.getCatalogIds()) {

					if (!(catalogIds.contains(catalogId))) {

						SchemeItem si = new SchemeItem();

						si.setCatalogId(catalogId);

						si.setSchemeId(schemeId);

						si.setCreateTimestamp(LocalDateTime.now());

						try {

							schemeItemRepository.persist(si);

						} catch (Exception e) {

							LOGGER.info("Scheme already exist");

						}

						model.addAttribute("response", mvcResponseSender.createResponseString(true));

					} else {

						throw new ProfitMandiBusinessException("Catalog exist for scheme", "SchemeId= " + schemeId + ", CatalogId= " + catalogId, "Catalog exist for scheme");

					}

				}

		}

		return "response";

	}

	@RequestMapping(value = "/schemes/delete", method = RequestMethod.DELETE)

	public String deleteShcemes(HttpServletRequest request,

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

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

			throws Exception {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		if (schemeId > 0 && catalogId > 0) {

			schemeItemRepository.deleteByCatalogIdsAndSchemeIds(catalogId, schemeId);

			model.addAttribute("response", mvcResponseSender.createResponseString(true));

			model.addAttribute("roleType", roleManager.isAdmin(loginDetails.getRoleIds()));

		}

		return "response";

	}

	@RequestMapping(value = "/extendAllSchemes", method = RequestMethod.POST)

	public String extendAllScheme(HttpServletRequest request, @RequestBody LocalDateTime extendDatetime, Model model)

			throws Exception {

		extendDatetime = LocalDateTime.of(extendDatetime.toLocalDate(), Utils.MAX_TIME);

		List<Scheme> schemes = schemeRepository.selectActiveAll();

		if (schemes.size() > 0) {

			for (Scheme scheme : schemes) {

				if (scheme.getExpireTimestamp() == null) {

					scheme.setEndDateTime(extendDatetime);

					schemeRepository.persist(scheme);

				}

			}

			model.addAttribute("response", mvcResponseSender.createResponseString(true));

			return "response";

		}

		model.addAttribute("response", mvcResponseSender.createResponseString(false));

		return "response";

	}

	@RequestMapping(value = "/extendSchemeById", method = RequestMethod.POST)

	public String extendSchemeById(HttpServletRequest request,

								   @RequestParam(name = ProfitMandiConstants.SCHEME_ID) int schemeId,

								   @RequestBody LocalDateTime extendDatetime, Model model) throws Exception {

		extendDatetime = LocalDateTime.of(extendDatetime.toLocalDate(), Utils.MAX_TIME);

		Scheme scheme = schemeRepository.selectById(schemeId);

		if ((!(scheme.getActiveTimestamp() == null)) && scheme.getExpireTimestamp() == null) {

			scheme.setEndDateTime(extendDatetime);

			schemeRepository.persist(scheme);

			model.addAttribute("response", mvcResponseSender.createResponseString(true));

			return "response";

		}

		model.addAttribute("response", mvcResponseSender.createResponseString(false));

		return "response";

	}

	@RequestMapping(value = "/createScheme", method = RequestMethod.POST)

	public String createScheme(HttpServletRequest request, @RequestBody CreateSchemeRequest createSchemeRequest, Model model)

			throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		LOGGER.info("CreateSchemeRequest {}", createSchemeRequest);

		schemeService.saveScheme(loginDetails.getFofoId(), createSchemeRequest);

		return getDefaultSchemes(request, model);

	}

	private String getDefaultSchemes(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {

		return getSchemes(request, 0, null, 30, 0, 0, PartnerType.ALL, "", model);

	}

	private List<Scheme> setSchemeAmountModel(List<Scheme> schemes) {

		for (Scheme scheme : schemes) {

			if (scheme.getAmountType().equals(AmountType.PERCENTAGE)) {

				scheme.setAmountModel(scheme.getAmount() + "%");

			} else {

				scheme.setAmountModel(scheme.getAmount() + "");

			}

		}

		return schemes;

	}

	//Show 20 recents

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

	public String getSchemes(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset,

							 @RequestParam(required = false) LocalDate date,

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

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

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

							 @RequestParam(name = "partnerType", required = false, defaultValue = "ALL") PartnerType partnerType,

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

			throws ProfitMandiBusinessException {

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

		if (date != null) {

			date = date.isAfter(LocalDate.now()) ? LocalDate.now() : date;

		}

		List<Scheme> schemes = null;

		List<SchemeInOut> schemeInOut = null;

		boolean fullAccess = this.getAccess(loginDetails.getEmailId());

		model.addAttribute("fullAccess", fullAccess);

		model.addAttribute("searchImei", searchImei);

		model.addAttribute("isAdmin", isAdmin);

		model.addAttribute("searchModel", searchModel);

		model.addAttribute("searchScheme", searchScheme);

		model.addAttribute("partnerType", partnerType);

		model.addAttribute("date", date);

		final LocalDate date1 = date;

		if (searchScheme > 0) {

			schemes = Arrays.asList(schemeRepository.selectById(searchScheme));

			this.setSchemeAmountModel(schemes);

			if (schemes.size() > 0) {

				model.addAttribute("schemes", schemes);

				return "schemes";

			} else {

				throw new ProfitMandiBusinessException("SchemeId", searchScheme, "SchemeId Not Found");

			}

		} else if (searchModel > 0) {

			TagListing tagListing = null;

			Item item = itemRepository.selectAllByCatalogItemId(searchModel).get(0);

			tagListing = tagListingRepository.selectByItemId(item.getId());

			model.addAttribute("modelName", item.getItemDescriptionNoColor());

			if (tagListing != null) {

				model.addAttribute("dp", tagListing.getSellingPrice());

				model.addAttribute("mop", tagListing.getMop());

			}

			schemes = schemeService.selectSchemeByPartnerType(partnerType, date, searchModel, isAdmin, offset, limit)

					.stream().filter(x -> {

						return (x.getId() != 411 && x.getId() != 612) || date1.isBefore(LocalDate.of(2021, 12, 1));

					}).collect(Collectors.toList());

			// Remove 411 and 612

			model.addAttribute("schemes", schemes);

			// For 7720(HR) remove investment

			int nlc = this.getNlc(item, loginDetails.getFofoId(), schemes, tagListing, searchModel);

			model.addAttribute("nlc", Math.round(nlc));

			return "schemes";

		} else if (org.apache.commons.lang3.StringUtils.isNotEmpty(searchImei)) {

			LOGGER.info("searchImei" + searchImei);

			InventoryItem inventoryItem = inventoryItemRepository.selectBySerialNumber(searchImei);

			Item item = itemRepository.selectById(inventoryItem.getItemId());

			Map<Integer, Scheme> schemeMap = new HashMap<>();

			if (inventoryItem != null) {

				LOGGER.info("inventoryItem" + inventoryItem);

				schemeInOut = schemeInOutRepository

						.selectByInventoryItemIds(new HashSet<>(Arrays.asList(inventoryItem.getId())));

				LOGGER.info("schemeInOut" + schemeInOut);

				if (!schemeInOut.isEmpty()) {

					List<Integer> schemeIds = schemeInOut.stream().map(x -> x.getSchemeId())

							.collect(Collectors.toList());

					schemes = schemeRepository.selectBySchemeIds(schemeIds);

					for (Scheme scheme : schemes) {

						if (scheme.getAmountType().equals(AmountType.PERCENTAGE)) {

							scheme.setAmountModel(scheme.getAmount() + "%");

						} else {

							scheme.setAmountModel(scheme.getAmount() + "");

						}

					}

					schemeMap = schemes.stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

				}

			}

			model.addAttribute("schemeMap", schemeMap);

			model.addAttribute("item", item);

			model.addAttribute("schemeInOut", schemeInOut);

			return "schemes-partner";

		}

		if (isAdmin) {

			schemes = schemeRepository.selectAll(0, 30);

			this.setSchemeAmountModel(schemes);

			model.addAttribute("schemes", schemes);

			return "schemes";

		} else {

			List<CreateOfferRequest> offers = null;

			Map<Integer, Map<Integer, Long>> offerSlabPayoutMap = new HashMap<>();

			List<PriceDropIMEI> priceDropImeis = new ArrayList<>();

			if (searchModel > 0) {

				offers = offerService.getPublishedOffers(date, loginDetails.getFofoId(), searchModel);

				for (CreateOfferRequest createOfferRequest : offers) {

					Map<Integer, Map<Integer, Long>> itemSlabPayoutMap = offerService

							.getSlabPayoutMap(createOfferRequest);

					Map<Integer, Long> slabPayoutMap = itemSlabPayoutMap.get(searchModel);

					offerSlabPayoutMap.put(createOfferRequest.getId(), slabPayoutMap);

				}

			} else {

				offers = new ArrayList<>();

			}

			if (org.apache.commons.lang3.StringUtils.isNotEmpty(searchImei)) {

				InventoryItem inventoryItem = inventoryItemRepository.selectBySerialNumberFofoId(searchImei,

						loginDetails.getFofoId());

				priceDropImeis = priceDropIMEIRepository.selectByFofoIdImei(loginDetails.getFofoId(), searchImei);

				for (PriceDropIMEI priceDropIMEI : priceDropImeis) {

					int priceDropId = priceDropIMEI.getPriceDropId();

					PriceDrop pd = priceDropRepository.selectById(priceDropId);

					priceDropIMEI.setPriceDrop(pd);

				}

			}

			FofoStore fs = fofoStoreRepository.selectByRetailerId(loginDetails.getFofoId());

			model.addAttribute("offers", offers);

			model.addAttribute("offerSlabPayoutMap", offerSlabPayoutMap);

			model.addAttribute("searchModel", searchModel);

			model.addAttribute("searchScheme", searchScheme);

			model.addAttribute("searchImei", searchImei);

			model.addAttribute("partnerCode", fs.getCode());

			model.addAttribute("fofoId", fs.getId());

			model.addAttribute("priceDropImeis", priceDropImeis);

			return "schemes-partner";

		}

	}

	private int getNlc(Item item, int fofoId, List<Scheme> schemes, TagListing tagListing, int itemId)

			throws ProfitMandiBusinessException {

		if (item.getBrand().equals("Vivo") && fofoStoreRepository.getWarehousePartnerMap().get(7720).stream()

				.filter(x -> x.getId() == fofoId).count() > 0) {

			schemes = schemes.stream().filter(x -> !x.getType().equals(SchemeType.INVESTMENT))

					.collect(Collectors.toList());

		}

		float nlc = tagListing.getSellingPrice();

		for (Scheme scheme : schemes) {

			if (scheme.getAmountType().equals(AmountType.PERCENTAGE)) {

				if (tagListing != null) {

					float taxRate = stateGstRateRepository.getIgstTaxRate(Arrays.asList(itemId)).get(itemId);

					float taxableSellingPrice = tagListing.getSellingPrice() / (1 + taxRate / 100);

					float amount = taxableSellingPrice * scheme.getAmount() / 100;

					scheme.setAmountModel(FormattingUtils.formatDecimal(amount) + " (" + scheme.getAmount() + "%)");

					nlc -= amount;

				} else {

					scheme.setAmountModel(scheme.getAmount() + "%");

				}

			} else {

				scheme.setAmountModel(scheme.getAmount() + "");

				nlc -= scheme.getAmount();

			}

		}

		return Math.round(nlc);

	}

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