Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.time.Instant;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.util.AbstractMap;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Date;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.stream.Collectors;

import javax.servlet.http.HttpServletRequest;

import javax.transaction.Transactional;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.json.JSONObject;

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

import org.springframework.beans.factory.annotation.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.GetMapping;

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

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 com.spice.profitmandi.common.enumuration.ContentType;

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

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

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

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

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

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

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

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

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

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

import com.spice.profitmandi.dao.entity.dtr.BrandLimit;

import com.spice.profitmandi.dao.entity.dtr.Document;

import com.spice.profitmandi.dao.entity.dtr.Retailer;

import com.spice.profitmandi.dao.entity.dtr.RetailerBlockBrands;

import com.spice.profitmandi.dao.entity.dtr.RetailerBrandsLimit;

import com.spice.profitmandi.dao.entity.dtr.Shop;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import com.spice.profitmandi.dao.repository.user.LocationRepository;

import com.spice.profitmandi.dao.repository.user.PromoterRepository;

import com.spice.profitmandi.dao.repository.user.UserRepository;

import com.spice.profitmandi.service.PartnerInvestmentService;

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

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

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

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

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

@Controller

@Transactional(rollbackOn = Throwable.class)

public class RetailerController {

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

	@Autowired

	private RetailerService retailerService;

	@Autowired

	private RetailerRepository retailerRepository;  

	@Autowired

	private PincodePartnerRepository PincodePartnerRepository;

	@Autowired

	private BrandLimitRepository brandLimitRepository;

	@Autowired

	private RetailerBrandsLimitService retailerBrandsLimitService;

	@Autowired

	private RetailerBrandsLimitRepository retailerBrandsLimitRepository;

	@Autowired

	private ShopRepository shopRepository;

	@Autowired

	private RetailerBlockBrandsRepository retailerBlockBrandsRepository;

	@Autowired

	private FofoStoreRepository fofoStoreRepository;

	@Autowired

	private DocumentRepository documentRepository;

	@Autowired

	private CookiesProcessor cookiesProcessor;

	@Autowired

	@Qualifier("userUserRepository")

	private UserRepository userRepository;

	@Autowired

	private AuthRepository authRepository;

	@Autowired

	private CsService csService;

	@Autowired

	private LocationRepository locationRepository;

	@Autowired

	private ResponseSender<?> responseSender;

	@Autowired

	private MVCResponseSender mvcResponseSender;

	@Autowired

	private InventoryService inventoryService;

	@Autowired

	private PromoterRepository promoterRepository;

	@Autowired

	private PartnerInvestmentService partnerInvestmentService;

	@Autowired

	private Mongo mongoClient;

	@Autowired

	private PartnerTypeChangeService partnerTypeChangeService;

	@Autowired

	private PartnerTypeChangeRepository partnerTypeChangeRepository;

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

	public String retailerInfoByEmailIdOrMobileNumber(HttpServletRequest request,

			@RequestParam(name = ProfitMandiConstants.EMAIL_ID_OR_MOBILE_NUMBER) String emailIdOrMobileNumber,

			Model model) throws ProfitMandiBusinessException {

		LOGGER.info("Request Received at url {} with emailIdOrMobileNumber {}", request.getRequestURI(),

				emailIdOrMobileNumber);

		Map<String, Object> map = retailerService.getByEmailIdOrMobileNumber(emailIdOrMobileNumber);

		model.addAllAttributes(map);

		model.addAttribute("counterSizes", CounterSize.values());

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

		LOGGER.info("warehouseMap", warehouseMap);

		model.addAttribute("warehouses", warehouseMap);

		if (map.containsKey("retailer")) {

			Retailer retailer = (Retailer) map.get("retailer");

			User user = userRepository.selectById(retailer.getId());

			if (user.getLocation() != null) {

				Location location = locationRepository.selectById(user.getLocation());

				model.addAttribute("locationdetail", location);

				LOGGER.info("location" + location);

			}

		}

		return "retailer-details";

	}

	@RequestMapping(value = "/retailerDetails", method = RequestMethod.PUT)

