Subversion Repositories SmartDukaan

package com.spice.profitmandi.dao.service;

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

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

import com.spice.profitmandi.common.util.Utils;

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

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

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

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

import com.spice.profitmandi.service.wallet.WalletService;

import in.shop2020.model.v1.order.WalletReferenceType;

import org.apache.logging.log4j.LogManager;

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

import org.springframework.stereotype.Component;

import java.math.BigDecimal;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.temporal.ChronoUnit;

import java.util.*;

import java.util.stream.Collectors;

@Component

public class SidbiService {

    private static final org.apache.logging.log4j.Logger LOGGER = LogManager.getLogger(SidbiService.class);

    @Autowired

    FofoSidbiSanctionRepository fofoSidbiSanctionRepository;

    @Autowired

    CreditAccountRepository creditAccountRepository;

    private static final double PROCESSING_FEE = 1.18;

    private static final double STAMP_FEE = 200;

    private static final String WALLET_DEDUCTION_NARRATION = "SIDBI Processing Fee @1% + GST@18% + STAMP DUTY(Rs.200)";

    //Logic specific to Sidbi Related Sanctions

    //Assumptions that 1Lac upto 12 months

    private static final List<Integer> PRINCIPAL_DEDUCTIONS_PER_LAC = Arrays.asList(2115, 2147, 2179, 2212, 2245, 2279, 2313, 2348, 2383, 2419, 2455, 2492, 2529, 2567, 2605, 2644, 2683, 2723, 2763, 2804, 2845, 2887, 2929, 2972);

    private static final int CUTOFF_DATE = 10;

    public Map<Integer, BigDecimal> getSuggestedLimitMap() {

        Map<Integer, BigDecimal> fofoSuggetedLimitMap = new HashMap<>();

        List<FofoSidbiSanction> fofoSidbiSanctions = fofoSidbiSanctionRepository.selectAllUnsettled();

        Map<Integer, List<FofoSidbiSanction>> fofoSidbiSanctionMap = fofoSidbiSanctions.stream().collect(Collectors.groupingBy(x -> x.getFofoId()));

        for (Map.Entry<Integer, List<FofoSidbiSanction>> fofoSactionEntry : fofoSidbiSanctionMap.entrySet()) {

            List<FofoSidbiSanction> fofoSidbiSanctionList = fofoSactionEntry.getValue();

            int fofoId = fofoSactionEntry.getKey();

            BigDecimal suggestedLimit = BigDecimal.valueOf(fofoSidbiSanctionList.stream().mapToDouble(x -> x.getUnsettledAmount()).sum());

            fofoSuggetedLimitMap.put(fofoId, suggestedLimit);

        }

        LOGGER.info("GetSuggestedLimitMap - {}", fofoSuggetedLimitMap);

        return fofoSuggetedLimitMap;

    }

    private double getActualLoan(double receivedAmount) {

        double number = Math.ceil(receivedAmount / ProfitMandiConstants.ONE_LAC);

        return number * ProfitMandiConstants.ONE_LAC;

    }

    private double getProcessingDeductions(FofoSidbiSanction fofoSidbiSanction) {

        double processingDeductions = (fofoSidbiSanction.getLoanAmount() * PROCESSING_FEE / 100) + STAMP_FEE;

        System.out.println("Processing deductions  " + processingDeductions);

        return processingDeductions;

    }

    //When advance is deducted from Original disbursements then deduction happens from next month

    private double getAdvancePaid(FofoSidbiSanction fofoSidbiSanction) {

        return fofoSidbiSanction.getLoanAmount() - fofoSidbiSanction.getSanctionAmount() - this.getProcessingDeductions(fofoSidbiSanction);

    }

    private double getDeduction(FofoSidbiSanction fofoSidbiSanction) {

        double deduction = 0d;

        LocalDate loanStartDate = fofoSidbiSanction.getCreatedOn().withDayOfMonth(5).toLocalDate();

        if (fofoSidbiSanction.getAdvanceInterestAmount() > 0d) {

            loanStartDate = loanStartDate.plusMonths(1);

        }

        int monthsBetween = (int) ChronoUnit.MONTHS.between(loanStartDate, LocalDate.now());

        LOGGER.info("loanStartDate - {}, now - {}, monthsBetween - {} ", loanStartDate, LocalDateTime.now(), monthsBetween);

        if (LocalDate.now().getDayOfMonth() < 5) {

            monthsBetween -= 1;

        }

        if (monthsBetween > 0) {

            for (int month = 1; month <= monthsBetween; month++) {

                deduction += PRINCIPAL_DEDUCTIONS_PER_LAC.get(monthsBetween - 1) * (fofoSidbiSanction.getLoanAmount() / ProfitMandiConstants.ONE_LAC);

            }

        }

        LOGGER.info("loanStartDate-  {}, Loan Amount - {}, Deduction - {}", loanStartDate, fofoSidbiSanction.getLoanAmount(), deduction);

        return deduction;

    }

