Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import com.google.gson.Gson;

import com.mongodb.DBObject;

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

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

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

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

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

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

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

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

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

import com.spice.profitmandi.dao.enumuration.cs.EscalationType;

import com.spice.profitmandi.dao.enumuration.dtr.CommunicationType;

import com.spice.profitmandi.dao.enumuration.dtr.LeadSource;

import com.spice.profitmandi.dao.enumuration.dtr.LeadStatus;

import com.spice.profitmandi.dao.model.*;

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

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

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

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

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

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

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

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

import com.spice.profitmandi.dao.repository.inventory.StateRepository;

import com.spice.profitmandi.dao.repository.transaction.UserWalletRepository;

import com.spice.profitmandi.service.AuthService;

import com.spice.profitmandi.service.PartnerCollectionService;

import com.spice.profitmandi.service.RbmTargetService;

import com.spice.profitmandi.service.catalog.BrandsService;

import com.spice.profitmandi.service.order.OrderService;

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

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

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

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

import org.apache.commons.csv.CSVFormat;

import org.apache.commons.csv.CSVParser;

import org.apache.commons.csv.CSVRecord;

import org.apache.commons.io.output.ByteArrayOutputStream;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

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

import org.springframework.core.io.InputStreamResource;

import org.springframework.http.HttpHeaders;

import org.springframework.http.HttpStatus;

import org.springframework.http.MediaType;

import org.springframework.http.ResponseEntity;

import org.springframework.stereotype.Controller;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.ui.Model;

import org.springframework.util.StringUtils;

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

import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import java.io.ByteArrayInputStream;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.Reader;

import java.text.DecimalFormat;

import java.time.DayOfWeek;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.LocalTime;

import java.time.format.DateTimeFormatter;

import java.time.temporal.TemporalAdjusters;

import java.util.*;

import java.util.Map.Entry;

import java.util.stream.Collectors;

@Controller

@Transactional(rollbackFor = Throwable.class)

public class LeadController {

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

    @Autowired

    private LeadRepository leadRepository;

    @Autowired

    private LeadActivityRepository leadActivityRepository;

    @Autowired

    private com.spice.profitmandi.dao.repository.dtr.LeadVisitRequestRepository leadVisitRequestRepository;

    @Autowired

    private StateRepository stateRepository;

    @Autowired

    private AuthService authService;

    @Autowired

    private AuthRepository authRepository;

    @Autowired

    private Gson gson;

    @Autowired

    private CookiesProcessor cookiesProcessor;

    @Autowired

    PositionRepository positionRepository;

    @Autowired

    private MVCResponseSender mvcResponseSender;

    @Autowired

    private PartnerCollectionPlanRepository partnerCollectionPlanRepository;

    @Autowired

    private CsService csService;

    @Autowired

    private FofoStoreRepository fofoStoreRepository;

    @Autowired

    private PartnerCollectionService partnerCollectionService;

    @Autowired

    private RetailerService retailerService;

    @Autowired

    private PartnerCollectionRemarkRepository partnerCollectionRemarkRepository;

    @Autowired

    private PartnerDailyInvestmentRepository partnerDailyInvestmentRepository;

    @Autowired

    private UserWalletRepository userWalletRepository;

    @Autowired

    private FranchiseeVisitRepository franchiseeVisitRepository;

    @Autowired

    private FranchiseeActivityRepository franchiseeActivityRepository;

    @Autowired

    private VisitRequestRepository visitRequestRepository;

    @Autowired

    private LeadBrandRepository leadBrandRepository;

    @Autowired

    private LeadDetailRepository leadDetailRepository;

    @Autowired

    private LeadLiveLocationRepository leadLiveLocationRepository;

    @Autowired

    private BeatRouteRepository beatRouteRepository;

    @Autowired

    private LeadRouteRepository leadRouteRepository;

    @Autowired

    private BeatRepository beatRepository;

    @Autowired

    private Mongo mongoClient;

    @Autowired

    private ResponseSender<?> responseSender;

    @Autowired

    private BrandsService brandsService;

    @Autowired

    OrderService orderService;

    @Autowired

    private RbmRatingRepository rbmRatingRepository;

    List<LeadStatus> status = Arrays.asList(LeadStatus.notInterested, LeadStatus.finalized);

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

    public String getOpenLead(HttpServletRequest request, @RequestParam(name = "leadStatus", required = false, defaultValue = "All") List<LeadStatus> leadStatus, @RequestParam(name = "color", required = false, defaultValue = "All") List<String> color, @RequestParam(name = "startDate", required = false) LocalDate startDate, @RequestParam(name = "endDate", required = false) LocalDate endDate, Model model) throws Exception {

        LocalDateTime startDateTime = startDate != null ? startDate.atStartOfDay() : null;

        LocalDateTime endDateTime = endDate != null ? endDate.atTime(23, 59, 59) : null;

        LOGGER.info("startDateTime: " + startDateTime + ", endDateTime: " + endDateTime);

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        String emailId = loginDetails.getEmailId();

        AuthUser authUser = authRepository.selectByEmailOrMobile(emailId);

        boolean isPositionSales = positionRepository.hasCategory(authUser.getId(), ProfitMandiConstants.TICKET_CATEGORY_SALES);

        if (leadStatus.contains(LeadStatus.All)) {

            leadStatus.add(LeadStatus.pending);

            leadStatus.add(LeadStatus.notInterested);

            leadStatus.add(LeadStatus.finalized);

        }

        if (color.contains("All")) {

            color.add("yellow");

            color.add("green");

        }

        List<Lead> leads = new ArrayList<>();

        model.addAttribute("colors", color);

        Map<Integer, List<LeadActivity>> leadActivityMap = new HashMap<>();

        List<Integer> authUserIds = null;

        LOGGER.info("color111" + color);

        List<Lead> leadFollowUp = new ArrayList<>();

        if (isPositionSales) {

            authUserIds = authService.getAllReportees(authUser.getId());

            authUserIds.add(authUser.getId());

            LOGGER.info("authIds" + authUserIds);

            LOGGER.info("leadStatus" + leadStatus);

            if (startDateTime == null) {

                if (!leadStatus.contains(LeadStatus.followUp)) {

                    leads = leadRepository.selectAllByColorStatusAndUpdatedTimestampAndAuthIds(leadStatus, authUserIds, color, LocalDateTime.now().minusMonths(1));

                }

                if (leadStatus.contains(LeadStatus.followUp) || leadStatus.contains(LeadStatus.All)) {

                    leadFollowUp = leadRepository.selectByAssignAuthIdsAndStatus(authUserIds, LeadStatus.followUp);

                    leads.addAll(leadFollowUp);

                }

            } else {

                if (!leadStatus.contains(LeadStatus.followUp)) {

                    leads = leadRepository.selectAllByColorStatusAndBetweenCreatedDateAndAuthIds(leadStatus, authUserIds, color, startDateTime, endDateTime);

                }

                if (leadStatus.contains(LeadStatus.followUp) || leadStatus.contains(LeadStatus.All)) {

                    leadFollowUp = leadRepository.selectByAssignAuthIdsAndStatus(authUserIds, LeadStatus.followUp);

                    leads.addAll(leadFollowUp);

                }

            }

        } else {

            if (startDateTime == null) {

                if (!leadStatus.contains(LeadStatus.followUp)) {

                    leads = leadRepository.selectAllByColorStatusAndUpdatedTimestamp(leadStatus, color, LocalDateTime.now().minusMonths(1));

                }

                if (leadStatus.contains(LeadStatus.followUp) || leadStatus.contains(LeadStatus.All)) {

                    leadFollowUp = leadRepository.selectAllByStatus(LeadStatus.followUp);

                    leads.addAll(leadFollowUp);

                }

                LOGGER.info("leadlocalDateTime1" + leads);

            } else {

                if (!leadStatus.contains(LeadStatus.followUp)) {

                    leads = leadRepository.selectAllByColorStatusAndBetweenCreatedDate(leadStatus, color, startDateTime, endDateTime);

                }

                if (leadStatus.contains(LeadStatus.followUp)) {

                    leadFollowUp = leadRepository.selectAllByStatus(LeadStatus.followUp);

                    leads.addAll(leadFollowUp);

                }

                LOGGER.info("leadlocalDateTime2" + leads);

            }

        }

        if (isPositionSales && authUserIds.size() > 0) {

            List<String> leadCreators = new ArrayList<>();

            leadCreators.add("daily-sync");

            leadCreators.addAll(csService.getAuthUserIds(ProfitMandiConstants.TICKET_CATEGORY_SALES, Arrays.asList(EscalationType.L1, EscalationType.L2)).stream().map(x -> x.getFullName()).collect(Collectors.toList()));

            leadCreators.addAll(csService.getAuthUserIds(ProfitMandiConstants.TICKET_CATEGORY_BGC, Arrays.asList(EscalationType.L1, EscalationType.L2, EscalationType.L3)).stream().map(x -> x.getFullName()).collect(Collectors.toList()));

            model.addAttribute("leadCreators", leadCreators);

        }

        List<Lead> weekLast = new ArrayList<>();

        List<Lead> weekThird = new ArrayList<>();

        List<Lead> weekSecond = new ArrayList<>();

        List<Lead> weekFirst = new ArrayList<>();

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

        List<LeadWeakWiseModel> lwDays = new ArrayList<>();

        for (int i = 7; i >= 1; i--) {

            LocalDateTime startOfDay = curDate.minusDays(i);

            LeadWeakWiseModel lm = new LeadWeakWiseModel();

            lm.setMonth(startOfDay.toLocalDate());

            lwDays.add(lm);

        }

        if (!leads.isEmpty()) {

            weekLast.addAll(

                    leads.stream().filter(x -> x.getCreatedTimestamp().isAfter(curDate.minusDays(28)) && x.getCreatedTimestamp().isBefore(curDate.minusDays(21))).collect(Collectors.toList()));

            weekThird.addAll(leads.stream().filter(x -> x.getCreatedTimestamp().isAfter(curDate.minusDays(21)) && x.getCreatedTimestamp().isBefore(curDate.minusDays(14))).collect(Collectors.toList()));

            weekSecond.addAll(leads.stream().filter(x -> x.getCreatedTimestamp().isAfter(curDate.minusDays(14)) && x.getCreatedTimestamp().isBefore(curDate.minusDays(7))).collect(Collectors.toList()));

            weekFirst.addAll(leads.stream().filter(x -> x.getCreatedTimestamp().isAfter(curDate.minusDays(7))).collect(Collectors.toList()));

        }

        LOGGER.info("weekLast" + weekLast);

        LOGGER.info("weekThird" + weekThird);

        LOGGER.info("weekSecond" + weekSecond);

        Map<String, Long> leadLasts = weekLast.stream().collect(Collectors.groupingBy(x -> x.getCreatedBy(), Collectors.counting()));

        Map<String, Long> leadThirds = weekThird.stream().collect(Collectors.groupingBy(x -> x.getCreatedBy(), Collectors.counting()));

        Map<String, Long> leadSeconds = weekSecond.stream().collect(Collectors.groupingBy(x -> x.getCreatedBy(), Collectors.mapping(Lead::getCreatedBy, Collectors.counting())));

        Map<String, Map<LocalDate, Long>> leadFirsts = weekFirst.stream().collect(Collectors.groupingBy(x -> x.getCreatedBy(), Collectors.groupingBy(x -> x.getCreatedTimestamp().toLocalDate(), Collectors.counting())));

        LOGGER.info("leadFirsts" + leadFirsts);

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

        if (!leads.isEmpty()) {

            authIds.addAll(leads.stream().map(x -> x.getAssignTo()).collect(Collectors.toList()));

            leadActivityMap = leadActivityRepository.selectAllByleadIds(leads.stream().map(x -> x.getId()).collect(Collectors.toList())).stream().collect(Collectors.groupingBy(LeadActivity::getLeadId, Collectors.toList()));

            Map<Integer, AuthUser> authIdAndAuthUserMap = authRepository.selectByIds(authIds).stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

            model.addAttribute("leadActivityMap", leadActivityMap);

            model.addAttribute("authIdAndAuthUserMap", authIdAndAuthUserMap);

            // Pending visit requests per lead — drives the "Visit request pending"

            // badge on the row template. Best-effort: never blocks the list render.

            try {

                List<Integer> leadIds = leads.stream().map(Lead::getId).collect(Collectors.toList());

                List<com.spice.profitmandi.dao.entity.user.LeadVisitRequest> pending =

                        leadVisitRequestRepository.selectByLeadIdsAndStatus(leadIds, "PENDING");

                Set<Integer> pendingSet = pending.stream()

                        .map(com.spice.profitmandi.dao.entity.user.LeadVisitRequest::getLeadId)

                        .collect(Collectors.toSet());

                model.addAttribute("pendingVisitRequestLeadIds", pendingSet);

            } catch (Exception e) {

                LOGGER.warn("pending visit-request lookup failed: {}", e.getMessage());

                model.addAttribute("pendingVisitRequestLeadIds", new HashSet<Integer>());

            }

        }

        ChartLeadModel cm = this.getLeadChart(leads);

        model.addAttribute("chartLead", gson.toJson(cm));

        LOGGER.info("ChartLeadModel" + gson.toJson(cm));

        LOGGER.info("lwDays" + lwDays);

        LOGGER.info("leads" + leads);

        List<String> stateNames = stateRepository.selectAll().stream().map(x -> x.getName()).collect(Collectors.toList());

//        List<AuthUser> authUsers = authRepository.selectAllActiveUser();

        List<AuthUser> authUsers = new ArrayList<>();

        List<AuthUser> salesUsers = csService.getAuthUserIds(ProfitMandiConstants.TICKET_CATEGORY_SALES, Arrays.asList(EscalationType.L1, EscalationType.L2, EscalationType.L3));

        List<AuthUser> abmUsers = csService.getAuthUserIds(ProfitMandiConstants.TICKET_CATEGORY_ABM, Arrays.asList(EscalationType.L1, EscalationType.L2, EscalationType.L3));

        List<AuthUser> bgcUsers = csService.getAuthUserIds(ProfitMandiConstants.TICKET_CATEGORY_BGC, Arrays.asList(EscalationType.L1, EscalationType.L2, EscalationType.L3));

        authUsers.addAll(salesUsers);

        authUsers.addAll(abmUsers);

        authUsers.addAll(bgcUsers);

        LocalDate lastDate = curDate.minusDays(1).toLocalDate();

        List<LocalDate> weekDates = new ArrayList<>();

        weekDates.add(curDate.minusDays(28).toLocalDate());

        weekDates.add(curDate.minusDays(22).toLocalDate());

        weekDates.add(curDate.minusDays(21).toLocalDate());

        weekDates.add(curDate.minusDays(15).toLocalDate());

        weekDates.add(curDate.minusDays(14).toLocalDate());

        weekDates.add(curDate.minusDays(8).toLocalDate());

        weekDates.add(curDate.minusDays(7).toLocalDate());

        LOGGER.info("lastDate" + lastDate);

        model.addAttribute("weekDates", weekDates);

        model.addAttribute("startDate", startDate);

        model.addAttribute("endDate", endDate);

        model.addAttribute("lastDate", lastDate);

        model.addAttribute("stateNames", stateNames);

        model.addAttribute("communicationTypes", CommunicationType.values());

        model.addAttribute("authUsers", authUsers);

        model.addAttribute("leads", leads);

        model.addAttribute("leadStatus", LeadStatus.values());

        model.addAttribute("leadLasts", leadLasts);

        model.addAttribute("leadThirds", leadThirds);

        model.addAttribute("leadSeconds", leadSeconds);

        model.addAttribute("leadFirsts", leadFirsts);

        model.addAttribute("lwDays", lwDays);

        model.addAttribute("selectedLeadStatus", leadStatus.get(0));

        boolean showBulkUploader =

                "sm@smartdukaan.com".equalsIgnoreCase(emailId);

        model.addAttribute("showBulkUploader", showBulkUploader);

        List<BrandCatalog> brandsDisplays = brandsService.getBrandsToDisplay(3);

        brandsDisplays.addAll(brandsService.getBrandsToDisplay(6));

        model.addAttribute("brandsDisplays", brandsDisplays.stream().distinct().collect(Collectors.toList()));

        LOGGER.info("brandsDisplays" + brandsDisplays);

        // Geo location status map for all leads

        if (!leads.isEmpty()) {

            List<Integer> allLeadIds = leads.stream().map(Lead::getId).collect(Collectors.toList());

            Map<Integer, LeadLiveLocation> geoLocationMap = leadLiveLocationRepository.selectByLeadIds(allLeadIds).stream()

                    .collect(Collectors.toMap(LeadLiveLocation::getLeadId, x -> x, (a, b) -> a));

            model.addAttribute("geoLocationMap", geoLocationMap);

        } else {

            model.addAttribute("geoLocationMap", new HashMap<>());

        }

        model.addAttribute("salesUsers", salesUsers);

        model.addAttribute("bgcUsers", bgcUsers);

        return "lead";

    }

