Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.time.LocalDateTime;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.stream.Collectors;

import javax.mail.internet.InternetAddress;

import javax.mail.internet.MimeMessage;

import javax.servlet.http.HttpServletRequest;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

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

import org.springframework.mail.javamail.JavaMailSender;

import org.springframework.mail.javamail.MimeMessageHelper;

import org.springframework.stereotype.Controller;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.ui.Model;

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.common.model.CustomRetailer;

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

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

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

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

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

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

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

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

import com.spice.profitmandi.dao.repository.user.UserRepository;

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

import com.spice.profitmandi.service.wallet.WalletService;

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

import in.shop2020.model.v1.order.WalletReferenceType;

@Controller

@Transactional(rollbackFor = Throwable.class)

public class RefferalController {

	@Autowired

	private RefferalRepository refferalRepository;

	@Autowired

	private MVCResponseSender mvcResponseSender;

	@Autowired

	private FofoStoreRepository fofoStoreRepository;

	@Autowired

	private RetailerService retailerService;

	@Autowired

	private WalletService walletService;

	@Autowired

	private RefferalMonthlyAmountRepository refferalMonthlyAmountRepository;

	@Autowired

	private UserRepository userRepository;

	@Autowired

	private com.spice.profitmandi.dao.repository.user.UserRepository userUserRepository;

	@Autowired

	JavaMailSender mailSender;

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

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

