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.Arrays;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

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 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.SDCreditRequirement;

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

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

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

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

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.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.SDCreditRequirementRepository;

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

import com.spice.profitmandi.service.NotificationService;

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

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

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

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

		Map<Integer, CurrentPartnerDailyInvestment> currentPartnerDailyInvestmentMap = currentPartnerDailyInvestmentRepository

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

			CurrentPartnerDailyInvestment currentPartnerDailyInvestment = currentPartnerDailyInvestmentMap.get(fofoId);

			BigDecimal suggestedAmount = BigDecimal.ZERO;

			if (currentPartnerDailyInvestment != null) {

				suggestedAmount = BigDecimal.valueOf(currentPartnerDailyInvestment.getTotalInvestment() * 0.1);

			}

			if (suggestedAmount.doubleValue() > 200000) {

				suggestedAmount = BigDecimal.valueOf(200000);

			}

			if (suggestedAmount.doubleValue() < 0) {

				suggestedAmount = BigDecimal.ZERO;

			}

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

			if (sdCreditRequirement == null) {

				sdCreditRequirement = new SDCreditRequirement();

				sdCreditRequirement.setFofoId(fofoId);

				sdCreditRequirement.setCreditDays(15);

				sdCreditRequirement.setRisk(CreditRisk.NO_RISK);

				sdCreditRequirement.setInterestRate(BigDecimal.valueOf(0.05));

				sdCreditRequirement.setSuggestedLimit(suggestedAmount);

				sdCreditRequirement.setLimit(suggestedAmount);

				sdCreditRequirement.setUtilizedAmount(BigDecimal.ZERO);

				sdCreditRequirement.setAvailableLimit(suggestedAmount);

				sdCreditRequirement.setCreateTimestamp(LocalDateTime.now());

				sdCreditRequirement.setUpdateTimestamp(LocalDateTime.now());

				sdCreditRequirementRepository.persist(sdCreditRequirement);

			}

			sdCreditRequirement.setSuggestedLimit(suggestedAmount);

			sdCreditRequirement.setLimit(suggestedAmount);

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

		BigDecimal suggestedAmount = new BigDecimal((fofoStore.getMinimumInvestment() * 0.1));

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

		sdCreditRequirement.setSecurityCheck(sdCreditRequirementModel.getSecurityCheck());

		// sdCreditRequirement.setSecurityCheck(2);

		sdCreditRequirement.setInterestRate(sdCreditRequirementModel.getInterest());

		sdCreditRequirement.setFreeDays(sdCreditRequirementModel.getFreeDays());

		sdCreditRequirement.setLimit(sdCreditRequirementModel.getLimit());

		sdCreditRequirement.setSuggestedLimit(suggestedAmount);

		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.setRisk(CreditRisk.NO_RISK);

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

		if (!sanctionRequests.isEmpty()) {

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

			Map<Integer, PartnerDailyInvestment> partnerDailyInvestmentMap = partnerDailyInvestmentRepository

					.selectAll(fofoIds, LocalDate.now().minusDays(90)).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("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(90)).stream()

				.collect(Collectors.toMap(x -> x.getFofoId(), 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("sanctionStatus", SanctionStatus.values());

		return "sanction-request-row";

	}

}