    public ChartLeadModel getLeadChart(List<Lead> leads) throws ProfitMandiBusinessException {

        Map<LeadStatus, Long> leadStatusMap = leads.stream().collect(

                Collectors.groupingBy(x -> x.getStatus(), Collectors.mapping(Lead::getStatus, Collectors.counting())));

        Map<String, Long> hotLeadsMap = leads.stream().collect(

                Collectors.groupingBy(x -> x.getColor(), Collectors.mapping(Lead::getColor, Collectors.counting())));

        LOGGER.info("hotLeadsMap" + hotLeadsMap);

        ChartLeadModel cm = new ChartLeadModel();

        HashSet<LeadStatus> labels = new HashSet<LeadStatus>();

        labels.addAll(leadStatusMap.keySet());

        List<String> hotLeads = new ArrayList<>();

        hotLeads.addAll(leadStatusMap.keySet().stream().map(x -> x.toString()).collect(Collectors.toSet()));

        hotLeads.add("HotLead");

        List<String> hotLeadKeys = new ArrayList<>();

        hotLeadKeys.add("HotLead");

        List<String> hotLeadGreen = new ArrayList<>(hotLeadKeys);

        LOGGER.info("hotLeads" + hotLeads);

        List<LeadStatus> labelList = new ArrayList<>(labels);

        List<String> backgroundColor = new ArrayList<>();

        LOGGER.info("hotLeadKeys" + hotLeadKeys);

        List<Long> values = new ArrayList<>();

        for (String hotLead : hotLeads) {

            if (hotLead.equals("pending")) {

                backgroundColor.add("pink");

                values.add(leadStatusMap.get(LeadStatus.pending));

            }

            if (hotLead.equals("notInterested")) {

                backgroundColor.add("red");

                values.add(leadStatusMap.get(LeadStatus.notInterested));

            }

            if (hotLead.equals("followUp")) {

                backgroundColor.add("#9ACD32");

                values.add(leadStatusMap.get(LeadStatus.followUp));

            }

            if (hotLead.equals("finalized")) {

                backgroundColor.add("blue");

                values.add(leadStatusMap.get(LeadStatus.finalized));

            }

            if (hotLead.equals("HotLead")) {

                backgroundColor.add("green");

                values.add(hotLeadsMap.get("Green"));

            }

        }

        LOGGER.info("labelList" + labelList);

        LOGGER.info("backgroundColor" + backgroundColor);

        LOGGER.info("labelsChartLead" + labels);

        LeadStatusData data = new LeadStatusData();

        data.setData(values);

        data.setBackgroundColor(backgroundColor);

        data.setLabel("DataSet 1");

        PieLables label = new PieLables();

        label.setFontColor("black");

        label.setFontSize(15);

        Legend legend = new Legend();

        legend.setLabels(label);

        legend.setPosition("left");

        List<LeadStatusData> dataList = new ArrayList<>();

        dataList.add(data);

        DataLeadModel datasets = new DataLeadModel();

        datasets.setDatasets(dataList);

        datasets.setLabels(hotLeads);

        OptionModel om = new OptionModel();

        om.setLegend(legend);

        cm.setType("pie");

        cm.setData(datasets);

        cm.setOptions(om);

        return cm;

    }

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