	public String updateRetailerDetails(HttpServletRequest request,

			@RequestBody UpdateRetailerRequest updateRetailerRequest, Model model) throws ProfitMandiBusinessException {

		LOGGER.info("Request Received at url {} with body {}", request.getRequestURI(), updateRetailerRequest);

		Map<String, Object> map = retailerService.updateRetailerDetails(updateRetailerRequest);

		model.addAllAttributes(map);

		model.addAttribute("counterSizes", CounterSize.values());

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

		LOGGER.info("warehouseMap", warehouseMap);

		model.addAttribute("warehouses", warehouseMap);

		return "retailer-details";

	}

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

	public String retailerInfo(HttpServletRequest request) throws Exception {

		return "retailer-info";

	}

	@RequestMapping(value = "/district/all/stateName", method = RequestMethod.GET)

	public ResponseEntity<?> getAllDistrict(@RequestParam(name = "stateName") String stateName) {

		return responseSender.ok(retailerService.getAllDistrictMaster(stateName));

	}

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

	public ResponseEntity<?> retailerDocumentById(HttpServletRequest request,

			@RequestParam(name = ProfitMandiConstants.DOCUMENT_ID) int documentId,

			@RequestParam(name = ProfitMandiConstants.RETAILER_ID) int retailerId) throws ProfitMandiBusinessException {

		Document document = documentRepository.selectById(documentId);

		Retailer retailer = retailerRepository.selectById(retailerId);

		if (retailer.getDocumentId() == null) {

			throw new ProfitMandiBusinessException(ProfitMandiConstants.RETAILER_ID, retailer.getId(), "RTLR_1012");

		}

		if (retailer.getDocumentId() != documentId) {

			throw new ProfitMandiBusinessException(ProfitMandiConstants.DOCUMENT_ID, documentId, "RTLR_1014");

		}

		return responseSender.ok(document);

	}

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

	public ResponseEntity<?> downloadRetailerDocument(HttpServletRequest request,

			@RequestParam(name = ProfitMandiConstants.RETAILER_ID) int retailerId, Model model)

			throws ProfitMandiBusinessException {

		Retailer retailer = retailerRepository.selectById(retailerId);

		if (retailer.getDocumentId() == null) {

			throw new ProfitMandiBusinessException(ProfitMandiConstants.RETAILER_ID, retailer.getId(), "RTLR_1012");

		}

		Document document = documentRepository.selectById(retailer.getDocumentId());

		FileInputStream file = null;

		try {

			file = new FileInputStream(document.getPath() + File.separator + document.getName());

		} catch (FileNotFoundException e) {

			LOGGER.error("Retailer Document file not found : ", e);

			throw new ProfitMandiBusinessException(ProfitMandiConstants.DOCUMENT_ID, document.getId(), "RTLR_1013");

		}

		// ByteArrayOutputStream byteArrayOutputStream = new

		// ByteArrayOutputStream();

		// ExcelUtils.writeSchemeModels(schemeModels, byteArrayOutputStream);

		final HttpHeaders headers = new HttpHeaders();

		String contentType = "";

		if (document.getContentType() == ContentType.JPEG) {

			contentType = "image/jpeg";

		} else if (document.getContentType() == ContentType.PNG) {

			contentType = "image/png";

		} else if (document.getContentType() == ContentType.PDF) {

			contentType = "application/pdf";

		}

		headers.set("Content-Type", contentType);

		headers.set("Content-disposition", "inline; filename=" + document.getName());

		headers.setContentLength(document.getSize());

		final InputStreamResource inputStreamResource = new InputStreamResource(file);

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

		// return

		// responseSender.ok(ResponseCodeHolder.getMessage("ITM_AGNG_OK_1000"));

	}

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

	public ResponseEntity<?> retailerShopDocumentById(HttpServletRequest request,

			@RequestParam(name = ProfitMandiConstants.SHOP_ID) int shopId,

			@RequestParam(name = ProfitMandiConstants.RETAILER_ID) int retailerId) throws ProfitMandiBusinessException {

		Shop shop = shopRepository.selectById(shopId);

		if (shop.getRetailerId() != retailerId) {

			throw new ProfitMandiBusinessException(ProfitMandiConstants.SHOP_ID, shop.getId(), "SHP_1004");

		}

		if (shop.getDocumentId() == null) {

			throw new ProfitMandiBusinessException(ProfitMandiConstants.RETAILER_ID, shop.getId(), "SHP_1005");

		}

		Document document = documentRepository.selectById(shop.getDocumentId());

		return responseSender.ok(document);

	}

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

