Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.time.LocalDateTime;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.stream.Collectors;

import javax.servlet.http.HttpServletRequest;

import javax.transaction.Transactional;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

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

import org.springframework.stereotype.Controller;

import org.springframework.ui.Model;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@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 AuthRepository authRepository;

	@Autowired

	private CookiesProcessor cookiesProcessor;

	@Autowired

	private MVCResponseSender mvcResponseSender;

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

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

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

		List<Lead> leads = leadRepository.selectAllByStatus(LeadStatus.followUp);

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

		leads.addAll(leadRepository.selectAllByStatus(LeadStatus.pending));

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

		if (!leads.isEmpty()) {

			for (Lead lead : leads) {

				authIds.add(lead.getAssignTo());

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

				if (!leadActivity.isEmpty()) {

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

				}

			}

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

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

			model.addAttribute("lead", leads);

			model.addAttribute("leadActivityMap", leadActivityMap);

			model.addAttribute("authIdAndAuthUserMap", authIdAndAuthUserMap);

		} else {

			model.addAttribute("lead", leads);

		}

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

				.collect(Collectors.toList());

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

		model.addAttribute("stateNames", stateNames);

		model.addAttribute("authUsers", authUsers);

		return "lead";

	}

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

		model.addAttribute("leadActivity", leadActivity);

		return "lead_activity_modal";

	}

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

		lead.setColor("yellow");

		// change

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

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

		lead.setCreatedBy(authUserName);

		lead.setAuthId(authUser.getId());

		leadRepository.persist(lead);

		LeadActivity leadActivity = new LeadActivity();

		leadActivity.setLeadId(lead.getId());

		leadActivity.setRemark(createRefferalRequest.getRemark());

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

			leadActivity.setSchelduleTimestamp(createRefferalRequest.getSchelduleTimestamp());

		} else {

			leadActivity.setSchelduleTimestamp(null);

		}

		leadActivity.setCreatedTimestamp(LocalDateTime.now());

		leadActivityRepository.persist(leadActivity);

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

		return "response";

	}

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

	public String EditLead(HttpServletRequest request,

			@RequestBody CreateLeacdActivityRequest createLeadActivityRequest, Model model) throws Exception {

		LeadActivity leadActivity = new LeadActivity();

		leadActivity.setLeadId(createLeadActivityRequest.getId());

		leadActivity.setRemark(createLeadActivityRequest.getRemark());

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

			leadActivity.setSchelduleTimestamp(createLeadActivityRequest.getScheldule());

		} else {

			leadActivity.setSchelduleTimestamp(null);

		}

		leadActivity.setCreatedTimestamp(LocalDateTime.now());

		leadActivityRepository.persist(leadActivity);

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

		lead.setAssignTo(createLeadActivityRequest.getAssignTo());

		lead.setStatus(createLeadActivityRequest.getStatus());

		lead.setUpdatedTimestamp(LocalDateTime.now());

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

		return "response";

	}

}