    public ResponseEntity<?> getdownloadLeadDataByDate(HttpServletRequest request,

                                                       @RequestParam(name = "leadStatus", required = false, defaultValue = "All") List<LeadStatus> leadStatus,

                                                       @RequestParam(name = "color", required = false, defaultValue = "All") List<String> color,

                                                       @RequestParam(name = "startDate", required = false) LocalDate startDate,

                                                       @RequestParam(name = "endDate", required = false) LocalDate endDate) throws Exception {

        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        String emailId = fofoDetails.getEmailId();

        LocalDateTime startDateTime = startDate != null ? startDate.atStartOfDay() : null;

        LocalDateTime endDateTime = endDate != null ? endDate.atTime(23, 59, 59) : null;

        List<Lead> leads = new ArrayList<>();

        AuthUser authUser = authRepository.selectByEmailOrMobile(emailId);

        if (leadStatus.contains(LeadStatus.All)) {

            leadStatus.add(LeadStatus.pending);

            leadStatus.add(LeadStatus.notInterested);

            leadStatus.add(LeadStatus.finalized);

            leadStatus.add(LeadStatus.followUp);

        }

        if (color.contains("All")) {

            color.add("yellow");

            color.add("green");

        }

        Map<Integer, List<LeadActivity>> leadActivityMap = new HashMap<>();

        boolean authPositon = positionRepository.hasCategory(authUser.getId(), ProfitMandiConstants.TICKET_CATEGORY_SALES);

        List<Integer> authUserIds = null;

        List<Lead> leadFollowUp = new ArrayList<>();

        if (authPositon) {

            authUserIds = authService.getAllReportees(authUser.getId());

            authUserIds.add(authUser.getId());

            if (startDateTime == null) {

                if (!leadStatus.contains(LeadStatus.followUp)) {

                    leads = leadRepository.selectAllByColorStatusAndUpdatedTimestampAndAuthIds(leadStatus, authUserIds, color, LocalDateTime.now().minusMonths(1));

                }

                if (leadStatus.contains(LeadStatus.followUp) || leadStatus.contains(LeadStatus.All)) {

                    leadFollowUp = leadRepository.selectByAssignAuthIdsAndStatus(authUserIds, LeadStatus.followUp);

                    leads.addAll(leadFollowUp);

                }

            } else {

                if (!leadStatus.contains(LeadStatus.followUp)) {

                    leads = leadRepository.selectAllByColorStatusAndBetweenCreatedDateAndAuthIds(leadStatus, authUserIds, color, startDateTime, endDateTime);

                }

                if (leadStatus.contains(LeadStatus.followUp) || leadStatus.contains(LeadStatus.All)) {

                    leadFollowUp = leadRepository.selectByAssignAuthIdsAndStatus(authUserIds, LeadStatus.followUp);

                    leads.addAll(leadFollowUp);

                }

            }

        } else {

            if (startDateTime == null) {

                if (!leadStatus.contains(LeadStatus.followUp)) {

                    leads = leadRepository.selectAllByColorStatusAndUpdatedTimestamp(leadStatus, color, LocalDateTime.now().minusMonths(1));

                }

                if (leadStatus.contains(LeadStatus.followUp) || leadStatus.contains(LeadStatus.All)) {

                    leadFollowUp = leadRepository.selectAllByStatus(LeadStatus.followUp);

                    leads.addAll(leadFollowUp);

                }

            } else {

                if (!leadStatus.contains(LeadStatus.followUp)) {

                    leads = leadRepository.selectAllByColorStatusAndBetweenCreatedDate(leadStatus, color, startDateTime, endDateTime);

                }

                if (leadStatus.contains(LeadStatus.followUp)) {

                    leadFollowUp = leadRepository.selectAllByStatus(LeadStatus.followUp);

                    leads.addAll(leadFollowUp);

                }

            }

        }

        // Build activity map and auth map (SAME AS VIEW ENDPOINT)

        if (!leads.isEmpty()) {

            List<Integer> leadIds = leads.stream().map(Lead::getId).collect(Collectors.toList());

            leadActivityMap = leadActivityRepository.selectAllByleadIds(leadIds).stream()

                    .collect(Collectors.groupingBy(LeadActivity::getLeadId));

        }

        List<Integer> authIds = leads.stream().map(Lead::getAssignTo).collect(Collectors.toList());

        Map<Integer, AuthUser> authIdAndAuthUserMap = authRepository.selectByIds(authIds).stream()

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

        // Build CSV rows (USE DIRECT LEAD PROPERTIES - NO ACTIVITY FALLBACK)

        List<List<?>> rows = new ArrayList<>();

        for (Lead lead : leads) {

            List<LeadActivity> activities = leadActivityMap.get(lead.getId());

            // Use FIRST activity's schedule timestamp if exists

            String scheduleTimestamp = (activities != null && !activities.isEmpty())

                    ? FormattingUtils.format(activities.get(0).getSchelduleTimestamp())

                    : "";

            // DIRECTLY use Lead properties (NO fallback to activity)

            Double potential = lead.getPotential();

            String outLetName = lead.getOutLetName() != null ? lead.getOutLetName() : "";

            // Assignee name (blank if missing)

            String assignTo = "";

            if (authIdAndAuthUserMap.containsKey(lead.getAssignTo())) {

                AuthUser user = authIdAndAuthUserMap.get(lead.getAssignTo());

                assignTo = (user.getFirstName() + " " + user.getLastName()).trim();

            }

            rows.add(Arrays.asList(

                    lead.getId(),

                    lead.getSource(),

                    lead.getFullName(),

                    outLetName,

                    potential,

                    lead.getLeadMobile(),

                    lead.getAddress() != null ? lead.getAddress() : "",

                    lead.getCity() != null ? lead.getCity() : "",

                    lead.getState() != null ? lead.getState() : "",

                    lead.getCreatedBy() != null ? lead.getCreatedBy() : "",

                    lead.getStatus().toString(),

                    FormattingUtils.format(lead.getCreatedTimestamp()),

                    FormattingUtils.format(lead.getUpdatedTimestamp()),

                    scheduleTimestamp,

                    lead.getClosureTimestamp() != null

                            ? FormattingUtils.format(lead.getClosureTimestamp())

                            : "",  // Handle null closure

                    assignTo,

                    lead.getColor() != null ? lead.getColor() : ""

            ));

        }

        // Generate CSV response

        ByteArrayOutputStream baos = FileUtil.getCSVByteStream(

                Arrays.asList("Id", "Source", "Partner Name", "Outlet Name", "Potential", "Mobile", "Address", "City", "State",

                        "Created By", "Status", "Created On", "Updated On", "Scheduled Timestamp",

                        "Closure Timestamp", "Assign To", "Color"),

                rows

        );

        return orderService.downloadReportInCsv(baos, rows, "LeadDetails_");

    }

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

