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

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.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 javax.transaction.Transactional;

import java.io.ByteArrayInputStream;

import java.io.InputStream;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.format.DateTimeFormatter;

import java.util.*;

import java.util.Map.Entry;

import java.util.stream.Collectors;

@Controller

@Transactional(rollbackOn = Throwable.class)

public class LeadController {

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

    @Autowired

    private LeadRepository leadRepository;

    @Autowired

    private LeadActivityRepository leadActivityRepository;

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

    @Autowired

    private ResponseSender<?> responseSender;

    @Autowired

    private BrandsService brandsService;

    @Autowired

    OrderService orderService;

    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 = "leadDate", required = false, defaultValue = "") LocalDate leadDate, Model model) throws Exception {

        LocalDateTime localDateTime = null;

        if (leadDate != null) {

            localDateTime = leadDate.atStartOfDay();

        }

        LOGGER.info("localDateTime" + localDateTime);

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        String emailId = loginDetails.getEmailId();

        AuthUser authUser = authRepository.selectByEmailOrMobile(emailId);

        boolean authPositon = 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 (authPositon) {

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

            authUserIds.add(authUser.getId());

            LOGGER.info("authIds" + authUserIds);

            LOGGER.info("leadStatus" + leadStatus);

            if (localDateTime == 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.selectAllByColorStatusAndUpdatedTimestampAndAuthIds(leadStatus, authUserIds, color, localDateTime);

                }

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

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

                    leads.addAll(leadFollowUp);

                }

            }

        } else {

            if (localDateTime == 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.selectAllByColorStatusAndUpdatedTimestamp(leadStatus, color, localDateTime);

                }

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

                    leadFollowUp = leadRepository.selectAllByStatus(LeadStatus.followUp);

                    leads.addAll(leadFollowUp);

                }

                LOGGER.info("leadlocalDateTime2" + leads);

            }

        }

        if (authPositon && 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.selectAllAuthUserByIds(authIds).stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

            model.addAttribute("leadActivityMap", leadActivityMap);

            model.addAttribute("authIdAndAuthUserMap", authIdAndAuthUserMap);

        }

        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 = csService.getAuthUserIds(ProfitMandiConstants.TICKET_CATEGORY_SALES, Arrays.asList(EscalationType.L1, EscalationType.L2, EscalationType.L3));

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

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

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

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

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

        LOGGER.info("brandsDisplays" + brandsDisplays);

        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 = "leadDate", required = false, defaultValue = "") LocalDate leadDate, Model model) throws Exception {

        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        String emailId = fofoDetails.getEmailId();

        LocalDateTime localDateTime = null;

        if (leadDate != null) {

            localDateTime = leadDate.atStartOfDay();

        }

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

        AuthUser authUser = authRepository.selectByEmailOrMobile(emailId);

        model.addAttribute("colors", color);

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

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

        List<Integer> authUserIds = null;

        LOGGER.info("color111" + color);

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

        if (authPositon) {

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

            authUserIds.add(authUser.getId());

            LOGGER.info("authIds" + authUserIds);

            LOGGER.info("leadStatus" + leadStatus);

            if (localDateTime == 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.selectAllByColorStatusAndUpdatedTimestampAndAuthIds(leadStatus, authUserIds, color, localDateTime);

                }

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

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

                    leads.addAll(leadFollowUp);

                }

            }

        } else {

            if (localDateTime == 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.selectAllByColorStatusAndUpdatedTimestamp(leadStatus, color, localDateTime);

                }

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

                    leadFollowUp = leadRepository.selectAllByStatus(LeadStatus.followUp);

                    leads.addAll(leadFollowUp);

                }

                LOGGER.info("leadlocalDateTime2" + leads);

            }

        }

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

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

        if (!leads.isEmpty()) {

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

        }

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

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

        for (Lead lead : leads) {

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

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

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

                    : null;

            Double potental = 0d;

            String outLetName = "";

            if (lead.getPotential() >= 0) {

                potental = lead.getPotential();

            } else if (activities != null && !activities.isEmpty()) {

                potental = activities.get(0).getPotential();

            } else potental = 0d;

            if (lead.getOutLetName() != null) {

                outLetName = lead.getOutLetName();

            } else if (activities != null && !activities.isEmpty()) {

                outLetName = activities.get(0).getOutletName();

            } else outLetName = "-";

            String assignTo = "-";

            if (authIdAndAuthUserMap.get(lead.getAssignTo()) != null) {

                assignTo = authIdAndAuthUserMap.get(lead.getAssignTo()).getFirstName() + " " + authIdAndAuthUserMap.get(lead.getAssignTo()).getLastName();

            } else assignTo = "-";

            rows.add(Arrays.asList(lead.getSource(), lead.getFullName(), outLetName, potental, lead.getLeadMobile(),

                    lead.getAddress(), lead.getCity(), lead.getState(), lead.getCreatedBy(), lead.getStatus(),

                    FormattingUtils.format(lead.getCreatedTimestamp()), FormattingUtils.format(lead.getUpdatedTimestamp()), scheduleTimestamp, FormattingUtils.format(lead.getClosureTimestamp()), assignTo, lead.getColor()));

        }

