Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import com.spice.profitmandi.common.enumuration.ContentType;
import com.spice.profitmandi.common.enumuration.CounterSize;
import com.spice.profitmandi.common.enumuration.FofoType;
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
import com.spice.profitmandi.common.model.*;
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.*;
import com.spice.profitmandi.dao.entity.fofo.*;
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.*;
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.authentication.RoleManager;
import com.spice.profitmandi.service.catalog.BrandsService;
import com.spice.profitmandi.service.inventory.InventoryService;
import com.spice.profitmandi.service.user.RetailerService;
import com.spice.profitmandi.service.user.StoreTimelineTatService;
import com.spice.profitmandi.web.model.LoginDetails;
import com.spice.profitmandi.web.util.CookiesProcessor;
import com.spice.profitmandi.web.util.MVCResponseSender;
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.*;

import javax.servlet.http.HttpServletRequest;
import javax.transaction.Transactional;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

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

        @Autowired
        PartnerOnBoardingPanelRepository partnerOnBoardingPanelRepository;

        @Autowired
        private StoreTimelineTatService storeTimelineTatService;

        @Autowired
        private RoleManager roleManager;

        @Autowired
        private RetailerContactRepository retailerContactRepository;

        @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);
                model.addAttribute("fofoTypes", FofoType.values());
                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);
                //retailerService.up

                model.addAllAttributes(map);
                model.addAttribute("counterSizes", CounterSize.values());
                Map<Integer, String> warehouseMap = ProfitMandiConstants.WAREHOUSE_MAP;
                LOGGER.info("warehouseMap", warehouseMap);
                model.addAttribute("warehouses", warehouseMap);
                model.addAttribute("fofoTypes", FofoType.values());
                return "retailer-details";
        }

        @RequestMapping(value = "/retailer/update-email", method = RequestMethod.POST)
        public String updateRetailerEmail(@RequestParam("newEmail") String newEmail, @RequestParam("fofoID") int fofoID) throws ProfitMandiBusinessException {
                retailerService.updateRetailerEmail(fofoID, newEmail);
                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 = "/getstore")
    public String getstore(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {

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

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

                Map<Integer, CustomRetailer> fofoIdsAndCustomRetailer = fofoIds.stream().map(x -> customRetailerMap.get(x))
                                .filter(x -> x != null).collect(Collectors.toList()).stream()
                                .collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));

                //LOGGER.info("fofoIds" + fofoIds);
                model.addAttribute("fofoIdsAndCustomRetailer", fofoIdsAndCustomRetailer);
                //LOGGER.info("fofoIdsAndCustomRetailer" + fofoIdsAndCustomRetailer);
                model.addAttribute("fofoIds", fofoIds);

                return "store";

        }

        private static final List<String> CHANGE_PARTNER_CATEGORY_PERMISSIONS = Arrays.asList("tarun.verma@smartdukaan.com", "kamini.sharma@smartdukaan.com", "shankar.mushra@smartdukaan.com");

        @RequestMapping(value = "/getPartnerinfo")
        public String getPartnerinfo(HttpServletRequest request, @RequestBody SelectStorePartnerInfo selectStorePartnerInfo,
                                                                 Model model) throws ProfitMandiBusinessException {
                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                //LOGGER.info("selectStorePartnerInfo" + selectStorePartnerInfo.getUserIds());
                List<FofoStore> fofoStores = fofoStoreRepository.selectByRetailerIds(selectStorePartnerInfo.getUserIds());
                //LOGGER.info("fofoStoresInfo" + fofoStores);
                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(), ProfitMandiConstants.MIN_INVESTMENT_PERCENTAGE,
                                                        ProfitMandiConstants.CUTOFF_INVESTMENT);
                                        if (fofoStore.getGraceCount() > 0) {
                                                fofoStore.setGraceDate(null);
                                                fofoStore.setGraceCount(0);
                                        }
                                } 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);
                boolean canChangeCategory = CHANGE_PARTNER_CATEGORY_PERMISSIONS.contains(loginDetails.getEmailId());
                model.addAttribute("canChangeCategory", canChangeCategory);

                return "store-investment";

        }

        @GetMapping(value = "/getAllStores")
        public String getAllStores(HttpServletRequest request, Model model) throws Exception {

                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(), ProfitMandiConstants.MIN_INVESTMENT_PERCENTAGE,
                                                        ProfitMandiConstants.CUTOFF_INVESTMENT);
                                        if (fofoStore.getGraceCount() > 0) {
                                                fofoStore.setGraceDate(null);
                                                fofoStore.setGraceCount(0);
                                        }
                                } 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);

                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                boolean canChangeCategory = CHANGE_PARTNER_CATEGORY_PERMISSIONS.contains(loginDetails.getEmailId());
                model.addAttribute("canChangeCategory", canChangeCategory);

                return "store-investment";

        }

        @GetMapping(value = "/getPartnerCategory")
    public String getPartnerCategory(HttpServletRequest request, @RequestParam int fofoId, Model model) throws ProfitMandiBusinessException {

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

                return "response";
        }

        @GetMapping(value = "/partners")
        public String getStoreName(HttpServletRequest request, Model model, @RequestParam String query) throws Exception {
                model.addAttribute("response1",
                                mvcResponseSender.createResponseString(retailerService.getFofoRetailers(false).values().stream()
                                                .filter(x -> 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",
                                                "rahul.katyal@smartdukaan.com", "tejbeer.kaur@smartdukaan.com", "sm@smartdukaan.com")
                                .contains(loginDetails.getEmailId())) {
                        throw new ProfitMandiBusinessException("Access Denied", "Unauthorised Access",
                                        "You are not authorise to deactivate retailer");
                }
                fofoStore.setActive(false);
                LOGGER.info("inserted into InActiveFofoStore successfully");
                model.addAttribute("response1", 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",
                                "rahul.katyal@smartdukaan.com", "sm@smartdukaan.com").contains(loginDetails.getEmailId())) {
                        throw new ProfitMandiBusinessException("Access Denied", "Unauthorised Access",
                                        "You are not authorise to activate retailer");
                }
                fofoStore.setActive(true);
                LOGGER.info("inserted into ActiveFofoStore successfully");
                model.addAttribute("response1", 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",
                                "rahul.katyal@smartdukaan.com", "sm@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);
                        LOGGER.info("inserted into InActiveFofoStore successfully");
                }

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

        @GetMapping(value = "/getAllInactiveStores")
    public String getInactiveStores(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {
                List<FofoStore> inActiveFofoStores = fofoStoreRepository.selectInActiveStore();

                LOGGER.info("inActiveFofoStores {}", inActiveFofoStores);
                Map<Integer, CustomRetailer> customRetailerMap = retailerService.getAllFofoRetailers();

                List<Integer> fofoIds = inActiveFofoStores.stream().map(x -> x.getId()).collect(Collectors.toList());

                Map<Integer, CustomRetailer> customRetailers = fofoIds.stream().map(x -> customRetailerMap.get(x))
                                .filter(x -> x != null).collect(Collectors.toList()).stream()
                                .collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));
                LOGGER.info("customRetailers {}", customRetailers);

                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", "amit.gupta@smartdukaan.com",
                                "rahul.katyal@smartdukaan.com", "sm@smartdukaan.com", "mohit.gulati@smartdukaan.com", "chiranjib.sarkar@smartdukaan.com").contains(loginDetails.getEmailId())) {
                        fofoStore.setGraceDate(LocalDate.now().plusDays(2));
                        fofoStore.setGraceCount(fofoStore.getGraceCount() + 1);
                        model.addAttribute("response1", 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 getShowPromoterInfo(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> customRetailerMap = retailerService.getAllFofoRetailers();

                Map<Integer, CustomRetailer> customRetailersMap = fofoIds.stream().map(x -> customRetailerMap.get(x))
                                .filter(x -> x != null).collect(Collectors.toList()).stream()
                                .collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));
                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.selectAllPromoterByFofoIdStatus(fofoId, offset, limit,true);

                        //size = promoterRepository.selectPromoterCount(fofoId);
                        size = promoterInfo.size();
                } else {
                        //rkb
                        promoterInfo = promoterRepository.selectAllPromoterStatus(offset, limit,true);

                        //size = promoterRepository.selectAllCount();
                        size = promoterInfo.size();
                }
                if (!promoterInfo.isEmpty()) {
                        Set<Integer> partnerIds = new HashSet<>();

                        for (Promoter promoterdetail : promoterInfo) {
                                partnerIds.add(promoterdetail.getRetailerId());
                        }
                        Map<Integer, CustomRetailer> partnersMap = null;
                        if (!partnerIds.equals(null)) {
                                LOGGER.info("partnerIds" + partnerIds);

                                partnersMap = partnerIds.stream().map(x -> customRetailerMap.get(x)).filter(x -> x != null)
                                                .collect(Collectors.toList()).stream().collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));

                        }

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

        public String getShowPromoterInactiveInfo(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> customRetailerMap = retailerService.getAllFofoRetailers();

                Map<Integer, CustomRetailer> customRetailersMap = fofoIds.stream().map(x -> customRetailerMap.get(x))
                                .filter(x -> x != null).collect(Collectors.toList()).stream()
                                .collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));
                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.selectAllPromoterByFofoIdStatus(fofoId, offset, limit,false);

                        //size = promoterRepository.selectPromoterCount(fofoId);
                        size = promoterInfo.size();

                } else {
                        //rkb
                        promoterInfo = promoterRepository.selectAllPromoterStatus(offset, limit,false);

                        //size = promoterRepository.selectAllCount();
                        size = promoterInfo.size();

                }
                if (!promoterInfo.isEmpty()) {
                        Set<Integer> partnerIds = new HashSet<>();

                        for (Promoter promoterdetail : promoterInfo) {
                                partnerIds.add(promoterdetail.getRetailerId());
                        }
                        Map<Integer, CustomRetailer> partnersMap = null;
                        if (!partnerIds.equals(null)) {
                                LOGGER.info("partnerIds" + partnerIds);

                                partnersMap = partnerIds.stream().map(x -> customRetailerMap.get(x)).filter(x -> x != null)
                                                .collect(Collectors.toList()).stream().collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));

                        }

                        LOGGER.info("partnerIds" + partnersMap);
                        model.addAttribute("promoterInfo", promoterInfo);
                        model.addAttribute("partnersMap", partnersMap);
                        model.addAttribute("start", offset + 1);
                        model.addAttribute("size", size);
                        model.addAttribute("url", "/getPaginatedPromoterInactiveInfo");

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

        }


        @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.selectAllPromoterByFofoIdStatus(fofoId, offset, limit,true);
                } else {
                        promoterInfo = promoterRepository.selectAllPromoterStatus(offset, limit,true);
                }
                LOGGER.info("promoterInfo" + promoterInfo);
                if (!promoterInfo.isEmpty()) {
                        Set<Integer> partnerIds = new HashSet<>();

                        for (Promoter promoterdetail : promoterInfo) {
                                partnerIds.add(promoterdetail.getRetailerId());
                        }
                        Map<Integer, CustomRetailer> partnersMap = null;
                        if (!partnerIds.equals(null)) {
                                LOGGER.info("partnerIds" + partnerIds);

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

                                partnersMap = partnerIds.stream().map(x -> customRetailerMap.get(x)).filter(x -> x != null)
                                                .collect(Collectors.toList()).stream().collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));

                        }

                        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 = "/getPaginatedPromoterInactiveInfo", method = RequestMethod.GET)
        public String getPaginatedPromoterInactiveInfo(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.selectAllPromoterByFofoIdStatus(fofoId, offset, limit,false);
                } else {
                        promoterInfo = promoterRepository.selectAllPromoterStatus(offset, limit,false);
                }
                LOGGER.info("promoterInfo" + promoterInfo);
                if (!promoterInfo.isEmpty()) {
                        Set<Integer> partnerIds = new HashSet<>();

                        for (Promoter promoterdetail : promoterInfo) {
                                partnerIds.add(promoterdetail.getRetailerId());
                        }
                        Map<Integer, CustomRetailer> partnersMap = null;
                        if (!partnerIds.equals(null)) {
                                LOGGER.info("partnerIds" + partnerIds);

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

                                partnersMap = partnerIds.stream().map(x -> customRetailerMap.get(x)).filter(x -> x != null)
                                                .collect(Collectors.toList()).stream().collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));

                        }

                        LOGGER.info("partnerIds" + partnersMap);
                        model.addAttribute("promoterInfo", promoterInfo);
                        model.addAttribute("partnersMap", partnersMap);
                        model.addAttribute("url", "/getPaginatedPromoterInactiveInfo");
                } else {
                        model.addAttribute("promoterInfo", promoterInfo);

                }

                return "promoter-inactive-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.setEmail(promoterdetailModel.getEmail());
                        promoter.setName(promoterdetailModel.getName());
                        promoter.setMobile(promoterdetailModel.getMobile());
                        promoter.setSdPortalAccess(promoterdetailModel.isSdPortalAccess());
                        promoter.setStatus(promoterdetailModel.isStatus());
                        promoterRepository.persist(promoter);

                        List<Promoter> promoters = promoterRepository.selectAllByRetailer(promoterdetailModel.getRetailerId());
                        if (!promoters.isEmpty()) {
                                FofoStore fs = fofoStoreRepository.selectByRetailerId(promoterdetailModel.getRetailerId());
                                PartnerOnBoardingPanel pobp = partnerOnBoardingPanelRepository.selectByCode(fs.getCode());
                                if (pobp != null) {
                                        storeTimelineTatService.promoterComplete(pobp.getId());
                                }
                        }

                } else {
                        promoter.setEmail(promoterdetailModel.getEmail());
                        promoter.setName(promoterdetailModel.getName());
                        promoter.setMobile(promoterdetailModel.getMobile());
                        promoter.setSdPortalAccess(promoterdetailModel.isSdPortalAccess());
                        promoter.setStatus(promoterdetailModel.isStatus());
                }
                LOGGER.info("sdport" + promoterdetailModel.isStatus());

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

                return "response";

        }
        @RequestMapping(value = "/setPromoterInActive", method = RequestMethod.POST)
        public String PromoterInActive(HttpServletRequest request, @RequestParam(name = "id", required = true, defaultValue = "0") int id, Model model) throws Exception {

                Promoter promoter = promoterRepository.selectById(id);

                promoter.setStatus(false);

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

                return "response";
        }
        @RequestMapping(value = "/activePromoterfromPartnerStore", method = RequestMethod.POST)
        public String activePromoterfromPartnerStore(HttpServletRequest request,
                                                                                                 @RequestParam(name = "id", defaultValue = "0") int id, Model model) throws Exception {

                Promoter promoter = promoterRepository.selectById(id);
                promoter.setStatus(true);
                model.addAttribute("response1", 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("response1", 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("response1", 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();

                Set<Integer> fofoIds = new HashSet<>(pp.get(authUser.getId()));

                Map<Integer, CustomRetailer> customRetailersMap = fofoIds.stream().map(x -> {
                        try {
                                return retailerService.getFofoRetailer(x);
                        } catch (ProfitMandiBusinessException e) {
                                // TODO Auto-generated catch block
                                return null;
                        }
                }).filter(x -> x != null).collect(Collectors.toMap(x -> x.getPartnerId(), x -> x));

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

                return "response";
        }

        @Autowired
        BrandsService brandsService;

        @RequestMapping(value = "/getBrandslimit", method = RequestMethod.GET)
        public String getBrandslimit(HttpServletRequest request, Model model) throws Exception {

                int fofoId = Utils.SYSTEM_PARTNER_ID;

                List<String> brands = brandsService.getBrandsToDisplay(3).stream().map(x -> x.getName()).collect(Collectors.toList());
                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,
                        @RequestParam(name = "minStockLimit", required = true, defaultValue = "0") float minStockLimit,
                        @RequestParam(name = "preLimit", required = true, defaultValue = "0") float preLimit,
                        @RequestParam(name = "preStockLimit", required = true, defaultValue = "0") float preStockLimit, 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);

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

                if (retailerBrands == null) {
                        retailerBrands = new RetailerBrandsLimit();
                        retailerBrands.setMinStockLimit(minStockLimit);
                        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.setMinStockLimit(minStockLimit);
                        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.setAllLimitByBrand(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.setAllLimitByBrand(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 = "/setBrandWiseStockLimit", method = RequestMethod.POST)
        public String setBrandWiseStockLimit(HttpServletRequest request,
                        @RequestParam(name = "brands", required = true, defaultValue = "") String brands,
                        @RequestParam(name = "stockLimit", required = true, defaultValue = "") float stockLimit, Model model)
                        throws Exception {

                LOGGER.info("limit" + stockLimit);

                BrandLimit brandLimit = brandLimitRepository.setLimitByBrands(brands);

                List<RetailerBrandsLimit> retailerBrandsLimit = retailerBrandsLimitRepository.setAllLimitByBrand(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(0);
                        brandLimit.setBrandName(brands);
                        brandLimit.setStockLimit(stockLimit);
                        brandLimit.setCreatedTimestamp(LocalDateTime.now());
                        brandLimit.setUpdatedTimestamp(LocalDateTime.now());
                        brandLimitRepository.persist(brandLimit);

                }

                else {
                        brandLimit.setStockLimit(stockLimit);

                        brandLimit.setUpdatedTimestamp(LocalDateTime.now());
                        brandLimitRepository.persist(brandLimit);

                }
                brandLimit = brandLimitRepository.setLimitByBrands(brands);

                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 {

                List<PincodePartner> partnerPincodeList = pincodePartnerRepository.selectPartnersByPincode(pincode);

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

                model.addAttribute("customRetailerMap", customRetailerMap);

                model.addAttribute("partnerPincodeList", partnerPincodeList);

                return "search-pincode-partner";

        }

        @RequestMapping(value = "/showPartnerPincode", method = RequestMethod.GET)
        public String showPartnerPincode(HttpServletRequest request,
                        @RequestParam(name = "partnerId", required = true, defaultValue = "") int partnerId, Model model)
                        throws Exception {

                List<PincodePartner> partnerPincodeList = pincodePartnerRepository.selectByPartnerId(partnerId);

                model.addAttribute("partnerPincodeList", partnerPincodeList);

                return "pincode-partner-index";

        }

        @RequestMapping(value = "/getAllPartnerPincode", method = RequestMethod.GET)
        public String getAllPartnerPincode(HttpServletRequest request, Model model) throws Exception {
                return "add-partner-pincode";
        }

        @RequestMapping(value = "/alternateRetailerContacts", method = RequestMethod.GET)
        public String alternateRetailerContacts(HttpServletRequest request, Model model) throws Exception {
                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                boolean isAdmin = roleManager.isAdmin(loginDetails.getRoleIds());

                model.addAttribute("isAdmin", isAdmin);
                return "retailer-contacts";
        }

        @RequestMapping(value = "/retailer-contact-list", method = RequestMethod.GET)
        public String getRetailerContactList(HttpServletRequest request, Model model, @RequestParam(defaultValue = "0") int fofoId)
                        throws Exception {

                List<RetailerContact> retailerContacts = retailerContactRepository.selectAllByRetailerId(fofoId);

                model.addAttribute("retailerContacts", retailerContacts);

                return "retailer-contact-list";

        }

        @RequestMapping(value = "/add-retailer-contact-list", method = RequestMethod.GET)
        public String updateRetailerContactList(HttpServletRequest request, Model model, @RequestParam(defaultValue = "0") int fofoId, @RequestParam String contactName, @RequestParam String contactNumber)
                        throws Exception {

                RetailerContact retailerContact = new RetailerContact();
                retailerContact.setFofoId(fofoId);
                retailerContact.setName(contactName);
                retailerContact.setMobile(contactNumber);
                retailerContact.setActive(true);
                retailerContact.setCreatedAt(LocalDateTime.now());
                retailerContactRepository.persist(retailerContact);

                List<RetailerContact> retailerContacts = retailerContactRepository.selectAllByRetailerId(fofoId);

                model.addAttribute("retailerContacts", retailerContacts);

                return "retailer-contact-list";

        }

        @RequestMapping(value = "/update-contact-status", method = RequestMethod.GET)
        public String updateRetailerContactStatus(HttpServletRequest request, Model model, @RequestParam(defaultValue = "0") int fofoId, @RequestParam(defaultValue = "0") int contactId, @RequestParam boolean active)
                        throws Exception {

                RetailerContact retailerContact = retailerContactRepository.selectById(contactId);
                retailerContact.setActive(active);

                List<RetailerContact> retailerContacts = retailerContactRepository.selectAllByRetailerId(fofoId);

                model.addAttribute("retailerContacts", retailerContacts);

                return "retailer-contact-list";

        }


}