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.onBoarding.LoiForm;
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.trialOnboarding.TrialFormRepository;
import com.spice.profitmandi.dao.repository.user.LocationRepository;
import com.spice.profitmandi.dao.repository.user.LoiFormRepository;
import com.spice.profitmandi.dao.repository.user.PromoterRepository;
import com.spice.profitmandi.dao.repository.user.UserRepository;
import com.spice.profitmandi.dao.repository.warehouse.WarehouseSupplierInvoiceRepository;
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 org.springframework.transaction.annotation.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(rollbackFor = Throwable.class)
public class RetailerController {

    private static final Logger LOGGER = LogManager.getLogger(RetailerController.class);
    private static final List<String> CHANGE_PARTNER_CATEGORY_PERMISSIONS = Arrays.asList("tarun.verma@smartdukaan.com", "kamini.sharma@smartdukaan.com", "shankar.mushra@smartdukaan.com");
    @Autowired
    PartnerOnBoardingPanelRepository partnerOnBoardingPanelRepository;
    @Autowired
    BrandsService brandsService;
    @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
    private StoreTimelineTatService storeTimelineTatService;
    @Autowired
    private RoleManager roleManager;
    @Autowired
    private RetailerContactRepository retailerContactRepository;
    @Autowired
    private WarehouseSupplierInvoiceRepository warehouseSupplierInvoiceRepository;

    @Autowired
    TrialFormRepository trialFormRepository;

    @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);
        LOGGER.info("map - {}", map.get("trialForm"));
        LOGGER.info("map - {}", map);
        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";
    }

    @Autowired
    LoiFormRepository loiFormRepository;

    @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);
        String storeCode = updateRetailerRequest.getFofostorecode();
        boolean isStoreCodeNotCreated = (storeCode == null || storeCode.isEmpty());
        LOGGER.info("isStoreCodeNotCreated - "+isStoreCodeNotCreated);
        if (!updateRetailerRequest.getFofoType().equals(FofoType.INTERNAL) && isStoreCodeNotCreated) {
            checkLoiCompletion(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";
    }

    private void checkLoiCompletion(UpdateRetailerRequest updateRetailerRequest) throws ProfitMandiBusinessException {
        TrialForm trialForm;
        try {
            trialForm = trialFormRepository.selectByEmailOrMobile(updateRetailerRequest.getUserMobileNumber());
            if (updateRetailerRequest.getFofoType().equals(FofoType.INTERNAL) || trialForm != null) {
                return; // Early return for internal type
            }
        } catch (Exception e) {
            trialForm = null;
        }
        if (updateRetailerRequest.getFofoType().equals(FofoType.INTERNAL) || trialForm != null) {
            return; // Early return for internal type
        }
        String userMobile = updateRetailerRequest.getUserMobileNumber();
        String gstNumber = updateRetailerRequest.getGstNumber();
        LoiForm loiForm = findLoiForm(userMobile, gstNumber);
        if (loiForm == null) {
            throw new ProfitMandiBusinessException("Loi Not Available", "Message - ", "Please fill the LOI_FORM and try again");
        }
        if (loiForm.getOnBoardingId() <= 0) {
            throw new ProfitMandiBusinessException("Loi not completed", "Message - ", "Please Complete LOI_FORM and try again");
        }
    }

    private LoiForm findLoiForm(String mobile, String gstNumber) throws ProfitMandiBusinessException {
        LoiForm form = loiFormRepository.selectByEmailOrMobile(mobile);
        if (form == null && gstNumber != null) {
            form = loiFormRepository.selectByEqualsKeyValue("gstNo", gstNumber);
        }
        return form;
    }

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

    }

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

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        PartnerTypeChange ptc = new PartnerTypeChange();
        ptc.setFofoId(fofoId);
        ptc.setPartnerType(partnerType);
        ptc.setCreateTimestamp(LocalDate.now().withDayOfMonth(1).atStartOfDay());
        ptc.setSource(PartnerTypeSource.MANUAL);
        ptc.setUpgradedBy(loginDetails.getEmailId());
        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", "vikas.jangra@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();

        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 = brandsService.getBrands(fofoId, null, 3).stream().map(x -> x.getName()).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";
    }

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

    }


}