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

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

        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 = "/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);

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

                size = leadRepository.selectCountByStatus(status);

                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("start", offset + 1);

                model.addAttribute("size", size);

                model.addAttribute("searchTerm", searchTerm);

                if (leads.size() < limit) {

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

                } else {

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

                }

            } else {

                throw new ProfitMandiBusinessException("lead", searchTerm, "leads Not Found");

            }

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

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

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

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

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

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

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

            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 lead = leadRepository.selectById(createLeadActivityRequest.getId());

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

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

        int authId = 0;

        if (lead != null) {

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

        AuthUser createdBy = authRepository.selectByEmailOrMobile(email);

        LOGGER.info("file" + file.toString());

        String fileName = file.getName();

        String fileNames = file.getOriginalFilename();

        LOGGER.info("fileName" + fileName);

        LOGGER.info("fileNames" + fileNames);

        List<CSVRecord> records = FileUtil.readFile(file);

        for (CSVRecord record : records) {

            Lead lead = new Lead();

            lead.setFirstName(record.get(0));

            lead.setLastName(record.get(1));

            lead.setAddress(record.get(2));

            lead.setCity(record.get(3));

            lead.setState(record.get(4));

            lead.setLeadMobile(record.get(5));

            LOGGER.info("record" + record.get(6));

            AuthUser assignTo = authRepository.selectByEmailOrMobile(record.get(6));

            if (assignTo == null) {

                throw new ProfitMandiBusinessException("Assign To ", record.get(6), "email id not exist");

            }

            lead.setAssignTo(assignTo.getId());

            lead.setSource(record.get(7));

            lead.setCreatedTimestamp(LocalDateTime.now());

            lead.setUpdatedTimestamp(LocalDateTime.now());

            lead.setStatus(LeadStatus.pending);

            lead.setColor("yellow");

            // change

            lead.setCreatedBy(createdBy.getFullName());

            lead.setAuthId(createdBy.getId());

            leadRepository.persist(lead);

            LeadActivity leadActivity = new LeadActivity();

            leadActivity.setLeadId(lead.getId());

            leadActivity.setRemark("New Lead");

            leadActivity.setSchelduleTimestamp(null);

            leadActivity.setCreatedTimestamp(LocalDateTime.now());

            leadActivityRepository.persist(leadActivity);

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

        }

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

        return "response";

    }

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

    public String teamCommitments(HttpServletRequest request, Model model) throws Exception {

        return "team-commitment";

    }

    @RequestMapping(value = "/leadDetail", method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_VALUE)

    public String leadDetail(HttpServletRequest request, @RequestBody LeadDetailModel leadDetailModel, Model model) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

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

        leadRepository.persistLeadDetail(leadDetailModel, authUser);

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

        return "response";

    }

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

    public String getLeadDetail(HttpServletRequest request, Model model) throws Exception {

        List<Integer> followUpleadIds = leadRepository.selectAllByStatus(LeadStatus.followUp).stream().map(x -> x.getId()).collect(Collectors.toList());

        List<LeadDetail> leadDetails = leadDetailRepository.selectByLeadIds(followUpleadIds);

        List<DBObject> mobileBrands = mongoClient.getAllBrandsToDisplay(3);

        List<String> brands = mobileBrands.stream().map(x -> (String) x.get("name")).collect(Collectors.toList());

        model.addAttribute("brands", brands);

        if (!leadDetails.isEmpty()) {

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

            List<Integer> leadIds = leadDetails.stream().map(x -> x.getLeadId()).collect(Collectors.toList());

            Map<Integer, Lead> leadMap = leadRepository.selectAllByIds(leadIds).stream().filter(x -> x.getStatus().equals(LeadStatus.followUp)).collect(Collectors.toMap(x -> x.getId(), x -> x));

            Map<Integer, Optional<LeadActivity>> leadActivityMap = leadActivityRepository.selectAllByleadIds(leadIds).stream().collect(Collectors.groupingBy(x -> x.getLeadId(), Collectors.maxBy(Comparator.comparing(LeadActivity::getId))));

            model.addAttribute("leadActivityMap", leadActivityMap);

            List<LeadBrand> leadBrands = leadBrandRepository.selectByLeadDetailId(detailsIds);

            LOGGER.info("leadBrands {}" + leadBrands);

            Map<Integer, Map<String, Integer>> leadDetailBrandValue = new HashMap<>();

            Map<Integer, List<LeadBrand>> leadDetail = leadBrands.stream().collect(Collectors.groupingBy(x -> x.getLeadDetailId(), Collectors.toList()));

            for (Entry<Integer, List<LeadBrand>> leadDetailEntry : leadDetail.entrySet()) {

                Map<String, Integer> brandValue = new HashMap<>();

                for (LeadBrand leadBrand : leadDetailEntry.getValue()) {

                    brandValue.put(leadBrand.getBrand(), leadBrand.getValue());

                }

                leadDetailBrandValue.put(leadDetailEntry.getKey(), brandValue);

            }

            LOGGER.info("leadDetailBrandValue {}" + leadDetailBrandValue);

            model.addAttribute("leadDetailBrandValue", leadDetailBrandValue);

            model.addAttribute("leadMap", leadMap);

        }

        model.addAttribute("leadDetails", leadDetails);

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

        model.addAttribute("authIdAndAuthUserMap", authIdAndAuthUserMap);

        return "lead-detail";

    }

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

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