//        #if($leadActivityMap.get($lead.getId()).get(0).getSchelduleTimestamp())

        org.apache.commons.io.output.ByteArrayOutputStream baos = FileUtil.getCSVByteStream(

                Arrays.asList("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);

        ResponseEntity<?> responseEntity = orderService.downloadReportInCsv(baos, rows, "Lead Details ");

        return responseEntity;

    }

    @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.selectAllAuthUserByIds(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.selectAllAuthUserByIds(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.selectAllAuthUserByIds(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.selectAllAuthUserByIds(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.selectAllAuthUserByIds(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);

        List<Lead> leadDetailList = leadRepository.selectByMobileNumber(createRefferalRequest.getMobile());

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

        if (!leadDetailList.isEmpty()) {

            AuthUser authUser1 = authRepository.selectById(leadDetailList.get(0).getAssignTo());

            throw new ProfitMandiBusinessException("Duplicate Entry",

                    "Lead already exists, created by " + leadDetailList.get(0).getCreatedBy() +

                            " on " + FormattingUtils.format(leadDetailList.get(0).getCreatedTimestamp()) +

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

        }

        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 (createRefferalRequest.getColorCheck() == true) {

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

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

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

            leadActivity.setSchelduleTimestamp(createLeadActivityRequest.getScheldule());

            leadActivity.setCommunicationType(createLeadActivityRequest.getCommunicationType());

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

                visitRequestRepository.createVisitRequest(createLeadActivityRequest.getId(), "lead", createLeadActivityRequest.getAssignTo(), createLeadActivityRequest.getScheldule());

            }

        } else {

            leadActivity.setSchelduleTimestamp(null);

        }

        leadActivity.setCreatedTimestamp(LocalDateTime.now());

        leadActivity.setAuthId(authUser.getId());

        leadActivityRepository.persist(leadActivity);

        lead.setAssignTo(createLeadActivityRequest.getAssignTo());

        lead.setStatus(createLeadActivityRequest.getStatus());

        if (createLeadActivityRequest.getColorCheck() == true) {

            lead.setColor("Green");

        } else {

            lead.setColor("Yellow");

        }

        lead.setNotinterestedReason(createLeadActivityRequest.getReason());

        lead.setUpdatedTimestamp(LocalDateTime.now());

        int authId = 0;

        authId = lead.getAssignTo();

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

        List<LeadActivity> leadActivitys = leadActivityRepository.selectBYLeadId(lead.getId());

        if (!leadActivitys.isEmpty()) {

            leadActivityMap.put(lead.getId(), leadActivitys.get(0));

        }

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

        AuthUser AuthUser = authRepository.selectById(authId);

        authIdAndAuthUserMap.put(AuthUser.getId(), AuthUser);

        model.addAttribute("leadActivityMap", leadActivityMap);

        model.addAttribute("authIdAndAuthUserMap", authIdAndAuthUserMap);

        model.addAttribute("lead", lead);

        return "edit-lead";

    }

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

    public ResponseEntity<?> downloadDelayDayTemplate(HttpServletRequest request) throws Exception {

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

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

        List<LeadSource> lss = LeadSource.enumValues;

        for (LeadSource ls : lss) {

            rows.add(Arrays.asList("-", "-", "-", "-", "-", "-", "-", ls));

        }

        for (String stateName : stateNames) {

            rows.add(Arrays.asList("-", "-", "-", "-", stateName, "-", "-", "-"));

        }

        org.apache.commons.io.output.ByteArrayOutputStream baos = FileUtil.getCSVByteStream(Arrays.asList("First Name", "Last Name", "Address", "City", "State", "Mobile", "Assign To(email)", "Source"), rows);

        final HttpHeaders headers = new HttpHeaders();

        headers.set("Content-Type", "text/csv");

        headers.set("Content-disposition", "inline; filename=leads.format.csv");

        headers.setContentLength(baos.toByteArray().length);

        final InputStream inputStream = new ByteArrayInputStream(baos.toByteArray());

        final InputStreamResource inputStreamResource = new InputStreamResource(inputStream);

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

    }

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

    public String readCsvFileAndSetLead(HttpServletRequest request, Model model, HttpServletResponse response, @RequestPart MultipartFile file) throws Throwable {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        String email = loginDetails.getEmailId();