	public String getRefferalsRequest(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {

		List<Refferal> refferals = refferalRepository.selectByStatus(RefferalStatus.pending);

		Map<String, CustomRetailer> customerRetailerMap = new HashMap<>();

		if (!refferals.isEmpty()) {

			Set<String> emails = refferals.stream().map(x -> x.getRefereeEmail()).collect(Collectors.toSet());

			List<User> users = userUserRepository.selectByEmailIds(emails);

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

			Map<Integer, CustomRetailer> customRetailers = retailerService.getFofoRetailers(fofoIds);

			customerRetailerMap = customRetailers.entrySet().stream()

					.collect(Collectors.toMap(x -> x.getValue().getEmail(), x -> x.getValue()));

		}

		model.addAttribute("customerRetailerMap", customerRetailerMap);

		model.addAttribute("rStatus", "pending");

		model.addAttribute("refferals", refferals);

		return "refferal";

	}

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

	public String getValidateRefferals(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {

		List<Refferal> refferals = refferalRepository.selectByStatus(RefferalStatus.validate);

		Map<String, CustomRetailer> customerRetailerMap = new HashMap<>();

		if (!refferals.isEmpty()) {

			Set<String> emails = refferals.stream().map(x -> x.getRefereeEmail()).collect(Collectors.toSet());

			List<User> users = userUserRepository.selectByEmailIds(emails);

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

			Map<Integer, CustomRetailer> customRetailers = retailerService.getFofoRetailers(fofoIds);

			customerRetailerMap = customRetailers.entrySet().stream()

					.collect(Collectors.toMap(x -> x.getValue().getEmail(), x -> x.getValue()));

		}

		model.addAttribute("customerRetailerMap", customerRetailerMap);

		model.addAttribute("refferals", refferals);

		model.addAttribute("rStatus", "validate");

		return "refferal";

	}

	@RequestMapping(value = "/validateRefferal", method = RequestMethod.PUT)

	public String validateRefferal(HttpServletRequest request,

			@RequestParam(name = "refferalId", defaultValue = "0") int refferalId, Model model) throws Exception {

		Refferal refferal = refferalRepository.selectById(refferalId);

		if (refferal.getStatus().equals(RefferalStatus.pending)) {

			refferal.setStatus(RefferalStatus.validate);

			refferal.setUpdatedTimestamp(LocalDateTime.now());

			refferalRepository.persist(refferal);

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

			String subject = "Referral Approval Request for " + refferal.getRefereeEmail();

			String messageText = this.getMessageForReferral(refferal);

			MimeMessage message = mailSender.createMimeMessage();

			MimeMessageHelper helper = new MimeMessageHelper(message, true);

			String[] email = { "tarun.verma@smartdukaan.com", "tejbeer.kaur@shop2020.in",

					"rakesh.sonawane@smartdukaan.com", "sm@smartdukaan.com" };

			helper.setSubject(subject);

			helper.setText(messageText, true);

			helper.setTo(email);

			InternetAddress senderAddress = new InternetAddress("noreply@smartdukaan.com", "Smartdukaan Alerts");

			helper.setFrom(senderAddress);

			mailSender.send(message);

		} else {

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

		}

		return "response";

	}

	private String getMessageForReferral(Refferal referral) {

		StringBuilder sb = new StringBuilder();

		sb.append("<html><body><p>Alert</p><p> Referral Requests:-</p>"

				+ "<br/><table style='border:1px solid black ;padding: 5px';>");

		sb.append("<tbody>\n" + "	    				<tr>\n"

				+ "	    					<th style='border:1px solid black;padding: 5px'>RefereeName</th>\n"

				+ "	    					<th style='border:1px solid black;padding: 5px'>Referee Email</th>\n"

				+ "	    					<th style='border:1px solid black;padding: 5px'>Referral Name</th>\n"

				+ "	    					<th style='border:1px solid black;padding: 5px'>Refferal Mobile</th>\n"

				+ "	    					<th style='border:1px solid black;padding: 5px'>city</th>\n"

				+ "	    					<th style='border:1px solid black;padding: 5px'>state</th>\n"

				+ "	    				</tr>");

		sb.append("<tr>");

		sb.append("<td style='border:1px solid black;padding: 5px'>" + referral.getRefereeName() + "</td>");

		sb.append("<td style='border:1px solid black;padding: 5px'>" + referral.getRefereeEmail() + "</td>");

		sb.append("<td style='border:1px solid black;padding: 5px'>" + referral.getFirstName() + "</td>");

		sb.append("<td style='border:1px solid black;padding: 5px'>" + referral.getMobile() + "</td>");

		sb.append("<td style='border:1px solid black;padding: 5px'>" + referral.getCity() + "</td>");

		sb.append("<td style='border:1px solid black;padding: 5px'>" + referral.getState() + "</td>");

		sb.append("</tr>");

		sb.append("</tbody></table></body></html>");

		return sb.toString();

	}

	@RequestMapping(value = "/approveRefferal", method = RequestMethod.PUT)

	public String approveRefferal(HttpServletRequest request,

			@RequestParam(name = "refferalId", defaultValue = "0") int refferalId, Model model) throws Exception {

		Refferal refferal = refferalRepository.selectById(refferalId);

		if (refferal.getStatus().equals(RefferalStatus.validate)) {

			refferal.setStatus(RefferalStatus.approved);

			refferal.setUpdatedTimestamp(LocalDateTime.now());

			refferal.setApprovedTimestamp(LocalDateTime.now());

			refferalRepository.persist(refferal);

			String subject = "Referral Request Approved for " + refferal.getRefereeEmail();

			String messageText = this.getMessageForReferral(refferal);

			this.sendMailWithAttachments(subject, messageText);

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

		} else {

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

		}

		return "response";

	}

	private void sendMailWithAttachments(String subject, String messageText) throws Exception {

		MimeMessage message = mailSender.createMimeMessage();

		MimeMessageHelper helper = new MimeMessageHelper(message, true);

		String[] email = { "neeraj.gupta@smartdukaan.com" };

		helper.setSubject(subject);

		helper.setText(messageText, true);

		helper.setTo(email);

		InternetAddress senderAddress = new InternetAddress("noreply@smartdukaan.com", "Smartdukaan Alerts");

		helper.setFrom(senderAddress);

		mailSender.send(message);

	}

	@RequestMapping(value = "/rejectRefferal", method = RequestMethod.PUT)

	public String rejectRefferal(HttpServletRequest request,

			@RequestParam(name = "refferalId", defaultValue = "0") int refferalId, @RequestParam String rejectionReason,

			Model model) throws Exception {

		Refferal refferal = refferalRepository.selectById(refferalId);

		if (refferal.getStatus().equals(RefferalStatus.pending)

				|| refferal.getStatus().equals(RefferalStatus.validate)) {

			refferal.setStatus(RefferalStatus.rejected);

			refferal.setRejectedReason(rejectionReason);

			refferal.setUpdatedTimestamp(LocalDateTime.now());

			refferalRepository.persist(refferal);

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

		} else {

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

		}

		return "response";

	}

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

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

		Map<String, Long> pastApprovedCountMap = null;

		List<Refferal> pastrefferal = new ArrayList<>();

		DateRangeModel drm = new DateRangeModel();

		drm.setStartDate(LocalDateTime.now().minusMonths(1).withDayOfMonth(1));

		drm.setEndDate(LocalDateTime.now().minusMonths(1).withDayOfMonth(16));

		List<Refferal> previousMonthapprovedRefferal = refferalRepository

				.selectByStatusAndDateRanges(RefferalStatus.approved, drm);

		drm.setStartDate(LocalDateTime.now().minusMonths(1).withDayOfMonth(16));

		drm.setEndDate(LocalDateTime.now().withDayOfMonth(16));

		LocalDateTime currentMonthdate = LocalDateTime.now().withDayOfMonth(1);

		List<Refferal> preCurrMonthapproved = refferalRepository

				.selectByStatusAndDateRange(RefferalStatus.approved, drm).stream()

				.filter(x -> x.getCreatedTimestamp().isBefore(currentMonthdate)).collect(Collectors.toList());

		preCurrMonthapproved.addAll(previousMonthapprovedRefferal);

		LOGGER.info("preCurrMonthapproved" + preCurrMonthapproved);

		Map<String, Long> preApproved = preCurrMonthapproved.stream()

				.collect(Collectors.groupingBy(Refferal::getRefereeEmail, Collectors.counting()));

		drm.setStartDate(LocalDateTime.now().minusMonths(2).withDayOfMonth(1));

		drm.setEndDate(LocalDateTime.now().minusMonths(2).withDayOfMonth(16));

		LocalDateTime previousMonthdate = LocalDateTime.now().minusMonths(1).withDayOfMonth(1);

		List<Refferal> oldMonthapprovedRefferal = refferalRepository

				.selectByStatusAndDateRanges(RefferalStatus.approved, drm);

		drm.setStartDate(LocalDateTime.now().minusMonths(2).withDayOfMonth(16));

		drm.setEndDate(LocalDateTime.now().minusMonths(1).withDayOfMonth(16));

		List<Refferal> oldPreMonthapproved = refferalRepository.selectByStatusAndDateRange(RefferalStatus.approved, drm)

				.stream().filter(x -> x.getCreatedTimestamp().isBefore(previousMonthdate)).collect(Collectors.toList());

		oldPreMonthapproved.addAll(oldMonthapprovedRefferal);

		LOGGER.info("oldPreMonthapproved" + oldPreMonthapproved);

		Map<String, Long> oldApproved = oldPreMonthapproved.stream()

				.collect(Collectors.groupingBy(Refferal::getRefereeEmail, Collectors.counting()));

		LOGGER.info("preApproved" + preApproved);

		if (preApproved.isEmpty() && oldApproved.isEmpty()) {

			pastrefferal = refferalRepository.selectByStatus(RefferalStatus.approved);

			pastApprovedCountMap = pastrefferal.stream()

					.collect(Collectors.groupingBy(Refferal::getRefereeEmail, Collectors.counting()));

		}

		List<Refferal> referalslist = new ArrayList<>();

		referalslist.addAll(oldPreMonthapproved);

		referalslist.addAll(pastrefferal);

		referalslist.addAll(preCurrMonthapproved);

		Map<String, CustomRetailer> customerRetailerMap = new HashMap<>();

		if (!referalslist.isEmpty()) {

			Set<String> emails = referalslist.stream().map(x -> x.getRefereeEmail()).collect(Collectors.toSet());

			List<User> users = userUserRepository.selectByEmailIds(emails);

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

			Map<Integer, CustomRetailer> customRetailers = retailerService.getFofoRetailers(fofoIds);

			customerRetailerMap = customRetailers.entrySet().stream()

					.collect(Collectors.toMap(x -> x.getValue().getEmail(), x -> x.getValue()));

		}

		model.addAttribute("customerRetailerMap", customerRetailerMap);

		LOGGER.info("refferal" + pastrefferal);

		LOGGER.info("oldApproved" + oldApproved);

		LOGGER.info("pastApproved" + pastApprovedCountMap);

		model.addAttribute("oldMonth", LocalDateTime.now().minusMonths(2).getMonth());

		model.addAttribute("oldApproved", oldApproved);

		model.addAttribute("oldPreMonthapproved", oldPreMonthapproved);

		model.addAttribute("previousMonth", LocalDateTime.now().minusMonths(1).getMonth());

		model.addAttribute("pastApproved", pastApprovedCountMap);

		model.addAttribute("pastrefferal", pastrefferal);

		model.addAttribute("preApproved", preApproved);

		model.addAttribute("preCurrMonthapproved", preCurrMonthapproved);

		return "refferal-approve";

	}

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

	public String addMoneyToWallet(HttpServletRequest request, @RequestParam String refereeEmail,

			@RequestParam int count, @RequestParam int amount, @RequestParam String month, Model model)

			throws Exception {

		User user = userRepository.selectByEmailId(refereeEmail);

		if (user != null) {

			RefferalMonthlyAmount rfm = new RefferalMonthlyAmount();

			rfm.setAmount(amount);

			rfm.setCount(count);

			rfm.setRefereeEmail(user.getEmailId());

			rfm.setCreatedTimstamp(LocalDateTime.now());

			refferalMonthlyAmountRepository.persist(rfm);

			walletService.addAmountToWallet(user.getId(), rfm.getId(), WalletReferenceType.REFERRAL_INCENTIVES,

					count + "referral of" + month + "Month", amount, LocalDateTime.now());

			DateRangeModel drm = new DateRangeModel();

			drm.setStartDate(LocalDateTime.now().minusMonths(1).withDayOfMonth(1));

			drm.setEndDate(LocalDateTime.now().minusMonths(1).withDayOfMonth(16));

			List<Refferal> previousMonthapprovedRefferal = refferalRepository

					.selectByEmailIdAndStatusAndDateRanges(user.getEmailId(), RefferalStatus.approved, drm);

			drm.setStartDate(LocalDateTime.now().minusMonths(1).withDayOfMonth(16));

			drm.setEndDate(LocalDateTime.now().withDayOfMonth(16));

			List<Refferal> previousAndcurrentMonthapprovedRefferal = refferalRepository

					.selectByEmailIdAndStatusAndDateRange(user.getEmailId(), RefferalStatus.approved, drm);

			LocalDateTime currentMonthdate = LocalDateTime.now().withDayOfMonth(1);

			List<Refferal> preCurrMonthapproved = previousAndcurrentMonthapprovedRefferal.stream()

					.filter(x -> x.getCreatedTimestamp().isBefore(currentMonthdate)).collect(Collectors.toList());

			List<Refferal> approvedRefferals = new ArrayList<>(previousMonthapprovedRefferal);

			approvedRefferals.addAll(preCurrMonthapproved);

			if (approvedRefferals.isEmpty()) {

				List<Refferal> pastApproved = refferalRepository.selectByStatusAndEmailId(RefferalStatus.approved,

						user.getEmailId());

				approvedRefferals.addAll(pastApproved);

			}

			for (Refferal refferl : approvedRefferals) {

				refferl.setStatus(RefferalStatus.transferred);

				refferl.setUpdatedTimestamp(LocalDateTime.now());

			}

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

		} else {

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

		}

		return "response";

	}

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

	public String addMoneyToWalletPrevious(HttpServletRequest request, @RequestParam String refereeEmail,

			@RequestParam int count, @RequestParam int amount, @RequestParam String month, Model model)

			throws Exception {

		User user = userRepository.selectByEmailId(refereeEmail);

		if (user != null) {

			RefferalMonthlyAmount rfm = new RefferalMonthlyAmount();

			rfm.setAmount(amount);

			rfm.setCount(count);

			rfm.setRefereeEmail(user.getEmailId());

			rfm.setCreatedTimstamp(LocalDateTime.now());

			refferalMonthlyAmountRepository.persist(rfm);

			walletService.addAmountToWallet(user.getId(), rfm.getId(), WalletReferenceType.CASHBACK,

					count + "referral of" + month + "Month", amount, LocalDateTime.now());

			DateRangeModel drm = new DateRangeModel();

			drm.setStartDate(LocalDateTime.now().minusMonths(2).withDayOfMonth(1));

			drm.setEndDate(LocalDateTime.now().minusMonths(2).withDayOfMonth(16));

			List<Refferal> oldMonthapprovedRefferal = refferalRepository

					.selectByEmailIdAndStatusAndDateRanges(user.getEmailId(), RefferalStatus.approved, drm);

			LOGGER.info("oldMonthapprovedRefferal" + oldMonthapprovedRefferal);

			drm.setStartDate(LocalDateTime.now().minusMonths(2).withDayOfMonth(16));

			drm.setEndDate(LocalDateTime.now().minusMonths(1).withDayOfMonth(16));

			List<Refferal> oldAndpreviousMonthapprovedRefferal = refferalRepository

					.selectByEmailIdAndStatusAndDateRange(user.getEmailId(), RefferalStatus.approved, drm);

			LocalDateTime previousMonthdate = LocalDateTime.now().minusMonths(1).withDayOfMonth(1);

			List<Refferal> oldPreMonthapproved = oldAndpreviousMonthapprovedRefferal.stream()

					.filter(x -> x.getCreatedTimestamp().isBefore(previousMonthdate)).collect(Collectors.toList());

			oldPreMonthapproved.addAll(oldMonthapprovedRefferal);

			LOGGER.info("oldPreMonthapproved" + oldPreMonthapproved);

			for (Refferal refferl : oldPreMonthapproved) {

				refferl.setStatus(RefferalStatus.transferred);

				refferl.setUpdatedTimestamp(LocalDateTime.now());

			}

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

		} else {

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

		}

		return "response";

	}

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

	public String getTransferredRefferals(HttpServletRequest request, Model model) throws ProfitMandiBusinessException {

		List<Refferal> refferals = refferalRepository.selectByStatus(RefferalStatus.transferred);

		Map<String, CustomRetailer> customerRetailerMap = new HashMap<>();

		if (!refferals.isEmpty()) {

			Set<String> emails = refferals.stream().map(x -> x.getRefereeEmail()).collect(Collectors.toSet());

			List<User> users = userUserRepository.selectByEmailIds(emails);

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

			Map<Integer, CustomRetailer> customRetailers = retailerService.getFofoRetailers(fofoIds);

			customerRetailerMap = customRetailers.entrySet().stream()

					.collect(Collectors.toMap(x -> x.getValue().getEmail(), x -> x.getValue()));

		}

		model.addAttribute("customerRetailerMap", customerRetailerMap);

		model.addAttribute("refferals", refferals);

		return "refferal";

	}

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

	public String getPaginatedTransferredRefferals(HttpServletRequest request,

			@RequestParam(name = "offset", defaultValue = "0") int offset,

			@RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws Exception {

		LOGGER.info("requested offset=[{}], limit = [{}]", offset, limit);

		List<Refferal> refferals = null;

		refferals = refferalRepository.selectAllRefferalByStatus(offset, limit, RefferalStatus.transferred);

		LOGGER.info("refferals" + refferals);

		if (!refferals.isEmpty()) {

			model.addAttribute("refferals", refferals);

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

		} else {

			model.addAttribute("refferals", refferals);

		}

		return "refferal-paginated";

	}

}