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.function.Function;
import java.util.stream.Collector;
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 = "/getValidateRefferals", method = RequestMethod.GET)
        public String getValidateRefferals(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.validate);
                LOGGER.info("refferals" + refferals);
                size = refferalRepository.selectCountByStatus(RefferalStatus.validate);
                if (!refferals.isEmpty()) {

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

                        model.addAttribute("size", size);
                        model.addAttribute("url", "/getPaginatedValidateRefferals");

                        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 = "/getPaginatedValidateRefferals", method = RequestMethod.GET)
        public String getPaginatedValidateRefferals(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.validate);
                LOGGER.info("refferals" + refferals);
                if (!refferals.isEmpty()) {

                        model.addAttribute("refferals", refferals);
                        model.addAttribute("rStatus", "validate");
                        model.addAttribute("url", "/getPaginatedValidateRefferals");

                } else {
                        model.addAttribute("refferals", refferals);

                }

                return "refferal-paginated";
        }

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

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

                }

                return "response";
        }

        @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);
                        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, @RequestParam String rejectionReason,
                        Model model) throws Exception {
                Refferal refferal = refferalRepository.selectById(refferalId);

                if (refferal.getStatus().equals(RefferalStatus.pending)) {
                        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 {
                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);

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

                Map<String, Long> oldApproved = oldPreMonthapproved.stream()
                                .collect(Collectors.groupingBy(Refferal::getRefereeEmail, Collectors.counting()));
                LOGGER.info("preApproved" + preApproved);

                LOGGER.info("oldApproved" + oldApproved);
                model.addAttribute("oldMonth", LocalDateTime.now().minusMonths(2).getMonth());
                model.addAttribute("oldApproved", oldApproved);
                model.addAttribute("previousMonth", LocalDateTime.now().minusMonths(1).getMonth());
                model.addAttribute("preApproved", preApproved);

                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.CASHBACK,
                                        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);

                        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,
                        @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";
        }
}