Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.math.BigDecimal;

import java.math.RoundingMode;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

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

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

import com.spice.profitmandi.common.model.CustomRetailer;

import com.spice.profitmandi.common.model.SendNotificationModel;

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

import com.spice.profitmandi.dao.entity.dtr.CreditAccount;

import com.spice.profitmandi.dao.entity.dtr.CreditStatus;

import com.spice.profitmandi.dao.entity.fofo.CurrentPartnerDailyInvestment;

import com.spice.profitmandi.dao.entity.fofo.FofoStore;

import com.spice.profitmandi.dao.entity.fofo.PartnerDailyInvestment;

import com.spice.profitmandi.dao.entity.transaction.Loan;

import com.spice.profitmandi.dao.entity.transaction.SDCreditRequirement;

import com.spice.profitmandi.dao.entity.transaction.SanctionRequest;

import com.spice.profitmandi.dao.entity.transaction.UserWallet;

import com.spice.profitmandi.dao.enumuration.fofo.Gateway;

import com.spice.profitmandi.dao.enumuration.transaction.SanctionStatus;

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

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

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

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

import com.spice.profitmandi.dao.repository.cs.CsService;

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

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

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

import com.spice.profitmandi.dao.repository.fofo.CurrentPartnerDailyInvestmentRepository;

import com.spice.profitmandi.dao.repository.fofo.PartnerDailyInvestmentRepository;

import com.spice.profitmandi.dao.repository.transaction.LoanRepository;

import com.spice.profitmandi.dao.repository.transaction.SDCreditRequirementRepository;

import com.spice.profitmandi.dao.repository.transaction.SanctionRequestRepository;

import com.spice.profitmandi.dao.repository.transaction.UserWalletRepository;

import com.spice.profitmandi.service.NotificationService;

import com.spice.profitmandi.service.transaction.SDCreditService;

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

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

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

@Controller

@Transactional(rollbackOn = Throwable.class)

public class SDCreditController {

	@Autowired

	private RetailerService retailerService;

	@Autowired

	SDCreditRequirementRepository sdCreditRequirementRepository;

	@Autowired

	SanctionRequestRepository sanctionRequestRepository;

	@Autowired

	PartnerDailyInvestmentRepository partnerDailyInvestmentRepository;

	@Autowired

	private FofoStoreRepository fofoStoreRepository;

	@Autowired

	private CreditAccountRepository creditAccountRepository;

	@Autowired

	private SDCreditService sdCreditService;

	@Autowired

	private NotificationService notificationService;

	@Autowired

	private AuthRepository authRepository;

	@Autowired

	private UserRepository userRepository;

	@Autowired

	private CurrentPartnerDailyInvestmentRepository currentPartnerDailyInvestmentRepository;

	@Autowired

	private UserWalletRepository userWalletRepository;

	@Autowired

	LoanRepository loanRepository;

	@Autowired

	private CookiesProcessor cookiesProcessor;

	@Autowired

	private CsService csService;

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

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

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

		Map<Integer, CustomRetailer> customRetailerMap = retailerService.getFofoRetailers(true);

		Map<Integer, SDCreditRequirement> sdCreditRequirementMap = sdCreditRequirementRepository.selectAll().stream()

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

		for (Entry<Integer, CustomRetailer> customRetailerEntry : customRetailerMap.entrySet()) {

			int fofoId = customRetailerEntry.getKey();

			SDCreditRequirement sdCreditRequirement = sdCreditRequirementMap.get(customRetailerEntry.getKey());

			if (sdCreditRequirement != null) {

				BigDecimal utilizedLimit = new BigDecimal(sdCreditService.getUtilizationAmount(fofoId));

				BigDecimal availableLimit = sdCreditRequirement.getLimit().subtract(utilizedLimit);

				LOGGER.info("utilizedLimit {} ", utilizedLimit);

				LOGGER.info("availableLimit {} ", availableLimit);

				sdCreditRequirement.setUtilizedAmount(utilizedLimit);

				sdCreditRequirement.setAvailableLimit(availableLimit);

				sdCreditRequirement.setUpdateTimestamp(LocalDateTime.now());

			}

		}