	public ResponseEntity<?> downloadRetailerShopDocument(HttpServletRequest request,

			@RequestParam(name = ProfitMandiConstants.SHOP_ID) int shopId,

			@RequestParam(name = ProfitMandiConstants.RETAILER_ID) int retailerId, Model model)

			throws ProfitMandiBusinessException {

		Shop shop = shopRepository.selectById(shopId);

		if (shop.getRetailerId() != retailerId) {

			throw new ProfitMandiBusinessException(ProfitMandiConstants.SHOP_ID, shop.getId(), "SHP_1004");

		}

		if (shop.getDocumentId() == null) {

			throw new ProfitMandiBusinessException(ProfitMandiConstants.RETAILER_ID, shop.getId(), "SHP_1005");

		}

		Document document = documentRepository.selectById(shop.getDocumentId());

		FileInputStream file = null;

		try {

			file = new FileInputStream(document.getPath() + File.separator + document.getName());

		} catch (FileNotFoundException e) {

			LOGGER.error("Retailer Document file not found : ", e);

			throw new ProfitMandiBusinessException(ProfitMandiConstants.DOCUMENT_ID, document.getId(), "RTLR_1013");

		}

		// ByteArrayOutputStream byteArrayOutputStream = new

		// ByteArrayOutputStream();

		// ExcelUtils.writeSchemeModels(schemeModels, byteArrayOutputStream);

		final HttpHeaders headers = new HttpHeaders();

		String contentType = "";

		if (document.getContentType() == ContentType.JPEG) {

			contentType = "image/jpeg";

		} else if (document.getContentType() == ContentType.PNG) {

			contentType = "image/png";

		} else if (document.getContentType() == ContentType.PDF) {

			contentType = "application/pdf";

		}

		headers.set("Content-Type", contentType);

		headers.set("Content-disposition", "inline; filename=" + document.getName());

		headers.setContentLength(document.getSize());

		final InputStreamResource inputStreamResource = new InputStreamResource(file);

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

		// return

		// responseSender.ok(ResponseCodeHolder.getMessage("ITM_AGNG_OK_1000"));

	}

	@GetMapping(value = "/getAllStores")

	public String getAllStores(HttpServletRequest request, Model model) {

		List<FofoStore> fofoStores = fofoStoreRepository.selectAll().stream().filter(x -> x.isActive())

				.collect(Collectors.toList());

		Map<Integer, Boolean> investments = new HashMap<>();

		for (FofoStore fofoStore : fofoStores) {

			boolean isOk = false;

			if (fofoStore.getGraceDate() != null && fofoStore.getGraceDate().isAfter(LocalDate.now())) {

				isOk = true;

			} else {

				try {

					isOk = partnerInvestmentService.isInvestmentOk(fofoStore.getId(), 10,

							ProfitMandiConstants.CUTOFF_INVESTMENT);

					if (fofoStore.getGraceCount() > 0) {

						fofoStore.setGraceDate(null);

						fofoStore.setGraceCount(0);

						fofoStoreRepository.persist(fofoStore);

					}

				} catch (ProfitMandiBusinessException e) {

				}

			}

			investments.put(fofoStore.getId(), isOk);

		}

		Map<Integer, CustomRetailer> customRetailers = retailerService.getFofoRetailers(false);

		model.addAttribute("fofoStores", fofoStores);

		model.addAttribute("investments", investments);

		model.addAttribute("customRetailers", customRetailers);

		return "store";

	}

	@GetMapping(value = "/getPartnerCategory")

	public String getPartnerCategory(HttpServletRequest request, @RequestParam int fofoId, Model model) {

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

		List<PartnerType> partnerTypes = partnerType.nextPartnerTypes();

		LOGGER.info("partnerType" + partnerTypes);

		model.addAttribute("partnerTypes", partnerTypes);

		model.addAttribute("fofoId", fofoId);

		return "partner-category";

	}

	@PostMapping(value = "/updatePartnerCategory")

	public String updatePartnerCategory(HttpServletRequest request, @RequestParam(name = "fofoId") int fofoId,

			@RequestParam(name = "partnerType") PartnerType partnerType, Model model) throws Exception {

		PartnerTypeChange ptc = new PartnerTypeChange();

		ptc.setFofoId(fofoId);

		ptc.setPartnerType(partnerType);

		ptc.setCreateTimestamp(LocalDate.now().atStartOfDay().plusDays(1));

		partnerTypeChangeRepository.persist(ptc);

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

		return "response";

	}

