Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import com.google.gson.Gson;

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

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

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.services.ReporticoService;

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.web.util.ResponseSender;

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

import com.spice.profitmandi.dao.entity.cs.Region;

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.cs.RegionRepository;

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.dao.repository.transaction.TransactionRepository;

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.offers.PartnerCriteria;

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.commons.lang.StringUtils;

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 {

	// LED TV

	private static final List<Integer> categoryIds = Arrays.asList(ProfitMandiConstants.MOBILE_CATEGORY_ID,

			ProfitMandiConstants.TABLET_CATEGORY_ID, 14202);

	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 OfferPayoutRepository offerPayoutRepository;

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

	@Autowired

	private CategoryRepository categoryRepository;

	@Autowired

	private Gson gson;

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

			"amit.gupta@smartdukaan.com", "tejbeer.kaur@smartdukaan.com", "raksha.vyas@smartdukaan.com");

	@Autowired

	SchemeRegionRepository schemeRegionRepository;

	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;

	}

	@Autowired

	RegionRepository regionRepository;

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

	public String getTagListingItemsByBrand(HttpServletRequest request, @RequestParam int categoryId, Model model)

			throws Exception {

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

		model.addAttribute("brands", brands);

		model.addAttribute("categoryId", categoryId);

		return "tag-listing-brands";

	}

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

	}

	@Autowired

	TransactionRepository transactionRepository;

	@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.getStatus().equals(SchemePayoutStatus.PENDING) && x.getRolledBackTimestamp() == null)

					.collect(Collectors.toList());

			float totalAmount = 0;

			LocalDateTime firstBillingDate = transactionRepository.getFirstBillingDate(fofoId);

			boolean sameYearMonth = firstBillingDate.getMonth() == startOfPreviousMonth.getMonth()

					&& firstBillingDate.getYear() == startOfPreviousMonth.getYear();

			for (SchemeInOut sio : schemeInouts) {

				if (sameYearMonth) {

					sio.setStatusDescription("Investment payout fully disbursed for first month");

					sio.setStatus(SchemePayoutStatus.CREDITED);

					sio.setCreditTimestamp(LocalDateTime.now());

					totalAmount += sio.getAmount();

				} else {

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

			}

			// Its ok to process Margins Pending for activation

			schemeService.processActivation();

			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", startOfPreviousMonth.toString());

		params.put("MANUAL_datesBetween_TODATE", lastOfPreviousMonth.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, 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.selectAllByCatalogIds(Arrays.asList(catalogId)).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("response1", mvcResponseSender.createResponseString(true));

					} else {

						model.addAttribute("response1", 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("response1", mvcResponseSender.createResponseString(true));

					} else {

						throw new ProfitMandiBusinessException("Catalog exist for scheme",

								"SchemeId= " + schemeId + ", CatalogId= " + catalogId, "Catalog exist for scheme");

					}

				}

		}

		return "response";

	}

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

		// List<Category> categories = inventoryService.getAllCategories();

		List<Category> categories = categoryRepository.selectByIds(categoryIds);

		categories = categories.stream().sorted(Comparator.comparing(Category::getId)).collect(Collectors.toList());

		// Set<String> brands =

		// inventoryService.getAllTagListingBrands(ProfitMandiConstants.MOBILE_CATEGORY_ID);

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

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

		List<Region> regionList = regionRepository.selectAll();

		model.addAttribute("fullAccesss", fullAccesss);

		model.addAttribute("regionList", regionList);

		model.addAttribute("categories", categories);

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

		return "create-scheme";

	}

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

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

			throws Exception {

		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("response1", mvcResponseSender.createResponseString(true));

			return "response";

		}

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

		return "response";

	}

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

	public String getTagListingItemsByBrand(HttpServletRequest request, @RequestParam int categoryId,

											@RequestParam List<String> brands, Model model) throws Exception {

		Map<Integer, String> catalogIdItemDescriptionMap = inventoryService.getModelDescriptionMap(categoryId, brands);

		model.addAttribute("catalogIdItemDescriptionMap", catalogIdItemDescriptionMap);

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

		return "tag-listing-items-description";

	}

	@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 = "/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("response1", mvcResponseSender.createResponseString(true));

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

		}

		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 {

		Scheme scheme = schemeRepository.selectById(schemeId);

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

			scheme.setEndDateTime(extendDatetime);

			schemeRepository.persist(scheme);

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

			return "response";

		}

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

		return "response";

	}

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

		} else if (!isAdmin) {

			date = LocalDate.now();

		}

		List<Scheme> schemes = null;

		List<SchemeInOut> schemeInOuts = 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);

				List<SchemeRegion> schemeRegionList = schemeRegionRepository.selectAllBySchemeIds(schemes.stream().map(x -> x.getId()).collect(Collectors.toList()));

				Map<Integer, String> schemeRegionMap = schemeRegionList.stream().collect(Collectors.groupingBy(x -> x.getSchemeId(), Collectors.mapping(y -> regionRepository.selectById(y.getRegionId()).getName(), Collectors.joining(","))));

				model.addAttribute("schemeRegionMap", schemeRegionMap);

				return "schemes";

			} else {

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

			}

		} else if (searchModel > 0) {

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

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

			if (tagListing != null) {

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

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

			}

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

			if (isAdmin) {

				schemes = schemeService

						.selectSchemeByPartnerType(partnerType, date, searchModel, isAdmin, offset, limit).stream()

						.filter(x -> x.getId() != 411 && x.getId() != 612).collect(Collectors.toList());

				this.setSchemeAmountModel(schemes);

				model.addAttribute("schemes", schemes);

				List<SchemeRegion> schemeRegionList = schemeRegionRepository.selectAllBySchemeIds(schemes.stream().map(x -> x.getId()).collect(Collectors.toList()));

				Map<Integer, String> schemeRegionMap = schemeRegionList.stream().collect(Collectors.groupingBy(x -> x.getSchemeId(), Collectors.mapping(y -> regionRepository.selectById(y.getRegionId()).getName(), Collectors.joining(","))));

				model.addAttribute("schemeRegionMap", schemeRegionMap);

				return "schemes";

			} else {

				partnerType = partnerTypeChangeService.getTypeOnDate(loginDetails.getFofoId(), date);

				schemes = schemeService

						.selectSchemeByPartnerTypeFofoId(partnerType, date, searchModel, loginDetails.getFofoId(), 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

				// this.setSchemeAmountModel(schemes);

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

				// For 7720(HR) remove investment

				model.addAttribute("schemes", schemes);

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

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

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

						searchModel);

				if (offers.size() > 0) {

					for (CreateOfferRequest createOfferRequest : offers) {

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

								.getSlabPayoutMap(createOfferRequest);

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

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

					}

					model.addAttribute("offers", offers);

					model.addAttribute("offerSlabPayoutMap", offerSlabPayoutMap);

					LOGGER.info("offer");

				}

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

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

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

				return "schemes-partner";

			}

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

			LOGGER.info("searchImei" + searchImei);

			InventoryItem inventoryItem = inventoryItemRepository.selectBySerialNumberFofoId(searchImei,

					loginDetails.getFofoId());

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

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

			double netEarnings = 0;

			if (inventoryItem != null) {

				// Offer payout

				List<OfferPayout> offerPayouts = offerPayoutRepository.selectAllBySerialNumber(loginDetails.getFofoId(),

						searchImei);

				Map<Integer, CreateOfferRequest> offerRequestMap = offerPayouts.stream()

						.map(x -> offerService.getOffer(loginDetails.getFofoId(), (int) x.getOfferId()))

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

				schemeInOuts = schemeInOutRepository

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

				if (!schemeInOuts.isEmpty()) {

					netEarnings += schemeInOuts.stream().filter(x -> x.getStatus().equals(SchemePayoutStatus.CREDITED))

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

					List<Integer> schemeIds = schemeInOuts.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));

				}

				List<PriceDropIMEI> priceDropImeis = priceDropIMEIRepository

						.selectByFofoIdImei(loginDetails.getFofoId(), searchImei);

				if (priceDropImeis.size() > 0) {

					for (PriceDropIMEI priceDropIMEI : priceDropImeis) {

						int priceDropId = priceDropIMEI.getPriceDropId();

						PriceDrop pd = priceDropRepository.selectById(priceDropId);

						priceDropIMEI.setPriceDrop(pd);

					}

					model.addAttribute("priceDropImeis", priceDropImeis);

				}

				netEarnings += offerPayouts.stream().collect(Collectors.summingDouble(x -> x.getAmount()));

				model.addAttribute("offerPayouts", offerPayouts);

				model.addAttribute("offerRequestMap", offerRequestMap);

				model.addAttribute("inventoryItem", inventoryItem);

				model.addAttribute("inventoryItem", inventoryItem);

			}

			model.addAttribute("netEarnings", netEarnings);

			model.addAttribute("fofoId", loginDetails.getFofoId());

			model.addAttribute("schemeMap", schemeMap);

			model.addAttribute("item", item);

			model.addAttribute("schemeInOut", schemeInOuts);

			return "schemes-partner";

		}

		if (isAdmin) {

			schemes = schemeRepository.selectAll(0, 100);

			this.setSchemeAmountModel(schemes);

			List<SchemeRegion> schemeRegionList = schemeRegionRepository.selectAllBySchemeIds(schemes.stream().map(x -> x.getId()).collect(Collectors.toList()));

			Map<Integer, String> schemeRegionMap = schemeRegionList.stream().collect(Collectors.groupingBy(x -> x.getSchemeId(), Collectors.mapping(y -> regionRepository.selectById(y.getRegionId()).getName(), Collectors.joining(","))));

			model.addAttribute("schemes", schemes);

			model.addAttribute("schemeRegionMap", schemeRegionMap);

			return "schemes";

		} else {

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

				InventoryItem inventoryItem = inventoryItemRepository.selectBySerialNumberFofoId(searchImei,

						loginDetails.getFofoId());

				List<PriceDropIMEI> priceDropImeis = priceDropIMEIRepository

						.selectByFofoIdImei(loginDetails.getFofoId(), searchImei);

				if (priceDropImeis.size() > 0) {

					for (PriceDropIMEI priceDropIMEI : priceDropImeis) {

						int priceDropId = priceDropIMEI.getPriceDropId();

						PriceDrop pd = priceDropRepository.selectById(priceDropId);

						priceDropIMEI.setPriceDrop(pd);

					}

					model.addAttribute("priceDropImeis", priceDropImeis);

				}

			}

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

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

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

			return "schemes-partner";

		}

	}

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

		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 amount = tagListing.getSellingPrice() * 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);

		Map<String, LastMonthCreditedIncomeModel> lastMonthPendingIncomeMap = schemeInOutRepository

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

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

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

		keySet.addAll(lastMonthPendingIncomeMap.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);

		});

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

		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 lastMonthEnd = lastMonthStart.plusMonths(1);