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

    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;

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

    }

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

        if (!updateRetailerRequest.getFofoType().equals(FofoType.INTERNAL)) {

            LoiForm loiForm = null;

            loiForm = loiFormRepository.selectByEmailOrMobile(updateRetailerRequest.getUserMobileNumber());

            if (loiForm == null) {

                loiForm = loiFormRepository.selectByEqualsKeyValue("gstNo", updateRetailerRequest.getGstNumber());

                if (loiForm == null) {

                    throw new ProfitMandiBusinessException("Loi Not Available of this User", "Message - ", "Please fill the LOI_FORM and try again");

                }

            }

        }

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

    }

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

        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 {