    public void processDeductions() {

        List<FofoSidbiSanction> fofoSidbiSanctions = fofoSidbiSanctionRepository.selectAllUnsettled();

        LOGGER.info("Sanctions Count - {}", fofoSidbiSanctions);

        Map<Integer, List<FofoSidbiSanction>> fofoSidbiSanctionMap = fofoSidbiSanctions.stream().collect(Collectors.groupingBy(x -> x.getFofoId()));

        for (Map.Entry<Integer, List<FofoSidbiSanction>> fofoSactionEntry : fofoSidbiSanctionMap.entrySet()) {

            for (FofoSidbiSanction fofoSidbiSanction : fofoSactionEntry.getValue()) {

                //fofoSidbiSanction.setSettledAmount(0);

                fofoSidbiSanction.setSettledAmount(this.getDeduction(fofoSidbiSanction));

                if (Utils.compareDouble(fofoSidbiSanction.getSettledAmount(), fofoSidbiSanction.getLoanAmount()) == 0) {

                    fofoSidbiSanction.setSettledOn(LocalDateTime.now());

                }

            }

        }

    }

    public void createSanction(int fofoId, LocalDateTime createTimestamp, double receivedAmount) {

        //Add table here

        FofoSidbiSanction fofoSidbiSanction = new FofoSidbiSanction();

        fofoSidbiSanction.setCreatedOn(createTimestamp);

        fofoSidbiSanction.setFofoId(fofoId);

        fofoSidbiSanction.setSanctionAmount(receivedAmount);

        fofoSidbiSanction.setLoanAmount(this.getActualLoan(receivedAmount));

        fofoSidbiSanction.setAdvanceInterestAmount(this.getAdvancePaid(fofoSidbiSanction));

        fofoSidbiSanctionRepository.persist(fofoSidbiSanction);

    }

    public void migrateSanctions() throws ProfitMandiBusinessException {

        List<FofoSidbiSanction> fofoSidbiSanctions = fofoSidbiSanctionRepository.selectAll(Optional.empty());

        for (FofoSidbiSanction fofoSidbiSanction : fofoSidbiSanctions) {

            fofoSidbiSanction.setLoanAmount(this.getActualLoan(fofoSidbiSanction.getSanctionAmount()));

            fofoSidbiSanction.setAdvanceInterestAmount(this.getAdvancePaid(fofoSidbiSanction));

            if (!Arrays.asList(175139259, 175139638).contains(fofoSidbiSanction.getFofoId())) {

                issueLimit(fofoSidbiSanction);

            }

        }

    }

    @Autowired

    WalletService walletService;

    @Autowired

    SDCreditService sdCreditService;

    public void issueLimit(FofoSidbiSanction fofoSidbiSanction) throws ProfitMandiBusinessException {

        if (fofoSidbiSanction.getIssuedOn() != null) {

            throw new ProfitMandiBusinessException("Sidbi Sanction Issue",

                    "Party - " + fofoSidbiSanction.getFofoId() + " - " + fofoSidbiSanction.getLoanAmount(), "");

        }

        fofoSidbiSanction.setIssuedOn(fofoSidbiSanction.getCreatedOn().plusDays(2));

        double deductions = this.getProcessingDeductions(fofoSidbiSanction);

        walletService.consumeAmountFromWallet(fofoSidbiSanction.getFofoId(), fofoSidbiSanction.getId(), WalletReferenceType.ADVANCE_SECURITY, "Deducted to fund advance", (float) deductions, fofoSidbiSanction.getCreatedOn(), true);

        try {

            sdCreditService.fundWallet(fofoSidbiSanction.getFofoId());

        } catch(Exception e) {

            LOGGER.info("Could not fund wallet for - ", fofoSidbiSanction.getFofoId());

        }

    }

}