    public String getClosedLead(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, @RequestParam(name = "searchTerm", required = false, defaultValue = "") String searchTerm, Model model) throws Exception {

        List<AuthUser> authUsers = authRepository.selectAllActiveUser();

        List<Lead> leads = null;

        long size = 0;

        leads = leadRepository.selectAllByStatus(status, offset, limit);

        size = leadRepository.selectCountByStatus(status);

        if (!leads.isEmpty()) {

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

            for (Lead lead : leads) {

                authIds.add(lead.getAssignTo());

            }

            Map<Integer, AuthUser> authIdAndAuthUserMap = authRepository.selectByIds(authIds).stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

            model.addAttribute("leads", leads);

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

            model.addAttribute("size", size);

            model.addAttribute("searchTerm", searchTerm);

            model.addAttribute("authIdAndAuthUserMap", authIdAndAuthUserMap);

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

            if (leads.size() < limit) {

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

            } else {

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

            }

        } else {

            model.addAttribute("lead", leads);

            model.addAttribute("size", size);

        }

        model.addAttribute("authUsers", authUsers);

        return "lead-close";

    }

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

    public String getPaginatedClosedLeads(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException {

        List<Lead> leads = null;

        leads = leadRepository.selectAllByStatus(status, offset, limit);

        if (!leads.isEmpty()) {

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

            for (Lead lead : leads) {

                authIds.add(lead.getAssignTo());

            }

            Map<Integer, AuthUser> authIdAndAuthUserMap = authRepository.selectByIds(authIds).stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

            model.addAttribute("authIdAndAuthUserMap", authIdAndAuthUserMap);

            model.addAttribute("leads", leads);

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

        } else {

            model.addAttribute("leads", leads);

        }

        return "lead-close-paginated";

    }

    @RequestMapping(value = "/searchLeads")

    public String getClosedLeads(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, @RequestParam(name = "searchTerm", required = false, defaultValue = "") String searchTerm, Model model) throws ProfitMandiBusinessException {

        List<AuthUser> authUsers = authRepository.selectAllActiveUser();

        List<Lead> leads = null;

        long size = 0;

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

            leads = leadRepository.selectBySearchTerm(status, searchTerm, offset, limit);

            size = leadRepository.selectCountByStatus(status);

            Map<Integer, AuthUser> authIdAndAuthUserMap = new HashMap<>();

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

            if (!(leads.size() == 0)) {

                for (Lead lead : leads) {

                    authIds.add(lead.getAssignTo());

                }

                authIdAndAuthUserMap = authRepository.selectByIds(authIds).stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

                if (leads.size() < limit) {

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

                } else {

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

                }

            } else {

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

            }

            model.addAttribute("leads", leads);

            model.addAttribute("authIdAndAuthUserMap", authIdAndAuthUserMap);

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

            model.addAttribute("size", size);

            model.addAttribute("searchTerm", searchTerm);

        } else {

            leads = leadRepository.selectAllByStatus(status, offset, limit);

            size = leadRepository.selectCountByStatus(status);

            if (!leads.isEmpty()) {

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

                for (Lead lead : leads) {

                    authIds.add(lead.getAssignTo());

                }

                Map<Integer, AuthUser> authIdAndAuthUserMap = authRepository.selectByIds(authIds).stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

                model.addAttribute("leads", leads);

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

                model.addAttribute("size", size);

                model.addAttribute("searchTerm", searchTerm);

                model.addAttribute("authIdAndAuthUserMap", authIdAndAuthUserMap);

                if (leads.size() < limit) {

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

                } else {

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

                }

            }

        }

        model.addAttribute("authUsers", authUsers);

        return "lead-close";

    }

