FINERACT-2412: add full term tranche calculations

budaidev · budaidev · commit b6771874b415 · 2025-12-17T12:05:22.000+01:00
diff --git a/fineract-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/loanschedule/data/LoanSchedulePeriodData.java b/fineract-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/loanschedule/data/LoanSchedulePeriodData.java
@@ -81,9 +81,16 @@ public final class LoanSchedulePeriodData {
 
     public static LoanSchedulePeriodData disbursementOnlyPeriod(final LocalDate disbursementDate, final BigDecimal principalDisbursed,
             final BigDecimal feeChargesDueAtTimeOfDisbursement, final boolean isDisbursed) {
+        return disbursementOnlyPeriod(disbursementDate, principalDisbursed, feeChargesDueAtTimeOfDisbursement, isDisbursed,
+                principalDisbursed);
+    }
+
+    public static LoanSchedulePeriodData disbursementOnlyPeriod(final LocalDate disbursementDate, final BigDecimal principalDisbursed,
+            final BigDecimal feeChargesDueAtTimeOfDisbursement, final boolean isDisbursed,
+            final BigDecimal principalLoanBalanceOutstanding) {
         return builder().dueDate(disbursementDate) //
                 .principalDisbursed(principalDisbursed) //
-                .principalLoanBalanceOutstanding(principalDisbursed) //
+                .principalLoanBalanceOutstanding(principalLoanBalanceOutstanding) //
                 .feeChargesDue(feeChargesDueAtTimeOfDisbursement) //
                 .feeChargesPaid(isDisbursed ? feeChargesDueAtTimeOfDisbursement : null) //
                 .feeChargesOutstanding(isDisbursed ? null : feeChargesDueAtTimeOfDisbursement) //
diff --git a/fineract-progressive-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/transactionprocessor/impl/AdvancedPaymentScheduleTransactionProcessor.java b/fineract-progressive-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/transactionprocessor/impl/AdvancedPaymentScheduleTransactionProcessor.java
@@ -227,6 +227,12 @@ public Pair<ChangedTransactionDetail, ProgressiveLoanInterestScheduleModel> repr
         final Integer installmentAmountInMultiplesOf = loan.getLoanProductRelatedDetail().getInstallmentAmountInMultiplesOf();
         ProgressiveLoanInterestScheduleModel scheduleModel = emiCalculator.generateInstallmentInterestScheduleModel(installments,
                 LoanConfigurationDetailsMapper.map(loan), installmentAmountInMultiplesOf, overpaymentHolder.getMoneyObject().getMc());
+
+        scheduleModel.allowFullTermForTranche(loan.isAllowFullTermForTranche());
+        if (loan.isAllowFullTermForTranche()) {
+            scheduleModel.originalNumberOfRepayments(loan.getNumberOfRepayments());
+        }
+
         ProgressiveTransactionCtx ctx = new ProgressiveTransactionCtx(currency, installments, charges, overpaymentHolder,
                 changedTransactionDetail, scheduleModel);
 
diff --git a/fineract-progressive-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/loanschedule/domain/ProgressiveLoanScheduleGenerator.java b/fineract-progressive-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/loanschedule/domain/ProgressiveLoanScheduleGenerator.java
@@ -31,6 +31,7 @@
 import java.util.List;
 import java.util.Optional;
 import java.util.Set;
+import lombok.extern.slf4j.Slf4j;
 import org.apache.fineract.infrastructure.core.service.MathUtil;
 import org.apache.fineract.organisation.monetary.data.CurrencyData;
 import org.apache.fineract.organisation.monetary.domain.MonetaryCurrency;
@@ -58,6 +59,7 @@
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
+@Slf4j
 @Component
 public class ProgressiveLoanScheduleGenerator implements LoanScheduleGenerator {
 
@@ -109,6 +111,10 @@ public LoanScheduleModel generate(final MathContext mc, final LoanApplicationTer
         final ProgressiveLoanInterestScheduleModel interestScheduleModel = emiCalculator.generatePeriodInterestScheduleModel(
                 expectedRepaymentPeriods, loanApplicationTerms.toLoanConfigurationDetails(),
                 loanApplicationTerms.getInstallmentAmountInMultiplesOf(), mc);
+
+        interestScheduleModel.allowFullTermForTranche(loanApplicationTerms.isAllowFullTermForTranche());
+        interestScheduleModel.originalNumberOfRepayments(loanApplicationTerms.getNumberOfRepayments());
+
         final List<LoanScheduleModelPeriod> periods = new ArrayList<>(expectedRepaymentPeriods.size());
 
         prepareDisbursementsOnLoanApplicationTerms(loanApplicationTerms);
@@ -309,7 +315,15 @@ private void processDisbursements(final LoanApplicationTerms loanApplicationTerm
             final List<LoanScheduleModelPeriod> periods, final BigDecimal chargesDueAtTimeOfDisbursement,
             final boolean includeDisbursementsAfterMaturityDate, final MathContext mc) {
 
+        // Check if any disbursement has actually occurred
+        boolean hasAnyDisbursement = disbursementDataList.stream().anyMatch(DisbursementData::isDisbursed);
+
         for (DisbursementData disbursementData : disbursementDataList) {
+            // If at least one disbursement has occurred, skip expected (undisbursed) tranches.
+            // If no disbursements have occurred yet, process all expected tranches for EMI calculation.
+            if (hasAnyDisbursement && !disbursementData.isDisbursed()) {
+                continue;
+            }
             final LocalDate disbursementDate = disbursementData.disbursementDate();
             final LocalDate periodFromDate = scheduleParams.getPeriodStartDate();
             final LocalDate periodDueDate = scheduleParams.getActualRepaymentDate();
@@ -525,11 +539,24 @@ private ScheduleExtensionResult calculateAdditionalPeriodsForFullTermTranches(fi
         int maxAdditionalPeriods = 0;
         LocalDate maxDisbursementDate = null;
         final int numberOfRepayments = loanApplicationTerms.getNumberOfRepayments();
+        final int currentPeriodCount = existingPeriods.size();
 
+        // For each subsequent tranche, calculate how many additional periods are needed
+        // Each tranche needs 'numberOfRepayments' periods starting from its disbursement period
         for (int i = 1; i < disbursementDataList.size(); i++) {
-            LocalDate disbursementDate = disbursementDataList.get(i).disbursementDate();
+            DisbursementData disbursementData = disbursementDataList.get(i);
+            // Skip expected disbursements that haven't actually been disbursed yet
+            if (!disbursementData.isDisbursed()) {
+                continue;
+            }
+            LocalDate disbursementDate = disbursementData.disbursementDate();
             int periodIndex = findPeriodIndexForDate(disbursementDate, existingPeriods);
-            int additionalPeriodsForThisTranche = periodIndex;
+            // This tranche needs 'numberOfRepayments' periods. The first repayment for this tranche
+            // is at the due date of the period containing the disbursement. Since the base schedule
+            // already has the first tranche's periods, subsequent tranches need periods extending
+            // from (periodIndex + 1) through (periodIndex + numberOfRepayments).
+            int lastRequiredPeriodIndex = periodIndex + numberOfRepayments;
+            int additionalPeriodsForThisTranche = Math.max(0, lastRequiredPeriodIndex - currentPeriodCount + 1);
             if (additionalPeriodsForThisTranche > maxAdditionalPeriods) {
                 maxAdditionalPeriods = additionalPeriodsForThisTranche;
                 maxDisbursementDate = disbursementDate;
diff --git a/fineract-progressive-loan/src/main/java/org/apache/fineract/portfolio/loanproduct/calc/ProgressiveEMICalculator.java b/fineract-progressive-loan/src/main/java/org/apache/fineract/portfolio/loanproduct/calc/ProgressiveEMICalculator.java
@@ -130,15 +130,86 @@ public void addDisbursement(final ProgressiveLoanInterestScheduleModel scheduleM
     }
 
     private void addDisbursement(final ProgressiveLoanInterestScheduleModel scheduleModel, final EmiChangeOperation operation) {
-        scheduleModel.repaymentPeriods().stream().filter(rp -> !operation.getSubmittedOnDate().isAfter(rp.getFromDate()))
-                .forEach(rp -> rp.setTotalDisbursedAmount(rp.getTotalDisbursedAmount().add(operation.getAmount())));
+        scheduleModel.repaymentPeriods().stream().filter(rp -> !operation.getSubmittedOnDate().isAfter(rp.getFromDate())).forEach(rp -> {
+            rp.setTotalDisbursedAmount(rp.getTotalDisbursedAmount().add(operation.getAmount()));
+        });
 
-        scheduleModel
-                .changeOutstandingBalanceAndUpdateInterestPeriods(operation.getSubmittedOnDate(), operation.getAmount(),
-                        scheduleModel.zero(), scheduleModel.zero())
-                .ifPresent((repaymentPeriod) -> calculateEMIValueAndRateFactors(
-                        getEffectiveRepaymentDueDate(scheduleModel, repaymentPeriod, operation.getSubmittedOnDate()), scheduleModel,
-                        operation));
+        if (scheduleModel.allowFullTermForTranche() && scheduleModel.originalNumberOfRepayments() > 0) {
+            addFullTermTrancheDisbursement(scheduleModel, operation);
+        } else {
+            scheduleModel
+                    .changeOutstandingBalanceAndUpdateInterestPeriods(operation.getSubmittedOnDate(), operation.getAmount(),
+                            scheduleModel.zero(), scheduleModel.zero())
+                    .ifPresent((repaymentPeriod) -> calculateEMIValueAndRateFactors(
+                            getEffectiveRepaymentDueDate(scheduleModel, repaymentPeriod, operation.getSubmittedOnDate()), scheduleModel,
+                            operation));
+        }
+    }
+
+    private void addFullTermTrancheDisbursement(final ProgressiveLoanInterestScheduleModel scheduleModel,
+            final EmiChangeOperation operation) {
+        final MathContext mc = scheduleModel.mc();
+        final LocalDate disbursementDate = operation.getSubmittedOnDate();
+        final Money disbursedAmount = operation.getAmount();
+        final int originalNumberOfRepayments = scheduleModel.originalNumberOfRepayments();
+
+        scheduleModel.changeOutstandingBalanceAndUpdateInterestPeriods(disbursementDate, disbursedAmount, scheduleModel.zero(),
+                scheduleModel.zero());
+
+        int disbursementPeriodIndex = findDisbursementPeriodIndex(scheduleModel, disbursementDate);
+        if (disbursementPeriodIndex < 0) {
+            disbursementPeriodIndex = 0;
+        }
+
+        int requiredEndIndex = disbursementPeriodIndex + originalNumberOfRepayments;
+        int currentPeriodCount = scheduleModel.repaymentPeriods().size();
+        if (requiredEndIndex > currentPeriodCount) {
+            extendScheduleForFullTermTranche(scheduleModel, requiredEndIndex - currentPeriodCount);
+        }
+
+        List<RepaymentPeriod> trancheRepaymentPeriods = scheduleModel.repaymentPeriods().subList(disbursementPeriodIndex,
+                disbursementPeriodIndex + originalNumberOfRepayments);
+
+        if (trancheRepaymentPeriods.isEmpty()) {
+            return;
+        }
+
+        calculateRateFactorForPeriods(trancheRepaymentPeriods, scheduleModel);
+
+        final BigDecimal rateFactorN = MathUtil.stripTrailingZeros(calculateRateFactorPlus1N(trancheRepaymentPeriods, mc));
+        final BigDecimal fnResult = MathUtil.stripTrailingZeros(calculateFnResult(trancheRepaymentPeriods, mc));
+
+        final Money trancheEmi = Money.of(disbursedAmount.getCurrencyData(),
+                calculateEMIValue(rateFactorN, disbursedAmount.getAmount(), fnResult, mc), mc);
+        final Money finalTrancheEmi = applyInstallmentAmountInMultiplesOf(scheduleModel, trancheEmi);
+
+        for (RepaymentPeriod period : trancheRepaymentPeriods) {
+            Money existingEmi = period.getEmi() != null ? period.getEmi() : scheduleModel.zero();
+            Money newEmi = existingEmi.plus(finalTrancheEmi, mc);
+            period.setEmi(newEmi);
+            period.setOriginalEmi(newEmi);
+        }
+
+        calculateOutstandingBalance(scheduleModel);
+    }
+
+    private void extendScheduleForFullTermTranche(final ProgressiveLoanInterestScheduleModel scheduleModel, int periodsToAdd) {
+        final int existingCount = scheduleModel.repaymentPeriods().size();
+        final LocalDate startDate = scheduleModel.getStartDate();
+        final List<LocalDateInterval> newPeriodDates = generateAdditionalRepaymentPeriodDueDates(scheduleModel, periodsToAdd, existingCount,
+                scheduleModel.resolveRepaymentPEriodLengthGeneratorFunction(startDate));
+        updateModel(scheduleModel, newPeriodDates, LocalDateInterval::startDate, LocalDateInterval::endDate);
+    }
+
+    private int findDisbursementPeriodIndex(final ProgressiveLoanInterestScheduleModel scheduleModel, final LocalDate disbursementDate) {
+        List<RepaymentPeriod> periods = scheduleModel.repaymentPeriods();
+        for (int i = 0; i < periods.size(); i++) {
+            RepaymentPeriod period = periods.get(i);
+            if (!disbursementDate.isBefore(period.getFromDate()) && disbursementDate.isBefore(period.getDueDate())) {
+                return i;
+            }
+        }
+        return periods.size() - 1;
     }
 
     private LocalDate getEffectiveRepaymentDueDate(final ProgressiveLoanInterestScheduleModel scheduleModel,
diff --git a/fineract-progressive-loan/src/main/java/org/apache/fineract/portfolio/loanproduct/calc/data/ProgressiveLoanInterestScheduleModel.java b/fineract-progressive-loan/src/main/java/org/apache/fineract/portfolio/loanproduct/calc/data/ProgressiveLoanInterestScheduleModel.java
@@ -69,6 +69,12 @@ public class ProgressiveLoanInterestScheduleModel {
     @Setter
     private LocalDate lastOverdueBalanceChange;
 
+    @Setter
+    private boolean allowFullTermForTranche = false;
+
+    @Setter
+    private int originalNumberOfRepayments;
+
     public ProgressiveLoanInterestScheduleModel(final List<RepaymentPeriod> repaymentPeriods,
             final ILoanConfigurationDetails loanProductRelatedDetail, final Integer installmentAmountInMultiplesOf, final MathContext mc) {
         this.repaymentPeriods = new ArrayList<>(repaymentPeriods);
@@ -96,15 +102,21 @@ private ProgressiveLoanInterestScheduleModel(final List<RepaymentPeriod> repayme
     }
 
     public ProgressiveLoanInterestScheduleModel deepCopy(MathContext mc) {
-        return new ProgressiveLoanInterestScheduleModel(repaymentPeriods, interestRates, loanProductRelatedDetail,
-                installmentAmountInMultiplesOf, mc, false);
+        ProgressiveLoanInterestScheduleModel copy = new ProgressiveLoanInterestScheduleModel(repaymentPeriods, interestRates,
+                loanProductRelatedDetail, installmentAmountInMultiplesOf, mc, false);
+        copy.allowFullTermForTranche(this.allowFullTermForTranche);
+        copy.originalNumberOfRepayments(this.originalNumberOfRepayments);
+        return copy;
     }
 
     public ProgressiveLoanInterestScheduleModel copyWithoutPaidAmounts() {
         final List<RepaymentPeriod> repaymentPeriodCopies = copyRepaymentPeriods(repaymentPeriods,
                 (previousPeriod, repaymentPeriod) -> RepaymentPeriod.copyWithoutPaidAmounts(previousPeriod, repaymentPeriod, mc));
-        return new ProgressiveLoanInterestScheduleModel(repaymentPeriodCopies, interestRates, loanProductRelatedDetail,
-                installmentAmountInMultiplesOf, mc, true);
+        ProgressiveLoanInterestScheduleModel copy = new ProgressiveLoanInterestScheduleModel(repaymentPeriodCopies, interestRates,
+                loanProductRelatedDetail, installmentAmountInMultiplesOf, mc, true);
+        copy.allowFullTermForTranche(this.allowFullTermForTranche);
+        copy.originalNumberOfRepayments(this.originalNumberOfRepayments);
+        return copy;
     }
 
     private List<RepaymentPeriod> copyRepaymentPeriods(final List<RepaymentPeriod> repaymentPeriods,
diff --git a/fineract-progressive-loan/src/main/java/org/apache/fineract/portfolio/loanproduct/calc/data/RepaymentPeriod.java b/fineract-progressive-loan/src/main/java/org/apache/fineract/portfolio/loanproduct/calc/data/RepaymentPeriod.java
@@ -344,6 +344,9 @@ public Money getCreditedAmounts() {
     public Money getOutstandingLoanBalance() {
         if (outstandingBalanceCalculation == null) {
             outstandingBalanceCalculation = Memo.of(() -> {
+                if (getInterestPeriods().isEmpty()) {
+                    return getZero();
+                }
                 InterestPeriod lastInterestPeriod = getInterestPeriods().getLast();
                 Money calculatedOutStandingLoanBalance = lastInterestPeriod.getOutstandingLoanBalance() //
                         .plus(lastInterestPeriod.getBalanceCorrectionAmount(), getMc()) //
diff --git a/fineract-progressive-loan/src/test/java/org/apache/fineract/portfolio/loanproduct/calc/ProgressiveEMICalculatorTest.java b/fineract-progressive-loan/src/test/java/org/apache/fineract/portfolio/loanproduct/calc/ProgressiveEMICalculatorTest.java
diff --git a/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/service/LoanRepaymentScheduleService.java b/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/service/LoanRepaymentScheduleService.java
diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanDisbursementDetailsIntegrationTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanDisbursementDetailsIntegrationTest.java
