Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.time.LocalDateTime;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import java.util.stream.Collectors;

import javax.servlet.http.HttpServletRequest;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.json.JSONObject;

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

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;

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

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

	public String getRefferalsRequest(HttpServletRequest request,

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

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

			throws ProfitMandiBusinessException {

		List<Refferal> refferals = null;

		long size = 0;

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

		LOGGER.info("refferals" + refferals);

		size = refferalRepository.selectCountByStatus(RefferalStatus.pending);

		if (!refferals.isEmpty()) {

			model.addAttribute("refferals", refferals);

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

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

			model.addAttribute("size", size);

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

			if (refferals.size() < limit) {

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

			} else {

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

			}

		} else {

			model.addAttribute("refferals", refferals);

			model.addAttribute("size", size);

		}

		return "refferal";

	}

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

	public String getPaginatedRefferalsRequest(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.pending);

		LOGGER.info("refferals" + refferals);

		if (!refferals.isEmpty()) {

			model.addAttribute("refferals", refferals);

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

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

		} else {

			model.addAttribute("refferals", refferals);

		}

		return "refferal-paginated";

	}

	@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.pending)) {

			refferal.setStatus(RefferalStatus.approved);

			refferal.setUpdatedTimestamp(LocalDateTime.now());

			refferal.setApprovedTimestamp(LocalDateTime.now());

			refferalRepository.persist(refferal);

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

		} else {

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

		}

		return "response";

	}

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

	public String rejectRefferal(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.rejected);

			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 {

		List<Integer> fofoIds = fofoStoreRepository.selectAll().stream().map(x -> x.getId())

				.collect(Collectors.toList());

		Map<Integer, CustomRetailer> customRetailersMap = retailerService.getFofoRetailerUserId(fofoIds);

		String customRetailers = JSONObject.valueToString(customRetailersMap.values());

		model.addAttribute("customRetailers", customRetailers);

		return "refferal-approve";

	}

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

	public String getApprovedRefferals(HttpServletRequest request, @RequestParam String refereeEmail, Model model)

			throws Exception {

		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(refereeEmail, RefferalStatus.approved, drm);

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

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

		List<Refferal> previousAndcurrentMonthapprovedRefferal = refferalRepository

				.selectByEmailIdAndStatusAndDateRange(refereeEmail, RefferalStatus.approved, drm);

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

		List<Refferal> preCurrMonthapproved = previousAndcurrentMonthapprovedRefferal.stream()

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

		long approvedRefferalCount = previousMonthapprovedRefferal.size() + preCurrMonthapproved.size();

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

		approvedRefferals.addAll(preCurrMonthapproved);

		long refferalAmount = 0;

		if (approvedRefferalCount <= 4) {

			refferalAmount = approvedRefferalCount * 5000;

		} else if (approvedRefferalCount >= 5 && approvedRefferalCount <= 9) {

			refferalAmount = approvedRefferalCount * 10000;

		} else if (approvedRefferalCount > 10) {

			refferalAmount = approvedRefferalCount * 200000;

		}

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

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

		List<Refferal> oldMonthapprovedRefferal = refferalRepository.selectByEmailIdAndStatusAndDateRanges(refereeEmail,

				RefferalStatus.approved, drm);

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

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

		List<Refferal> oldAndpreviousMonthapprovedRefferal = refferalRepository

				.selectByEmailIdAndStatusAndDateRange(refereeEmail, 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());

		long oldMonthapprovedRefferalCount = oldMonthapprovedRefferal.size() + oldPreMonthapproved.size();

		List<Refferal> oldMonthapprovedRefferals = new ArrayList<>(oldMonthapprovedRefferal);

		oldMonthapprovedRefferals.addAll(oldPreMonthapproved);

		long oldRefferalAmount = 0;

		if (oldMonthapprovedRefferalCount <= 4) {

			oldRefferalAmount = oldMonthapprovedRefferalCount * 5000;

		} else if (oldMonthapprovedRefferalCount >= 5 && oldMonthapprovedRefferalCount <= 9) {

			oldRefferalAmount = oldMonthapprovedRefferalCount * 10000;

		} else if (oldMonthapprovedRefferalCount > 10) {

			oldRefferalAmount = oldMonthapprovedRefferalCount * 200000;

		}

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

		model.addAttribute("oldMonthapprovedRefferals", oldMonthapprovedRefferals);

		model.addAttribute("oldMonthapprovedRefferalCount", oldMonthapprovedRefferalCount);

		model.addAttribute("oldRefferalAmount", oldRefferalAmount);

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

		model.addAttribute("approvedRefferals", approvedRefferals);

		model.addAttribute("approvedRefferalCount", approvedRefferalCount);

		model.addAttribute("refferalAmount", refferalAmount);

		return "refferal-approve-info";

	}

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

			rfm.setCreatedTimstamp(LocalDateTime.now());

			refferalMonthlyAmountRepository.persist(rfm);

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

					count + "refferal of" + month + "Month", amount);

			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(refereeEmail, RefferalStatus.approved, drm);

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

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

			List<Refferal> previousAndcurrentMonthapprovedRefferal = refferalRepository

					.selectByEmailIdAndStatusAndDateRange(refereeEmail, 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);

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

			rfm.setCreatedTimstamp(LocalDateTime.now());

			refferalMonthlyAmountRepository.persist(rfm);

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

					count + "refferal of" + month + "Month", amount);

			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(refereeEmail, RefferalStatus.approved, drm);

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

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

			List<Refferal> oldAndpreviousMonthapprovedRefferal = refferalRepository

					.selectByEmailIdAndStatusAndDateRange(refereeEmail, 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());

			List<Refferal> oldMonthapprovedRefferals = new ArrayList<>(oldMonthapprovedRefferal);

			oldMonthapprovedRefferals.addAll(oldPreMonthapproved);

			for (Refferal refferl : oldMonthapprovedRefferals) {

				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,

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

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

			throws ProfitMandiBusinessException {

		List<Refferal> refferals = null;

		long size = 0;

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

		LOGGER.info("refferals" + refferals);

		size = refferalRepository.selectCountByStatus(RefferalStatus.transferred);

		if (!refferals.isEmpty()) {

			model.addAttribute("refferals", refferals);

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

			model.addAttribute("size", size);

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

			if (refferals.size() < limit) {

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

			} else {

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

			}

		} else {

			model.addAttribute("refferals", refferals);

			model.addAttribute("size", size);

		}

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

	}

}