    @RequestMapping(value = "/searchLeadPaginated")

    public String searchLeadPaginated(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, @RequestParam(name = "searchTerm", required = false, defaultValue = "") String searchTerm, Model model) throws ProfitMandiBusinessException {

        LOGGER.info("In search Item....");

        List<Lead> leads = null;

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

            leads = leadRepository.selectBySearchTerm(status, searchTerm, offset, limit);

            if (!(leads.size() == 0)) {

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

                for (Lead lead : leads) {

                    authIds.add(lead.getAssignTo());

                }

                Map<Integer, AuthUser> authIdAndAuthUserMap = authRepository.selectByIds(authIds).stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

                model.addAttribute("authIdAndAuthUserMap", authIdAndAuthUserMap);

                model.addAttribute("leads", leads);

            }

        }

        return "lead-close-paginated";

    }

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

    public String getLeadActivity(HttpServletRequest request, @RequestParam int leadId, Model model) throws Exception {

        List<LeadActivity> leadActivity = leadActivityRepository.selectBYLeadId(leadId);

        LOGGER.info("leadActivity" + leadActivity);

        model.addAttribute("leadActivity", leadActivity);

        model.addAttribute("authUserMap", authRepository.selectAllActiveUser().stream().collect(Collectors.toMap(x -> x.getId(), x -> x)));

        return "lead_activity_modal";

    }

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

    public ResponseEntity<?> getLead(HttpServletRequest request, @RequestParam int leadId) throws Exception {

        Lead lead = leadRepository.selectById(leadId);

        LeadDetail leadDetail = leadDetailRepository.selectByLeadId(lead.getId());

        if (leadDetail != null) {

            lead.setOutLetName(leadDetail.getOutletName());

        }

        return responseSender.ok(lead);

    }

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

    public String CreateLead(HttpServletRequest request, @RequestBody CreateRefferalRequest createRefferalRequest, Model model) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        Lead leadDetails = leadRepository.selectByMobileNumber(createRefferalRequest.getMobile());

        LOGGER.info("Lead Details {}", leadDetails);

        if (leadDetails != null && leadDetails.getStatus() != LeadStatus.notInterested) {

            AuthUser authUser1 = authRepository.selectById(leadDetails.getAssignTo());

            model.addAttribute("response1", "Lead already exists, created by " + leadDetails.getCreatedBy() +

                    " on " + FormattingUtils.format(leadDetails.getCreatedTimestamp()) +

                    ", assigned to " + authUser1.getFullName());

            return "response";

        }

        LOGGER.info("createRefferalRequest" + createRefferalRequest.getSchelduleTimestamp());

        Lead lead = new Lead();

        lead.setFirstName(createRefferalRequest.getFirstName());

        lead.setLastName(createRefferalRequest.getLastName());

        lead.setLeadMobile(createRefferalRequest.getMobile());

        lead.setState(createRefferalRequest.getState());

        lead.setCity(createRefferalRequest.getCity());

        lead.setAddress(createRefferalRequest.getAddress());

        lead.setCreatedTimestamp(LocalDateTime.now());

        lead.setUpdatedTimestamp(LocalDateTime.now());

        lead.setStatus(createRefferalRequest.getStatus());

        lead.setAssignTo(createRefferalRequest.getAssignTo());

        lead.setSource(createRefferalRequest.getSource());

        if (Boolean.TRUE.equals(createRefferalRequest.getColorCheck())) {

            lead.setColor("Green");

        } else {

            lead.setColor("Yellow");

        }

        // change

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

        String authUserName = authUser.getFirstName() + " " + authUser.getLastName();

        lead.setCreatedBy(authUserName);

        lead.setAuthId(authUser.getId());

        LOGGER.info("lead --- {}", lead);

        leadRepository.persist(lead);

        LeadActivity leadActivity = new LeadActivity();

        leadActivity.setLeadId(lead.getId());

        leadActivity.setRemark(createRefferalRequest.getRemark());

        leadActivity.setAuthId(authUser.getId());

        LOGGER.info("createRefferalRequest" + createRefferalRequest.getCommunicationType());

        if (createRefferalRequest.getStatus() == LeadStatus.followUp) {

            leadActivity.setSchelduleTimestamp(createRefferalRequest.getSchelduleTimestamp());

            leadActivity.setCommunicationType(createRefferalRequest.getCommunicationType());

            if (leadActivity.getCommunicationType().equals(CommunicationType.VISIT)) {

                visitRequestRepository.createVisitRequest(lead.getId(), "lead", lead.getAssignTo(), createRefferalRequest.getSchelduleTimestamp());

            }

        } else {

            leadActivity.setSchelduleTimestamp(null);

        }

        leadActivity.setCreatedTimestamp(LocalDateTime.now());

        leadActivityRepository.persist(leadActivity);

        if (!lead.getStatus().equals(LeadStatus.notInterested)) {

            LeadDetailModel leadDetail = new LeadDetailModel();

            leadDetail.setLeadId(lead.getId());

            leadDetail.setOutletName(createRefferalRequest.getOutletName());

            leadDetail.setCounterSize(createRefferalRequest.getCounterSize());

            leadDetail.setFrontp(createRefferalRequest.getFrontp());

            leadDetail.setFrontWithMarket(createRefferalRequest.getFrontWithMarket());

            leadDetail.setInternalLongShot(createRefferalRequest.getInternalLongShot());

            leadDetail.setInternalLeftWall(createRefferalRequest.getInternalLeftWall());

            leadDetail.setInternalRightWall(createRefferalRequest.getInternalRightWall());

            List<LeadBrandModel> brandModels = new ArrayList<LeadBrandModel>();

            for (LeadBrandModel leadBrandModel : createRefferalRequest.getLeadBrands()) {

                LeadBrandModel leadBrand = new LeadBrandModel();

                leadBrand.setBrand(leadBrandModel.getBrand());

                leadBrand.setValue(leadBrandModel.getValue());

                brandModels.add(leadBrand);

            }

            leadDetail.setLeadBrands(brandModels);

            leadRepository.persistLeadDetail(leadDetail, authUser);

        }

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

        return "response";

    }

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

    public String EditLead(HttpServletRequest request, @RequestBody CreateLeacdActivityRequest createLeadActivityRequest, Model model) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

        Lead lead = leadRepository.selectById(createLeadActivityRequest.getId());

        AuthUser leadAuthUser = authRepository.selectById(lead.getAuthId());

        LeadDetail leadDetail = leadDetailRepository.selectByLeadId(createLeadActivityRequest.getId());

        // Geo gate: required for follow-up / finalized (anything that schedules

        // a visit or beat slot). For notInterested (close-out) no geo / no beat

        // is needed — only the activity (status + reason + remark) is saved.

        // Non-sales assignees (BGC / other internal hand-offs) also bypass the

        // gate — those are just routing the lead to another department's queue

        // and don't carry a beat-day attachment.

        int assignToId = createLeadActivityRequest.getAssignTo();

        boolean assigneeIsSales = assignToId > 0

                && positionRepository.hasCategory(assignToId, ProfitMandiConstants.TICKET_CATEGORY_SALES);

        if (createLeadActivityRequest.getStatus() != LeadStatus.notInterested && assigneeIsSales) {

            LeadLiveLocation approvedGeo = leadLiveLocationRepository.selectApprovedByLeadId(createLeadActivityRequest.getId());

            if (approvedGeo == null) {

                throw new ProfitMandiBusinessException("Lead", "", "Live geo-location for this lead has not been approved yet. Please approve the geo-location before editing.");

            }

        }

        if (leadDetail == null && !createLeadActivityRequest.getStatus().equals(LeadStatus.notInterested) && leadAuthUser.isActive()) {

            throw new ProfitMandiBusinessException("LeadDetail", "", "Please fill lead detail");

        }

        LeadActivity leadActivity = new LeadActivity();

        leadActivity.setLeadId(createLeadActivityRequest.getId());

        leadActivity.setRemark(createLeadActivityRequest.getRemark());

        LOGGER.info("createRefferalRequest" + createLeadActivityRequest);