	@GetMapping(value = "/partners")

	public String getStoreName(HttpServletRequest request, Model model, @RequestParam String query) throws Exception {

		model.addAttribute("response", mvcResponseSender

				.createResponseString(retailerService.getFofoRetailers(false).values().stream().filter(x -> {

					return x.getDisplayName().toLowerCase().matches(".*?" + query.toLowerCase() + ".*?");

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

		return "response";

	}

	@PostMapping(value = "/deactivateStore")

	public String deActivateStore(HttpServletRequest request,

			@RequestParam(name = ProfitMandiConstants.FOFO_ID) int fofoId, Model model) throws Exception {

		FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(fofoId);

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		if (!Arrays.asList("kamini.sharma@smartdukaan.com", "tarun.verma@smartdukaan.com", "amit.gupta@smartdukaan.com")

				.contains(loginDetails.getEmailId())) {

			throw new ProfitMandiBusinessException("Access Denied", "Unauthorised Access",

					"You are not authorise to deactivate retailer");

		}

		fofoStore.setActive(false);

		fofoStoreRepository.persist(fofoStore);

		LOGGER.info("inserted into InActiveFofoStore successfully");

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

		return "response";

	}

	@PostMapping(value = "/activateStoreForever")

	public String activateStoreForever(HttpServletRequest request,

			@RequestParam(name = ProfitMandiConstants.FOFO_ID) int fofoId, Model model) throws Exception {

		FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(fofoId);

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		if (!Arrays.asList("kamini.sharma@smartdukaan.com", "tarun.verma@smartdukaan.com", "amit.gupta@smartdukaan.com","manish.tiwari@smartdukaan.com")

				.contains(loginDetails.getEmailId())) {

			throw new ProfitMandiBusinessException("Access Denied", "Unauthorised Access",

					"You are not authorise to activate retailer");

		}

		fofoStore.setActive(true);

		fofoStoreRepository.persist(fofoStore);

		LOGGER.info("inserted into ActiveFofoStore successfully");

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

		return "response";

	}

	@PostMapping(value = "/activateStoreTemporary")

	public String activateStoreTemporary(HttpServletRequest request,

			@RequestParam(name = ProfitMandiConstants.FOFO_ID) int fofoId,

			@RequestParam(name = "days", required = true ) int days,Model model) throws Exception {

		FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(fofoId);

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		if (!Arrays.asList("kamini.sharma@smartdukaan.com", "tarun.verma@smartdukaan.com", "amit.gupta@smartdukaan.com","manish.tiwari@smartdukaan.com")

				.contains(loginDetails.getEmailId())) {

			throw new ProfitMandiBusinessException("Access Denied", "Unauthorised Access",

					"You are not authorise to deactivate retailer");

		}

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

		LocalDateTime EndDate = currentDate.plusDays(days);

		fofoStore.setActiveTimeStamp(EndDate);

		LOGGER.info("EndDate"+EndDate);

		LOGGER.info("getActiveTimeStamp"+fofoStore.getActiveTimeStamp());

		if( currentDate.isBefore(fofoStore.getActiveTimeStamp()))

		{

		fofoStore.setActive(true);

		fofoStoreRepository.persist(fofoStore);

		LOGGER.info("inserted into InActiveFofoStore successfully");

		}

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

		return "response";

	}

	@GetMapping(value = "/getAllInactiveStores")

	public String getInactiveStores(HttpServletRequest request, Model model) {

		List<FofoStore> inActiveFofoStores = fofoStoreRepository.selectInActiveStore();

		Map<Integer, CustomRetailer> customRetailers = retailerService

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

		model.addAttribute("inActiveFofoStores", inActiveFofoStores);

		model.addAttribute("customRetailers", customRetailers);

		return "inactive-stores";

	}

	// Extend billing for 2 days

	@PostMapping(value = "/extendBilling")

	public String extendBilling(HttpServletRequest request,

			@RequestParam(name = ProfitMandiConstants.FOFO_ID) int fofoId, Model model) throws Exception {

		FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(fofoId);

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		if (Arrays.asList("kamini.sharma@smartdukaan.com", "tarun.verma@smartdukaan.com", "prakash.rai@smartdukaan.com",

				"amit.gupta@smartdukaan.com").contains(loginDetails.getEmailId())) {

			fofoStore.setGraceDate(LocalDate.now().plusDays(2));

			fofoStore.setGraceCount(fofoStore.getGraceCount() + 1);

			fofoStoreRepository.persist(fofoStore);

			model.addAttribute("response", mvcResponseSender.createResponseString(fofoStore.getGraceCount()));

		} else {

			throw new ProfitMandiBusinessException("Access Denied", "Unauthorised Access",

					"You are not authorise to extend billing");

		}

		return "response";

	}

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

	public String getPromoterInfo(HttpServletRequest request,

			@RequestParam(name = "offset", defaultValue = "0") int offset,

			@RequestParam(name = "limit", defaultValue = "10") int limit,

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

			throws Exception {

		LOGGER.info("requested url : " + request.getRequestURL().toString());

		List<Promoter> promoterInfo = null;

		long size = 0;

		List<Integer> fofoIds = fofoStoreRepository.selectAll().stream().map(x -> x.getId())

				.collect(Collectors.toList());

		Map<Integer, CustomRetailer> customRetailersMap = retailerService.getFofoRetailers(fofoIds);

		String customRetailers = JSONObject.valueToString(customRetailersMap.values());

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

		brands.add("Airtel");

		brands.add("Vodafone");

		brands.add("Idea");

		LOGGER.info("brands" + brands);

		model.addAttribute("customRetailers", customRetailers);

		model.addAttribute("brands", brands);

		if (fofoId != 0) {

			promoterInfo = promoterRepository.selectAllPromoterByFofoId(fofoId, offset, limit);

			size = promoterRepository.selectPromoterCount(fofoId);

		} else {

			promoterInfo = promoterRepository.selectAllPromoter(offset, limit);

			size = promoterRepository.selectAllCount();

		}

		if (!promoterInfo.isEmpty()) {

			List<Integer> partnerIds = new ArrayList<>();

			for (Promoter promoterdetail : promoterInfo) {

				partnerIds.add(promoterdetail.getRetailerId());

			}

			Map<Integer, CustomRetailer> partnersMap = null;

			if (!partnerIds.equals(null)) {

				LOGGER.info("partnerIds" + partnerIds);

				partnersMap = retailerService.getFofoRetailers(partnerIds);

			}

			LOGGER.info("partnerIds" + partnersMap);

			model.addAttribute("promoterInfo", promoterInfo);

			model.addAttribute("partnersMap", partnersMap);

			model.addAttribute("start", offset + 1);

			model.addAttribute("size", size);

			model.addAttribute("url", "/getPaginatedPromoterInfo");

			if (promoterInfo.size() < limit) {

				model.addAttribute("end", offset + promoterInfo.size());

			} else {

				model.addAttribute("end", offset + limit);

			}

		} else {

			model.addAttribute("promoterInfo", promoterInfo);

			model.addAttribute("size", size);

		}

		return "promoter-info";

	}

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

	public String getPaginatedPromoterInfo(HttpServletRequest request,

			@RequestParam(name = "offset", defaultValue = "0") int offset,

			@RequestParam(name = "limit", defaultValue = "10") int limit,

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

			throws ProfitMandiBusinessException {

		LOGGER.info("requested offset=[{}], limit = [{}]", offset, limit);

		List<Promoter> promoterInfo = null;

		if (fofoId != 0) {

			promoterInfo = promoterRepository.selectAllPromoterByFofoId(fofoId, offset, limit);

		} else {

			promoterInfo = promoterRepository.selectAllPromoter(offset, limit);

		}

		LOGGER.info("promoterInfo" + promoterInfo);

		if (!promoterInfo.isEmpty()) {

			List<Integer> partnerIds = new ArrayList<>();

			for (Promoter promoterdetail : promoterInfo) {

				partnerIds.add(promoterdetail.getRetailerId());

			}

			Map<Integer, CustomRetailer> partnersMap = null;

			if (!partnerIds.equals(null)) {

				LOGGER.info("partnerIds" + partnerIds);

				partnersMap = retailerService.getFofoRetailers(partnerIds);

			}

			LOGGER.info("partnerIds" + partnersMap);

			model.addAttribute("promoterInfo", promoterInfo);

			model.addAttribute("partnersMap", partnersMap);

			model.addAttribute("url", "/getPaginatedPromoterInfo");

		} else {

			model.addAttribute("promoterInfo", promoterInfo);

		}

		return "promoter-info-paginated";

	}

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

	public String createPromoter(HttpServletRequest request, @RequestBody PromoterDetailModel promoterdetailModel,

			Model model) throws Exception {

		LOGGER.info("requested url : " + request.getRequestURL().toString());

		LOGGER.info("requested url : " + promoterdetailModel);

		Promoter promoter = promoterRepository.selectById(promoterdetailModel.getId());

		if (promoter == null) {

			promoter = new Promoter();

			promoter.setBrand(promoterdetailModel.getBrand());

			promoter.setRetailerId(promoterdetailModel.getRetailerId());

			promoter.setCreatedTimestamp(LocalDateTime.now());

		}

		promoter.setName(promoterdetailModel.getName());

		promoter.setEmail(promoterdetailModel.getEmail());

		promoter.setMobile(promoterdetailModel.getMobile());

		promoter.setSdPortalAccess(promoterdetailModel.isSdPortalAccess());

		promoter.setStatus(promoterdetailModel.isStatus());

		LOGGER.info("sdport" + promoterdetailModel.isStatus());

		promoterRepository.persist(promoter);

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

		return "response";

	}

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

	public String removePromoterfromPartnerStore(HttpServletRequest request,

			@RequestParam(name = "id", defaultValue = "0") int id, Model model) throws Exception {

		Promoter promoter = promoterRepository.selectById(id);

		promoter.setStatus(false);

		promoterRepository.persist(promoter);

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

		return "response";

	}

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

	public String addLocation(HttpServletRequest request, @RequestBody AddLocationModel addLocationModel, Model model)

			throws Exception {

		Location location = new Location();

		location.setName(addLocationModel.getName());

		location.setLine1(addLocationModel.getLine1());

		location.setLine2(addLocationModel.getLine2());

		location.setCity(addLocationModel.getCity());

		location.setState(addLocationModel.getState());

		location.setPin(addLocationModel.getPin());

		LOGGER.info("PostLocation" + location);

		locationRepository.persist(location);

		User user = userRepository.selectById(addLocationModel.getUserId());

		user.setLocation(location.getId());

		userRepository.persist(user);

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

		return "response";

	}

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

	public String updateLocation(HttpServletRequest request, @RequestBody AddLocationModel addLocationModel,

			Model model) throws Exception {

		Location userlocation = locationRepository.selectById(addLocationModel.getUserId());

		userlocation.setName(addLocationModel.getName());

		userlocation.setCity(addLocationModel.getCity());

		userlocation.setLine1(addLocationModel.getLine1());

		userlocation.setLine2(addLocationModel.getLine2());

		userlocation.setPin(addLocationModel.getPin());

		userlocation.setState(addLocationModel.getState());

		locationRepository.persist(userlocation);

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

		return "response";

	}

	@RequestMapping(value = "/getPartnerReadonlyInfo")

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

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		AuthUser authUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());

		Map<Integer, List<Integer>> pp = csService.getAuthUserIdPartnerIdMapping();

		List<Integer> fofoIds = pp.get(authUser.getId());

		Map<Integer, CustomRetailer> customRetailersMap = retailerService.getFofoRetailers(fofoIds);

		model.addAttribute("customRetailersMap", customRetailersMap);

		return "partner-readonly-info";

	}

	@RequestMapping(value = "/getBlockBrandMapping")

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

		int fofoId = Utils.SYSTEM_PARTNER_ID;

		Set<String> brands = null;

		brands = mongoClient.getMongoBrands(fofoId, null, 3).stream().map(x -> (String) x.get("name"))

				.collect(Collectors.toSet());

		LOGGER.info("brands" + brands);

		model.addAttribute("brands", brands);

		return "block-brand-mapping";

	}

	@RequestMapping(value = "/getBlockBrand")

	public String getBlockBrand(HttpServletRequest request,

			@RequestParam(name = "brand", required = true, defaultValue = "0") String brand, Model model)

			throws Exception {

		List<RetailerBlockBrands> retailerBlockBrands = retailerBlockBrandsRepository.selectAllByBrands(brand);

		List<Integer> blockBrandPartners = retailerBlockBrands.stream().map(x -> x.getFofoId())

				.collect(Collectors.toList());

		Map<Integer, CustomRetailer> customRetailers = retailerService.getFofoRetailers(true);

		LOGGER.info("retailerBlockBrands" + retailerBlockBrands);

		model.addAttribute("blockBrandPartners", blockBrandPartners);

		model.addAttribute("retailerBlockBrands", retailerBlockBrands);

		model.addAttribute("customRetailers", customRetailers);

		return "retailer-block-brand";

	}

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

	public String getBlockBrandMappping(HttpServletRequest request,

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

			@RequestParam(name = "fofoIds", required = true, defaultValue = "0") List<Integer> fofoIds, Model model)

			throws Exception {

		List<RetailerBlockBrands> retailerBlockBrands = retailerBlockBrandsRepository.selectAllByBrands(brand);

		if (!retailerBlockBrands.isEmpty()) {

			retailerBlockBrandsRepository.deleteAllbyBrands(brand);

		}

		for (int id : fofoIds) {

			RetailerBlockBrands retailerBlockBrand = new RetailerBlockBrands();

			retailerBlockBrand.setFofoId(id);

			retailerBlockBrand.setBlockBrands(brand);

			retailerBlockBrandsRepository.persist(retailerBlockBrand);

		}

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

		return "response";

	}

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

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

		int fofoId = Utils.SYSTEM_PARTNER_ID;

		Set<String> brands = null;

		brands = mongoClient.getMongoBrands(fofoId, null, 3).stream().map(x -> (String) x.get("name"))

				.collect(Collectors.toSet());

		model.addAttribute("brands", brands);

		return "brands-limit";

	}

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

	public String getUpdateLimit(HttpServletRequest request,

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

			@RequestParam(name = "fofoId", required = true, defaultValue = "0") int fofoId,

			@RequestParam(name = "limit", required = true, defaultValue = "0") float limit, Model model)

			throws Exception {

		CustomRetailer cr = retailerService.getFofoRetailer(fofoId);

		Map.Entry<Integer, CustomRetailer> customRetailers = new AbstractMap.SimpleEntry(cr.getPartnerId(), cr);

		// Map<Integer, CustomRetailer> customRetailers =

		// retailerService.getFofoRetailers(true);

		LOGGER.info("customRetailers" + customRetailers);

		RetailerBrandsLimit retailerBrands = retailerBrandsLimitRepository.selectLimitByBrandAndFofoId(fofoId, brand);

		if (retailerBrands == null) {

			retailerBrands = new RetailerBrandsLimit();

			retailerBrands.setBrandLimit(limit);

			retailerBrands.setIsUpdate(1);

			retailerBrands.setCreatedTimestamp(LocalDateTime.now());

			retailerBrands.setPartnerId(fofoId);

			retailerBrands.setBrandName(brand);

			retailerBrands.setUpdatedTimestamp(LocalDateTime.now());

			retailerBrandsLimitRepository.persist(retailerBrands);

		}

		else {

			retailerBrands.setBrandLimit(limit);

			retailerBrands.setIsUpdate(1);

			retailerBrands.setUpdatedTimestamp(LocalDateTime.now());

			retailerBrandsLimitRepository.persist(retailerBrands);

		}

		retailerBrands = retailerBrandsLimitRepository.selectLimitByBrandAndFofoId(fofoId, brand);

		Map<Integer, RetailerBrandsLimit> retailerBrandsLimitMap = new HashMap<>();

		retailerBrandsLimitMap.put(retailerBrands.getPartnerId(), retailerBrands);

		BrandLimit brandLimit = brandLimitRepository.setLimitByBrands(brand);

		model.addAttribute("retailerBrandsLimitMap", retailerBrandsLimitMap);

		model.addAttribute("brandLimit", brandLimit);

		model.addAttribute("customRetailers", customRetailers);

		model.addAttribute("brand", brand);

		return "brands-limit-row-mapping";

	}

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

	public String getRetailerBrandslimit(HttpServletRequest request,

			@RequestParam(name = "brand", required = true, defaultValue = "0") String brand, Model model)

			throws Exception {

		Map<Integer, CustomRetailer> customRetailers = retailerService.getFofoRetailers(true);

		List<RetailerBrandsLimit> retailerBrandsLimit = retailerBrandsLimitRepository.setAllLimitByBrands(brand);

		Map<Integer, RetailerBrandsLimit> retailerBrandsLimitMap = retailerBrandsLimit.stream()

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

		model.addAttribute("customRetailers", customRetailers);

		model.addAttribute("brand", brand);

		model.addAttribute("retailerBrandsLimitMap", retailerBrandsLimitMap);

		BrandLimit brandLimit = brandLimitRepository.setLimitByBrands(brand);

		model.addAttribute("brandLimit", brandLimit);

		return "brands-limit-mapping";

	}

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

	public String brandwiseLimit(HttpServletRequest request,

			@RequestParam(name = "brands", required = true, defaultValue = "") String brands,

			@RequestParam(name = "limit", required = true, defaultValue = "") float limit, Model model)

			throws Exception {

		LOGGER.info("limit" + limit);

		BrandLimit brandLimit = brandLimitRepository.setLimitByBrands(brands);

		List<RetailerBrandsLimit> retailerBrandsLimit = retailerBrandsLimitRepository.setAllLimitByBrands(brands);

		Map<Integer, RetailerBrandsLimit> retailerBrandsLimitMap = retailerBrandsLimit.stream()

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

		Map<Integer, CustomRetailer> customRetailers = retailerService.getFofoRetailers(true);

		if (brandLimit == null) {

			brandLimit = new BrandLimit();

			brandLimit.setBrandLimit(limit);

			brandLimit.setBrandName(brands);

			brandLimit.setCreatedTimestamp(LocalDateTime.now());

			brandLimit.setUpdatedTimestamp(LocalDateTime.now());

			brandLimitRepository.persist(brandLimit);

		}

		else {

			brandLimit.setBrandLimit(limit);

			brandLimit.setUpdatedTimestamp(LocalDateTime.now());

			brandLimitRepository.persist(brandLimit);

		}

		brandLimit = brandLimitRepository.setLimitByBrands(brands);

		LOGGER.info("brandLimit" + brandLimit);

		model.addAttribute("brand", brands);

		model.addAttribute("brandLimit", brandLimit);

		model.addAttribute("customRetailers", customRetailers);

		model.addAttribute("retailerBrandsLimitMap", retailerBrandsLimitMap);

		return "brands-limit-mapping";

	}

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

	public String setPartnerPincode(HttpServletRequest request,

			@RequestParam(name = "pincode", required = true, defaultValue = "") String pincode,

			@RequestParam(name = "fofoId", required = true, defaultValue = "") int fofoId,Model model) throws Exception {

		if(!pincode.equals("")) {

	    PincodePartner pinPartner = new PincodePartner();	

		pinPartner.setFofoId(fofoId);

		pinPartner.setPincode(pincode);

		PincodePartnerRepository.perist(pinPartner);

		}

	List<PincodePartner> partnerPincodeList=	PincodePartnerRepository.selectByPartnerId(fofoId);

	LOGGER.info("partnerPincodeList" +partnerPincodeList);

	model.addAttribute("partnerPincodeList", partnerPincodeList);

		return "pincode-partner-index";

	}

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

	public String removePartnerPincode(HttpServletRequest request,

			@RequestParam int id,

			@RequestParam(name = "fofoId", required = true, defaultValue = "") int fofoId,Model model) throws Exception {

	PincodePartnerRepository.delete(id);

	List<PincodePartner> partnerPincodeList=	PincodePartnerRepository.selectByPartnerId(fofoId);

	LOGGER.info("partnerPincodeList" +partnerPincodeList);

	model.addAttribute("partnerPincodeList", partnerPincodeList);

		return "pincode-partner-index";

	}

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

	public String removeSearchPincode(HttpServletRequest request,@RequestParam int id,

			@RequestParam(name = "pin", required = true, defaultValue = "") String pin,

			@RequestParam(name = "fofoId", required = true, defaultValue = "") int fofoId,Model model) throws Exception {

	PincodePartnerRepository.delete(id);

	List<PincodePartner> partnerPincodeList=	PincodePartnerRepository.selectPartnersByPincode(pin);

	Map<Integer, CustomRetailer> customRetailerMap = retailerService.getFofoRetailers(true);

	model.addAttribute("customRetailerMap", customRetailerMap);

	model.addAttribute("partnerPincodeList", partnerPincodeList);

		return "search-pincode-partner";

	}

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

	public String searchPincodePartner(HttpServletRequest request,

			@RequestParam(name = "pincode", required = true, defaultValue = "") String pincode,Model model) throws Exception {