Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import java.math.BigDecimal;

import java.math.RoundingMode;

import java.time.Duration;

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.mail.javamail.JavaMailSender;

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.common.util.Utils;

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

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.entity.user.Address;

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

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

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.dao.repository.user.AddressRepository;

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;

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

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

	@Autowired

	AddressRepository addressRepository;

	@Autowired

	OrderRepository orderRepository;

	@Autowired

	private LoanStatementRepository loanStatementRepository;

	@Autowired

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

	@Autowired

	private JavaMailSender mailSender;

	@Autowired

	private MVCResponseSender mvcResponseSender;

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

		if (!sanctionRequests.isEmpty()) {

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

			Map<Integer, Long> partnerCreditDaysMap = new HashMap<>();

			Map<Integer, Integer> partnerActiveLoanMap = new HashMap<>();

			for (Integer fofoId : fofoIds) {

				List<Loan> loans = loanRepository.selectActiveLoan(fofoId);

				if (!loans.isEmpty()) {

					partnerActiveLoanMap.put(fofoId, loans.size());

					Loan loan = loans.get(loans.size() - 1);

					long daysBetween = Duration.between(loan.getCreatedOn(), LocalDateTime.now()).toDays();

					partnerCreditDaysMap.put(fofoId, daysBetween);

				}

				model.addAttribute("partnerCreditDaysMap", partnerCreditDaysMap);

				model.addAttribute("partnerActiveLoanMap", partnerActiveLoanMap);

			}

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

			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("sdCreditRequirementMap", sdCreditRequirementMap);

			model.addAttribute("userWalletMap", userWalletMap);

		}

		model.addAttribute("sanctionRequests", sanctionRequests);

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

			com.spice.profitmandi.dao.entity.user.User user = userUserRepository

					.selectById(sanctionRequest.getFofoId());

			Address address = addressRepository.selectById(user.getAddressId());

			notificationService.sendWhatsappMessage(message, title, address.getPhoneNumber());

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

			String empMessage = "Congratulations! Your Partner " + customRetailer.getBusinessName()

					+ " credit limit is increased for today Rs."

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

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

			SendNotificationModel sendNotificationModel = new SendNotificationModel();

			sendNotificationModel.setCampaignName("Sanction Request");

			sendNotificationModel.setTitle("title");

			sendNotificationModel.setMessage(empMessage);

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

			notificationService.sendWhatsappMessage(empMessage, title, authUser.getMobileNumber());

		}

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

		sanctionRequest.setStockHold(sanctionRequestModel.isStockHold());

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

	}

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

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

		List<Order> allOrders = orderRepository.selectHoldOrder();

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

		if (!allOrders.isEmpty()) {

			Map<Integer, Double> transactionAmountMap = allOrders.stream().collect(

					Collectors.groupingBy(Order::getTransactionId, Collectors.summingDouble(x -> x.getTotalAmount())));

			Map<Integer, List<Order>> transactionOrdersMap = allOrders.stream()

					.collect(Collectors.groupingBy(Order::getTransactionId, Collectors.toList()));

			List<SanctionRequest> sanctionRequests = sanctionRequestRepository

					.selectByTransactionId(new ArrayList<>(transactionAmountMap.keySet()));

			model.addAttribute("transactionAmountMap", transactionAmountMap);

			model.addAttribute("transactionOrdersMap", transactionOrdersMap);

			model.addAttribute("sanctionRequests", sanctionRequests);

			Map<Integer, Double> transactionCreditMap = new HashMap<>();

			for (Entry<Integer, List<Order>> transactionOrderEntry : transactionOrdersMap.entrySet()) {

				List<Order> orders = transactionOrderEntry.getValue();

				LocalDateTime createDate = orders.get(0).getCreateTimestamp();

				int fofoId = orders.get(0).getRetailerId();

				double loanSettleAmount = loanStatementRepository.selectByDateAndFofoId(createDate, fofoId).stream()

						.filter(x -> x.getAmount().doubleValue() > 0)

						.collect(Collectors.summingDouble(x -> x.getAmount().doubleValue()));

				transactionCreditMap.put(transactionOrderEntry.getKey(), loanSettleAmount);

			}

			model.addAttribute("transactionCreditMap", transactionCreditMap);

		}

		return "sanction-order-hold";

	}

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

	public String unholdOrder(HttpServletRequest request, @RequestParam int transactionId, Model model)

			throws Exception {

		List<Order> orders = orderRepository.selectAllByTransactionId(transactionId);

		LOGGER.info("orders" + orders);

		if (!orders.isEmpty()) {

			orders.forEach(x -> x.setShipmentHold(false));

		}

		double totalAmount = orders.stream().collect(Collectors.summingDouble(x -> x.getTotalAmount()));

		try {

			List<String> authUserEmail = csService.getAuthUserIdByPartnerId(orders.get(0).getRetailerId()).stream()

					.map(x -> x.getEmailId()).collect(Collectors.toList());

			authUserEmail.add("vinay.p@smartdukaan.com");

			authUserEmail.add("shivam.gupta@smartdukaan.com");

			String[] emailTo = authUserEmail.toArray(new String[authUserEmail.size()]);

			String[] ccTo = { "tarun.verma@smartdukaan.com", "kamini.sharma@smartdukaan.com" };

			String subject = "Dispatched " + (orders.get(0).getRetailerName());

			String message = String.format("Dear Team, \n" + "Kindly note the meterial for the "

					+ orders.get(0).getRetailerName() + "of Rs." + totalAmount + " is dispatched.");

			LOGGER.info("message" + message);

			Utils.sendMailWithAttachments(mailSender, emailTo, ccTo, subject, message);

		} catch (Exception e) {

			e.printStackTrace();

		}

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

		return "response";

	}

}