This is an automated email from the ASF dual-hosted git repository.
adamsaghy pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/fineract.git
The following commit(s) were added to refs/heads/develop by this push:
new 94360c9f8 FINERACT-2114: Interest rate modification - Advanced payment
allocation processor support
94360c9f8 is described below
commit 94360c9f8aa0387b352f635f0841a83ea962cfcb
Author: Janos Meszaros <[email protected]>
AuthorDate: Tue Oct 29 10:44:52 2024 +0100
FINERACT-2114: Interest rate modification - Advanced payment allocation
processor support
---
.../infrastructure/core/service/DateUtils.java | 5 +
.../loanaccount/domain/LoanTermVariationType.java | 8 +-
...tLoanRepaymentScheduleTransactionProcessor.java | 2 +-
...dvancedPaymentScheduleTransactionProcessor.java | 67 ++++-
...argeOrTransaction.java => ChangeOperation.java} | 54 ++--
.../loanschedule/data/InterestRate.java | 6 +-
.../data/ProgressiveLoanInterestScheduleModel.java | 30 +-
.../loanschedule/data/RepaymentPeriod.java | 6 +-
.../domain/ProgressiveLoanScheduleGenerator.java | 66 ++---
.../loanproduct/calc/ProgressiveEMICalculator.java | 39 ++-
.../impl/ChangeOperationTest.java | 159 +++++++++++
.../impl/ChargeOrTransactionTest.java | 127 ---------
.../calc/ProgressiveEMICalculatorTest.java | 302 ++++++++++++---------
.../service/reaging/LoanReAgingValidator.java | 4 +-
.../LoanReAmortizationValidator.java | 4 +-
...PaymentAllocationLoanRepaymentScheduleTest.java | 119 ++++++++
16 files changed, 634 insertions(+), 364 deletions(-)
diff --git
a/fineract-core/src/main/java/org/apache/fineract/infrastructure/core/service/DateUtils.java
b/fineract-core/src/main/java/org/apache/fineract/infrastructure/core/service/DateUtils.java
index be86204ab..f151a37ab 100644
---
a/fineract-core/src/main/java/org/apache/fineract/infrastructure/core/service/DateUtils.java
+++
b/fineract-core/src/main/java/org/apache/fineract/infrastructure/core/service/DateUtils.java
@@ -79,6 +79,11 @@ public final class DateUtils {
return truncate == null ? now : now.truncatedTo(truncate);
}
+ @NotNull
+ public static OffsetDateTime
getOffsetDateTimeOfTenantFromLocalDate(@NotNull final LocalDate date) {
+ return OffsetDateTime.of(date.atStartOfDay(),
getOffsetDateTimeOfTenant().getOffset());
+ }
+
public static LocalDateTime getLocalDateTimeOfSystem() {
return getLocalDateTimeOfSystem(null);
}
diff --git
a/fineract-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/LoanTermVariationType.java
b/fineract-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/LoanTermVariationType.java
index a8c6b0fee..7a462c004 100644
---
a/fineract-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/LoanTermVariationType.java
+++
b/fineract-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/LoanTermVariationType.java
@@ -26,9 +26,11 @@ public enum LoanTermVariationType {
PRINCIPAL_AMOUNT(3, "loanTermType.principalAmount"), //
DUE_DATE(4, "loanTermType.dueDate"), //
INSERT_INSTALLMENT(5, "loanTermType.insertInstallment"), //
- DELETE_INSTALLMENT(6, "loanTermType.deleteInstallment"),
GRACE_ON_INTEREST(7, "loanTermType.graceOnInterest"), GRACE_ON_PRINCIPAL(8,
- "loanTermType.graceOnPrincipal"), EXTEND_REPAYMENT_PERIOD(9,
- "loanTermType.extendRepaymentPeriod"),
INTEREST_RATE_FROM_INSTALLMENT(10, "loanTermType.interestRateFromInstallment");
+ DELETE_INSTALLMENT(6, "loanTermType.deleteInstallment"), //
+ GRACE_ON_INTEREST(7, "loanTermType.graceOnInterest"), //
+ GRACE_ON_PRINCIPAL(8, "loanTermType.graceOnPrincipal"), //
+ EXTEND_REPAYMENT_PERIOD(9, "loanTermType.extendRepaymentPeriod"), //
+ INTEREST_RATE_FROM_INSTALLMENT(10,
"loanTermType.interestRateFromInstallment"); //
private final Integer value;
private final String code;
diff --git
a/fineract-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/transactionprocessor/AbstractLoanRepaymentScheduleTransactionProcessor.java
b/fineract-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/transactionprocessor/AbstractLoanRepaymentScheduleTransactionProcessor.java
index 73d909b05..da6743277 100644
---
a/fineract-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/transactionprocessor/AbstractLoanRepaymentScheduleTransactionProcessor.java
+++
b/fineract-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/transactionprocessor/AbstractLoanRepaymentScheduleTransactionProcessor.java
@@ -478,7 +478,7 @@ public abstract class
AbstractLoanRepaymentScheduleTransactionProcessor implemen
&&
disbursementDate.equals(loanRepaymentScheduleInstallment.getObligationsMetOnDate());
}
- private boolean isNotObligationsMet(LoanRepaymentScheduleInstallment
loanRepaymentScheduleInstallment) {
+ protected boolean isNotObligationsMet(LoanRepaymentScheduleInstallment
loanRepaymentScheduleInstallment) {
return !loanRepaymentScheduleInstallment.isObligationsMet() &&
loanRepaymentScheduleInstallment.getObligationsMetOnDate() == null;
}
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
index 2852da4ba..6fa0875e3 100644
---
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
@@ -63,6 +63,8 @@ import
org.apache.fineract.infrastructure.core.service.ThreadLocalContextUtil;
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.LoanTermVariationsData;
+import
org.apache.fineract.portfolio.loanaccount.data.LoanTermVariationsDataWrapper;
import
org.apache.fineract.portfolio.loanaccount.domain.ChangedTransactionDetail;
import org.apache.fineract.portfolio.loanaccount.domain.Loan;
import org.apache.fineract.portfolio.loanaccount.domain.LoanCharge;
@@ -71,6 +73,7 @@ import
org.apache.fineract.portfolio.loanaccount.domain.LoanCreditAllocationRule
import
org.apache.fineract.portfolio.loanaccount.domain.LoanPaymentAllocationRule;
import
org.apache.fineract.portfolio.loanaccount.domain.LoanRepaymentScheduleInstallment;
import
org.apache.fineract.portfolio.loanaccount.domain.LoanRepaymentScheduleProcessingWrapper;
+import org.apache.fineract.portfolio.loanaccount.domain.LoanTermVariations;
import org.apache.fineract.portfolio.loanaccount.domain.LoanTransaction;
import
org.apache.fineract.portfolio.loanaccount.domain.LoanTransactionRelation;
import
org.apache.fineract.portfolio.loanaccount.domain.LoanTransactionRelationTypeEnum;
@@ -169,8 +172,6 @@ public class AdvancedPaymentScheduleTransactionProcessor
extends AbstractLoanRep
currentInstallment.updateObligationsMet(currency,
disbursementDate);
}
- List<ChargeOrTransaction> chargeOrTransactions =
createSortedChargesAndTransactionsList(loanTransactions, charges);
-
MoneyHolder overpaymentHolder = new MoneyHolder(Money.zero(currency));
final Loan loan = loanTransactions.get(0).getLoan();
final Integer installmentAmountInMultiplesOf =
loan.getLoanProduct().getInstallmentAmountInMultiplesOf();
@@ -180,17 +181,26 @@ public class AdvancedPaymentScheduleTransactionProcessor
extends AbstractLoanRep
ProgressiveTransactionCtx ctx = new
ProgressiveTransactionCtx(currency, installments, charges, overpaymentHolder,
changedTransactionDetail, scheduleModel);
+ LoanTermVariationsDataWrapper loanTermVariations = Optional
+
.ofNullable(loan.getActiveLoanTermVariations()).map(loanTermVariationsSet ->
loanTermVariationsSet.stream()
+
.map(LoanTermVariations::toData).collect(Collectors.toCollection(ArrayList::new)))
+ .map(LoanTermVariationsDataWrapper::new).orElse(null);
+ List<ChangeOperation> changeOperations =
createSortedChangeList(loanTermVariations, loanTransactions, charges);
+
List<LoanTransaction> overpaidTransactions = new ArrayList<>();
- for (final ChargeOrTransaction chargeOrTransaction :
chargeOrTransactions) {
- if (chargeOrTransaction.isTransaction()) {
- LoanTransaction transaction =
chargeOrTransaction.getLoanTransaction().get();
+ for (final ChangeOperation changeOperation : changeOperations) {
+ if (changeOperation.isInterestRateChange()) {
+ final LoanTermVariationsData interestRateChange =
changeOperation.getInterestRateChange().get();
+ processInterestRateChange(installments, interestRateChange,
scheduleModel);
+ } else if (changeOperation.isTransaction()) {
+ LoanTransaction transaction =
changeOperation.getLoanTransaction().get();
processSingleTransaction(transaction, ctx);
transaction =
getProcessedTransaction(changedTransactionDetail, transaction);
if (transaction.isOverPaid() &&
transaction.isRepaymentLikeType()) { // TODO CREDIT, DEBIT
overpaidTransactions.add(transaction);
}
} else {
- LoanCharge loanCharge =
chargeOrTransaction.getLoanCharge().get();
+ LoanCharge loanCharge = changeOperation.getLoanCharge().get();
processSingleCharge(loanCharge, currency, installments,
disbursementDate);
if (!loanCharge.isFullyPaid() &&
!overpaidTransactions.isEmpty()) {
overpaidTransactions =
processOverpaidTransactions(overpaidTransactions, currency, installments,
charges,
@@ -205,13 +215,37 @@ public class AdvancedPaymentScheduleTransactionProcessor
extends AbstractLoanRep
createNewTransaction(oldTransaction, newTransaction, ctx);
}
recalculateInterestForDate(ThreadLocalContextUtil.getBusinessDate(),
ctx);
- List<LoanTransaction> txs = chargeOrTransactions.stream() //
- .filter(ChargeOrTransaction::isTransaction) //
+ List<LoanTransaction> txs = changeOperations.stream() //
+ .filter(ChangeOperation::isTransaction) //
.map(e -> e.getLoanTransaction().get()).toList();
reprocessInstallments(disbursementDate, txs, installments, currency);
return Pair.of(changedTransactionDetail, scheduleModel);
}
+ private void processInterestRateChange(final
List<LoanRepaymentScheduleInstallment> installments,
+ final LoanTermVariationsData interestRateChange, final
ProgressiveLoanInterestScheduleModel scheduleModel) {
+ final LocalDate interestRateChangeSubmittedOnDate =
interestRateChange.getTermVariationApplicableFrom();
+ final BigDecimal newInterestRate =
interestRateChange.getDecimalValue();
+ emiCalculator.changeInterestRate(scheduleModel,
interestRateChangeSubmittedOnDate, newInterestRate);
+ processInterestRateChangeOnInstallments(scheduleModel,
interestRateChangeSubmittedOnDate, installments);
+ }
+
+ private void processInterestRateChangeOnInstallments(final
ProgressiveLoanInterestScheduleModel scheduleModel,
+ final LocalDate interestRateChangeSubmittedOnDate, final
List<LoanRepaymentScheduleInstallment> installments) {
+ installments.stream() //
+ .filter(installment -> isNotObligationsMet(installment)
+ &&
!interestRateChangeSubmittedOnDate.isAfter(installment.getDueDate()))
+ .forEach(installment ->
updateInstallmentIfInterestPeriodPresent(scheduleModel, installment)); //
+ }
+
+ private void updateInstallmentIfInterestPeriodPresent(final
ProgressiveLoanInterestScheduleModel scheduleModel,
+ final LoanRepaymentScheduleInstallment installment) {
+ emiCalculator.findRepaymentPeriod(scheduleModel,
installment.getDueDate()).ifPresent(interestRepaymentPeriod -> {
+
installment.updateInterestCharged(interestRepaymentPeriod.getDueInterest().getAmount());
+
installment.updatePrincipal(interestRepaymentPeriod.getDuePrincipal().getAmount());
+ });
+ }
+
@Override
public ChangedTransactionDetail reprocessLoanTransactions(LocalDate
disbursementDate, List<LoanTransaction> loanTransactions,
MonetaryCurrency currency, List<LoanRepaymentScheduleInstallment>
installments, Set<LoanCharge> charges) {
@@ -736,17 +770,20 @@ public class AdvancedPaymentScheduleTransactionProcessor
extends AbstractLoanRep
}
@NotNull
- private List<ChargeOrTransaction>
createSortedChargesAndTransactionsList(List<LoanTransaction> loanTransactions,
- Set<LoanCharge> charges) {
- List<ChargeOrTransaction> chargeOrTransactions = new ArrayList<>();
+ private List<ChangeOperation> createSortedChangeList(final
LoanTermVariationsDataWrapper loanTermVariations,
+ final List<LoanTransaction> loanTransactions, final
Set<LoanCharge> charges) {
+ List<ChangeOperation> changeOperations = new ArrayList<>();
+ if (loanTermVariations != null &&
!loanTermVariations.getInterestRateFromInstallment().isEmpty()) {
+
changeOperations.addAll(loanTermVariations.getInterestRateFromInstallment().stream().map(ChangeOperation::new).toList());
+ }
if (charges != null) {
-
chargeOrTransactions.addAll(charges.stream().map(ChargeOrTransaction::new).toList());
+
changeOperations.addAll(charges.stream().map(ChangeOperation::new).toList());
}
if (loanTransactions != null) {
-
chargeOrTransactions.addAll(loanTransactions.stream().map(ChargeOrTransaction::new).toList());
+
changeOperations.addAll(loanTransactions.stream().map(ChangeOperation::new).toList());
}
- Collections.sort(chargeOrTransactions);
- return chargeOrTransactions;
+ Collections.sort(changeOperations);
+ return changeOperations;
}
private void handleDisbursementWithEMICalculator(LoanTransaction
disbursementTransaction, TransactionCtx transactionCtx) {
diff --git
a/fineract-progressive-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/transactionprocessor/impl/ChargeOrTransaction.java
b/fineract-progressive-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/transactionprocessor/impl/ChangeOperation.java
similarity index 73%
rename from
fineract-progressive-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/transactionprocessor/impl/ChargeOrTransaction.java
rename to
fineract-progressive-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/transactionprocessor/impl/ChangeOperation.java
index 504719b67..16469f8a0 100644
---
a/fineract-progressive-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/transactionprocessor/impl/ChargeOrTransaction.java
+++
b/fineract-progressive-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/transactionprocessor/impl/ChangeOperation.java
@@ -24,26 +24,40 @@ import java.time.OffsetDateTime;
import java.util.Optional;
import lombok.Getter;
import org.apache.fineract.infrastructure.core.service.DateUtils;
+import org.apache.fineract.portfolio.loanaccount.data.LoanTermVariationsData;
import org.apache.fineract.portfolio.loanaccount.domain.LoanCharge;
import org.apache.fineract.portfolio.loanaccount.domain.LoanTransaction;
import org.jetbrains.annotations.NotNull;
@Getter
-public class ChargeOrTransaction implements Comparable<ChargeOrTransaction> {
+public class ChangeOperation implements Comparable<ChangeOperation> {
+ private final Optional<LoanTermVariationsData> interestRateChange;
private final Optional<LoanCharge> loanCharge;
private final Optional<LoanTransaction> loanTransaction;
- public ChargeOrTransaction(LoanCharge loanCharge) {
+ public ChangeOperation(LoanCharge loanCharge) {
+ this.interestRateChange = Optional.empty();
this.loanCharge = Optional.of(loanCharge);
this.loanTransaction = Optional.empty();
}
- public ChargeOrTransaction(LoanTransaction loanTransaction) {
+ public ChangeOperation(LoanTransaction loanTransaction) {
+ this.interestRateChange = Optional.empty();
this.loanTransaction = Optional.of(loanTransaction);
this.loanCharge = Optional.empty();
}
+ public ChangeOperation(LoanTermVariationsData interestRateChange) {
+ this.interestRateChange = Optional.of(interestRateChange);
+ this.loanTransaction = Optional.empty();
+ this.loanCharge = Optional.empty();
+ }
+
+ public boolean isInterestRateChange() {
+ return interestRateChange.isPresent();
+ }
+
public boolean isTransaction() {
return loanTransaction.isPresent();
}
@@ -52,8 +66,18 @@ public class ChargeOrTransaction implements
Comparable<ChargeOrTransaction> {
return loanCharge.isPresent();
}
+ private boolean isAccrualActivity() {
+ return isTransaction() && loanTransaction.get().isAccrualActivity();
+ }
+
+ private boolean isBackdatedCharge() {
+ return isCharge() && DateUtils.isBefore(loanCharge.get().getDueDate(),
loanCharge.get().getSubmittedOnDate());
+ }
+
private LocalDate getEffectiveDate() {
- if (loanCharge.isPresent()) {
+ if (interestRateChange.isPresent()) {
+ return getSubmittedOnDate();
+ } else if (loanCharge.isPresent()) {
if (isBackdatedCharge()) {
return loanCharge.get().getDueDate();
} else {
@@ -66,16 +90,10 @@ public class ChargeOrTransaction implements
Comparable<ChargeOrTransaction> {
}
}
- private boolean isAccrualActivity() {
- return isTransaction() && loanTransaction.get().isAccrualActivity();
- }
-
- private boolean isBackdatedCharge() {
- return isCharge() && DateUtils.isBefore(loanCharge.get().getDueDate(),
loanCharge.get().getSubmittedOnDate());
- }
-
private LocalDate getSubmittedOnDate() {
- if (loanCharge.isPresent()) {
+ if (interestRateChange.isPresent()) {
+ return interestRateChange.get().getTermVariationApplicableFrom();
+ } else if (loanCharge.isPresent()) {
return loanCharge.get().getSubmittedOnDate();
} else if (loanTransaction.isPresent()) {
return loanTransaction.get().getSubmittedOnDate();
@@ -85,7 +103,9 @@ public class ChargeOrTransaction implements
Comparable<ChargeOrTransaction> {
}
private OffsetDateTime getCreatedDateTime() {
- if (loanCharge.isPresent() &&
loanCharge.get().getCreatedDate().isPresent()) {
+ if (interestRateChange.isPresent()) {
+ return
DateUtils.getOffsetDateTimeOfTenantFromLocalDate(getSubmittedOnDate());
+ } else if (loanCharge.isPresent() &&
loanCharge.get().getCreatedDate().isPresent()) {
return loanCharge.get().getCreatedDate().get();
} else if (loanTransaction.isPresent()) {
return loanTransaction.get().getCreatedDateTime();
@@ -96,16 +116,16 @@ public class ChargeOrTransaction implements
Comparable<ChargeOrTransaction> {
@Override
@SuppressFBWarnings(value = "EQ_COMPARETO_USE_OBJECT_EQUALS",
justification = "TODO: fix this! See:
https://stackoverflow.com/questions/2609037/findbugs-how-to-solve-eq-compareto-use-object-equals")
- public int compareTo(@NotNull ChargeOrTransaction o) {
+ public int compareTo(@NotNull ChangeOperation o) {
int datePortion = DateUtils.compare(this.getEffectiveDate(),
o.getEffectiveDate());
if (datePortion == 0) {
- boolean isAccrual = isAccrualActivity();
+ final boolean isAccrual = isAccrualActivity();
if (isAccrual != o.isAccrualActivity()) {
return isAccrual ? 1 : -1;
}
int submittedDate = DateUtils.compare(getSubmittedOnDate(),
o.getSubmittedOnDate());
if (submittedDate == 0) {
- return DateUtils.compare(getCreatedDateTime(),
o.getCreatedDateTime());
+ return DateUtils.compare(getCreatedDateTime(),
o.getCreatedDateTime(), null);
}
return submittedDate;
}
diff --git
a/fineract-progressive-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/loanschedule/data/InterestRate.java
b/fineract-progressive-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/loanschedule/data/InterestRate.java
index bf5fe3474..50e78716a 100644
---
a/fineract-progressive-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/loanschedule/data/InterestRate.java
+++
b/fineract-progressive-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/loanschedule/data/InterestRate.java
@@ -22,9 +22,9 @@ import java.math.BigDecimal;
import java.time.LocalDate;
import org.jetbrains.annotations.NotNull;
-public record InterestRate(LocalDate effectiveFrom, //
- LocalDate validFrom, //
- BigDecimal interestRate //
+public record InterestRate(//
+ LocalDate effectiveFrom, //
+ BigDecimal interestRate//
) implements Comparable<InterestRate> {
@Override
diff --git
a/fineract-progressive-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/loanschedule/data/ProgressiveLoanInterestScheduleModel.java
b/fineract-progressive-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/loanschedule/data/ProgressiveLoanInterestScheduleModel.java
index 9f0782603..70b0ca0a8 100644
---
a/fineract-progressive-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/loanschedule/data/ProgressiveLoanInterestScheduleModel.java
+++
b/fineract-progressive-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/loanschedule/data/ProgressiveLoanInterestScheduleModel.java
@@ -23,8 +23,10 @@ import java.math.MathContext;
import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
+import java.util.Collections;
import java.util.List;
import java.util.Optional;
+import java.util.TreeSet;
import java.util.function.Consumer;
import lombok.Data;
import lombok.experimental.Accessors;
@@ -36,7 +38,7 @@ import
org.apache.fineract.portfolio.loanproduct.domain.LoanProductRelatedDetail
public class ProgressiveLoanInterestScheduleModel {
private final List<RepaymentPeriod> repaymentPeriods;
- private final List<InterestRate> interestRates;
+ private final TreeSet<InterestRate> interestRates;
private final LoanProductRelatedDetail loanProductRelatedDetail;
private final Integer installmentAmountInMultiplesOf;
private MathContext mc;
@@ -44,17 +46,17 @@ public class ProgressiveLoanInterestScheduleModel {
public ProgressiveLoanInterestScheduleModel(List<RepaymentPeriod>
repaymentPeriods, LoanProductRelatedDetail loanProductRelatedDetail,
Integer installmentAmountInMultiplesOf, MathContext mc) {
this.repaymentPeriods = repaymentPeriods;
- this.interestRates = new ArrayList<>();
+ this.interestRates = new TreeSet<>(Collections.reverseOrder());
this.loanProductRelatedDetail = loanProductRelatedDetail;
this.installmentAmountInMultiplesOf = installmentAmountInMultiplesOf;
this.mc = mc;
}
- private ProgressiveLoanInterestScheduleModel(List<RepaymentPeriod>
repaymentPeriods, final List<InterestRate> interestRates,
+ private ProgressiveLoanInterestScheduleModel(List<RepaymentPeriod>
repaymentPeriods, final TreeSet<InterestRate> interestRates,
LoanProductRelatedDetail loanProductRelatedDetail, Integer
installmentAmountInMultiplesOf, MathContext mc) {
this.mc = mc;
this.repaymentPeriods = copyRepaymentPeriods(repaymentPeriods);
- this.interestRates = new ArrayList<>(interestRates);
+ this.interestRates = new TreeSet<>(interestRates);
this.loanProductRelatedDetail = loanProductRelatedDetail;
this.installmentAmountInMultiplesOf = installmentAmountInMultiplesOf;
}
@@ -80,8 +82,15 @@ public class ProgressiveLoanInterestScheduleModel {
}
private BigDecimal findInterestRate(final LocalDate effectiveDate) {
- return interestRates.stream().filter(ir ->
!ir.effectiveFrom().isAfter(effectiveDate)).map(InterestRate::interestRate).findFirst()
-
.orElse(loanProductRelatedDetail.getAnnualNominalInterestRate());
+ return interestRates.stream() //
+ .filter(ir -> !ir.effectiveFrom().isAfter(effectiveDate)) //
+ .map(InterestRate::interestRate) //
+ .findFirst() //
+
.orElse(loanProductRelatedDetail.getAnnualNominalInterestRate()); //
+ }
+
+ public void addInterestRate(final LocalDate newInterestEffectiveDate,
final BigDecimal newInterestRate) {
+ interestRates.add(new InterestRate(newInterestEffectiveDate,
newInterestRate));
}
public Optional<RepaymentPeriod> findRepaymentPeriod(final LocalDate
repaymentPeriodDueDate) {
@@ -128,11 +137,12 @@ public class ProgressiveLoanInterestScheduleModel {
}
return repaymentPeriods.stream()//
.filter(repaymentPeriod -> {
- if (repaymentPeriod.getPrevious().isPresent()) {
- return
balanceChangeDate.isAfter(repaymentPeriod.getFromDate())
+ final boolean isFirstPeriod =
repaymentPeriod.getPrevious().isEmpty();
+ if (isFirstPeriod) {
+ return
!balanceChangeDate.isBefore(repaymentPeriod.getFromDate())
&&
!balanceChangeDate.isAfter(repaymentPeriod.getDueDate());
} else {
- return
!balanceChangeDate.isBefore(repaymentPeriod.getFromDate())
+ return
balanceChangeDate.isAfter(repaymentPeriod.getFromDate())
&&
!balanceChangeDate.isAfter(repaymentPeriod.getDueDate());
}
})//
@@ -183,7 +193,7 @@ public class ProgressiveLoanInterestScheduleModel {
repaymentPeriod.getInterestPeriods().add(interestPeriod);
}
- private Money getZero() {
+ public Money getZero() {
return Money.zero(loanProductRelatedDetail.getCurrency(), mc);
}
}
diff --git
a/fineract-progressive-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/loanschedule/data/RepaymentPeriod.java
b/fineract-progressive-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/loanschedule/data/RepaymentPeriod.java
index 3a21b51b3..2a3935227 100644
---
a/fineract-progressive-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/loanschedule/data/RepaymentPeriod.java
+++
b/fineract-progressive-loan/src/main/java/org/apache/fineract/portfolio/loanaccount/loanschedule/data/RepaymentPeriod.java
@@ -127,8 +127,12 @@ public class RepaymentPeriod {
return getEmi().minus(getCalculatedDueInterest(), mc);
}
+ public Money getTotalPaidAmount() {
+ return getPaidPrincipal().plus(getPaidInterest());
+ }
+
public boolean isFullyPaid() {
- return getEmi().isEqualTo(getPaidPrincipal().plus(getPaidInterest()));
+ return getEmi().isEqualTo(getTotalPaidAmount());
}
public Money getDueInterest() {
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
index bb4b69e3d..411e0c71b 100644
---
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
@@ -35,7 +35,6 @@ import
org.apache.fineract.organisation.monetary.domain.MonetaryCurrency;
import org.apache.fineract.organisation.monetary.domain.Money;
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;
@@ -61,27 +60,19 @@ public class ProgressiveLoanScheduleGenerator implements
LoanScheduleGenerator {
private final ScheduledDateGenerator scheduledDateGenerator;
private final EMICalculator emiCalculator;
+ public LoanSchedulePlan generate(final MathContext mc, final
LoanRepaymentScheduleModelData modelData) {
+ LoanApplicationTerms loanApplicationTerms =
LoanApplicationTerms.assembleFrom(modelData, mc);
+ return LoanSchedulePlan.from(generate(mc, loanApplicationTerms, null,
null));
+ }
+
@Override
public LoanScheduleModel generate(final MathContext mc, final
LoanApplicationTerms loanApplicationTerms,
final Set<LoanCharge> loanCharges, final HolidayDetailDTO
holidayDetailDTO) {
final ApplicationCurrency applicationCurrency =
loanApplicationTerms.getApplicationCurrency();
- // generate list of proposed schedule due dates
- LocalDate loanEndDate =
scheduledDateGenerator.getLastRepaymentDate(loanApplicationTerms,
holidayDetailDTO);
- if (loanApplicationTerms.getLoanTermVariations() != null) {
- LoanTermVariationsData lastDueDateVariation =
loanApplicationTerms.getLoanTermVariations()
- .fetchLoanTermDueDateVariationsData(loanEndDate);
- if (lastDueDateVariation != null) {
- loanEndDate = lastDueDateVariation.getDateValue();
- }
- }
-
// determine the total charges due at time of disbursement
final BigDecimal chargesDueAtTimeOfDisbursement =
deriveTotalChargesDueAtTimeOfDisbursement(loanCharges);
- // setup variables for tracking important facts required for loan
- // schedule generation.
-
final MonetaryCurrency currency = loanApplicationTerms.getCurrency();
LocalDate periodStartDate =
RepaymentStartDateType.DISBURSEMENT_DATE.equals(loanApplicationTerms.getRepaymentStartDateType())
? loanApplicationTerms.getExpectedDisbursementDate()
@@ -94,6 +85,7 @@ public class ProgressiveLoanScheduleGenerator implements
LoanScheduleGenerator {
// set and handled separately after all installments generated
final Set<LoanCharge> nonCompoundingCharges =
separateTotalCompoundingPercentageCharges(loanCharges);
+ // generate list of proposed schedule due dates
final List<LoanScheduleModelRepaymentPeriod> expectedRepaymentPeriods
= scheduledDateGenerator.generateRepaymentPeriods(mc,
periodStartDate, loanApplicationTerms, holidayDetailDTO);
final ProgressiveLoanInterestScheduleModel interestScheduleModel =
emiCalculator.generateInterestScheduleModel(
@@ -102,29 +94,17 @@ public class ProgressiveLoanScheduleGenerator implements
LoanScheduleGenerator {
final List<LoanScheduleModelPeriod> periods = new
ArrayList<>(expectedRepaymentPeriods.size());
prepareDisbursementsOnLoanApplicationTerms(loanApplicationTerms);
-
- final ArrayList<DisbursementData> disbursementDataList = new
ArrayList<>(loanApplicationTerms.getDisbursementDatas());
-
disbursementDataList.sort(Comparator.comparing(DisbursementData::disbursementDate));
+ final List<DisbursementData> disbursementDataList =
getSortedDisbursementList(loanApplicationTerms);
for (LoanScheduleModelRepaymentPeriod repaymentPeriod :
expectedRepaymentPeriods) {
scheduleParams.setPeriodStartDate(repaymentPeriod.getFromDate());
scheduleParams.setActualRepaymentDate(repaymentPeriod.getDueDate());
-
+ // in same repayment period the logic firstly applies interest
rate changes and just after the disbursements
+ applyInterestRateChangesOnPeriod(loanApplicationTerms,
repaymentPeriod, interestScheduleModel);
processDisbursements(loanApplicationTerms, disbursementDataList,
scheduleParams, interestScheduleModel, periods,
chargesDueAtTimeOfDisbursement, false, mc);
repaymentPeriod.setPeriodNumber(scheduleParams.getInstalmentNumber());
- if (loanApplicationTerms.getLoanTermVariations() != null) {
- for (var interestRateChange :
loanApplicationTerms.getLoanTermVariations().getInterestRateFromInstallment()) {
- final LocalDate interestRateSubmittedOnDate =
interestRateChange.getTermVariationApplicableFrom();
- final BigDecimal newInterestRate =
interestRateChange.getDecimalValue();
- if
(interestRateSubmittedOnDate.isAfter(repaymentPeriod.getFromDate())
- &&
!interestRateSubmittedOnDate.isAfter(repaymentPeriod.getDueDate())) {
-
emiCalculator.changeInterestRate(interestScheduleModel,
interestRateSubmittedOnDate, newInterestRate);
- }
- }
- }
-
emiCalculator.findRepaymentPeriod(interestScheduleModel,
repaymentPeriod.getDueDate()).ifPresent(interestRepaymentPeriod -> {
final Money principalDue =
interestRepaymentPeriod.getDuePrincipal();
final Money interestDue =
interestRepaymentPeriod.getDueInterest();
@@ -166,10 +146,24 @@ public class ProgressiveLoanScheduleGenerator implements
LoanScheduleGenerator {
scheduleParams.getTotalRepaymentExpected().getAmount(),
totalOutstanding);
}
- public LoanSchedulePlan generate(final MathContext mc, final
LoanRepaymentScheduleModelData modelData) {
+ private List<DisbursementData>
getSortedDisbursementList(LoanApplicationTerms loanApplicationTerms) {
+ final List<DisbursementData> disbursementDataList = new
ArrayList<>(loanApplicationTerms.getDisbursementDatas());
+
disbursementDataList.sort(Comparator.comparing(DisbursementData::disbursementDate));
+ return disbursementDataList;
+ }
- LoanApplicationTerms loanApplicationTerms =
LoanApplicationTerms.assembleFrom(modelData, mc);
- return LoanSchedulePlan.from(generate(mc, loanApplicationTerms, null,
null));
+ private void applyInterestRateChangesOnPeriod(final LoanApplicationTerms
loanApplicationTerms,
+ final LoanScheduleModelRepaymentPeriod repaymentPeriod, final
ProgressiveLoanInterestScheduleModel interestScheduleModel) {
+ if (loanApplicationTerms.getLoanTermVariations() != null) {
+ for (var interestRateChange :
loanApplicationTerms.getLoanTermVariations().getInterestRateFromInstallment()) {
+ final LocalDate interestRateSubmittedOnDate =
interestRateChange.getTermVariationApplicableFrom();
+ final BigDecimal newInterestRate =
interestRateChange.getDecimalValue();
+ if
(interestRateSubmittedOnDate.isAfter(repaymentPeriod.getFromDate())
+ &&
!interestRateSubmittedOnDate.isAfter(repaymentPeriod.getDueDate())) {
+ emiCalculator.changeInterestRate(interestScheduleModel,
interestRateSubmittedOnDate, newInterestRate);
+ }
+ }
+ }
}
private void prepareDisbursementsOnLoanApplicationTerms(final
LoanApplicationTerms loanApplicationTerms) {
@@ -181,10 +175,10 @@ public class ProgressiveLoanScheduleGenerator implements
LoanScheduleGenerator {
}
}
- private void processDisbursements(final LoanApplicationTerms
loanApplicationTerms,
- final ArrayList<DisbursementData> disbursementDataList, final
LoanScheduleParams scheduleParams,
- final ProgressiveLoanInterestScheduleModel interestScheduleModel,
final List<LoanScheduleModelPeriod> periods,
- final BigDecimal chargesDueAtTimeOfDisbursement, final boolean
includeDisbursementsAfterMaturityDate, final MathContext mc) {
+ private void processDisbursements(final LoanApplicationTerms
loanApplicationTerms, final List<DisbursementData> disbursementDataList,
+ final LoanScheduleParams scheduleParams, final
ProgressiveLoanInterestScheduleModel interestScheduleModel,
+ final List<LoanScheduleModelPeriod> periods, final BigDecimal
chargesDueAtTimeOfDisbursement,
+ final boolean includeDisbursementsAfterMaturityDate, final
MathContext mc) {
for (DisbursementData disbursementData : disbursementDataList) {
final LocalDate disbursementDate =
disbursementData.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
index 1898e0dac..97b1d3bcc 100644
---
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
@@ -81,16 +81,14 @@ public final class ProgressiveEMICalculator implements
EMICalculator {
@Override
public void addDisbursement(final ProgressiveLoanInterestScheduleModel
scheduleModel, final LocalDate disbursementDueDate,
final Money disbursedAmount) {
- scheduleModel
-
.changeOutstandingBalanceAndUpdateInterestPeriods(disbursementDueDate,
disbursedAmount,
- Money.zero(disbursedAmount.getCurrency(),
scheduleModel.mc()))
+
scheduleModel.changeOutstandingBalanceAndUpdateInterestPeriods(disbursementDueDate,
disbursedAmount, scheduleModel.getZero())
.ifPresent((repaymentPeriod) ->
calculateEMIValueAndRateFactors(
getEffectiveRepaymentDueDate(scheduleModel,
repaymentPeriod, disbursementDueDate), scheduleModel));
}
private LocalDate getEffectiveRepaymentDueDate(final
ProgressiveLoanInterestScheduleModel scheduleModel,
- final RepaymentPeriod changedRepaymentPeriod, final LocalDate
disbursementDueDate) {
- final boolean isRelatedToNextRepaymentPeriod =
changedRepaymentPeriod.getDueDate().isEqual(disbursementDueDate);
+ final RepaymentPeriod changedRepaymentPeriod, final LocalDate
operationDueDate) {
+ final boolean isRelatedToNextRepaymentPeriod =
changedRepaymentPeriod.getDueDate().isEqual(operationDueDate);
if (isRelatedToNextRepaymentPeriod) {
final Optional<RepaymentPeriod> nextRepaymentPeriod =
scheduleModel.repaymentPeriods().stream()
.filter(repaymentPeriod ->
changedRepaymentPeriod.equals(repaymentPeriod.getPrevious().orElse(null))).findFirst();
@@ -106,14 +104,20 @@ public final class ProgressiveEMICalculator implements
EMICalculator {
@Override
public void changeInterestRate(final ProgressiveLoanInterestScheduleModel
scheduleModel, final LocalDate newInterestSubmittedOnDate,
final BigDecimal newInterestRate) {
- // TODO: impl
+ final LocalDate interestRateChangeEffectiveDate =
newInterestSubmittedOnDate.minusDays(1);
+ scheduleModel.addInterestRate(interestRateChangeEffectiveDate,
newInterestRate);
+ scheduleModel
+
.changeOutstandingBalanceAndUpdateInterestPeriods(interestRateChangeEffectiveDate,
scheduleModel.getZero(),
+ scheduleModel.getZero())
+ .ifPresent(repaymentPeriod -> calculateEMIValueAndRateFactors(
+ getEffectiveRepaymentDueDate(scheduleModel,
repaymentPeriod, interestRateChangeEffectiveDate), scheduleModel));
}
@Override
public void addBalanceCorrection(ProgressiveLoanInterestScheduleModel
scheduleModel, LocalDate balanceCorrectionDate,
Money balanceCorrectionAmount) {
- final Money zeroAmount =
Money.zero(balanceCorrectionAmount.getCurrency());
-
scheduleModel.changeOutstandingBalanceAndUpdateInterestPeriods(balanceCorrectionDate,
zeroAmount, balanceCorrectionAmount)
+ scheduleModel
+
.changeOutstandingBalanceAndUpdateInterestPeriods(balanceCorrectionDate,
scheduleModel.getZero(), balanceCorrectionAmount)
.ifPresent(repaymentPeriod -> {
calculateRateFactorForRepaymentPeriod(repaymentPeriod,
scheduleModel);
calculateOutstandingBalance(scheduleModel);
@@ -186,10 +190,8 @@ public final class ProgressiveEMICalculator implements
EMICalculator {
final ProgressiveLoanInterestScheduleModel scheduleModel) {
final List<RepaymentPeriod> relatedRepaymentPeriods =
scheduleModel.getRelatedRepaymentPeriods(calculateFromRepaymentPeriodDueDate);
calculateRateFactorForPeriods(relatedRepaymentPeriods, scheduleModel);
- // TODO: optimalize
calculateOutstandingBalance(scheduleModel);
calculateEMIOnPeriods(relatedRepaymentPeriods, scheduleModel);
- // TODO: optimalize
calculateOutstandingBalance(scheduleModel);
calculateLastUnpaidRepaymentPeriodEMI(scheduleModel);
checkAndAdjustEmiIfNeededOnRelatedRepaymentPeriods(scheduleModel,
relatedRepaymentPeriods);
@@ -229,7 +231,9 @@ public final class ProgressiveEMICalculator implements
EMICalculator {
.isGreaterThan(Money.of(originalEmi.getCurrency(),
BigDecimal.valueOf(lowerHalfOfRelatedPeriods), mc));
if (shouldBeAdjusted) {
- Money adjustment = emiDifference.dividedBy(numberOfRelatedPeriods,
mc);
+ long uncountablePeriods =
relatedRepaymentPeriods.stream().filter(rp ->
originalEmi.isLessThan(rp.getTotalPaidAmount()))
+ .count();
+ Money adjustment = emiDifference.dividedBy(Math.max(1,
numberOfRelatedPeriods - uncountablePeriods), mc);
Money adjustedEqualMonthlyInstallmentValue =
applyInstallmentAmountInMultiplesOf(scheduleModel,
originalEmi.plus(adjustment, mc));
if (adjustedEqualMonthlyInstallmentValue.isEqualTo(originalEmi)) {
@@ -238,7 +242,8 @@ public final class ProgressiveEMICalculator implements
EMICalculator {
final LocalDate relatedPeriodsFirstDueDate =
relatedRepaymentPeriods.get(0).getDueDate();
final ProgressiveLoanInterestScheduleModel newScheduleModel =
scheduleModel.deepCopy(mc);
newScheduleModel.repaymentPeriods().forEach(period -> {
- if (!period.getDueDate().isBefore(relatedPeriodsFirstDueDate))
{
+ if (!period.getDueDate().isBefore(relatedPeriodsFirstDueDate)
+ &&
!adjustedEqualMonthlyInstallmentValue.isLessThan(period.getTotalPaidAmount())) {
period.setEmi(adjustedEqualMonthlyInstallmentValue);
}
});
@@ -393,7 +398,11 @@ public final class ProgressiveEMICalculator implements
EMICalculator {
calculateEMIValue(rateFactorN, outstandingBalance.getAmount(),
fnResult, mc), mc);
final Money finalEqualMonthlyInstallment =
applyInstallmentAmountInMultiplesOf(scheduleModel, equalMonthlyInstallment);
- repaymentPeriods.forEach(period ->
period.setEmi(finalEqualMonthlyInstallment));
+ repaymentPeriods.forEach(period -> {
+ if
(!finalEqualMonthlyInstallment.isLessThan(period.getTotalPaidAmount())) {
+ period.setEmi(finalEqualMonthlyInstallment);
+ }
+ });
}
Money applyInstallmentAmountInMultiplesOf(final
ProgressiveLoanInterestScheduleModel scheduleModel,
@@ -571,7 +580,7 @@ public final class ProgressiveEMICalculator implements
EMICalculator {
return interestRate//
.multiply(interestFractionPerPeriod, mc)//
.multiply(actualDaysInPeriod, mc)//
- .divide(calculatedDaysInPeriod, mc);//
+ .divide(calculatedDaysInPeriod,
mc).setScale(mc.getPrecision(), mc.getRoundingMode());//
}
/**
@@ -585,7 +594,7 @@ public final class ProgressiveEMICalculator implements
EMICalculator {
return interestRate//
.multiply(interestFractionPerPeriod, mc)//
.multiply(actualDaysInPeriod, mc)//
- .divide(calculatedDaysInPeriod, mc);//
+ .divide(calculatedDaysInPeriod,
mc).setScale(mc.getPrecision(), mc.getRoundingMode());//
}
/**
diff --git
a/fineract-progressive-loan/src/test/java/org/apache/fineract/portfolio/loanaccount/domain/transactionprocessor/impl/ChangeOperationTest.java
b/fineract-progressive-loan/src/test/java/org/apache/fineract/portfolio/loanaccount/domain/transactionprocessor/impl/ChangeOperationTest.java
new file mode 100644
index 000000000..426957388
--- /dev/null
+++
b/fineract-progressive-loan/src/test/java/org/apache/fineract/portfolio/loanaccount/domain/transactionprocessor/impl/ChangeOperationTest.java
@@ -0,0 +1,159 @@
+/**
+ * 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.domain.transactionprocessor.impl;
+
+import com.google.common.collect.Collections2;
+import java.time.LocalDate;
+import java.time.OffsetDateTime;
+import java.util.Collection;
+import java.util.List;
+import java.util.Optional;
+import org.apache.fineract.infrastructure.core.domain.FineractPlatformTenant;
+import org.apache.fineract.infrastructure.core.service.ThreadLocalContextUtil;
+import org.apache.fineract.portfolio.loanaccount.data.LoanTermVariationsData;
+import org.apache.fineract.portfolio.loanaccount.domain.LoanCharge;
+import org.apache.fineract.portfolio.loanaccount.domain.LoanTransaction;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+
+public class ChangeOperationTest {
+
+ // DateUtils.getOffsetDateTimeOfTenantFromLocalDate
+ private static final MockedStatic<ThreadLocalContextUtil>
threadLocalContextUtil = Mockito.mockStatic(ThreadLocalContextUtil.class);
+
+ @BeforeAll
+ public static void init() {
+ threadLocalContextUtil.when(ThreadLocalContextUtil::getTenant)
+ .thenReturn(new FineractPlatformTenant(null, null, null,
"Europe/Budapest", null));
+ }
+
+ @AfterAll
+ public static void tearDown() {
+ threadLocalContextUtil.close();
+ }
+
+ @Test
+ public void testCompareToEqual() {
+ ChangeOperation interestChange =
createInterestRateChange("2023-10-17");
+ ChangeOperation charge = createCharge("2023-10-17", "2023-10-17",
"2023-10-17T10:15:30+01:00");
+ ChangeOperation transaction = createTransaction("2023-10-17",
"2023-10-17", "2023-10-17T10:15:30+01:00");
+ Assertions.assertTrue(interestChange.compareTo(transaction) < 0);
+ Assertions.assertTrue(interestChange.compareTo(charge) < 0);
+ Assertions.assertTrue(charge.compareTo(transaction) == 0);
+ Assertions.assertTrue(transaction.compareTo(charge) == 0);
+ }
+
+ @Test
+ public void testCompareToEqualBackdatedCharge() {
+ ChangeOperation interestChange =
createInterestRateChange("2023-10-17");
+ ChangeOperation charge = createCharge("2023-10-16", "2023-10-17",
"2023-10-17T10:15:30+01:00");
+ ChangeOperation transaction = createTransaction("2023-10-16",
"2023-10-17", "2023-10-17T10:15:30+01:00");
+ Assertions.assertTrue(interestChange.compareTo(transaction) > 0);
+ Assertions.assertTrue(interestChange.compareTo(charge) > 0);
+ Assertions.assertTrue(charge.compareTo(transaction) == 0);
+ Assertions.assertTrue(transaction.compareTo(charge) == 0);
+ }
+
+ @Test
+ public void testCompareToCreatedDateTime() {
+ ChangeOperation charge = createCharge("2023-10-17", "2023-10-17",
"2023-10-17T10:15:31+01:00");
+ ChangeOperation transaction = createTransaction("2023-10-17",
"2023-10-17", "2023-10-17T10:15:30+01:00");
+ Assertions.assertTrue(charge.compareTo(transaction) > 0);
+ Assertions.assertTrue(transaction.compareTo(charge) < 0);
+ }
+
+ @Test
+ public void testCompareToSubmittedOnDate() {
+ ChangeOperation charge = createCharge("2023-10-17", "2023-10-17",
"2023-10-17T10:15:30+01:00");
+ ChangeOperation transaction = createTransaction("2023-10-17",
"2023-10-16", "2023-10-17T10:15:30+01:00");
+ Assertions.assertTrue(charge.compareTo(transaction) > 0);
+ Assertions.assertTrue(transaction.compareTo(charge) < 0);
+ }
+
+ @Test
+ public void testComparatorEffectiveDate() {
+ ChangeOperation charge = createCharge("2023-10-17", "2023-10-17",
"2023-10-17T10:15:30+01:00");
+ ChangeOperation transaction = createTransaction("2023-10-16",
"2023-10-17", "2023-10-17T10:15:30+01:00");
+ Assertions.assertTrue(charge.compareTo(transaction) > 0);
+ Assertions.assertTrue(transaction.compareTo(charge) < 0);
+ }
+
+ @Test
+ public void testComparatorOnDifferentSubmittedDay() {
+ ChangeOperation cot1 = createCharge("2023-10-17", "2023-10-17",
"2023-10-17T10:15:30+01:00");
+ ChangeOperation cot2 = createTransaction("2023-10-17", "2023-10-19",
"2023-10-19T10:16:30+01:00");
+ ChangeOperation cot3 = createCharge("2023-10-17", "2023-10-18",
"2023-10-18T10:14:30+01:00");
+ Collection<List<ChangeOperation>> permutations =
Collections2.permutations(List.of(cot1, cot2, cot3));
+ List<ChangeOperation> expected = List.of(cot1, cot3, cot2);
+ for (List<ChangeOperation> permutation : permutations) {
+ Assertions.assertEquals(expected,
permutation.stream().sorted().toList());
+ }
+ }
+
+ @Test
+ public void testComparatorOnSameDayBackdatedCharge() {
+ ChangeOperation cot1 = createCharge("2023-10-17", "2023-10-19",
"2023-10-19T10:15:31+01:00");
+ ChangeOperation cot2 = createTransaction("2023-10-17", "2023-10-19",
"2023-10-19T10:15:33+01:00");
+ ChangeOperation cot3 = createCharge("2023-10-17", "2023-10-19",
"2023-10-19T10:15:32+01:00");
+ Collection<List<ChangeOperation>> permutations =
Collections2.permutations(List.of(cot1, cot2, cot3));
+ List<ChangeOperation> expected = List.of(cot1, cot3, cot2);
+ for (List<ChangeOperation> permutation : permutations) {
+ Assertions.assertEquals(expected,
permutation.stream().sorted().toList());
+ }
+ }
+
+ @Test
+ public void testComparatorOnSameDay() {
+ ChangeOperation cot1 = createCharge("2023-10-24", "2023-10-19",
"2023-10-19T10:15:31+01:00");
+ ChangeOperation cot2 = createTransaction("2023-10-19", "2023-10-19",
"2023-10-19T10:15:33+01:00");
+ ChangeOperation cot3 = createCharge("2023-10-24", "2023-10-19",
"2023-10-19T10:15:32+01:00");
+ Collection<List<ChangeOperation>> permutations =
Collections2.permutations(List.of(cot1, cot2, cot3));
+ List<ChangeOperation> expected = List.of(cot1, cot3, cot2);
+ for (List<ChangeOperation> permutation : permutations) {
+ Assertions.assertEquals(expected,
permutation.stream().sorted().toList());
+ }
+ }
+
+ private ChangeOperation createInterestRateChange(String submittedDate) {
+ LoanTermVariationsData interestRateChange =
Mockito.mock(LoanTermVariationsData.class);
+
Mockito.when(interestRateChange.getTermVariationApplicableFrom()).thenReturn(LocalDate.parse(submittedDate));
+ return new ChangeOperation(interestRateChange);
+ }
+
+ private ChangeOperation createCharge(String effectiveDate, String
submittedDate, String creationDateTime) {
+ LoanCharge charge = Mockito.mock(LoanCharge.class);
+
Mockito.when(charge.getDueDate()).thenReturn(LocalDate.parse(effectiveDate));
+
Mockito.when(charge.getSubmittedOnDate()).thenReturn(LocalDate.parse(submittedDate));
+
Mockito.when(charge.getCreatedDate()).thenReturn(Optional.of(OffsetDateTime.parse(creationDateTime)));
+ return new ChangeOperation(charge);
+ }
+
+ private ChangeOperation createTransaction(String transactionDate, String
submittedDate, String creationDateTime) {
+ LoanTransaction transaction = Mockito.mock(LoanTransaction.class);
+
Mockito.when(transaction.getSubmittedOnDate()).thenReturn(LocalDate.parse(submittedDate));
+
Mockito.when(transaction.getTransactionDate()).thenReturn(LocalDate.parse(transactionDate));
+
Mockito.when(transaction.getCreatedDateTime()).thenReturn(OffsetDateTime.parse(creationDateTime));
+ return new ChangeOperation(transaction);
+ }
+
+}
diff --git
a/fineract-progressive-loan/src/test/java/org/apache/fineract/portfolio/loanaccount/domain/transactionprocessor/impl/ChargeOrTransactionTest.java
b/fineract-progressive-loan/src/test/java/org/apache/fineract/portfolio/loanaccount/domain/transactionprocessor/impl/ChargeOrTransactionTest.java
deleted file mode 100644
index 20ac2238b..000000000
---
a/fineract-progressive-loan/src/test/java/org/apache/fineract/portfolio/loanaccount/domain/transactionprocessor/impl/ChargeOrTransactionTest.java
+++ /dev/null
@@ -1,127 +0,0 @@
-/**
- * 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.domain.transactionprocessor.impl;
-
-import com.google.common.collect.Collections2;
-import java.time.LocalDate;
-import java.time.OffsetDateTime;
-import java.util.Collection;
-import java.util.List;
-import java.util.Optional;
-import org.apache.fineract.portfolio.loanaccount.domain.LoanCharge;
-import org.apache.fineract.portfolio.loanaccount.domain.LoanTransaction;
-import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
-
-public class ChargeOrTransactionTest {
-
- @Test
- public void testCompareToEqual() {
- ChargeOrTransaction charge = createCharge("2023-10-17", "2023-10-17",
"2023-10-17T10:15:30+01:00");
- ChargeOrTransaction transaction = createTransaction("2023-10-17",
"2023-10-17", "2023-10-17T10:15:30+01:00");
- Assertions.assertTrue(charge.compareTo(transaction) == 0);
- Assertions.assertTrue(transaction.compareTo(charge) == 0);
- }
-
- @Test
- public void testCompareToEqualBackdatedCharge() {
- ChargeOrTransaction charge = createCharge("2023-10-16", "2023-10-17",
"2023-10-17T10:15:30+01:00");
- ChargeOrTransaction transaction = createTransaction("2023-10-16",
"2023-10-17", "2023-10-17T10:15:30+01:00");
- Assertions.assertTrue(charge.compareTo(transaction) == 0);
- Assertions.assertTrue(transaction.compareTo(charge) == 0);
- }
-
- @Test
- public void testCompareToCreatedDateTime() {
- ChargeOrTransaction charge = createCharge("2023-10-17", "2023-10-17",
"2023-10-17T10:15:31+01:00");
- ChargeOrTransaction transaction = createTransaction("2023-10-17",
"2023-10-17", "2023-10-17T10:15:30+01:00");
- Assertions.assertTrue(charge.compareTo(transaction) > 0);
- Assertions.assertTrue(transaction.compareTo(charge) < 0);
- }
-
- @Test
- public void testCompareToSubmittedOnDate() {
- ChargeOrTransaction charge = createCharge("2023-10-17", "2023-10-17",
"2023-10-17T10:15:30+01:00");
- ChargeOrTransaction transaction = createTransaction("2023-10-17",
"2023-10-16", "2023-10-17T10:15:30+01:00");
- Assertions.assertTrue(charge.compareTo(transaction) > 0);
- Assertions.assertTrue(transaction.compareTo(charge) < 0);
- }
-
- @Test
- public void testComparatorEffectiveDate() {
- ChargeOrTransaction charge = createCharge("2023-10-17", "2023-10-17",
"2023-10-17T10:15:30+01:00");
- ChargeOrTransaction transaction = createTransaction("2023-10-16",
"2023-10-17", "2023-10-17T10:15:30+01:00");
- Assertions.assertTrue(charge.compareTo(transaction) > 0);
- Assertions.assertTrue(transaction.compareTo(charge) < 0);
- }
-
- @Test
- public void testComparatorOnDifferentSubmittedDay() {
- ChargeOrTransaction cot1 = createCharge("2023-10-17", "2023-10-17",
"2023-10-17T10:15:30+01:00");
- ChargeOrTransaction cot2 = createTransaction("2023-10-17",
"2023-10-19", "2023-10-19T10:16:30+01:00");
- ChargeOrTransaction cot3 = createCharge("2023-10-17", "2023-10-18",
"2023-10-18T10:14:30+01:00");
- Collection<List<ChargeOrTransaction>> permutations =
Collections2.permutations(List.of(cot1, cot2, cot3));
- List<ChargeOrTransaction> expected = List.of(cot1, cot3, cot2);
- for (List<ChargeOrTransaction> permutation : permutations) {
- Assertions.assertEquals(expected,
permutation.stream().sorted().toList());
- }
- }
-
- @Test
- public void testComparatorOnSameDayBackdatedCharge() {
- ChargeOrTransaction cot1 = createCharge("2023-10-17", "2023-10-19",
"2023-10-19T10:15:31+01:00");
- ChargeOrTransaction cot2 = createTransaction("2023-10-17",
"2023-10-19", "2023-10-19T10:15:33+01:00");
- ChargeOrTransaction cot3 = createCharge("2023-10-17", "2023-10-19",
"2023-10-19T10:15:32+01:00");
- Collection<List<ChargeOrTransaction>> permutations =
Collections2.permutations(List.of(cot1, cot2, cot3));
- List<ChargeOrTransaction> expected = List.of(cot1, cot3, cot2);
- for (List<ChargeOrTransaction> permutation : permutations) {
- Assertions.assertEquals(expected,
permutation.stream().sorted().toList());
- }
- }
-
- @Test
- public void testComparatorOnSameDay() {
- ChargeOrTransaction cot1 = createCharge("2023-10-24", "2023-10-19",
"2023-10-19T10:15:31+01:00");
- ChargeOrTransaction cot2 = createTransaction("2023-10-19",
"2023-10-19", "2023-10-19T10:15:33+01:00");
- ChargeOrTransaction cot3 = createCharge("2023-10-24", "2023-10-19",
"2023-10-19T10:15:32+01:00");
- Collection<List<ChargeOrTransaction>> permutations =
Collections2.permutations(List.of(cot1, cot2, cot3));
- List<ChargeOrTransaction> expected = List.of(cot1, cot3, cot2);
- for (List<ChargeOrTransaction> permutation : permutations) {
- Assertions.assertEquals(expected,
permutation.stream().sorted().toList());
- }
- }
-
- private ChargeOrTransaction createCharge(String effectiveDate, String
submittedDate, String creationDateTime) {
- LoanCharge charge = Mockito.mock(LoanCharge.class);
-
Mockito.when(charge.getDueDate()).thenReturn(LocalDate.parse(effectiveDate));
-
Mockito.when(charge.getSubmittedOnDate()).thenReturn(LocalDate.parse(submittedDate));
-
Mockito.when(charge.getCreatedDate()).thenReturn(Optional.of(OffsetDateTime.parse(creationDateTime)));
- return new ChargeOrTransaction(charge);
- }
-
- private ChargeOrTransaction createTransaction(String transactionDate,
String submittedDate, String creationDateTime) {
- LoanTransaction transaction = Mockito.mock(LoanTransaction.class);
-
Mockito.when(transaction.getSubmittedOnDate()).thenReturn(LocalDate.parse(submittedDate));
-
Mockito.when(transaction.getTransactionDate()).thenReturn(LocalDate.parse(transactionDate));
-
Mockito.when(transaction.getCreatedDateTime()).thenReturn(OffsetDateTime.parse(creationDateTime));
- return new ChargeOrTransaction(transaction);
- }
-
-}
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
index c129a5e4f..aca3641bc 100644
---
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
@@ -44,7 +44,6 @@ import org.jetbrains.annotations.NotNull;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;
import org.junit.jupiter.api.extension.ExtendWith;
@@ -95,13 +94,12 @@ class ProgressiveEMICalculatorTest {
final BigDecimal daysInPeriod =
BigDecimal.valueOf(DateUtils.getDifferenceInDays(period.getFromDate(),
period.getDueDate()));
final BigDecimal daysInYear =
BigDecimal.valueOf(daysInYearType.getNumberOfDays(period.getFromDate()));
final BigDecimal daysInMonth =
BigDecimal.valueOf(daysInMonthType.getNumberOfDays(period.getFromDate()));
- final BigDecimal rateFactor =
emiCalculator.rateFactorByRepaymentEveryMonth(interestRate, BigDecimal.ONE,
daysInMonth, daysInYear,
- daysInPeriod, daysInPeriod, mc);
- return rateFactor.setScale(12, MoneyHelper.getRoundingMode());
+ return emiCalculator.rateFactorByRepaymentEveryMonth(interestRate,
BigDecimal.ONE, daysInMonth, daysInYear, daysInPeriod,
+ daysInPeriod, mc);
}
@Test
- public void
testRateFactorByRepaymentEveryMonthMethod_DayInYear365_DaysInMonthActual() {
+ public void
test_rateFactorByRepaymentEveryMonthMethod_DayInYear365_DaysInMonthActual() {
// Given
final DaysInYearType daysInYearType = DaysInYearType.DAYS_365;
final DaysInMonthType daysInMonthType = DaysInMonthType.ACTUAL;
@@ -116,7 +114,7 @@ class ProgressiveEMICalculatorTest {
}
@Test
- public void
testRateFactorByRepaymentEveryMonthMethod_DayInYearActual_DaysInMonthActual() {
+ public void
test_rateFactorByRepaymentEveryMonthMethod_DayInYearActual_DaysInMonthActual() {
// Given
final DaysInYearType daysInYearType = DaysInYearType.ACTUAL;
final DaysInMonthType daysInMonthType = DaysInMonthType.ACTUAL;
@@ -132,7 +130,7 @@ class ProgressiveEMICalculatorTest {
}
@Test
- public void
testFnValueFunction_RepayEvery1Month_DayInYear365_DaysInMonthActual() {
+ public void
test_fnValueFunction_RepayEvery1Month_DayInYear365_DaysInMonthActual() {
// Given
final DaysInYearType daysInYearType = DaysInYearType.DAYS_365;
final DaysInMonthType daysInMonthType = DaysInMonthType.ACTUAL;
@@ -159,7 +157,7 @@ class ProgressiveEMICalculatorTest {
}
@Test
- public void testEMICalculator_generateInterestScheduleModel() {
+ public void test_generateInterestScheduleModel() {
final List<LoanScheduleModelRepaymentPeriod> expectedRepaymentPeriods
= new ArrayList<>();
final Integer installmentAmountInMultiplesOf = null;
@@ -184,7 +182,7 @@ class ProgressiveEMICalculatorTest {
@Test
@Timeout(1) // seconds
- public void testEMICalculation_performance() {
+ public void test_emi_calculator_performance() {
final List<LoanScheduleModelRepaymentPeriod> expectedRepaymentPeriods
= new ArrayList<>();
@@ -223,19 +221,19 @@ class ProgressiveEMICalculatorTest {
List<RepaymentPeriod> repaymentPeriods =
interestSchedule.repaymentPeriods();
for (int i = 0; i < repaymentPeriods.size(); i++) {
final RepaymentPeriod repaymentPeriod = repaymentPeriods.get(i);
- Assertions.assertTrue(0 <
toDouble(repaymentPeriod.getDuePrincipal().getAmount()));
- Assertions.assertTrue(0 <
toDouble(repaymentPeriod.getDueInterest().getAmount()));
+ Assertions.assertTrue(0 <
toDouble(repaymentPeriod.getDuePrincipal()));
+ Assertions.assertTrue(0 <
toDouble(repaymentPeriod.getDueInterest()));
if (i == repaymentPeriods.size() - 1) {
- Assertions.assertEquals(0.0,
toDouble(repaymentPeriod.getOutstandingLoanBalance().getAmount()));
+ Assertions.assertEquals(0.0,
toDouble(repaymentPeriod.getOutstandingLoanBalance()));
} else {
- Assertions.assertEquals(8.65,
toDouble(repaymentPeriod.getEmi().getAmount()));
- Assertions.assertTrue(0 <
toDouble(repaymentPeriod.getOutstandingLoanBalance().getAmount()));
+ Assertions.assertEquals(8.65,
toDouble(repaymentPeriod.getEmi()));
+ Assertions.assertTrue(0 <
toDouble(repaymentPeriod.getOutstandingLoanBalance()));
}
}
}
@Test
- public void testEMICalculation_CheckEmiButNewEmiNotBetterThanOriginal() {
+ public void test_emiAdjustment_newCalculatedEmiNotBetterThanOriginal() {
final List<LoanScheduleModelRepaymentPeriod> expectedRepaymentPeriods
= new ArrayList<>();
@@ -272,7 +270,7 @@ class ProgressiveEMICalculatorTest {
}
@Test
- public void
testEMICalculation_disbursedAmt100_dayInYears360_daysInMonth30_repayEvery1Month()
{
+ public void
test_disbursedAmt100_dayInYears360_daysInMonth30_repayEvery1Month() {
final List<LoanScheduleModelRepaymentPeriod> expectedRepaymentPeriods
= new ArrayList<>();
@@ -283,7 +281,7 @@ class ProgressiveEMICalculatorTest {
expectedRepaymentPeriods.add(repayment(5, LocalDate.of(2024, 5, 1),
LocalDate.of(2024, 6, 1)));
expectedRepaymentPeriods.add(repayment(6, LocalDate.of(2024, 6, 1),
LocalDate.of(2024, 7, 1)));
- final BigDecimal interestRate = new BigDecimal("9.4822");
+ final BigDecimal interestRate = BigDecimal.valueOf(9.4822);
final Integer installmentAmountInMultiplesOf = null;
Mockito.when(loanProductRelatedDetail.getAnnualNominalInterestRate()).thenReturn(interestRate);
@@ -296,7 +294,7 @@ class ProgressiveEMICalculatorTest {
final ProgressiveLoanInterestScheduleModel interestSchedule =
emiCalculator.generateInterestScheduleModel(expectedRepaymentPeriods,
loanProductRelatedDetail, installmentAmountInMultiplesOf, mc);
- final Money disbursedAmount = Money.of(monetaryCurrency,
BigDecimal.valueOf(100));
+ final Money disbursedAmount = toMoney(100.0);
emiCalculator.addDisbursement(interestSchedule, LocalDate.of(2024, 1,
1), disbursedAmount);
checkPeriod(interestSchedule, 0, 0, 17.13, 0.0, 0.0, 0.79, 16.34,
83.66);
@@ -309,7 +307,7 @@ class ProgressiveEMICalculatorTest {
}
@Test
- public void
testEMICalculation_multi_disbursedAmt200_2ndOnDueDate_dayInYears360_daysInMonth30_repayEvery1Month()
{
+ public void
test_multi_disbursedAmt200_2ndOnDueDate_dayInYears360_daysInMonth30_repayEvery1Month()
{
final List<LoanScheduleModelRepaymentPeriod> expectedRepaymentPeriods
= new ArrayList<>();
@@ -356,7 +354,7 @@ class ProgressiveEMICalculatorTest {
}
@Test
- public void
testEMICalculation_disbursedAmt100_dayInYears360_daysInMonth30_repayEvery1Month_reschedule()
{
+ public void
test_reschedule_disbursedAmt100_dayInYears360_daysInMonth30_repayEvery1Month() {
final List<LoanScheduleModelRepaymentPeriod> expectedRepaymentPeriods
= new ArrayList<>();
@@ -367,7 +365,7 @@ class ProgressiveEMICalculatorTest {
expectedRepaymentPeriods.add(repayment(5, LocalDate.of(2024, 5, 15),
LocalDate.of(2024, 6, 15)));
expectedRepaymentPeriods.add(repayment(6, LocalDate.of(2024, 6, 15),
LocalDate.of(2024, 7, 15)));
- final BigDecimal interestRate = new BigDecimal("9.4822");
+ final BigDecimal interestRate = BigDecimal.valueOf(9.4822);
final Integer installmentAmountInMultiplesOf = null;
Mockito.when(loanProductRelatedDetail.getAnnualNominalInterestRate()).thenReturn(interestRate);
@@ -380,7 +378,7 @@ class ProgressiveEMICalculatorTest {
final ProgressiveLoanInterestScheduleModel interestSchedule =
emiCalculator.generateInterestScheduleModel(expectedRepaymentPeriods,
loanProductRelatedDetail, installmentAmountInMultiplesOf, mc);
- final Money disbursedAmount = Money.of(monetaryCurrency,
BigDecimal.valueOf(100));
+ final Money disbursedAmount = toMoney(100.0);
emiCalculator.addDisbursement(interestSchedule, LocalDate.of(2024, 1,
1), disbursedAmount);
checkPeriod(interestSchedule, 0, 0, 17.13, 0.0, 0.0, 0.79, 16.34,
83.66);
@@ -392,9 +390,8 @@ class ProgressiveEMICalculatorTest {
checkPeriod(interestSchedule, 5, 0, 17.13, 0.007901833333, 0.13,
17.00, 0.0);
}
- @Disabled("till interest rate change got implemented")
@Test
- public void
testEMICalculation_disbursedAmt100_dayInYears360_daysInMonth30_repayEvery1Month_reschedule_interest_on0201_4per()
{
+ public void
test_reschedule_interest_on0201_4per_disbursedAmt100_dayInYears360_daysInMonth30_repayEvery1Month()
{
final List<LoanScheduleModelRepaymentPeriod> expectedRepaymentPeriods
= new ArrayList<>();
@@ -405,7 +402,7 @@ class ProgressiveEMICalculatorTest {
expectedRepaymentPeriods.add(repayment(5, LocalDate.of(2024, 5, 1),
LocalDate.of(2024, 6, 1)));
expectedRepaymentPeriods.add(repayment(6, LocalDate.of(2024, 6, 1),
LocalDate.of(2024, 7, 1)));
- final BigDecimal interestRate = new BigDecimal("7");
+ final BigDecimal interestRate = BigDecimal.valueOf(7.0);
final Integer installmentAmountInMultiplesOf = null;
Mockito.when(loanProductRelatedDetail.getAnnualNominalInterestRate()).thenReturn(interestRate);
@@ -420,10 +417,10 @@ class ProgressiveEMICalculatorTest {
final ProgressiveLoanInterestScheduleModel interestSchedule =
emiCalculator.generateInterestScheduleModel(expectedRepaymentPeriods,
loanProductRelatedDetail, installmentAmountInMultiplesOf, mc);
- final Money disbursedAmount = Money.of(monetaryCurrency,
BigDecimal.valueOf(100));
+ final Money disbursedAmount = toMoney(100.0);
emiCalculator.addDisbursement(interestSchedule, LocalDate.of(2024, 1,
1), disbursedAmount);
- final BigDecimal interestRateNewValue = new BigDecimal("4");
+ final BigDecimal interestRateNewValue = BigDecimal.valueOf(4.0);
final LocalDate interestChangeDate = LocalDate.of(2024, 2, 2);
emiCalculator.changeInterestRate(interestSchedule, interestChangeDate,
interestRateNewValue);
@@ -436,9 +433,55 @@ class ProgressiveEMICalculatorTest {
checkPeriod(interestSchedule, 5, 0, 16.89, 0.003333333333, 0.06,
16.83, 0.0);
}
- @Disabled("till interest rate change got implemented")
@Test
- public void
testEMICalculation_disbursedAmt100_dayInYears360_daysInMonth30_repayEvery1Month_reschedule_interest_on0215_4per()
{
+ public void
test_reschedule_interest_on0201_2nd_EMI_not_changeable_disbursedAmt100_dayInYears360_daysInMonth30_repayEvery1Month()
{
+
+ final List<LoanScheduleModelRepaymentPeriod> expectedRepaymentPeriods
= new ArrayList<>();
+
+ expectedRepaymentPeriods.add(repayment(1, LocalDate.of(2024, 1, 1),
LocalDate.of(2024, 2, 1)));
+ expectedRepaymentPeriods.add(repayment(2, LocalDate.of(2024, 2, 1),
LocalDate.of(2024, 3, 1)));
+ expectedRepaymentPeriods.add(repayment(3, LocalDate.of(2024, 3, 1),
LocalDate.of(2024, 4, 1)));
+ expectedRepaymentPeriods.add(repayment(4, LocalDate.of(2024, 4, 1),
LocalDate.of(2024, 5, 1)));
+ expectedRepaymentPeriods.add(repayment(5, LocalDate.of(2024, 5, 1),
LocalDate.of(2024, 6, 1)));
+ expectedRepaymentPeriods.add(repayment(6, LocalDate.of(2024, 6, 1),
LocalDate.of(2024, 7, 1)));
+
+ final BigDecimal interestRate = BigDecimal.valueOf(7.0);
+ final Integer installmentAmountInMultiplesOf = null;
+
+
Mockito.when(loanProductRelatedDetail.getAnnualNominalInterestRate()).thenReturn(interestRate);
+
Mockito.when(loanProductRelatedDetail.getDaysInYearType()).thenReturn(DaysInYearType.DAYS_360.getValue());
+
Mockito.when(loanProductRelatedDetail.getDaysInMonthType()).thenReturn(DaysInMonthType.DAYS_30.getValue());
+
Mockito.when(loanProductRelatedDetail.getRepaymentPeriodFrequencyType()).thenReturn(PeriodFrequencyType.MONTHS);
+ Mockito.when(loanProductRelatedDetail.getRepayEvery()).thenReturn(1);
+
Mockito.when(loanProductRelatedDetail.getCurrency()).thenReturn(monetaryCurrency);
+
+
threadLocalContextUtil.when(ThreadLocalContextUtil::getBusinessDate).thenReturn(LocalDate.of(2024,
2, 14));
+
+ final ProgressiveLoanInterestScheduleModel interestModel =
emiCalculator.generateInterestScheduleModel(expectedRepaymentPeriods,
+ loanProductRelatedDetail, installmentAmountInMultiplesOf, mc);
+
+ final Money disbursedAmount = toMoney(100.0);
+ emiCalculator.addDisbursement(interestModel, LocalDate.of(2024, 1, 1),
disbursedAmount);
+ emiCalculator.payInterest(interestModel, LocalDate.of(2024, 2, 1),
LocalDate.of(2024, 2, 1), toMoney(0.58));
+ emiCalculator.payPrincipal(interestModel, LocalDate.of(2024, 2, 1),
LocalDate.of(2024, 2, 1), toMoney(16.43));
+
+ emiCalculator.payPrincipal(interestModel, LocalDate.of(2024, 3, 1),
LocalDate.of(2024, 2, 1), toMoney(16.90));
+
+ final BigDecimal interestRateNewValue = BigDecimal.valueOf(4.0);
+ final LocalDate interestChangeDate = LocalDate.of(2024, 2, 2);
+ emiCalculator.changeInterestRate(interestModel, interestChangeDate,
interestRateNewValue);
+
+ checkPeriod(interestModel, 0, 0, 17.01, 0.0, 0.0, 0.58, 16.43, 66.67);
+ checkPeriod(interestModel, 0, 1, 17.01, 0.005833333333, 0.58, 16.43,
66.67);
+ checkPeriod(interestModel, 1, 0, 17.01, 0.003333333333, 0.22, 0.0,
17.01, 66.56);
+ checkPeriod(interestModel, 2, 0, 16.85, 0.003333333333, 0.22, 0.44,
16.41, 50.15);
+ checkPeriod(interestModel, 3, 0, 16.85, 0.003333333333, 0.17, 16.68,
33.47);
+ checkPeriod(interestModel, 4, 0, 16.85, 0.003333333333, 0.11, 16.74,
16.73);
+ checkPeriod(interestModel, 5, 0, 16.79, 0.003333333333, 0.06, 16.73,
0.0);
+ }
+
+ @Test
+ public void
test_reschedule_interest_on0215_4per_disbursedAmt100_dayInYears360_daysInMonth30_repayEvery1Month()
{
final List<LoanScheduleModelRepaymentPeriod> expectedRepaymentPeriods
= new ArrayList<>();
@@ -449,7 +492,7 @@ class ProgressiveEMICalculatorTest {
expectedRepaymentPeriods.add(repayment(5, LocalDate.of(2024, 5, 1),
LocalDate.of(2024, 6, 1)));
expectedRepaymentPeriods.add(repayment(6, LocalDate.of(2024, 6, 1),
LocalDate.of(2024, 7, 1)));
- final BigDecimal interestRate = new BigDecimal("7");
+ final BigDecimal interestRate = BigDecimal.valueOf(7.0);
final Integer installmentAmountInMultiplesOf = null;
Mockito.when(loanProductRelatedDetail.getAnnualNominalInterestRate()).thenReturn(interestRate);
@@ -464,14 +507,15 @@ class ProgressiveEMICalculatorTest {
final ProgressiveLoanInterestScheduleModel interestSchedule =
emiCalculator.generateInterestScheduleModel(expectedRepaymentPeriods,
loanProductRelatedDetail, installmentAmountInMultiplesOf, mc);
- final Money disbursedAmount = Money.of(monetaryCurrency,
BigDecimal.valueOf(100));
+ final Money disbursedAmount = toMoney(100.0);
emiCalculator.addDisbursement(interestSchedule, LocalDate.of(2024, 1,
1), disbursedAmount);
- final BigDecimal interestRateNewValue = new BigDecimal("4");
+ final BigDecimal interestRateNewValue = BigDecimal.valueOf(4.0);
final LocalDate interestChangeDate = LocalDate.of(2024, 2, 15);
emiCalculator.changeInterestRate(interestSchedule, interestChangeDate,
interestRateNewValue);
- checkPeriod(interestSchedule, 0, 0, 17.01, 0.005833333333, 0.58,
16.43, 83.57);
+ checkPeriod(interestSchedule, 0, 0, 17.01, 0.0, 0.0, 0.58, 16.43,
83.57);
+ checkPeriod(interestSchedule, 0, 1, 17.01, 0.005833333333, 0.58, 0.58,
16.43, 83.57);
checkPeriod(interestSchedule, 1, 0, 16.90, 0.002614942529, 0.22, 0.37,
16.53, 67.04);
checkPeriod(interestSchedule, 1, 1, 16.90, 0.001839080460, 0.15, 0.37,
16.53, 67.04);
checkPeriod(interestSchedule, 2, 0, 16.90, 0.003333333333, 0.22,
16.68, 50.36);
@@ -484,7 +528,7 @@ class ProgressiveEMICalculatorTest {
* This test case tests a period early and late repayment with balance
correction
*/
@Test
- public void
testEMICalculation_disbursedAmt100_dayInYears360_daysInMonth30_repayEvery1Month_add_balance_correction_on0215()
{
+ public void
test_balance_correction_on0215_disbursedAmt100_dayInYears360_daysInMonth30_repayEvery1Month()
{
final List<LoanScheduleModelRepaymentPeriod> expectedRepaymentPeriods
= new ArrayList<>();
@@ -495,7 +539,7 @@ class ProgressiveEMICalculatorTest {
expectedRepaymentPeriods.add(repayment(5, LocalDate.of(2024, 5, 1),
LocalDate.of(2024, 6, 1)));
expectedRepaymentPeriods.add(repayment(6, LocalDate.of(2024, 6, 1),
LocalDate.of(2024, 7, 1)));
- final BigDecimal interestRate = new BigDecimal("7");
+ final BigDecimal interestRate = BigDecimal.valueOf(7.0);
final Integer installmentAmountInMultiplesOf = null;
Mockito.when(loanProductRelatedDetail.getAnnualNominalInterestRate()).thenReturn(interestRate);
@@ -510,37 +554,36 @@ class ProgressiveEMICalculatorTest {
final ProgressiveLoanInterestScheduleModel interestSchedule =
emiCalculator.generateInterestScheduleModel(expectedRepaymentPeriods,
loanProductRelatedDetail, installmentAmountInMultiplesOf, mc);
- final Money disbursedAmount = Money.of(monetaryCurrency,
BigDecimal.valueOf(100));
+ final Money disbursedAmount = toMoney(100.0);
emiCalculator.addDisbursement(interestSchedule, LocalDate.of(2024, 1,
1), disbursedAmount);
// schedule 1st period 1st day
PayableDetails payableDetails =
emiCalculator.getPayableDetails(interestSchedule, LocalDate.of(2024, 2, 1),
LocalDate.of(2024, 1, 1));
- Assertions.assertEquals(100,
toDouble(payableDetails.getOutstandingBalance().getAmount()));
- Assertions.assertEquals(17.01,
toDouble(payableDetails.getPayablePrincipal().getAmount()));
- Assertions.assertEquals(0.0,
toDouble(payableDetails.getPayableInterest().getAmount()));
+ Assertions.assertEquals(100,
toDouble(payableDetails.getOutstandingBalance()));
+ Assertions.assertEquals(17.01,
toDouble(payableDetails.getPayablePrincipal()));
+ Assertions.assertEquals(0.0,
toDouble(payableDetails.getPayableInterest()));
// schedule 2nd period last day
payableDetails = emiCalculator.getPayableDetails(interestSchedule,
LocalDate.of(2024, 3, 1), LocalDate.of(2024, 3, 1));
- Assertions.assertEquals(83.57,
toDouble(payableDetails.getOutstandingBalance().getAmount()));
- Assertions.assertEquals(16.52,
toDouble(payableDetails.getPayablePrincipal().getAmount()));
- Assertions.assertEquals(0.49,
toDouble(payableDetails.getPayableInterest().getAmount()));
+ Assertions.assertEquals(83.57,
toDouble(payableDetails.getOutstandingBalance()));
+ Assertions.assertEquals(16.52,
toDouble(payableDetails.getPayablePrincipal()));
+ Assertions.assertEquals(0.49,
toDouble(payableDetails.getPayableInterest()));
// pay off a period with balance correction
final LocalDate op1stCorrectionPeriodDueDate = LocalDate.of(2024, 3,
1);
final LocalDate op1stCorrectionDate = LocalDate.of(2024, 2, 15);
- final Money op1stCorrectionAmount = Money.of(monetaryCurrency,
BigDecimal.valueOf(16.77));
+ final Money op1stCorrectionAmount = toMoney(16.77);
// get remaining balance and dues for a date
final PayableDetails repaymentDetails1st =
emiCalculator.getPayableDetails(interestSchedule, op1stCorrectionPeriodDueDate,
op1stCorrectionDate);
- Assertions.assertEquals(83.57,
toDouble(repaymentDetails1st.getOutstandingBalance().getAmount()));
- Assertions.assertEquals(16.77,
toDouble(repaymentDetails1st.getPayablePrincipal().getAmount()));
- Assertions.assertEquals(0.24,
toDouble(repaymentDetails1st.getPayableInterest().getAmount()));
+ Assertions.assertEquals(83.57,
toDouble(repaymentDetails1st.getOutstandingBalance()));
+ Assertions.assertEquals(16.77,
toDouble(repaymentDetails1st.getPayablePrincipal()));
+ Assertions.assertEquals(0.24,
toDouble(repaymentDetails1st.getPayableInterest()));
emiCalculator.payPrincipal(interestSchedule,
op1stCorrectionPeriodDueDate, op1stCorrectionDate, op1stCorrectionAmount);
- emiCalculator.payInterest(interestSchedule,
op1stCorrectionPeriodDueDate, op1stCorrectionDate,
- Money.of(monetaryCurrency, BigDecimal.valueOf(0.24)));
+ emiCalculator.payInterest(interestSchedule,
op1stCorrectionPeriodDueDate, op1stCorrectionDate, toMoney(0.24));
checkPeriod(interestSchedule, 0, 1, 17.01, 0.005833333333, 0.58,
16.43, 83.57);
checkPeriod(interestSchedule, 1, 0, 17.01, 0.002816091954, 0.24,
16.77, 66.80);
@@ -553,18 +596,17 @@ class ProgressiveEMICalculatorTest {
// totally pay off another period with balance correction
final LocalDate op2ndCorrectionPeriodDueDate = LocalDate.of(2024, 4,
1);
final LocalDate op2ndCorrectionDate = LocalDate.of(2024, 3, 1);
- final Money op2ndCorrectionAmount = Money.of(monetaryCurrency,
BigDecimal.valueOf(16.42));
+ final Money op2ndCorrectionAmount = toMoney(16.42);
// get remaining balance and dues for a date
final PayableDetails repaymentDetails2st =
emiCalculator.getPayableDetails(interestSchedule, op2ndCorrectionPeriodDueDate,
op2ndCorrectionDate);
- Assertions.assertEquals(66.80,
toDouble(repaymentDetails2st.getOutstandingBalance().getAmount()));
- Assertions.assertEquals(16.81,
toDouble(repaymentDetails2st.getPayablePrincipal().getAmount()));
- Assertions.assertEquals(0.20,
toDouble(repaymentDetails2st.getPayableInterest().getAmount()));
+ Assertions.assertEquals(66.80,
toDouble(repaymentDetails2st.getOutstandingBalance()));
+ Assertions.assertEquals(16.81,
toDouble(repaymentDetails2st.getPayablePrincipal()));
+ Assertions.assertEquals(0.20,
toDouble(repaymentDetails2st.getPayableInterest()));
emiCalculator.payPrincipal(interestSchedule,
op2ndCorrectionPeriodDueDate, op2ndCorrectionDate, op2ndCorrectionAmount);
- emiCalculator.payInterest(interestSchedule,
op2ndCorrectionPeriodDueDate, op2ndCorrectionDate,
- Money.of(monetaryCurrency, BigDecimal.valueOf(0.49)));
+ emiCalculator.payInterest(interestSchedule,
op2ndCorrectionPeriodDueDate, op2ndCorrectionDate, toMoney(0.49));
checkPeriod(interestSchedule, 0, 1, 17.01, 0.005833333333, 0.58,
16.43, 83.57);
checkPeriod(interestSchedule, 1, 0, 17.01, 0.002816091954, 0.24,
16.77, 50.38);
@@ -578,17 +620,17 @@ class ProgressiveEMICalculatorTest {
LocalDate periodDueDate = LocalDate.of(2024, 7, 1);
LocalDate payDate = LocalDate.of(2024, 7, 1);
final PayableDetails repaymentDetails3rd =
emiCalculator.getPayableDetails(interestSchedule, periodDueDate, payDate);
- Assertions.assertEquals(16.75,
toDouble(repaymentDetails3rd.getOutstandingBalance().getAmount()));
- Assertions.assertEquals(16.75,
toDouble(repaymentDetails3rd.getPayablePrincipal().getAmount()));
- Assertions.assertEquals(0.1,
toDouble(repaymentDetails3rd.getPayableInterest().getAmount()));
+ Assertions.assertEquals(16.75,
toDouble(repaymentDetails3rd.getOutstandingBalance()));
+ Assertions.assertEquals(16.75,
toDouble(repaymentDetails3rd.getPayablePrincipal()));
+ Assertions.assertEquals(0.1,
toDouble(repaymentDetails3rd.getPayableInterest()));
// check numbers after the last period due date
periodDueDate = LocalDate.of(2024, 7, 1);
payDate = LocalDate.of(2024, 7, 15);
final PayableDetails repaymentDetails4th =
emiCalculator.getPayableDetails(interestSchedule, periodDueDate, payDate);
- Assertions.assertEquals(16.75,
toDouble(repaymentDetails4th.getOutstandingBalance().getAmount()));
- Assertions.assertEquals(16.75,
toDouble(repaymentDetails4th.getPayablePrincipal().getAmount()));
- Assertions.assertEquals(0.1,
toDouble(repaymentDetails4th.getPayableInterest().getAmount()));
+ Assertions.assertEquals(16.75,
toDouble(repaymentDetails4th.getOutstandingBalance()));
+ Assertions.assertEquals(16.75,
toDouble(repaymentDetails4th.getPayablePrincipal()));
+ Assertions.assertEquals(0.1,
toDouble(repaymentDetails4th.getPayableInterest()));
// balance update on the last period, check the right interest
interval split
emiCalculator.addBalanceCorrection(interestSchedule,
LocalDate.of(2024, 6, 10), Money.of(monetaryCurrency, BigDecimal.ZERO));
@@ -601,7 +643,7 @@ class ProgressiveEMICalculatorTest {
}
@Test
- public void
testEMICalculation_disbursedAmt100_dayInYears360_daysInMonth30_repayEvery1Month_payoff_on0215()
{
+ public void
test_payoff_on0215_disbursedAmt100_dayInYears360_daysInMonth30_repayEvery1Month()
{
final List<LoanScheduleModelRepaymentPeriod> expectedRepaymentPeriods
= new ArrayList<>();
@@ -612,7 +654,7 @@ class ProgressiveEMICalculatorTest {
expectedRepaymentPeriods.add(repayment(5, LocalDate.of(2024, 5, 1),
LocalDate.of(2024, 6, 1)));
expectedRepaymentPeriods.add(repayment(6, LocalDate.of(2024, 6, 1),
LocalDate.of(2024, 7, 1)));
- final BigDecimal interestRate = new BigDecimal("7");
+ final BigDecimal interestRate = BigDecimal.valueOf(7.0);
final Integer installmentAmountInMultiplesOf = null;
Mockito.when(loanProductRelatedDetail.getAnnualNominalInterestRate()).thenReturn(interestRate);
@@ -627,51 +669,43 @@ class ProgressiveEMICalculatorTest {
final ProgressiveLoanInterestScheduleModel interestSchedule =
emiCalculator.generateInterestScheduleModel(expectedRepaymentPeriods,
loanProductRelatedDetail, installmentAmountInMultiplesOf, mc);
- final Money disbursedAmount = Money.of(monetaryCurrency,
BigDecimal.valueOf(100));
+ final Money disbursedAmount = toMoney(100.0);
emiCalculator.addDisbursement(interestSchedule, LocalDate.of(2024, 1,
1), disbursedAmount);
// partially pay off a period with balance correction
final LocalDate op1stCorrectionPeriodDueDate = LocalDate.of(2024, 3,
1);
final LocalDate op1stCorrectionDate = LocalDate.of(2024, 2, 15);
- final Money op1stCorrectionAmount = Money.of(monetaryCurrency,
BigDecimal.valueOf(15.0));
+ final Money op1stCorrectionAmount = toMoney(15.0);
// get remaining balance and dues for a date
final PayableDetails repaymentDetails1st =
emiCalculator.getPayableDetails(interestSchedule, op1stCorrectionPeriodDueDate,
op1stCorrectionDate);
- Assertions.assertEquals(83.57,
toDouble(repaymentDetails1st.getOutstandingBalance().getAmount()));
- Assertions.assertEquals(16.77,
toDouble(repaymentDetails1st.getPayablePrincipal().getAmount()));
- Assertions.assertEquals(0.24,
toDouble(repaymentDetails1st.getPayableInterest().getAmount()));
+ Assertions.assertEquals(83.57,
toDouble(repaymentDetails1st.getOutstandingBalance()));
+ Assertions.assertEquals(16.77,
toDouble(repaymentDetails1st.getPayablePrincipal()));
+ Assertions.assertEquals(0.24,
toDouble(repaymentDetails1st.getPayableInterest()));
PayableDetails details = null;
// check getPayableDetails forcast
details = emiCalculator.getPayableDetails(interestSchedule,
LocalDate.of(2024, 3, 1), LocalDate.of(2024, 3, 1));
- Assertions.assertEquals(83.57,
toDouble(details.getOutstandingBalance().getAmount()));
- Assertions.assertEquals(16.52,
toDouble(details.getPayablePrincipal().getAmount()));
- Assertions.assertEquals(0.49,
toDouble(details.getPayableInterest().getAmount()));
+ Assertions.assertEquals(83.57,
toDouble(details.getOutstandingBalance()));
+ Assertions.assertEquals(16.52,
toDouble(details.getPayablePrincipal()));
+ Assertions.assertEquals(0.49, toDouble(details.getPayableInterest()));
// apply balance change and check again
emiCalculator.payPrincipal(interestSchedule, LocalDate.of(2024, 2, 1),
op1stCorrectionDate, op1stCorrectionAmount);
details = emiCalculator.getPayableDetails(interestSchedule,
LocalDate.of(2024, 3, 1), LocalDate.of(2024, 3, 1));
- Assertions.assertEquals(83.57,
toDouble(details.getOutstandingBalance().getAmount()));
- Assertions.assertEquals(16.52,
toDouble(details.getPayablePrincipal().getAmount()));
- Assertions.assertEquals(0.49,
toDouble(details.getPayableInterest().getAmount()));
-
- emiCalculator.payPrincipal(interestSchedule, LocalDate.of(2024, 2, 1),
LocalDate.of(2024, 2, 15),
- Money.of(monetaryCurrency, BigDecimal.valueOf(1.43)));
- emiCalculator.payInterest(interestSchedule, LocalDate.of(2024, 2, 1),
LocalDate.of(2024, 2, 15),
- Money.of(monetaryCurrency, BigDecimal.valueOf(0.58)));
- emiCalculator.payPrincipal(interestSchedule, LocalDate.of(2024, 3, 1),
LocalDate.of(2024, 2, 15),
- Money.of(monetaryCurrency, BigDecimal.valueOf(16.77)));
- emiCalculator.payInterest(interestSchedule, LocalDate.of(2024, 3, 1),
LocalDate.of(2024, 2, 15),
- Money.of(monetaryCurrency, BigDecimal.valueOf(0.24)));
- emiCalculator.payPrincipal(interestSchedule, LocalDate.of(2024, 4, 1),
LocalDate.of(2024, 2, 15),
- Money.of(monetaryCurrency, BigDecimal.valueOf(17.01)));
- emiCalculator.payPrincipal(interestSchedule, LocalDate.of(2024, 5, 1),
LocalDate.of(2024, 2, 15),
- Money.of(monetaryCurrency, BigDecimal.valueOf(17.01)));
- emiCalculator.payPrincipal(interestSchedule, LocalDate.of(2024, 6, 1),
LocalDate.of(2024, 2, 15),
- Money.of(monetaryCurrency, BigDecimal.valueOf(17.01)));
- emiCalculator.payPrincipal(interestSchedule, LocalDate.of(2024, 7, 1),
LocalDate.of(2024, 2, 15),
- Money.of(monetaryCurrency, BigDecimal.valueOf(15.77)));
+ Assertions.assertEquals(83.57,
toDouble(details.getOutstandingBalance()));
+ Assertions.assertEquals(16.52,
toDouble(details.getPayablePrincipal()));
+ Assertions.assertEquals(0.49, toDouble(details.getPayableInterest()));
+
+ emiCalculator.payPrincipal(interestSchedule, LocalDate.of(2024, 2, 1),
LocalDate.of(2024, 2, 15), toMoney(1.43));
+ emiCalculator.payInterest(interestSchedule, LocalDate.of(2024, 2, 1),
LocalDate.of(2024, 2, 15), toMoney(0.58));
+ emiCalculator.payPrincipal(interestSchedule, LocalDate.of(2024, 3, 1),
LocalDate.of(2024, 2, 15), toMoney(16.77));
+ emiCalculator.payInterest(interestSchedule, LocalDate.of(2024, 3, 1),
LocalDate.of(2024, 2, 15), toMoney(0.24));
+ emiCalculator.payPrincipal(interestSchedule, LocalDate.of(2024, 4, 1),
LocalDate.of(2024, 2, 15), toMoney(17.01));
+ emiCalculator.payPrincipal(interestSchedule, LocalDate.of(2024, 5, 1),
LocalDate.of(2024, 2, 15), toMoney(17.01));
+ emiCalculator.payPrincipal(interestSchedule, LocalDate.of(2024, 6, 1),
LocalDate.of(2024, 2, 15), toMoney(17.01));
+ emiCalculator.payPrincipal(interestSchedule, LocalDate.of(2024, 7, 1),
LocalDate.of(2024, 2, 15), toMoney(15.77));
// check periods in model
@@ -685,7 +719,7 @@ class ProgressiveEMICalculatorTest {
}
@Test
- public void
testEMICalculation_disbursedAmt100_dayInYears360_daysInMonth30_repayEvery1Month_payoff_on0115()
{
+ public void
test_payoff_on0115_disbursedAmt100_dayInYears360_daysInMonth30_repayEvery1Month()
{
final List<LoanScheduleModelRepaymentPeriod> expectedRepaymentPeriods
= new ArrayList<>();
@@ -696,7 +730,7 @@ class ProgressiveEMICalculatorTest {
expectedRepaymentPeriods.add(repayment(5, LocalDate.of(2024, 5, 1),
LocalDate.of(2024, 6, 1)));
expectedRepaymentPeriods.add(repayment(6, LocalDate.of(2024, 6, 1),
LocalDate.of(2024, 7, 1)));
- final BigDecimal interestRate = new BigDecimal("7");
+ final BigDecimal interestRate = BigDecimal.valueOf(7.0);
final Integer installmentAmountInMultiplesOf = null;
Mockito.when(loanProductRelatedDetail.getAnnualNominalInterestRate()).thenReturn(interestRate);
@@ -717,13 +751,13 @@ class ProgressiveEMICalculatorTest {
// get remaining balance and dues on due date
PayableDetails payableDetails =
emiCalculator.getPayableDetails(interestSchedule, LocalDate.of(2024, 2, 1),
LocalDate.of(2024, 2, 1));
- Assertions.assertEquals(16.43,
toDouble(payableDetails.getPayablePrincipal().getAmount()));
- Assertions.assertEquals(0.58,
toDouble(payableDetails.getPayableInterest().getAmount()));
+ Assertions.assertEquals(16.43,
toDouble(payableDetails.getPayablePrincipal()));
+ Assertions.assertEquals(0.58,
toDouble(payableDetails.getPayableInterest()));
// check numbers on payoff date
payableDetails = emiCalculator.getPayableDetails(interestSchedule,
LocalDate.of(2024, 2, 1), LocalDate.of(2024, 1, 15));
- Assertions.assertEquals(16.75,
toDouble(payableDetails.getPayablePrincipal().getAmount()));
- Assertions.assertEquals(0.26,
toDouble(payableDetails.getPayableInterest().getAmount()));
+ Assertions.assertEquals(16.75,
toDouble(payableDetails.getPayablePrincipal()));
+ Assertions.assertEquals(0.26,
toDouble(payableDetails.getPayableInterest()));
emiCalculator.payPrincipal(interestSchedule, LocalDate.of(2024, 2, 1),
LocalDate.of(2024, 1, 15), toMoney(16.75));
emiCalculator.payInterest(interestSchedule, LocalDate.of(2024, 2, 1),
LocalDate.of(2024, 1, 15), toMoney(0.26));
@@ -738,8 +772,8 @@ class ProgressiveEMICalculatorTest {
emiCalculator.payPrincipal(interestSchedule, LocalDate.of(2024, 6, 1),
LocalDate.of(2024, 1, 15), toMoney(17.01));
payableDetails = emiCalculator.getPayableDetails(interestSchedule,
LocalDate.of(2024, 7, 1), LocalDate.of(2024, 7, 1));
- Assertions.assertEquals(15.21,
toDouble(payableDetails.getPayablePrincipal().getAmount()));
- Assertions.assertEquals(0.5,
toDouble(payableDetails.getPayableInterest().getAmount()));
+ Assertions.assertEquals(15.21,
toDouble(payableDetails.getPayablePrincipal()));
+ Assertions.assertEquals(0.5,
toDouble(payableDetails.getPayableInterest()));
// check periods in model
checkPeriod(interestSchedule, 0, 0, 17.01, 0.0, 0.0, 0.26, 16.75,
15.21);
@@ -765,7 +799,7 @@ class ProgressiveEMICalculatorTest {
}
@Test
- public void
testEMICalculation_multiDisbursedAmt300InSamePeriod_dayInYears360_daysInMonth30_repayEvery1Month()
{
+ public void
test_multiDisbursedAmt300InSamePeriod_dayInYears360_daysInMonth30_repayEvery1Month()
{
final List<LoanScheduleModelRepaymentPeriod> expectedRepaymentPeriods
= new ArrayList<>();
@@ -776,7 +810,7 @@ class ProgressiveEMICalculatorTest {
expectedRepaymentPeriods.add(repayment(5, LocalDate.of(2024, 5, 1),
LocalDate.of(2024, 6, 1)));
expectedRepaymentPeriods.add(repayment(6, LocalDate.of(2024, 6, 1),
LocalDate.of(2024, 7, 1)));
- final BigDecimal interestRate = new BigDecimal("9.4822");
+ final BigDecimal interestRate = BigDecimal.valueOf(9.4822);
final Integer installmentAmountInMultiplesOf = null;
Mockito.when(loanProductRelatedDetail.getAnnualNominalInterestRate()).thenReturn(interestRate);
@@ -789,7 +823,7 @@ class ProgressiveEMICalculatorTest {
final ProgressiveLoanInterestScheduleModel interestSchedule =
emiCalculator.generateInterestScheduleModel(expectedRepaymentPeriods,
loanProductRelatedDetail, installmentAmountInMultiplesOf, mc);
- Money disbursedAmount = Money.of(monetaryCurrency,
BigDecimal.valueOf(100));
+ Money disbursedAmount = toMoney(100);
emiCalculator.addDisbursement(interestSchedule, LocalDate.of(2024, 1,
1), disbursedAmount);
checkPeriod(interestSchedule, 0, 0, 17.13, 0.0, 0.0, 0.79, 16.34,
83.66);
@@ -800,7 +834,7 @@ class ProgressiveEMICalculatorTest {
checkPeriod(interestSchedule, 4, 0, 17.13, 0.007901833333, 0.27,
16.86, 17.0);
checkPeriod(interestSchedule, 5, 0, 17.13, 0.007901833333, 0.13,
17.00, 0.0);
- disbursedAmount = Money.of(monetaryCurrency, BigDecimal.valueOf(200));
+ disbursedAmount = toMoney(200.0);
emiCalculator.addDisbursement(interestSchedule, LocalDate.of(2024, 1,
8), disbursedAmount);
checkPeriod(interestSchedule, 0, 0, 51.33, 0.0, 0.0, 2.02, 49.31,
250.69);
@@ -814,7 +848,7 @@ class ProgressiveEMICalculatorTest {
}
@Test
- public void
testEMICalculation_multiDisbursedAmt200InDifferentPeriod_dayInYears360_daysInMonth30_repayEvery1Month()
{
+ public void
test_multiDisbursedAmt200InDifferentPeriod_dayInYears360_daysInMonth30_repayEvery1Month()
{
final List<LoanScheduleModelRepaymentPeriod> expectedRepaymentPeriods
= new ArrayList<>();
@@ -825,7 +859,7 @@ class ProgressiveEMICalculatorTest {
expectedRepaymentPeriods.add(repayment(5, LocalDate.of(2024, 5, 1),
LocalDate.of(2024, 6, 1)));
expectedRepaymentPeriods.add(repayment(6, LocalDate.of(2024, 6, 1),
LocalDate.of(2024, 7, 1)));
- final BigDecimal interestRate = new BigDecimal("9.4822");
+ final BigDecimal interestRate = BigDecimal.valueOf(9.4822);
final Integer installmentAmountInMultiplesOf = null;
Mockito.when(loanProductRelatedDetail.getAnnualNominalInterestRate()).thenReturn(interestRate);
@@ -838,7 +872,7 @@ class ProgressiveEMICalculatorTest {
final ProgressiveLoanInterestScheduleModel interestSchedule =
emiCalculator.generateInterestScheduleModel(expectedRepaymentPeriods,
loanProductRelatedDetail, installmentAmountInMultiplesOf, mc);
- Money disbursedAmount = Money.of(monetaryCurrency,
BigDecimal.valueOf(100));
+ Money disbursedAmount = toMoney(100.0);
emiCalculator.addDisbursement(interestSchedule, LocalDate.of(2024, 1,
1), disbursedAmount);
checkPeriod(interestSchedule, 0, 0, 17.13, 0.0, 0.0, 0.79, 16.34,
83.66);
@@ -849,7 +883,7 @@ class ProgressiveEMICalculatorTest {
checkPeriod(interestSchedule, 4, 0, 17.13, 0.007901833333, 0.27,
16.86, 17.0);
checkPeriod(interestSchedule, 5, 0, 17.13, 0.007901833333, 0.13,
17.00, 0.0);
- disbursedAmount = Money.of(monetaryCurrency, BigDecimal.valueOf(100));
+ disbursedAmount = toMoney(100.0);
emiCalculator.addDisbursement(interestSchedule, LocalDate.of(2024, 2,
15), disbursedAmount);
checkPeriod(interestSchedule, 0, 0, 17.13, 0.0, 0.0, 0.79, 16.34,
83.66);
@@ -863,7 +897,7 @@ class ProgressiveEMICalculatorTest {
}
@Test
- public void
testEMICalculation_multiDisbursedAmt150InSamePeriod_dayInYears360_daysInMonth30_repayEvery1Month_backdated_disbursement()
{
+ public void
test_multiDisbursedAmt150InSamePeriod_dayInYears360_daysInMonth30_repayEvery1Month_backdated_disbursement()
{
final List<LoanScheduleModelRepaymentPeriod> expectedRepaymentPeriods
= new ArrayList<>();
@@ -874,7 +908,7 @@ class ProgressiveEMICalculatorTest {
expectedRepaymentPeriods.add(repayment(5, LocalDate.of(2024, 5, 1),
LocalDate.of(2024, 6, 1)));
expectedRepaymentPeriods.add(repayment(6, LocalDate.of(2024, 6, 1),
LocalDate.of(2024, 7, 1)));
- final BigDecimal interestRate = new BigDecimal("9.4822");
+ final BigDecimal interestRate = BigDecimal.valueOf(9.4822);
final Integer installmentAmountInMultiplesOf = null;
Mockito.when(loanProductRelatedDetail.getAnnualNominalInterestRate()).thenReturn(interestRate);
@@ -887,14 +921,14 @@ class ProgressiveEMICalculatorTest {
final ProgressiveLoanInterestScheduleModel interestSchedule =
emiCalculator.generateInterestScheduleModel(expectedRepaymentPeriods,
loanProductRelatedDetail, installmentAmountInMultiplesOf, mc);
- Money disbursedAmount = Money.of(monetaryCurrency,
BigDecimal.valueOf(100));
+ Money disbursedAmount = toMoney(100.0);
emiCalculator.addDisbursement(interestSchedule, LocalDate.of(2024, 1,
5), disbursedAmount);
- disbursedAmount = Money.of(monetaryCurrency, BigDecimal.valueOf(50));
+ disbursedAmount = toMoney(50.0);
emiCalculator.addDisbursement(interestSchedule, LocalDate.of(2024, 1,
8), disbursedAmount);
// add disbursement on same date
- disbursedAmount = Money.of(monetaryCurrency, BigDecimal.valueOf(25));
+ disbursedAmount = toMoney(25.0);
emiCalculator.addDisbursement(interestSchedule, LocalDate.of(2024, 1,
8), disbursedAmount);
checkPeriod(interestSchedule, 0, 0, 29.94, 0.001019591398, 0.00, 1.15,
28.79, 146.21);
@@ -908,7 +942,7 @@ class ProgressiveEMICalculatorTest {
}
@Test
- public void
testEMICalculation_disbursedAmt100_dayInYearsActual_daysInMonthActual_repayEvery1Month()
{
+ public void
test_disbursedAmt100_dayInYearsActual_daysInMonthActual_repayEvery1Month() {
final List<LoanScheduleModelRepaymentPeriod> expectedRepaymentPeriods
= List.of(
repayment(1, LocalDate.of(2023, 12, 12), LocalDate.of(2024, 1,
12)),
@@ -918,7 +952,7 @@ class ProgressiveEMICalculatorTest {
repayment(5, LocalDate.of(2024, 4, 12), LocalDate.of(2024, 5,
1)),
repayment(6, LocalDate.of(2024, 5, 12), LocalDate.of(2024, 6,
1)));
- final BigDecimal interestRate = new BigDecimal("9.4822");
+ final BigDecimal interestRate = BigDecimal.valueOf(9.4822);
final Integer installmentAmountInMultiplesOf = null;
Mockito.when(loanProductRelatedDetail.getAnnualNominalInterestRate()).thenReturn(interestRate);
@@ -931,7 +965,7 @@ class ProgressiveEMICalculatorTest {
final ProgressiveLoanInterestScheduleModel interestSchedule =
emiCalculator.generateInterestScheduleModel(expectedRepaymentPeriods,
loanProductRelatedDetail, installmentAmountInMultiplesOf, mc);
- final Money disbursedAmount = Money.of(monetaryCurrency,
BigDecimal.valueOf(100));
+ final Money disbursedAmount = toMoney(100.0);
emiCalculator.addDisbursement(interestSchedule, LocalDate.of(2023, 12,
12), disbursedAmount);
checkPeriod(interestSchedule, 0, 0, 17.13, 0.0, 0.0, 0.80, 16.33,
83.67);
@@ -944,7 +978,7 @@ class ProgressiveEMICalculatorTest {
}
@Test
- public void
testEMICalculation_disbursedAmt1000_NoInterest_repayEvery1Month() {
+ public void test_disbursedAmt1000_NoInterest_repayEvery1Month() {
final List<LoanScheduleModelRepaymentPeriod> expectedRepaymentPeriods
= List.of(
repayment(2, LocalDate.of(2024, 1, 1), LocalDate.of(2024, 2,
1)),
@@ -952,7 +986,7 @@ class ProgressiveEMICalculatorTest {
repayment(4, LocalDate.of(2024, 3, 1), LocalDate.of(2024, 4,
1)),
repayment(5, LocalDate.of(2024, 4, 1), LocalDate.of(2024, 5,
1)));
- final BigDecimal interestRate = new BigDecimal("0");
+ final BigDecimal interestRate = BigDecimal.ZERO;
final Integer installmentAmountInMultiplesOf = null;
Mockito.when(loanProductRelatedDetail.getAnnualNominalInterestRate()).thenReturn(interestRate);
@@ -965,7 +999,7 @@ class ProgressiveEMICalculatorTest {
final ProgressiveLoanInterestScheduleModel interestSchedule =
emiCalculator.generateInterestScheduleModel(expectedRepaymentPeriods,
loanProductRelatedDetail, installmentAmountInMultiplesOf, mc);
- final Money disbursedAmount = Money.of(monetaryCurrency,
BigDecimal.valueOf(1000));
+ final Money disbursedAmount = toMoney(1000.0);
emiCalculator.addDisbursement(interestSchedule, LocalDate.of(2024, 1,
1), disbursedAmount);
checkPeriod(interestSchedule, 0, 0, 250.0, 0.0, 0.0, 250.0, 750.0);
@@ -975,7 +1009,7 @@ class ProgressiveEMICalculatorTest {
}
@Test
- public void
testEMICalculation_disbursedAmt100_dayInYears364_daysInMonthActual_repayEvery1Week()
{
+ public void
test_disbursedAmt100_dayInYears364_daysInMonthActual_repayEvery1Week() {
final List<LoanScheduleModelRepaymentPeriod> expectedRepaymentPeriods
= List.of(
repayment(1, LocalDate.of(2024, 1, 1), LocalDate.of(2024, 1,
8)),
@@ -985,7 +1019,7 @@ class ProgressiveEMICalculatorTest {
repayment(5, LocalDate.of(2024, 1, 29), LocalDate.of(2024, 2,
5)),
repayment(6, LocalDate.of(2024, 2, 5), LocalDate.of(2024, 2,
12)));
- final BigDecimal interestRate = new BigDecimal("9.4822");
+ final BigDecimal interestRate = BigDecimal.valueOf(9.4822);
final Integer installmentAmountInMultiplesOf = null;
Mockito.when(loanProductRelatedDetail.getAnnualNominalInterestRate()).thenReturn(interestRate);
@@ -998,7 +1032,7 @@ class ProgressiveEMICalculatorTest {
final ProgressiveLoanInterestScheduleModel interestSchedule =
emiCalculator.generateInterestScheduleModel(expectedRepaymentPeriods,
loanProductRelatedDetail, installmentAmountInMultiplesOf, mc);
- final Money disbursedAmount = Money.of(monetaryCurrency,
BigDecimal.valueOf(100));
+ final Money disbursedAmount = toMoney(100.0);
emiCalculator.addDisbursement(interestSchedule, LocalDate.of(2024, 1,
1), disbursedAmount);
checkPeriod(interestSchedule, 0, 0, 16.77, 0.0, 0.0, 0.18, 16.59,
83.41);
@@ -1011,14 +1045,14 @@ class ProgressiveEMICalculatorTest {
}
@Test
- public void
testEMICalculation_disbursedAmt100_dayInYears364_daysInMonthActual_repayEvery2Week()
{
+ public void
test_disbursedAmt100_dayInYears364_daysInMonthActual_repayEvery2Week() {
final List<LoanScheduleModelRepaymentPeriod> expectedRepaymentPeriods
= List.of(
repayment(1, LocalDate.of(2024, 1, 1), LocalDate.of(2024, 1,
15)),
repayment(2, LocalDate.of(2024, 1, 15), LocalDate.of(2024, 1,
29)),
repayment(3, LocalDate.of(2024, 1, 29), LocalDate.of(2024, 2,
12)));
- final BigDecimal interestRate = new BigDecimal("9.4822");
+ final BigDecimal interestRate = BigDecimal.valueOf(9.4822);
final Integer installmentAmountInMultiplesOf = null;
Mockito.when(loanProductRelatedDetail.getAnnualNominalInterestRate()).thenReturn(interestRate);
@@ -1031,7 +1065,7 @@ class ProgressiveEMICalculatorTest {
final ProgressiveLoanInterestScheduleModel interestSchedule =
emiCalculator.generateInterestScheduleModel(expectedRepaymentPeriods,
loanProductRelatedDetail, installmentAmountInMultiplesOf, mc);
- final Money disbursedAmount = Money.of(monetaryCurrency,
BigDecimal.valueOf(100));
+ final Money disbursedAmount = toMoney(100.0);
emiCalculator.addDisbursement(interestSchedule, LocalDate.of(2024, 1,
1), disbursedAmount);
checkPeriod(interestSchedule, 0, 0, 33.57, 0.0, 0.0, 0.36, 33.21,
66.79);
@@ -1041,7 +1075,7 @@ class ProgressiveEMICalculatorTest {
}
@Test
- public void
testEMICalculation_disbursedAmt100_dayInYears360_daysInMonthDoesntMatter_repayEvery15Days()
{
+ public void
test_disbursedAmt100_dayInYears360_daysInMonthDoesntMatter_repayEvery15Days() {
final List<LoanScheduleModelRepaymentPeriod> expectedRepaymentPeriods
= List.of(
repayment(1, LocalDate.of(2024, 1, 1), LocalDate.of(2024, 1,
16)),
@@ -1051,7 +1085,7 @@ class ProgressiveEMICalculatorTest {
repayment(5, LocalDate.of(2024, 3, 1), LocalDate.of(2024, 3,
16)),
repayment(6, LocalDate.of(2024, 3, 16), LocalDate.of(2024, 3,
31)));
- final BigDecimal interestRate = new BigDecimal("9.4822");
+ final BigDecimal interestRate = BigDecimal.valueOf(9.4822);
final Integer installmentAmountInMultiplesOf = null;
Mockito.when(loanProductRelatedDetail.getAnnualNominalInterestRate()).thenReturn(interestRate);
@@ -1064,7 +1098,7 @@ class ProgressiveEMICalculatorTest {
final ProgressiveLoanInterestScheduleModel interestSchedule =
emiCalculator.generateInterestScheduleModel(expectedRepaymentPeriods,
loanProductRelatedDetail, installmentAmountInMultiplesOf, mc);
- final Money disbursedAmount = Money.of(monetaryCurrency,
BigDecimal.valueOf(100));
+ final Money disbursedAmount = toMoney(100.0);
emiCalculator.addDisbursement(interestSchedule, LocalDate.of(2024, 1,
1), disbursedAmount);
checkPeriod(interestSchedule, 0, 0, 16.90, 0.0, 0.0, 0.40, 16.50,
83.50);
@@ -1105,16 +1139,20 @@ class ProgressiveEMICalculatorTest {
final RepaymentPeriod repaymentPeriod =
interestScheduleModel.repaymentPeriods().get(repaymentIdx);
final InterestPeriod interestPeriod =
repaymentPeriod.getInterestPeriods().get(interestIdx);
- Assertions.assertEquals(emiValue,
toDouble(repaymentPeriod.getEmi().getAmount()));
+ Assertions.assertEquals(emiValue, toDouble(repaymentPeriod.getEmi()));
Assertions.assertEquals(rateFactor,
toDouble(applyMathContext(interestPeriod.getRateFactor())));
- Assertions.assertEquals(interestDue,
toDouble(interestPeriod.getCalculatedDueInterest().getAmount()));
- Assertions.assertEquals(interestDueCumulated,
toDouble(repaymentPeriod.getDueInterest().getAmount()));
- Assertions.assertEquals(principalDue,
toDouble(repaymentPeriod.getDuePrincipal().getAmount()));
- Assertions.assertEquals(remaingBalance,
toDouble(repaymentPeriod.getOutstandingLoanBalance().getAmount()));
+ Assertions.assertEquals(interestDue,
toDouble(interestPeriod.getCalculatedDueInterest()));
+ Assertions.assertEquals(interestDueCumulated,
toDouble(repaymentPeriod.getDueInterest()));
+ Assertions.assertEquals(principalDue,
toDouble(repaymentPeriod.getDuePrincipal()));
+ Assertions.assertEquals(remaingBalance,
toDouble(repaymentPeriod.getOutstandingLoanBalance()));
+ }
+
+ private static double toDouble(final Money value) {
+ return value == null ? 0.0 : toDouble(value.getAmount());
}
private static double toDouble(final BigDecimal value) {
- return value == null ? 0 : value.doubleValue();
+ return value == null ? 0.0 : value.doubleValue();
}
private static BigDecimal applyMathContext(final BigDecimal value) {
diff --git
a/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/service/reaging/LoanReAgingValidator.java
b/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/service/reaging/LoanReAgingValidator.java
index 99785147c..196a386d7 100644
---
a/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/service/reaging/LoanReAgingValidator.java
+++
b/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/service/reaging/LoanReAgingValidator.java
@@ -35,7 +35,7 @@ import
org.apache.fineract.portfolio.loanaccount.api.LoanReAgingApiConstants;
import org.apache.fineract.portfolio.loanaccount.domain.Loan;
import org.apache.fineract.portfolio.loanaccount.domain.LoanTransaction;
import
org.apache.fineract.portfolio.loanaccount.domain.transactionprocessor.impl.AdvancedPaymentScheduleTransactionProcessor;
-import
org.apache.fineract.portfolio.loanaccount.domain.transactionprocessor.impl.ChargeOrTransaction;
+import
org.apache.fineract.portfolio.loanaccount.domain.transactionprocessor.impl.ChangeOperation;
import
org.apache.fineract.portfolio.loanaccount.loanschedule.domain.LoanScheduleType;
import org.springframework.stereotype.Component;
@@ -145,6 +145,6 @@ public class LoanReAgingValidator {
}
private boolean transactionHappenedAfterOther(LoanTransaction transaction,
LoanTransaction otherTransaction) {
- return new ChargeOrTransaction(transaction).compareTo(new
ChargeOrTransaction(otherTransaction)) > 0;
+ return new ChangeOperation(transaction).compareTo(new
ChangeOperation(otherTransaction)) > 0;
}
}
diff --git
a/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/service/reamortization/LoanReAmortizationValidator.java
b/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/service/reamortization/LoanReAmortizationValidator.java
index 28087f74a..58ad2fb7c 100644
---
a/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/service/reamortization/LoanReAmortizationValidator.java
+++
b/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/service/reamortization/LoanReAmortizationValidator.java
@@ -34,7 +34,7 @@ import
org.apache.fineract.portfolio.loanaccount.api.LoanReAmortizationApiConsta
import org.apache.fineract.portfolio.loanaccount.domain.Loan;
import org.apache.fineract.portfolio.loanaccount.domain.LoanTransaction;
import
org.apache.fineract.portfolio.loanaccount.domain.transactionprocessor.impl.AdvancedPaymentScheduleTransactionProcessor;
-import
org.apache.fineract.portfolio.loanaccount.domain.transactionprocessor.impl.ChargeOrTransaction;
+import
org.apache.fineract.portfolio.loanaccount.domain.transactionprocessor.impl.ChangeOperation;
import
org.apache.fineract.portfolio.loanaccount.loanschedule.domain.LoanScheduleType;
import org.springframework.stereotype.Component;
@@ -130,6 +130,6 @@ public class LoanReAmortizationValidator {
}
private boolean transactionHappenedAfterOther(LoanTransaction transaction,
LoanTransaction otherTransaction) {
- return new ChargeOrTransaction(transaction).compareTo(new
ChargeOrTransaction(otherTransaction)) > 0;
+ return new ChangeOperation(transaction).compareTo(new
ChangeOperation(otherTransaction)) > 0;
}
}
diff --git
a/integration-tests/src/test/java/org/apache/fineract/integrationtests/AdvancedPaymentAllocationLoanRepaymentScheduleTest.java
b/integration-tests/src/test/java/org/apache/fineract/integrationtests/AdvancedPaymentAllocationLoanRepaymentScheduleTest.java
index 5091ade69..c01171f47 100644
---
a/integration-tests/src/test/java/org/apache/fineract/integrationtests/AdvancedPaymentAllocationLoanRepaymentScheduleTest.java
+++
b/integration-tests/src/test/java/org/apache/fineract/integrationtests/AdvancedPaymentAllocationLoanRepaymentScheduleTest.java
@@ -83,6 +83,7 @@ import
org.apache.fineract.portfolio.loanaccount.domain.transactionprocessor.imp
import
org.apache.fineract.portfolio.loanaccount.domain.transactionprocessor.impl.FineractStyleLoanRepaymentScheduleTransactionProcessor;
import
org.apache.fineract.portfolio.loanaccount.loanschedule.domain.LoanScheduleProcessingType;
import
org.apache.fineract.portfolio.loanaccount.loanschedule.domain.LoanScheduleType;
+import
org.apache.fineract.portfolio.loanproduct.domain.LoanRescheduleStrategyMethod;
import org.apache.fineract.portfolio.loanproduct.domain.PaymentAllocationType;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
@@ -5213,6 +5214,124 @@ public class
AdvancedPaymentAllocationLoanRepaymentScheduleTest extends BaseLoan
});
}
+ // UC14-: Advanced payment allocation with Interest, Interest
Recalculation Enabled
+ // Interest Calculation Period Type: daily
+ // Use original EMI and apply disbursement and change Interest Rate
+ // ADVANCED_PAYMENT_ALLOCATION_STRATEGY
+ // 1. Create a Loan product with Adv. Payment. Alloc. and with 7%
Interest, 360/30, 1 repayment per month
+ // 2. Submit Loan and approve
+ // 3. Disburse
+ // 4. Validate Repayment Schedule
+ // 5. Reschedule Interest Rate to 4%
+ // 6. Validate Repayment Schedule
+ @Test
+ public void uc147d() {
+ final String operationDate = "1 January 2024";
+ runAt(operationDate, () -> {
+ BigDecimal interestRatePerPeriod = BigDecimal.valueOf(7.0);
+
+ Long clientId =
clientHelper.createClient(ClientHelper.defaultClientCreationRequest()).getClientId();
+ PostLoanProductsRequest product =
createOnePeriod30DaysLongNoInterestPeriodicAccrualProductWithAdvancedPaymentAllocation()
+
.interestRatePerPeriod(interestRatePerPeriod.doubleValue()).interestRateFrequencyType(YEARS)//
+ .daysInMonthType(DaysInMonthType.DAYS_30)//
+ .daysInYearType(DaysInYearType.DAYS_360)//
+ .numberOfRepayments(6)//
+ .repaymentEvery(1)//
+
.repaymentFrequencyType(RepaymentFrequencyType.MONTHS.longValue())//
+
.repaymentStartDateType(LoanProduct.RepaymentStartDateTypeEnum.SUBMITTED_ON_DATE.ordinal())//
+ .enableDownPayment(false)//
+ .allowPartialPeriodInterestCalcualtion(null)//
+ .enableAutoRepaymentForDownPayment(null)//
+ .isInterestRecalculationEnabled(true)//
+ .interestRecalculationCompoundingMethod(0)//
+
.interestCalculationPeriodType(InterestCalculationPeriodType.DAILY)//
+ .multiDisburseLoan(true)//
+ .disallowExpectedDisbursements(true)//
+ .allowApprovedDisbursedAmountsOverApplied(true)//
+ .overAppliedCalculationType("flat")//
+ .overAppliedNumber(10000)//
+ .maxTrancheCount(10)//
+ .outstandingLoanBalance(10000.0)//
+ .installmentAmountInMultiplesOf(null)//
+
.rescheduleStrategyMethod(LoanRescheduleStrategyMethod.ADJUST_LAST_UNPAID_PERIOD.getValue())//
+ .recalculationRestFrequencyType(1);//
+ PostLoanProductsResponse loanProductResponse =
loanProductHelper.createLoanProduct(product);
+ PostLoansRequest applicationRequest = applyLoanRequest(clientId,
loanProductResponse.getResourceId(), operationDate, 100.0, 6);
+
+ applicationRequest = applicationRequest.numberOfRepayments(6)//
+ .loanTermFrequency(6)//
+ .loanTermFrequencyType(2)//
+ .interestRatePerPeriod(interestRatePerPeriod)//
+ .interestCalculationPeriodType(DAYS)//
+
.transactionProcessingStrategyCode(LoanProductTestBuilder.ADVANCED_PAYMENT_ALLOCATION_STRATEGY)//
+ .repaymentEvery(1)//
+ .repaymentFrequencyType(2)//
+ .maxOutstandingLoanBalance(BigDecimal.valueOf(10000.0))//
+ ;//
+
+ PostLoansResponse loanResponse =
loanTransactionHelper.applyLoan(applicationRequest);
+
+ loanTransactionHelper.approveLoan(loanResponse.getLoanId(), new
PostLoansLoanIdRequest()//
+ .approvedLoanAmount(BigDecimal.valueOf(100))//
+
.approvedOnDate(operationDate).dateFormat(DATETIME_PATTERN).locale("en"));//
+
+ loanTransactionHelper.disburseLoan(loanResponse.getLoanId(), new
PostLoansLoanIdRequest()//
+ .transactionAmount(BigDecimal.valueOf(100.0))//
+
.actualDisbursementDate(operationDate).dateFormat(DATETIME_PATTERN).locale("en"));//
+
+ GetLoansLoanIdResponse loanDetails =
loanTransactionHelper.getLoanDetails(loanResponse.getLoanId());
+ validateLoanSummaryBalances(loanDetails, 102.05, 0.0, 100.0, 0.0,
null);
+
+ validateRepaymentPeriod(loanDetails, 1, LocalDate.of(2024, 2, 1),
16.43, 0.0, 16.43, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.58, 0.0,
+ 0.58, 0.0, 0.0);
+ validateRepaymentPeriod(loanDetails, 2, LocalDate.of(2024, 3, 1),
16.52, 0.0, 16.52, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.49, 0.0,
+ 0.49, 0.0, 0.0);
+ validateRepaymentPeriod(loanDetails, 3, LocalDate.of(2024, 4, 1),
16.62, 0.0, 16.62, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.39, 0.0,
+ 0.39, 0.0, 0.0);
+ validateRepaymentPeriod(loanDetails, 4, LocalDate.of(2024, 5, 1),
16.72, 0.0, 16.72, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.29, 0.0,
+ 0.29, 0.0, 0.0);
+ validateRepaymentPeriod(loanDetails, 5, LocalDate.of(2024, 6, 1),
16.81, 0.0, 16.81, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.20, 0.0,
+ 0.20, 0.0, 0.0);
+ validateRepaymentPeriod(loanDetails, 6, LocalDate.of(2024, 7, 1),
16.90, 0.0, 16.90, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.10, 0.0,
+ 0.10, 0.0, 0.0);
+ assertTrue(loanDetails.getStatus().getActive());
+ assertEquals(loanDetails.getNumberOfRepayments(), 6);
+
+ updateBusinessDate("1 February 2024");
+ loanTransactionHelper.makeRepayment("1 February 2024", 17.01f,
loanResponse.getLoanId().intValue());
+
+ updateBusinessDate("14 February 2024");
+ PostCreateRescheduleLoansResponse rescheduleLoansResponse =
loanRescheduleRequestHelper//
+ .createLoanRescheduleRequest(new
PostCreateRescheduleLoansRequest()//
+ .loanId(loanDetails.getId())//
+ .rescheduleReasonId(1L)//
+ .rescheduleFromDate("15 February
2024").dateFormat(DATETIME_PATTERN).locale("en")//
+ .submittedOnDate("14 February 2024")//
+ .newInterestRate(BigDecimal.valueOf(4.0)));//
+
+
loanRescheduleRequestHelper.approveLoanRescheduleRequest(rescheduleLoansResponse.getResourceId(),
//
+ new PostUpdateRescheduleLoansRequest()//
+ .approvedOnDate("14 February
2024").locale("en").dateFormat(DATETIME_PATTERN));//
+
+ loanDetails =
loanTransactionHelper.getLoanDetails(loanResponse.getLoanId());
+ validateLoanSummaryBalances(loanDetails, 84.5, 17.01, 83.57,
16.43, null);
+
+ validateRepaymentPeriod(loanDetails, 1, LocalDate.of(2024, 2, 1),
16.43, 16.43, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.58, 0.58,
+ 0.0, 0.0, 0.0);
+ validateRepaymentPeriod(loanDetails, 2, LocalDate.of(2024, 3, 1),
16.53, 0.0, 16.53, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.37, 0.0,
+ 0.37, 0.0, 0.0);
+ validateRepaymentPeriod(loanDetails, 3, LocalDate.of(2024, 4, 1),
16.68, 0.0, 16.68, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.22, 0.0,
+ 0.22, 0.0, 0.0);
+ validateRepaymentPeriod(loanDetails, 4, LocalDate.of(2024, 5, 1),
16.73, 0.0, 16.73, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.17, 0.0,
+ 0.17, 0.0, 0.0);
+ validateRepaymentPeriod(loanDetails, 5, LocalDate.of(2024, 6, 1),
16.79, 0.0, 16.79, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.11, 0.0,
+ 0.11, 0.0, 0.0);
+ validateRepaymentPeriod(loanDetails, 6, LocalDate.of(2024, 7, 1),
16.84, 0.0, 16.84, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.06, 0.0,
+ 0.06, 0.0, 0.0);
+ assertTrue(loanDetails.getStatus().getActive());
+ });
+ }
+
// uc148a: Advanced payment allocation, with Interest Recalculation in
Loan Product and Adjust last, unpaid period
// ADVANCED_PAYMENT_ALLOCATION_STRATEGY
// 1. Create a Loan product with Adv. Pment. Alloc. with Interest
Recalculation enabled and Adjust last, unpaid