FINERACT-1981: pay-off transaction for progressive loans

fineract-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/data/LoanSummaryData.java

@@ -250,7 +250,7 @@ private static BigDecimal computeTotalUnpaidPayableNotDueInterestAmountOnActualP
         return BigDecimal.ZERO;
     }
 
-    private static BigDecimal computeAccruedInterestTillDay(final LoanSchedulePeriodData period, final long untilDay,
+    public static BigDecimal computeAccruedInterestTillDay(final LoanSchedulePeriodData period, final long untilDay,
             final CurrencyData currency) {
         Integer remainingDays = period.getDaysInPeriod();
         BigDecimal totalAccruedInterest = BigDecimal.ZERO;

fineract-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/data/OutstandingAmountsDTO.java

@@ -0,0 +1,65 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.portfolio.loanaccount.data;
+
+import lombok.Data;
+import lombok.experimental.Accessors;
+import org.apache.fineract.organisation.monetary.domain.MonetaryCurrency;
+import org.apache.fineract.organisation.monetary.domain.Money;
+
+@Data
+@Accessors(chain = true, fluent = true)
+public class OutstandingAmountsDTO {
+
+    private Money principal;
+    private Money interest;
+    private Money feeCharges;
+    private Money penaltyCharges;
+
+    public OutstandingAmountsDTO(MonetaryCurrency currency) {
+        this.principal = Money.zero(currency);
+        this.interest = Money.zero(currency);
+        this.feeCharges = Money.zero(currency);
+        this.penaltyCharges = Money.zero(currency);
+    }
+
+    public Money getTotalOutstanding() {
+        return principal() //
+                .plus(interest()) //
+                .plus(feeCharges()) //
+                .plus(penaltyCharges());
+    }
+
+    public void plusPrincipal(Money principal) {
+        this.principal = this.principal.plus(principal);
+    }
+
+    public void plusInterest(Money interest) {
+        this.interest = this.interest.plus(interest);
+    }
+
+    public void plusFeeCharges(Money feeCharges) {
+        this.feeCharges = this.feeCharges.plus(feeCharges);
+    }
+
+    public void plusPenaltyCharges(Money penaltyCharges) {
+        this.penaltyCharges = this.penaltyCharges.plus(penaltyCharges);
+    }
+
+}

fineract-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/Loan.java

@@ -109,6 +109,7 @@
 import org.apache.fineract.portfolio.loanaccount.data.DisbursementData;
 import org.apache.fineract.portfolio.loanaccount.data.HolidayDetailDTO;
 import org.apache.fineract.portfolio.loanaccount.data.LoanTermVariationsData;
+import org.apache.fineract.portfolio.loanaccount.data.OutstandingAmountsDTO;
 import org.apache.fineract.portfolio.loanaccount.data.ScheduleGeneratorDTO;
 import org.apache.fineract.portfolio.loanaccount.domain.transactionprocessor.LoanRepaymentScheduleTransactionProcessor;
 import org.apache.fineract.portfolio.loanaccount.domain.transactionprocessor.MoneyHolder;
@@ -4368,8 +4369,8 @@ private LoanScheduleDTO getRecalculatedSchedule(final ScheduleGeneratorDTO gener
                 loanRepaymentScheduleTransactionProcessor, generatorDTO.getRecalculateFrom());
     }
 
-    public LoanRepaymentScheduleInstallment fetchPrepaymentDetail(final ScheduleGeneratorDTO scheduleGeneratorDTO, final LocalDate onDate) {
-        LoanRepaymentScheduleInstallment installment;
+    public OutstandingAmountsDTO fetchPrepaymentDetail(final ScheduleGeneratorDTO scheduleGeneratorDTO, final LocalDate onDate) {
+        OutstandingAmountsDTO outstandingAmounts;
 
         if (this.loanRepaymentScheduleDetail.isInterestRecalculationEnabled()) {
             final MathContext mc = MoneyHelper.getMathContext();
@@ -4381,12 +4382,12 @@ public LoanRepaymentScheduleInstallment fetchPrepaymentDetail(final ScheduleGene
                     .create(loanApplicationTerms.getLoanScheduleType(), interestMethod);
             final LoanRepaymentScheduleTransactionProcessor loanRepaymentScheduleTransactionProcessor = this.transactionProcessorFactory
                     .determineProcessor(this.transactionProcessingStrategyCode);
-            installment = loanScheduleGenerator.calculatePrepaymentAmount(getCurrency(), onDate, loanApplicationTerms, mc, this,
+            outstandingAmounts = loanScheduleGenerator.calculatePrepaymentAmount(getCurrency(), onDate, loanApplicationTerms, mc, this,
                     scheduleGeneratorDTO.getHolidayDetailDTO(), loanRepaymentScheduleTransactionProcessor);
         } else {
-            installment = this.getTotalOutstandingOnLoan();
+            outstandingAmounts = this.getTotalOutstandingOnLoan();
         }
-        return installment;
+        return outstandingAmounts;
     }
 
     public LoanApplicationTerms constructLoanApplicationTerms(final ScheduleGeneratorDTO scheduleGeneratorDTO) {
@@ -4460,11 +4461,11 @@ public BigDecimal constructLoanTermVariations(FloatingRateDTO floatingRateDTO, B
         return annualNominalInterestRate;
     }
 
-    private LoanRepaymentScheduleInstallment getTotalOutstandingOnLoan() {
-        Money feeCharges = Money.zero(loanCurrency());
-        Money penaltyCharges = Money.zero(loanCurrency());
+    private OutstandingAmountsDTO getTotalOutstandingOnLoan() {
         Money totalPrincipal = Money.zero(loanCurrency());
         Money totalInterest = Money.zero(loanCurrency());
+        Money feeCharges = Money.zero(loanCurrency());
+        Money penaltyCharges = Money.zero(loanCurrency());
         final Set<LoanInterestRecalcualtionAdditionalDetails> compoundingDetails = null;
         List<LoanRepaymentScheduleInstallment> repaymentSchedule = getRepaymentScheduleInstallments();
         for (final LoanRepaymentScheduleInstallment scheduledRepayment : repaymentSchedule) {
@@ -4473,9 +4474,8 @@ private LoanRepaymentScheduleInstallment getTotalOutstandingOnLoan() {
             feeCharges = feeCharges.plus(scheduledRepayment.getFeeChargesOutstanding(loanCurrency()));
             penaltyCharges = penaltyCharges.plus(scheduledRepayment.getPenaltyChargesOutstanding(loanCurrency()));
         }
-        LocalDate businessDate = DateUtils.getBusinessLocalDate();
-        return new LoanRepaymentScheduleInstallment(null, 0, businessDate, businessDate, totalPrincipal.getAmount(),
-                totalInterest.getAmount(), feeCharges.getAmount(), penaltyCharges.getAmount(), false, compoundingDetails);
+        return new OutstandingAmountsDTO(totalPrincipal.getCurrency()).principal(totalPrincipal).interest(totalInterest)
+                .feeCharges(feeCharges).penaltyCharges(penaltyCharges);
     }
 
     public LocalDate fetchInterestRecalculateFromDate() {

fineract-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/LoanRepaymentScheduleInstallment.java

@@ -583,20 +583,20 @@ public Money payInterestComponent(final LocalDate transactionDate, final Money t
         return interestPortionOfTransaction;
     }
 
-    public Money payPrincipalComponent(final LocalDate transactionDate, final Money transactionAmountRemaining) {
+    public Money payPrincipalComponent(final LocalDate transactionDate, final Money transactionAmount) {
 
-        final MonetaryCurrency currency = transactionAmountRemaining.getCurrency();
+        final MonetaryCurrency currency = transactionAmount.getCurrency();
         Money principalPortionOfTransaction = Money.zero(currency);
-        if (transactionAmountRemaining.isZero()) {
+        if (transactionAmount.isZero()) {
             return principalPortionOfTransaction;
         }
         final Money principalDue = getPrincipalOutstanding(currency);
-        if (transactionAmountRemaining.isGreaterThanOrEqualTo(principalDue)) {
+        if (transactionAmount.isGreaterThanOrEqualTo(principalDue)) {
             this.principalCompleted = getPrincipalCompleted(currency).plus(principalDue).getAmount();
             principalPortionOfTransaction = principalPortionOfTransaction.plus(principalDue);
         } else {
-            this.principalCompleted = getPrincipalCompleted(currency).plus(transactionAmountRemaining).getAmount();
-            principalPortionOfTransaction = principalPortionOfTransaction.plus(transactionAmountRemaining);
+            this.principalCompleted = getPrincipalCompleted(currency).plus(transactionAmount).getAmount();
+            principalPortionOfTransaction = principalPortionOfTransaction.plus(transactionAmount);
         }
 
         this.principalCompleted = defaultToNullIfZero(this.principalCompleted);

fineract-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/loanschedule/domain/AbstractCumulativeLoanScheduleGenerator.java

@@ -45,6 +45,7 @@
 import org.apache.fineract.portfolio.loanaccount.data.DisbursementData;
 import org.apache.fineract.portfolio.loanaccount.data.HolidayDetailDTO;
 import org.apache.fineract.portfolio.loanaccount.data.LoanTermVariationsData;
+import org.apache.fineract.portfolio.loanaccount.data.OutstandingAmountsDTO;
 import org.apache.fineract.portfolio.loanaccount.domain.Loan;
 import org.apache.fineract.portfolio.loanaccount.domain.LoanCharge;
 import org.apache.fineract.portfolio.loanaccount.domain.LoanInterestRecalcualtionAdditionalDetails;
@@ -2775,7 +2776,7 @@ private LocalDate getNextCompoundScheduleDate(LocalDate startDate, LoanApplicati
      * Method returns the amount payable to close the loan account as of today.
      */
     @Override
-    public LoanRepaymentScheduleInstallment calculatePrepaymentAmount(final MonetaryCurrency currency, final LocalDate onDate,
+    public OutstandingAmountsDTO calculatePrepaymentAmount(final MonetaryCurrency currency, final LocalDate onDate,
             final LoanApplicationTerms loanApplicationTerms, final MathContext mc, Loan loan, final HolidayDetailDTO holidayDetailDTO,
             final LoanRepaymentScheduleTransactionProcessor loanRepaymentScheduleTransactionProcessor) {
 
@@ -2790,10 +2791,10 @@ public LoanRepaymentScheduleInstallment calculatePrepaymentAmount(final Monetary
 
         loanRepaymentScheduleTransactionProcessor.reprocessLoanTransactions(loanApplicationTerms.getExpectedDisbursementDate(),
                 loanTransactions, currency, loanScheduleDTO.getInstallments(), loan.getActiveCharges());
-        Money feeCharges = Money.zero(currency);
-        Money penaltyCharges = Money.zero(currency);
         Money totalPrincipal = Money.zero(currency);
         Money totalInterest = Money.zero(currency);
+        Money feeCharges = Money.zero(currency);
+        Money penaltyCharges = Money.zero(currency);
         for (final LoanRepaymentScheduleInstallment currentInstallment : loanScheduleDTO.getInstallments()) {
             if (currentInstallment.isNotFullyPaidOff()) {
                 totalPrincipal = totalPrincipal.plus(currentInstallment.getPrincipalOutstanding(currency));
@@ -2802,8 +2803,10 @@ public LoanRepaymentScheduleInstallment calculatePrepaymentAmount(final Monetary
                 penaltyCharges = penaltyCharges.plus(currentInstallment.getPenaltyChargesOutstanding(currency));
             }
         }
-        final Set<LoanInterestRecalcualtionAdditionalDetails> compoundingDetails = null;
-        return new LoanRepaymentScheduleInstallment(null, 0, onDate, onDate, totalPrincipal.getAmount(), totalInterest.getAmount(),
-                feeCharges.getAmount(), penaltyCharges.getAmount(), false, compoundingDetails);
+        return new OutstandingAmountsDTO(currency) //
+                .principal(totalPrincipal) //
+                .interest(totalInterest) //
+                .feeCharges(feeCharges) //
+                .penaltyCharges(penaltyCharges);
     }
 }

fineract-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/loanschedule/domain/LoanScheduleGenerator.java

@@ -23,9 +23,9 @@
 import java.util.Set;
 import org.apache.fineract.organisation.monetary.domain.MonetaryCurrency;
 import org.apache.fineract.portfolio.loanaccount.data.HolidayDetailDTO;
+import org.apache.fineract.portfolio.loanaccount.data.OutstandingAmountsDTO;
 import org.apache.fineract.portfolio.loanaccount.domain.Loan;
 import org.apache.fineract.portfolio.loanaccount.domain.LoanCharge;
-import org.apache.fineract.portfolio.loanaccount.domain.LoanRepaymentScheduleInstallment;
 import org.apache.fineract.portfolio.loanaccount.domain.transactionprocessor.LoanRepaymentScheduleTransactionProcessor;
 import org.apache.fineract.portfolio.loanaccount.loanschedule.data.LoanScheduleDTO;
 
@@ -38,8 +38,8 @@ LoanScheduleDTO rescheduleNextInstallments(MathContext mc, LoanApplicationTerms
             HolidayDetailDTO holidayDetailDTO, LoanRepaymentScheduleTransactionProcessor loanRepaymentScheduleTransactionProcessor,
             LocalDate rescheduleFrom);
 
-    LoanRepaymentScheduleInstallment calculatePrepaymentAmount(MonetaryCurrency currency, LocalDate onDate,
-            LoanApplicationTerms loanApplicationTerms, MathContext mc, Loan loan, HolidayDetailDTO holidayDetailDTO,
+    OutstandingAmountsDTO calculatePrepaymentAmount(MonetaryCurrency currency, LocalDate onDate, LoanApplicationTerms loanApplicationTerms,
+            MathContext mc, Loan loan, HolidayDetailDTO holidayDetailDTO,
             LoanRepaymentScheduleTransactionProcessor loanRepaymentScheduleTransactionProcessor);
 
 }

fineract-progressive-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/loanschedule/domain/ProgressiveLoanScheduleGenerator.java

@@ -18,22 +18,29 @@
  */
 package org.apache.fineract.portfolio.loanaccount.loanschedule.domain;
 
+import static java.time.temporal.ChronoUnit.DAYS;
+
 import java.math.BigDecimal;
 import java.math.MathContext;
+import java.math.RoundingMode;
 import java.time.LocalDate;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.apache.fineract.infrastructure.core.service.MathUtil;
 import org.apache.fineract.organisation.monetary.domain.ApplicationCurrency;
 import org.apache.fineract.organisation.monetary.domain.MonetaryCurrency;
 import org.apache.fineract.organisation.monetary.domain.Money;
+import org.apache.fineract.organisation.monetary.domain.MoneyHelper;
 import org.apache.fineract.portfolio.loanaccount.data.DisbursementData;
 import org.apache.fineract.portfolio.loanaccount.data.HolidayDetailDTO;
 import org.apache.fineract.portfolio.loanaccount.data.LoanTermVariationsData;
+import org.apache.fineract.portfolio.loanaccount.data.OutstandingAmountsDTO;
 import org.apache.fineract.portfolio.loanaccount.domain.Loan;
 import org.apache.fineract.portfolio.loanaccount.domain.LoanCharge;
 import org.apache.fineract.portfolio.loanaccount.domain.LoanRepaymentScheduleInstallment;
@@ -48,6 +55,7 @@
 import org.apache.fineract.portfolio.loanproduct.domain.RepaymentStartDateType;
 import org.springframework.stereotype.Component;
 
+@Slf4j
 @Component
 @RequiredArgsConstructor
 public class ProgressiveLoanScheduleGenerator implements LoanScheduleGenerator {
@@ -222,10 +230,80 @@ public LoanScheduleDTO rescheduleNextInstallments(MathContext mc, LoanApplicatio
     }
 
     @Override
-    public LoanRepaymentScheduleInstallment calculatePrepaymentAmount(MonetaryCurrency currency, LocalDate onDate,
+    public OutstandingAmountsDTO calculatePrepaymentAmount(MonetaryCurrency currency, LocalDate onDate,
             LoanApplicationTerms loanApplicationTerms, MathContext mc, Loan loan, HolidayDetailDTO holidayDetailDTO,
             LoanRepaymentScheduleTransactionProcessor loanRepaymentScheduleTransactionProcessor) {
-        return null;
+        return switch (loanApplicationTerms.getPreClosureInterestCalculationStrategy()) {
+            case TILL_PRE_CLOSURE_DATE -> {
+                log.debug("calculating prepayment amount till pre closure date (Strategy A)");
+                OutstandingAmountsDTO outstandingAmounts = new OutstandingAmountsDTO(currency);
+                AtomicBoolean firstAfterPayoff = new AtomicBoolean(true);
+                loan.getRepaymentScheduleInstallments().forEach(installment -> {
+                    boolean isInstallmentAfterPayoff = installment.getDueDate().isAfter(onDate);
+
+                    outstandingAmounts.plusPrincipal(installment.getPrincipalOutstanding(currency));
+                    if (isInstallmentAfterPayoff) {
+                        if (firstAfterPayoff.getAndSet(false)) {
+                            outstandingAmounts.plusInterest(calculatePayableInterest(loan, installment, onDate));
+                        } else {
+                            log.debug("Installment {} - {} is after payoff, not counting interest", installment.getFromDate(),
+                                    installment.getDueDate());
+                        }
+                    } else {
+                        log.debug("adding interest for {} - {}: {}", installment.getFromDate(), installment.getDueDate(),
+                                installment.getInterestOutstanding(currency));
+                        outstandingAmounts.plusInterest(installment.getInterestOutstanding(currency));
+                    }
+                    outstandingAmounts.plusFeeCharges(installment.getFeeChargesOutstanding(currency));
+                    outstandingAmounts.plusPenaltyCharges(installment.getPenaltyChargesOutstanding(currency));
+                });
+                yield outstandingAmounts;
+            }
+
+            case TILL_REST_FREQUENCY_DATE -> {
+                log.debug("calculating prepayment amount till rest frequency date (Strategy B)");
+                OutstandingAmountsDTO outstandingAmounts = new OutstandingAmountsDTO(currency);
+                loan.getRepaymentScheduleInstallments().forEach(installment -> {
+                    boolean isPayoffAfterInstallmentFrom = installment.getFromDate().isAfter(onDate);
+
+                    outstandingAmounts.plusPrincipal(installment.getPrincipalOutstanding(currency));
+                    if (!isPayoffAfterInstallmentFrom) {
+                        outstandingAmounts.plusInterest(installment.getInterestOutstanding(currency));
+                    } else {
+                        log.debug("Payoff after installment {}, not counting interest", installment.getDueDate());
+                    }
+                    outstandingAmounts.plusFeeCharges(installment.getFeeChargesOutstanding(currency));
+                    outstandingAmounts.plusPenaltyCharges(installment.getPenaltyChargesOutstanding(currency));
+                });
+
+                yield outstandingAmounts;
+            }
+            case NONE -> throw new UnsupportedOperationException("Pre-closure interest calculation strategy not supported");
+        };
+    }
+
+    private Money calculatePayableInterest(Loan loan, LoanRepaymentScheduleInstallment installment, LocalDate onDate) {
+        RoundingMode roundingMode = MoneyHelper.getRoundingMode();
+        MonetaryCurrency currency = loan.getCurrency();
+        Money originalInterest = installment.getInterestCharged(currency);
+        log.debug("calculating interest for {} from {} to {}", originalInterest, installment.getFromDate(), installment.getDueDate());
+
+        LocalDate start = installment.getFromDate();
+        Money payableInterest = Money.zero(currency);
+
+        while (!start.isEqual(onDate)) {
+            long between = DAYS.between(start, installment.getDueDate());
+            Money dailyInterest = originalInterest.minus(payableInterest).dividedBy(between, roundingMode);
+            log.debug("Daily interest is {}: {} / {}, total: {}", dailyInterest, originalInterest.minus(payableInterest), between,
+                    payableInterest.add(dailyInterest));
+            payableInterest = payableInterest.add(dailyInterest);
+            start = start.plusDays(1);
+        }
+
+        payableInterest = payableInterest.minus(installment.getInterestPaid(currency).minus(installment.getInterestWaived(currency)));
+
+        log.debug("Payable interest is {}", payableInterest);
+        return payableInterest;
     }
 
     // Private, internal methods