		model.addAttribute("customRetailerMap", customRetailerMap);

		model.addAttribute("sdCreditRequirementMap", sdCreditRequirementMap);

		return "sd-credit";

	}

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

	public String sdCredit(HttpServletRequest request, @RequestBody SdCreditRequirementModel sdCreditRequirementModel,

			Model model) throws Exception {

		LOGGER.info("sdCreditRequirementModel {} ", sdCreditRequirementModel);

		int fofoId = sdCreditRequirementModel.getFofoId();

		SDCreditRequirement sdCreditRequirement = sdCreditRequirementRepository

				.selectByFofoId(sdCreditRequirementModel.getFofoId());

		FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(sdCreditRequirementModel.getFofoId());

		sdCreditRequirement.setSecurityCheck(sdCreditRequirementModel.getSecurityCheck());

		// sdCreditRequirement.setSecurityCheck(2);

		sdCreditRequirement.setInterestRate(sdCreditRequirementModel.getInterest());

		sdCreditRequirement.setFreeDays(sdCreditRequirementModel.getFreeDays());

		sdCreditRequirement.setLimit(sdCreditRequirementModel.getLimit());

		BigDecimal utilizedLimit = new BigDecimal(sdCreditService.getUtilizationAmount(fofoId));

		BigDecimal availableLimit = sdCreditRequirement.getLimit().subtract(utilizedLimit);

		LOGGER.info("utilizedLimit {} ", utilizedLimit);

		LOGGER.info("availableLimit {} ", availableLimit);

		sdCreditRequirement.setUtilizedAmount(utilizedLimit);

		sdCreditRequirement.setAvailableLimit(availableLimit);

		sdCreditRequirement.setCreditDays(15);

		sdCreditRequirement.setUpdateTimestamp(LocalDateTime.now());

		if (sdCreditRequirement.getSecurityCheck() > 0) {

			CreditAccount creditAccount = creditAccountRepository

					.selectByFofoIdAndGateway(sdCreditRequirementModel.getFofoId(), Gateway.SDDIRECT);

			if (creditAccount == null) {

				creditAccount = new CreditAccount();

				creditAccount.setFofoId(sdCreditRequirementModel.getFofoId());

				creditAccount.setGateway(Gateway.SDDIRECT);

				creditAccount.setCreditStatus(CreditStatus.SANCTIONED);

				creditAccount.setActive(false);

				creditAccount.setUpdatedOn(LocalDateTime.now());

				creditAccountRepository.persist(creditAccount);

			}

			creditAccount.setInterestRate(sdCreditRequirement.getInterestRate().floatValue());

			creditAccount.setSanctionedAmount(sdCreditRequirement.getLimit().floatValue());

			creditAccount.setAvailableAmount(availableLimit.floatValue());

			creditAccount.setFreeDays(sdCreditRequirement.getFreeDays());

			creditAccount.setUpdatedOn(LocalDateTime.now());

		}

		LOGGER.info("sdCreditRequirement {} ", sdCreditRequirement);

		CustomRetailer customRetailer = retailerService.getFofoRetailer(sdCreditRequirementModel.getFofoId());

		sdCreditRequirement = sdCreditRequirementRepository.selectByFofoId(sdCreditRequirementModel.getFofoId());

		Map<Integer, SDCreditRequirement> sdCreditRequirementMap = new HashMap<>();

		sdCreditRequirementMap.put(sdCreditRequirement.getFofoId(), sdCreditRequirement);

		model.addAttribute("sdCreditRequirementMap", sdCreditRequirementMap);

		model.addAttribute("customRetailer", customRetailer);

		return "sd-credit-requirement-row";

	}

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

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

		List<SanctionRequest> sanctionRequests = sanctionRequestRepository.selectByDate(LocalDate.now());

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

		Map<Integer, SDCreditRequirement> sdCreditRequirementMap = sdCreditRequirementRepository.selectAll().stream()

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

		Map<Integer, UserWallet> userWalletMap = userWalletRepository.selectByRetailerIds(new HashSet<>(fofoIds))

				.stream().collect(Collectors.toMap(x -> x.getUserId(), x -> x));

		if (!sanctionRequests.isEmpty()) {

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

			Map<Integer, PartnerDailyInvestment> partnerDailyInvestmentMap = partnerDailyInvestmentRepository

					.selectAll(fofoIds, LocalDate.now().minusDays(1)).stream()

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

			model.addAttribute("customRetailerMap", customRetailerMap);

			model.addAttribute("partnerDailyInvestmentMap", partnerDailyInvestmentMap);

		}

		model.addAttribute("sanctionRequests", sanctionRequests);

		model.addAttribute("sdCreditRequirementMap", sdCreditRequirementMap);

		model.addAttribute("userWalletMap", userWalletMap);

		model.addAttribute("sanctionStatus", SanctionStatus.values());

		return "sanction-request";

	}

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

	public String sanctionRequest(HttpServletRequest request, @RequestBody SanctionRequestModel sanctionRequestModel,

			Model model) throws Exception {

		LOGGER.info("sanctionRequestModel {} ", sanctionRequestModel);

		Map<Integer, SDCreditRequirement> sdCreditRequirementMap = sdCreditRequirementRepository.selectAll().stream()

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

		SanctionRequest sanctionRequest = sanctionRequestRepository.selectById(sanctionRequestModel.getId());

		List<Integer> fofoIds = sanctionRequestRepository.selectByDate(LocalDate.now()).stream().map(x -> x.getFofoId())

				.collect(Collectors.toList());

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

		LOGGER.info("freeDays {} ", sdCreditRequirementMap.get(sanctionRequest.getFofoId()).getFreeDays());

		if (sanctionRequestModel.getStatus().equals(SanctionStatus.APPROVED)) {

			CustomRetailer customRetailer = customRetailerMap.get(sanctionRequest.getFofoId());

			sanctionRequest.setApprovalTimestamp(LocalDateTime.now());

			BigDecimal availableAmount = sdCreditService.getAvailableAmount(sanctionRequest.getFofoId());

			String title = "Sanction Request Approved";

			String url = "http://app.smartdukaan.com/pages/home/credit";

			String message = "congratulations! Your credit limit is increased for today Rs."

					+ sanctionRequest.getApprovalAmount().setScale(2, RoundingMode.HALF_UP)

					+ " your total available limit is Rs." + availableAmount.setScale(2, RoundingMode.HALF_UP);

			notificationService.sendNotification(sanctionRequest.getFofoId(), title, MessageType.notification, title,

					message, url);

			AuthUser authUser = authRepository.selectById(sanctionRequest.getAuthId());

			SendNotificationModel sendNotificationModel = new SendNotificationModel();

			sendNotificationModel.setCampaignName("Loan");

			sendNotificationModel.setTitle("Sanction Request Approved");

			sendNotificationModel.setMessage("congratulations! Your Partner  " + customRetailer.getBusinessName()

					+ "credit limit is increased for today Rs."

					+ sanctionRequest.getApprovalAmount().setScale(2, RoundingMode.HALF_UP)

					+ " your total available limit is Rs." + availableAmount.setScale(2, RoundingMode.HALF_UP));

			sendNotificationModel.setType("url");

			sendNotificationModel.setUrl("https://app.smartdukaan.com/pages/home/credit");

			sendNotificationModel.setExpiresat(LocalDateTime.now().plusDays(2));

			sendNotificationModel.setMessageType(MessageType.notification);

			sendNotificationModel

					.setUserIds(Arrays.asList(userRepository.selectByEmailId(authUser.getEmailId()).getId()));

			System.out.println(sendNotificationModel);

			notificationService.sendNotification(sendNotificationModel);

		}

		if (sdCreditRequirementMap.get(sanctionRequest.getFofoId()).getFreeDays() >= sanctionRequestModel

				.getFreeDays()) {

			sanctionRequest.setFreeDays(sanctionRequestModel.getFreeDays());

		} else {

			throw new ProfitMandiBusinessException("Free Days", "Free Days", "Free Days is not more than "

					+ sdCreditRequirementMap.get(sanctionRequest.getFofoId()).getFreeDays() + " days ");

		}

		sanctionRequest.setApprovalAmount(sanctionRequestModel.getApprovalAmount());

		sanctionRequest.setStatus(sanctionRequestModel.getStatus());

		Map<Integer, PartnerDailyInvestment> partnerDailyInvestmentMap = partnerDailyInvestmentRepository

				.selectAll(fofoIds, LocalDate.now().minusDays(1)).stream()

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

		Map<Integer, UserWallet> userWalletMap = userWalletRepository.selectByRetailerIds(new HashSet<>(fofoIds))

				.stream().collect(Collectors.toMap(x -> x.getUserId(), x -> x));

		sanctionRequest = sanctionRequestRepository.selectById(sanctionRequestModel.getId());

		model.addAttribute("customRetailerMap", customRetailerMap);

		model.addAttribute("sanctionRequest", sanctionRequest);

		model.addAttribute("partnerDailyInvestmentMap", partnerDailyInvestmentMap);

		model.addAttribute("sdCreditRequirementMap", sdCreditRequirementMap);

		model.addAttribute("userWalletMap", userWalletMap);

		model.addAttribute("sanctionStatus", SanctionStatus.values());

		return "sanction-request-row";

	}

	List<String> emails = Arrays.asList("kamini.sharma@smartdukaan.com", "neeraj.gupta@smartdukaan.com",

			"amit.gupta@smartdukaan.com");

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

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

		LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

		String email = loginDetails.getEmailId();

		AuthUser authUser = authRepository.selectByEmailOrMobile(email);

		Map<String, Set<Integer>> storeGuyMap = csService.getAuthUserPartnerIdMapping();

		Set<Integer> fofoIds = storeGuyMap.get(authUser.getEmailId());

		if (emails.contains(authUser.getEmailId())) {

			fofoIds = storeGuyMap.get("tarun.verma@smartdukaan.com");

			LOGGER.info("fofoIds" + fofoIds);

		}

		LOGGER.info("fofoIds" + fofoIds);

		if (fofoIds == null) {

			throw new ProfitMandiBusinessException("you are not authorized", "", "you are not authorized" + " " + "");

		}

		List<Loan> loans = loanRepository.selectAllLoans(new ArrayList<>(fofoIds));

		List<Integer> loanFofoIds = loans.stream().map(x -> x.getFofoId()).collect(Collectors.toList());

		List<SDCreditRequirement> sdCreditRequirements = sdCreditRequirementRepository

				.selectByFofoIds(new ArrayList<>(loanFofoIds));

		Map<Integer, Long> loanCountMap = loans.stream()

				.collect(Collectors.groupingBy(x -> x.getFofoId(), Collectors.counting()));

		Map<Integer, UserWallet> userWalletMap = userWalletRepository.selectByRetailerIds(fofoIds).stream()

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

		Map<Integer, CurrentPartnerDailyInvestment> currentPartnerDailyInvestmentMap = currentPartnerDailyInvestmentRepository

				.selectAll().stream().collect(Collectors.toMap(x -> x.getFofoId(), x -> x));

		model.addAttribute("userWalletMap", userWalletMap);

		model.addAttribute("currentPartnerDailyInvestmentMap", currentPartnerDailyInvestmentMap);

		Map<Integer, CustomRetailer> customRetailerMap = retailerService.getFofoRetailers(new ArrayList<>(fofoIds));

		model.addAttribute("sdCreditRequirements", sdCreditRequirements);

		model.addAttribute("loanCountMap", loanCountMap);

		model.addAttribute("customRetailerMap", customRetailerMap);

		return "loan-summary";

	}

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

	public String getLoanSummary(HttpServletRequest request, @RequestParam int fofoId, Model model)

			throws ProfitMandiBusinessException {

		SDCreditResponseOut sdCreditResponseOut = sdCreditService.sdDirectService(fofoId);

		CustomRetailer customRetailer = retailerService.getFofoRetailer(fofoId);

		model.addAttribute("customRetailer", customRetailer);

		model.addAttribute("loanSummary", sdCreditResponseOut.getLoans());

		return "loan-summary-detail";

	}

}