You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@fineract.apache.org by ar...@apache.org on 2023/02/03 12:26:19 UTC
[fineract] branch develop updated: FINERACT-1839: Reversal on the loan account after CBR / Chargeback
This is an automated email from the ASF dual-hosted git repository.
arnold 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 0a2db35f8 FINERACT-1839: Reversal on the loan account after CBR / Chargeback
0a2db35f8 is described below
commit 0a2db35f8d791cf3d31b20a53862c99b82a4fbde
Author: Adam Saghy <ad...@gmail.com>
AuthorDate: Thu Feb 2 20:34:03 2023 +0100
FINERACT-1839: Reversal on the loan account after CBR / Chargeback
---
.../service/LoanDelinquencyDomainServiceImpl.java | 68 +++---
.../portfolio/loanaccount/domain/Loan.java | 22 +-
.../domain/LoanRepaymentScheduleInstallment.java | 6 +-
.../loanaccount/domain/LoanTransaction.java | 5 +-
...tLoanRepaymentScheduleTransactionProcessor.java | 267 +++++++++++++++------
.../LoanWritePlatformServiceJpaRepositoryImpl.java | 3 +-
.../LoanDelinquencyDomainServiceTest.java | 4 +
.../ClientLoanIntegrationTest.java | 229 ++++++++++++++++++
8 files changed, 492 insertions(+), 112 deletions(-)
diff --git a/fineract-provider/src/main/java/org/apache/fineract/portfolio/delinquency/service/LoanDelinquencyDomainServiceImpl.java b/fineract-provider/src/main/java/org/apache/fineract/portfolio/delinquency/service/LoanDelinquencyDomainServiceImpl.java
index 1d569c90b..72086c72f 100644
--- a/fineract-provider/src/main/java/org/apache/fineract/portfolio/delinquency/service/LoanDelinquencyDomainServiceImpl.java
+++ b/fineract-provider/src/main/java/org/apache/fineract/portfolio/delinquency/service/LoanDelinquencyDomainServiceImpl.java
@@ -20,6 +20,8 @@ package org.apache.fineract.portfolio.delinquency.service;
import java.math.BigDecimal;
import java.time.LocalDate;
+import java.util.List;
+import java.util.Objects;
import lombok.extern.slf4j.Slf4j;
import org.apache.fineract.infrastructure.core.service.DateUtils;
import org.apache.fineract.organisation.monetary.domain.MonetaryCurrency;
@@ -27,7 +29,6 @@ import org.apache.fineract.portfolio.loanaccount.data.CollectionData;
import org.apache.fineract.portfolio.loanaccount.domain.Loan;
import org.apache.fineract.portfolio.loanaccount.domain.LoanRepaymentScheduleInstallment;
import org.apache.fineract.portfolio.loanaccount.domain.LoanTransaction;
-import org.apache.fineract.portfolio.loanaccount.domain.LoanTransactionToRepaymentScheduleMapping;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@@ -43,17 +44,19 @@ public class LoanDelinquencyDomainServiceImpl implements LoanDelinquencyDomainSe
final MonetaryCurrency loanCurrency = loan.getCurrency();
LocalDate overdueSinceDate = null;
CollectionData collectionData = CollectionData.template();
- BigDecimal amountAvailable = BigDecimal.ZERO;
+ BigDecimal amountAvailable;
BigDecimal outstandingAmount = BigDecimal.ZERO;
boolean oldestOverdueInstallment = false;
boolean overdueSinceDateWasSet = false;
boolean firstNotYetDueInstallment = false;
+ LoanRepaymentScheduleInstallment latestInstallment = loan.getLastLoanRepaymentScheduleInstallment();
+
+ List<LoanTransaction> chargebackTransactions = loan.getLoanTransactions(LoanTransaction::isChargeback);
log.debug("Loan id {} with {} installments", loan.getId(), loan.getRepaymentScheduleInstallments().size());
// Get the oldest overdue installment if exists one
for (LoanRepaymentScheduleInstallment installment : loan.getRepaymentScheduleInstallments()) {
if (!installment.isObligationsMet()) {
-
if (installment.getDueDate().isBefore(businessDate)) {
log.debug("Loan Id: {} with installment {} due date {}", loan.getId(), installment.getInstallmentNumber(),
installment.getDueDate());
@@ -66,10 +69,17 @@ public class LoanDelinquencyDomainServiceImpl implements LoanDelinquencyDomainSe
amountAvailable = installment.getTotalPaid(loanCurrency).getAmount();
- for (LoanTransactionToRepaymentScheduleMapping mappingInstallment : installment
- .getLoanTransactionToRepaymentScheduleMappings()) {
- final LoanTransaction loanTransaction = mappingInstallment.getLoanTransaction();
- if (loanTransaction.isChargeback()) {
+ boolean isLatestInstallment = Objects.equals(installment.getId(), latestInstallment.getId());
+ for (LoanTransaction loanTransaction : chargebackTransactions) {
+ boolean isLoanTransactionIsOnOrAfterInstallmentFromDate = loanTransaction.getTransactionDate().isEqual(
+ installment.getFromDate()) || loanTransaction.getTransactionDate().isAfter(installment.getFromDate());
+ boolean isLoanTransactionIsBeforeNotLastInstallmentDueDate = !isLatestInstallment
+ && loanTransaction.getTransactionDate().isBefore(installment.getDueDate());
+ boolean isLoanTransactionIsOnOrBeforeLastInstallmentDueDate = isLatestInstallment
+ && (loanTransaction.getTransactionDate().isEqual(installment.getDueDate())
+ || loanTransaction.getTransactionDate().isBefore(installment.getDueDate()));
+ if (isLoanTransactionIsOnOrAfterInstallmentFromDate && (isLoanTransactionIsBeforeNotLastInstallmentDueDate
+ || isLoanTransactionIsOnOrBeforeLastInstallmentDueDate)) {
amountAvailable = amountAvailable.subtract(loanTransaction.getAmount());
if (amountAvailable.compareTo(BigDecimal.ZERO) < 0) {
overdueSinceDate = loanTransaction.getTransactionDate();
@@ -78,29 +88,33 @@ public class LoanDelinquencyDomainServiceImpl implements LoanDelinquencyDomainSe
}
}
}
- }
- } else if (!firstNotYetDueInstallment) {
- log.debug("Loan Id: {} with installment {} due date {}", loan.getId(), installment.getInstallmentNumber(),
- installment.getDueDate());
- firstNotYetDueInstallment = true;
- amountAvailable = installment.getTotalPaid(loanCurrency).getAmount();
- log.debug("Amount available {}", amountAvailable);
- for (LoanTransactionToRepaymentScheduleMapping mappingInstallment : installment
- .getLoanTransactionToRepaymentScheduleMappings()) {
- final LoanTransaction loanTransaction = mappingInstallment.getLoanTransaction();
- if (loanTransaction.isChargeback() && loanTransaction.getTransactionDate().isBefore(businessDate)) {
- log.debug("Loan CB Transaction: {} {} {}", loanTransaction.getId(), loanTransaction.getTransactionDate(),
- loanTransaction.getAmount());
- amountAvailable = amountAvailable.subtract(loanTransaction.getAmount());
- if (amountAvailable.compareTo(BigDecimal.ZERO) < 0 && !overdueSinceDateWasSet) {
- overdueSinceDate = loanTransaction.getTransactionDate();
- overdueSinceDateWasSet = true;
+ } else if (!firstNotYetDueInstallment) {
+ log.debug("Loan Id: {} with installment {} due date {}", loan.getId(), installment.getInstallmentNumber(),
+ installment.getDueDate());
+ firstNotYetDueInstallment = true;
+ amountAvailable = installment.getTotalPaid(loanCurrency).getAmount();
+ log.debug("Amount available {}", amountAvailable);
+ for (LoanTransaction loanTransaction : chargebackTransactions) {
+ boolean isLoanTransactionIsOnOrAfterInstallmentFromDate = loanTransaction.getTransactionDate().isEqual(
+ installment.getFromDate()) || loanTransaction.getTransactionDate().isAfter(installment.getFromDate());
+ boolean isLoanTransactionIsBeforeInstallmentDueDate = loanTransaction.getTransactionDate()
+ .isBefore(installment.getDueDate());
+ boolean isLoanTransactionIsBeforeBusinessDate = loanTransaction.getTransactionDate().isBefore(businessDate);
+ if (isLoanTransactionIsOnOrAfterInstallmentFromDate && isLoanTransactionIsBeforeInstallmentDueDate
+ && isLoanTransactionIsBeforeBusinessDate) {
+ log.debug("Loan CB Transaction: {} {} {}", loanTransaction.getId(), loanTransaction.getTransactionDate(),
+ loanTransaction.getAmount());
+ amountAvailable = amountAvailable.subtract(loanTransaction.getAmount());
+ if (amountAvailable.compareTo(BigDecimal.ZERO) < 0 && !overdueSinceDateWasSet) {
+ overdueSinceDate = loanTransaction.getTransactionDate();
+ overdueSinceDateWasSet = true;
+ }
}
}
- }
- if (amountAvailable.compareTo(BigDecimal.ZERO) < 0) {
- outstandingAmount = outstandingAmount.add(amountAvailable.abs());
+ if (amountAvailable.compareTo(BigDecimal.ZERO) < 0) {
+ outstandingAmount = outstandingAmount.add(amountAvailable.abs());
+ }
}
}
}
diff --git a/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/Loan.java b/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/Loan.java
index e9ccab2fd..a1307afc2 100644
--- a/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/Loan.java
+++ b/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/Loan.java
@@ -44,6 +44,7 @@ import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
+import java.util.function.Predicate;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Embedded;
@@ -1346,8 +1347,7 @@ public class Loan extends AbstractAuditableWithUTCDateTimeCustom {
}
installment.updateAccrualPortion(interest, fee, penality);
}
- LoanRepaymentScheduleInstallment lastInstallment = getRepaymentScheduleInstallments()
- .get(getRepaymentScheduleInstallments().size() - 1);
+ LoanRepaymentScheduleInstallment lastInstallment = getLastLoanRepaymentScheduleInstallment();
for (LoanTransaction loanTransaction : accruals) {
if (loanTransaction.getTransactionDate().isAfter(lastInstallment.getDueDate()) && !loanTransaction.isReversed()) {
loanTransaction.reverse();
@@ -3798,9 +3798,10 @@ public class Loan extends AbstractAuditableWithUTCDateTimeCustom {
if (loanTransaction.isReversed()) {
continue;
}
- if ((loanTransaction.isRefund() || loanTransaction.isRefundForActiveLoan() || loanTransaction.isCreditBalanceRefund()
- || loanTransaction.isChargeback())) {
+ if (loanTransaction.isRefund() || loanTransaction.isRefundForActiveLoan()) {
totalPaidInRepayments = totalPaidInRepayments.minus(loanTransaction.getAmount(currency));
+ } else if (loanTransaction.isCreditBalanceRefund() || loanTransaction.isChargeback()) {
+ totalPaidInRepayments = totalPaidInRepayments.minus(loanTransaction.getOverPaymentPortion(currency));
}
}
@@ -5804,7 +5805,7 @@ public class Loan extends AbstractAuditableWithUTCDateTimeCustom {
if (loanTransaction.isDisbursement() || loanTransaction.isIncomePosting()) {
outstanding = outstanding.plus(loanTransaction.getAmount(getCurrency()));
loanTransaction.updateOutstandingLoanBalance(outstanding.getAmount());
- } else if (loanTransaction.isChargeback()) {
+ } else if (loanTransaction.isChargeback() || loanTransaction.isCreditBalanceRefund()) {
Money transactionOutstanding = loanTransaction.getAmount(getCurrency());
if (!loanTransaction.getOverPaymentPortion(getCurrency()).isZero()) {
transactionOutstanding = loanTransaction.getAmount(getCurrency())
@@ -6277,9 +6278,6 @@ public class Loan extends AbstractAuditableWithUTCDateTimeCustom {
final LoanRepaymentScheduleTransactionProcessor loanRepaymentScheduleTransactionProcessor = this.transactionProcessorFactory
.determineProcessor(this.transactionProcessingStrategyCode);
final Money overpaidAmount = calculateTotalOverpayment(); // Before Transaction
- if (overpaidAmount.isGreaterThanZero()) {
- chargebackTransaction.setOverPayments(overpaidAmount);
- }
if (chargebackTransaction.isNotZero(loanCurrency())) {
addLoanTransaction(chargebackTransaction);
@@ -7018,4 +7016,12 @@ public class Loan extends AbstractAuditableWithUTCDateTimeCustom {
return this.chargedOff;
}
+ public LoanRepaymentScheduleInstallment getLastLoanRepaymentScheduleInstallment() {
+ return getRepaymentScheduleInstallments().get(getRepaymentScheduleInstallments().size() - 1);
+ }
+
+ public List<LoanTransaction> getLoanTransactions(Predicate<LoanTransaction> predicate) {
+ return getLoanTransactions().stream().filter(predicate).toList();
+ }
+
}
diff --git a/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/LoanRepaymentScheduleInstallment.java b/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/LoanRepaymentScheduleInstallment.java
index 9e864bb51..ab2b6326d 100644
--- a/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/LoanRepaymentScheduleInstallment.java
+++ b/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/LoanRepaymentScheduleInstallment.java
@@ -393,6 +393,10 @@ public class LoanRepaymentScheduleInstallment extends AbstractAuditableWithUTCDa
this.obligationsMet = false;
this.obligationsMetOnDate = null;
+ if (this.credits != null) {
+ this.principal = this.principal.subtract(this.credits);
+ this.credits = null;
+ }
}
public void resetAccrualComponents() {
@@ -836,7 +840,7 @@ public class LoanRepaymentScheduleInstallment extends AbstractAuditableWithUTCDa
}
}
- public void updateDueChargeback(final LocalDate transactionDate, final Money transactionAmount) {
+ public void updateDueAndCredits(final LocalDate transactionDate, final Money transactionAmount) {
updateDueDate(transactionDate);
addToCredits(transactionAmount.getAmount());
addToPrincipal(transactionDate, transactionAmount);
diff --git a/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/LoanTransaction.java b/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/LoanTransaction.java
index 9a0fbcc60..2ae376090 100644
--- a/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/LoanTransaction.java
+++ b/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/LoanTransaction.java
@@ -291,9 +291,8 @@ public class LoanTransaction extends AbstractAuditableWithUTCDateTimeCustom {
public static LoanTransaction creditBalanceRefund(final Loan loan, final Office office, final Money amount, final LocalDate paymentDate,
final ExternalId externalId) {
- final PaymentDetail paymentDetail = null;
- return new LoanTransaction(loan, office, LoanTransactionType.CREDIT_BALANCE_REFUND, paymentDetail, amount.getAmount(), paymentDate,
- externalId);
+ return new LoanTransaction(loan, office, LoanTransactionType.CREDIT_BALANCE_REFUND.getValue(), paymentDate, amount.getAmount(),
+ null, null, null, null, amount.getAmount(), false, null, externalId);
}
public static LoanTransaction refundForActiveLoan(final Office office, final Money amount, final PaymentDetail paymentDetail,
diff --git a/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/transactionprocessor/AbstractLoanRepaymentScheduleTransactionProcessor.java b/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/transactionprocessor/AbstractLoanRepaymentScheduleTransactionProcessor.java
index ecb992846..46d79637a 100644
--- a/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/transactionprocessor/AbstractLoanRepaymentScheduleTransactionProcessor.java
+++ b/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/domain/transactionprocessor/AbstractLoanRepaymentScheduleTransactionProcessor.java
@@ -25,7 +25,9 @@ import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
+import java.util.Map;
import java.util.Set;
+import org.apache.fineract.interoperation.util.MathUtil;
import org.apache.fineract.organisation.monetary.domain.MonetaryCurrency;
import org.apache.fineract.organisation.monetary.domain.Money;
import org.apache.fineract.portfolio.loanaccount.data.LoanChargePaidDetail;
@@ -34,7 +36,6 @@ import org.apache.fineract.portfolio.loanaccount.domain.Loan;
import org.apache.fineract.portfolio.loanaccount.domain.LoanCharge;
import org.apache.fineract.portfolio.loanaccount.domain.LoanChargePaidBy;
import org.apache.fineract.portfolio.loanaccount.domain.LoanInstallmentCharge;
-import org.apache.fineract.portfolio.loanaccount.domain.LoanInterestRecalcualtionAdditionalDetails;
import org.apache.fineract.portfolio.loanaccount.domain.LoanRepaymentScheduleInstallment;
import org.apache.fineract.portfolio.loanaccount.domain.LoanRepaymentScheduleProcessingWrapper;
import org.apache.fineract.portfolio.loanaccount.domain.LoanTransaction;
@@ -93,7 +94,7 @@ public abstract class AbstractLoanRepaymentScheduleTransactionProcessor implemen
wrapper.reprocess(currency, disbursementDate, installments, charges);
final ChangedTransactionDetail changedTransactionDetail = new ChangedTransactionDetail();
- final List<LoanTransaction> transactionstoBeProcessed = new ArrayList<>();
+ final List<LoanTransaction> transactionsToBeProcessed = new ArrayList<>();
for (final LoanTransaction loanTransaction : transactionsPostDisbursement) {
if (loanTransaction.isChargePayment()) {
List<LoanChargePaidDetail> chargePaidDetails = new ArrayList<>();
@@ -147,11 +148,11 @@ public abstract class AbstractLoanRepaymentScheduleTransactionProcessor implemen
}
} else {
- transactionstoBeProcessed.add(loanTransaction);
+ transactionsToBeProcessed.add(loanTransaction);
}
}
- for (final LoanTransaction loanTransaction : transactionstoBeProcessed) {
+ for (final LoanTransaction loanTransaction : transactionsToBeProcessed) {
// TODO: analyze and remove this
if (!loanTransaction.getTypeOf().equals(LoanTransactionType.REFUND_FOR_ACTIVE_LOAN)) {
final Comparator<LoanRepaymentScheduleInstallment> byDate = new Comparator<LoanRepaymentScheduleInstallment>() {
@@ -188,13 +189,7 @@ public abstract class AbstractLoanRepaymentScheduleTransactionProcessor implemen
loanTransaction.updateLoanTransactionToRepaymentScheduleMappings(
newLoanTransaction.getLoanTransactionToRepaymentScheduleMappings());
} else {
- loanTransaction.reverse();
- loanTransaction.updateExternalId(null);
- newLoanTransaction.copyLoanTransactionRelations(loanTransaction.getLoanTransactionRelations());
- // Adding Replayed relation from newly created transaction to reversed transaction
- newLoanTransaction.getLoanTransactionRelations().add(LoanTransactionRelation.linkToTransaction(newLoanTransaction,
- loanTransaction, LoanTransactionRelationTypeEnum.REPLAYED));
- changedTransactionDetail.getNewTransactionMappings().put(loanTransaction.getId(), newLoanTransaction);
+ createNewTransactionIfNecessary(loanTransaction, newLoanTransaction, currency, changedTransactionDetail);
}
}
@@ -203,13 +198,200 @@ public abstract class AbstractLoanRepaymentScheduleTransactionProcessor implemen
handleWriteOff(loanTransaction, currency, installments);
} else if (loanTransaction.isRefundForActiveLoan()) {
loanTransaction.resetDerivedComponents();
-
handleRefund(loanTransaction, currency, installments, charges);
+ } else if (loanTransaction.isCreditBalanceRefund()) {
+ recalculateCreditTransaction(changedTransactionDetail, loanTransaction, currency, installments, transactionsToBeProcessed);
+ } else if (loanTransaction.isChargeback()) {
+ recalculateCreditTransaction(changedTransactionDetail, loanTransaction, currency, installments, transactionsToBeProcessed);
+ reprocessChargebackTransactionRelation(changedTransactionDetail, transactionsToBeProcessed);
}
}
+ reprocessInstallments(installments, currency);
+
return changedTransactionDetail;
}
+ private void reprocessChargebackTransactionRelation(ChangedTransactionDetail changedTransactionDetail,
+ List<LoanTransaction> transactionsToBeProcessed) {
+
+ List<LoanTransaction> mergedTransactionList = getMergedTransactionList(transactionsToBeProcessed, changedTransactionDetail);
+ for (Map.Entry<Long, LoanTransaction> entry : changedTransactionDetail.getNewTransactionMappings().entrySet()) {
+ if (entry.getValue().isChargeback()) {
+ for (LoanTransaction loanTransaction : mergedTransactionList) {
+ if (loanTransaction.isReversed()) {
+ continue;
+ }
+ LoanTransactionRelation newLoanTransactionRelation = null;
+ LoanTransactionRelation oldLoanTransactionRelation = null;
+ for (LoanTransactionRelation transactionRelation : loanTransaction.getLoanTransactionRelations()) {
+ if (entry.getKey().equals(transactionRelation.getToTransaction().getId())
+ && LoanTransactionRelationTypeEnum.CHARGEBACK.equals(transactionRelation.getRelationType())) {
+ newLoanTransactionRelation = LoanTransactionRelation.linkToTransaction(loanTransaction, entry.getValue(),
+ LoanTransactionRelationTypeEnum.CHARGEBACK);
+ oldLoanTransactionRelation = transactionRelation;
+ break;
+ }
+ }
+ if (newLoanTransactionRelation != null) {
+ loanTransaction.getLoanTransactionRelations().add(newLoanTransactionRelation);
+ loanTransaction.getLoanTransactionRelations().remove(oldLoanTransactionRelation);
+ }
+ }
+ }
+ }
+ }
+
+ private void reprocessInstallments(List<LoanRepaymentScheduleInstallment> installments, MonetaryCurrency currency) {
+ LoanRepaymentScheduleInstallment lastInstallment = installments.get(installments.size() - 1);
+ if (lastInstallment.isAdditional() && lastInstallment.getDue(currency).isZero()) {
+ installments.remove(lastInstallment);
+ }
+ }
+
+ private void recalculateCreditTransaction(ChangedTransactionDetail changedTransactionDetail, LoanTransaction loanTransaction,
+ MonetaryCurrency currency, List<LoanRepaymentScheduleInstallment> installments,
+ List<LoanTransaction> transactionsToBeProcessed) {
+ // pass through for new transactions
+ if (loanTransaction.getId() == null) {
+ return;
+ }
+ final LoanTransaction newLoanTransaction = LoanTransaction.copyTransactionProperties(loanTransaction);
+
+ List<LoanTransaction> mergedList = getMergedTransactionList(transactionsToBeProcessed, changedTransactionDetail);
+ Money overpaidAmount = calculateOverpaidAmount(loanTransaction, mergedList, installments, currency);
+ processCreditTransaction(newLoanTransaction, overpaidAmount, currency, installments);
+ createNewTransactionIfNecessary(loanTransaction, newLoanTransaction, currency, changedTransactionDetail);
+ }
+
+ private List<LoanTransaction> getMergedTransactionList(List<LoanTransaction> transactionList,
+ ChangedTransactionDetail changedTransactionDetail) {
+ List<LoanTransaction> mergedList = new ArrayList<>(changedTransactionDetail.getNewTransactionMappings().values());
+ mergedList.addAll(new ArrayList<>(transactionList));
+ return mergedList;
+ }
+
+ private void createNewTransactionIfNecessary(LoanTransaction loanTransaction, LoanTransaction newLoanTransaction,
+ MonetaryCurrency currency, ChangedTransactionDetail changedTransactionDetail) {
+ if (!LoanTransaction.transactionAmountsMatch(currency, loanTransaction, newLoanTransaction)) {
+ loanTransaction.reverse();
+ loanTransaction.updateExternalId(null);
+ newLoanTransaction.copyLoanTransactionRelations(loanTransaction.getLoanTransactionRelations());
+ // Adding Replayed relation from newly created transaction to reversed transaction
+ newLoanTransaction.getLoanTransactionRelations().add(LoanTransactionRelation.linkToTransaction(newLoanTransaction,
+ loanTransaction, LoanTransactionRelationTypeEnum.REPLAYED));
+ changedTransactionDetail.getNewTransactionMappings().put(loanTransaction.getId(), newLoanTransaction);
+ }
+ }
+
+ private Money calculateOverpaidAmount(LoanTransaction loanTransaction, List<LoanTransaction> transactions,
+ List<LoanRepaymentScheduleInstallment> installments, MonetaryCurrency currency) {
+ Money totalPaidInRepayments = Money.zero(currency);
+
+ Money cumulativeTotalPaidOnInstallments = Money.zero(currency);
+ for (final LoanRepaymentScheduleInstallment scheduledRepayment : installments) {
+ cumulativeTotalPaidOnInstallments = cumulativeTotalPaidOnInstallments
+ .plus(scheduledRepayment.getPrincipalCompleted(currency).plus(scheduledRepayment.getInterestPaid(currency)))
+ .plus(scheduledRepayment.getFeeChargesPaid(currency)).plus(scheduledRepayment.getPenaltyChargesPaid(currency));
+ }
+
+ for (final LoanTransaction transaction : transactions) {
+ if (transaction.isReversed()) {
+ continue;
+ }
+ if (transaction.equals(loanTransaction)) {
+ // We want to process only the transactions prior to the actual one
+ break;
+ }
+ if (transaction.isRefund() || transaction.isRefundForActiveLoan()) {
+ totalPaidInRepayments = totalPaidInRepayments.minus(transaction.getAmount(currency));
+ } else if (transaction.isCreditBalanceRefund() || transaction.isChargeback()) {
+ totalPaidInRepayments = totalPaidInRepayments.minus(transaction.getOverPaymentPortion(currency));
+ } else if (transaction.isRepaymentType()) {
+ totalPaidInRepayments = totalPaidInRepayments.plus(transaction.getAmount(currency));
+ }
+ }
+
+ // if total paid in transactions higher than repayment schedule then
+ // theres an overpayment.
+ return MathUtil.negativeToZero(totalPaidInRepayments.minus(cumulativeTotalPaidOnInstallments));
+ }
+
+ private void processCreditTransaction(LoanTransaction loanTransaction, Money overpaidAmount, MonetaryCurrency currency,
+ List<LoanRepaymentScheduleInstallment> installments) {
+ loanTransaction.resetDerivedComponents();
+ List<LoanTransactionToRepaymentScheduleMapping> transactionMappings = new ArrayList<>();
+ final Comparator<LoanRepaymentScheduleInstallment> byDate = Comparator.comparing(LoanRepaymentScheduleInstallment::getDueDate);
+ installments.sort(byDate);
+ final Money zeroMoney = Money.zero(currency);
+ Money transactionAmount = loanTransaction.getAmount(currency);
+ Money principalPortion = MathUtil.negativeToZero(loanTransaction.getAmount(currency).minus(overpaidAmount));
+ Money repaidAmount = MathUtil.negativeToZero(transactionAmount.minus(principalPortion));
+ loanTransaction.updateOverPayments(repaidAmount);
+ loanTransaction.updateComponents(principalPortion, zeroMoney, zeroMoney, zeroMoney);
+
+ if (principalPortion.isGreaterThanZero()) {
+ final LocalDate transactionDate = loanTransaction.getTransactionDate();
+ boolean loanTransactionMapped = false;
+ LocalDate pastDueDate = null;
+ for (final LoanRepaymentScheduleInstallment currentInstallment : installments) {
+ pastDueDate = currentInstallment.getDueDate();
+ if (!currentInstallment.isAdditional() && currentInstallment.getDueDate().isAfter(transactionDate)) {
+ currentInstallment.addToCredits(transactionAmount.getAmount());
+ currentInstallment.addToPrincipal(transactionDate, transactionAmount);
+ if (repaidAmount.isGreaterThanZero()) {
+ currentInstallment.payPrincipalComponent(loanTransaction.getTransactionDate(), repaidAmount);
+ transactionMappings.add(LoanTransactionToRepaymentScheduleMapping.createFrom(loanTransaction, currentInstallment,
+ repaidAmount, zeroMoney, zeroMoney, zeroMoney));
+ }
+ loanTransactionMapped = true;
+ break;
+
+ // If already exists an additional installment just update the due date and
+ // principal from the Loan charge back transaction
+ } else if (currentInstallment.isAdditional()) {
+ currentInstallment.updateDueAndCredits(transactionDate, transactionAmount);
+ if (repaidAmount.isGreaterThanZero()) {
+ currentInstallment.payPrincipalComponent(loanTransaction.getTransactionDate(), repaidAmount);
+ transactionMappings.add(LoanTransactionToRepaymentScheduleMapping.createFrom(loanTransaction, currentInstallment,
+ repaidAmount, zeroMoney, zeroMoney, zeroMoney));
+ }
+ loanTransactionMapped = true;
+ break;
+ }
+ }
+
+ // New installment will be added (N+1 scenario)
+ if (!loanTransactionMapped) {
+ if (loanTransaction.getTransactionDate().equals(pastDueDate)) {
+ LoanRepaymentScheduleInstallment currentInstallment = installments.get(installments.size() - 1);
+ currentInstallment.addToCredits(transactionAmount.getAmount());
+ currentInstallment.addToPrincipal(transactionDate, transactionAmount);
+ if (repaidAmount.isGreaterThanZero()) {
+ currentInstallment.payPrincipalComponent(loanTransaction.getTransactionDate(), repaidAmount);
+ transactionMappings.add(LoanTransactionToRepaymentScheduleMapping.createFrom(loanTransaction, currentInstallment,
+ repaidAmount, zeroMoney, zeroMoney, zeroMoney));
+ }
+ } else {
+ Loan loan = loanTransaction.getLoan();
+ LoanRepaymentScheduleInstallment installment = new LoanRepaymentScheduleInstallment(loan, (installments.size() + 1),
+ pastDueDate, transactionDate, transactionAmount.getAmount(), zeroMoney.getAmount(), zeroMoney.getAmount(),
+ zeroMoney.getAmount(), false, null);
+ installment.markAsAdditional();
+ installment.addToCredits(transactionAmount.getAmount());
+ loan.addLoanRepaymentScheduleInstallment(installment);
+
+ if (repaidAmount.isGreaterThanZero()) {
+ installment.payPrincipalComponent(loanTransaction.getTransactionDate(), repaidAmount);
+ transactionMappings.add(LoanTransactionToRepaymentScheduleMapping.createFrom(loanTransaction, installment,
+ repaidAmount, zeroMoney, zeroMoney, zeroMoney));
+ }
+ }
+ }
+
+ loanTransaction.updateLoanTransactionToRepaymentScheduleMappings(transactionMappings);
+ }
+ }
+
/**
* Provides support for processing the latest transaction (which should be latest transaction) against the loan
* schedule.
@@ -524,66 +706,7 @@ public abstract class AbstractLoanRepaymentScheduleTransactionProcessor implemen
@Override
public void handleChargeback(LoanTransaction loanTransaction, MonetaryCurrency currency, Money overpaidAmount,
List<LoanRepaymentScheduleInstallment> installments) {
- List<LoanTransactionToRepaymentScheduleMapping> transactionMappings = new ArrayList<>();
- final Comparator<LoanRepaymentScheduleInstallment> byDate = new Comparator<LoanRepaymentScheduleInstallment>() {
-
- @Override
- public int compare(LoanRepaymentScheduleInstallment ord1, LoanRepaymentScheduleInstallment ord2) {
- return ord1.getDueDate().compareTo(ord2.getDueDate());
- }
- };
- Collections.sort(installments, byDate);
- final Money zeroMoney = Money.zero(currency);
- Money transactionAmountUnprocessed = loanTransaction.getAmount(currency);
- if (overpaidAmount.isGreaterThanZero()) {
- transactionAmountUnprocessed = loanTransaction.getAmount(currency).minus(overpaidAmount);
- if (transactionAmountUnprocessed.isLessThanZero()) {
- transactionAmountUnprocessed = zeroMoney;
- }
- }
-
- if (transactionAmountUnprocessed.isGreaterThanZero()) {
- final LocalDate transactionDate = loanTransaction.getTransactionDate();
- boolean loanTransactionMapped = false;
- LocalDate pastDueDate = null;
- for (final LoanRepaymentScheduleInstallment currentInstallment : installments) {
- pastDueDate = currentInstallment.getDueDate();
- if (!currentInstallment.isAdditional() && currentInstallment.getDueDate().isAfter(transactionDate)) {
- currentInstallment.addToCredits(transactionAmountUnprocessed.getAmount());
- currentInstallment.addToPrincipal(transactionDate, transactionAmountUnprocessed);
- transactionMappings.add(LoanTransactionToRepaymentScheduleMapping.createFrom(loanTransaction, currentInstallment,
- transactionAmountUnprocessed, zeroMoney, zeroMoney, zeroMoney));
-
- loanTransactionMapped = true;
-
- break;
-
- // If already exists an additional installment just update the due date and
- // principal from the Loan charge back transaction
- } else if (currentInstallment.isAdditional()) {
- currentInstallment.updateDueChargeback(transactionDate, transactionAmountUnprocessed);
- loanTransactionMapped = true;
- break;
- }
- }
-
- // New installment will be added (N+1 scenario)
- if (!loanTransactionMapped) {
- Loan loan = loanTransaction.getLoan();
- final Set<LoanInterestRecalcualtionAdditionalDetails> compoundingDetails = null;
- LoanRepaymentScheduleInstallment installment = new LoanRepaymentScheduleInstallment(loan, (installments.size() + 1),
- pastDueDate, transactionDate, transactionAmountUnprocessed.getAmount(), zeroMoney.getAmount(),
- zeroMoney.getAmount(), zeroMoney.getAmount(), false, compoundingDetails);
- installment.markAsAdditional();
- installment.addToCredits(transactionAmountUnprocessed.getAmount());
- loan.addLoanRepaymentScheduleInstallment(installment);
-
- transactionMappings.add(LoanTransactionToRepaymentScheduleMapping.createFrom(loanTransaction, installment,
- transactionAmountUnprocessed, zeroMoney, zeroMoney, zeroMoney));
- }
-
- loanTransaction.updateLoanTransactionToRepaymentScheduleMappings(transactionMappings);
- }
+ processCreditTransaction(loanTransaction, overpaidAmount, currency, installments);
}
@Override
diff --git a/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/service/LoanWritePlatformServiceJpaRepositoryImpl.java b/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/service/LoanWritePlatformServiceJpaRepositoryImpl.java
index afac84139..a6a358fdb 100644
--- a/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/service/LoanWritePlatformServiceJpaRepositoryImpl.java
+++ b/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanaccount/service/LoanWritePlatformServiceJpaRepositoryImpl.java
@@ -1302,7 +1302,8 @@ public class LoanWritePlatformServiceJpaRepositoryImpl implements LoanWritePlatf
private void validateLoanTransactionAmountChargeBack(LoanTransaction loanTransaction, LoanTransaction chargebackTransaction) {
BigDecimal actualAmount = BigDecimal.ZERO;
for (LoanTransactionRelation loanTransactionRelation : loanTransaction.getLoanTransactionRelations()) {
- if (loanTransactionRelation.getRelationType().equals(LoanTransactionRelationTypeEnum.CHARGEBACK)) {
+ if (loanTransactionRelation.getRelationType().equals(LoanTransactionRelationTypeEnum.CHARGEBACK)
+ && loanTransactionRelation.getToTransaction().isNotReversed()) {
actualAmount = actualAmount.add(loanTransactionRelation.getToTransaction().getPrincipalPortion());
}
}
diff --git a/fineract-provider/src/test/java/org/apache/fineract/portfolio/deliquency/LoanDelinquencyDomainServiceTest.java b/fineract-provider/src/test/java/org/apache/fineract/portfolio/deliquency/LoanDelinquencyDomainServiceTest.java
index e462aeb67..ef48eb58a 100644
--- a/fineract-provider/src/test/java/org/apache/fineract/portfolio/deliquency/LoanDelinquencyDomainServiceTest.java
+++ b/fineract-provider/src/test/java/org/apache/fineract/portfolio/deliquency/LoanDelinquencyDomainServiceTest.java
@@ -26,10 +26,12 @@ import java.math.RoundingMode;
import java.time.LocalDate;
import java.time.ZoneId;
import java.util.Arrays;
+import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
+import java.util.function.Predicate;
import org.apache.fineract.infrastructure.businessdate.domain.BusinessDateType;
import org.apache.fineract.infrastructure.configuration.domain.ConfigurationDomainService;
import org.apache.fineract.infrastructure.core.domain.FineractPlatformTenant;
@@ -136,6 +138,8 @@ public class LoanDelinquencyDomainServiceTest {
when(loanProduct.getLoanProductRelatedDetail()).thenReturn(loanProductRelatedDetail);
when(loan.getLoanProduct()).thenReturn(loanProduct);
when(loan.getRepaymentScheduleInstallments()).thenReturn(repaymentScheduleInstallments);
+ when(loan.getLoanTransactions(Mockito.any(Predicate.class))).thenReturn(Collections.emptyList());
+ when(loan.getLastLoanRepaymentScheduleInstallment()).thenReturn(repaymentScheduleInstallments.get(0));
when(loan.getCurrency()).thenReturn(currency);
CollectionData collectionData = underTest.getOverdueCollectionData(loan);
diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/ClientLoanIntegrationTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/ClientLoanIntegrationTest.java
index c69acfd3f..79adfb007 100644
--- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/ClientLoanIntegrationTest.java
+++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/ClientLoanIntegrationTest.java
@@ -7137,6 +7137,235 @@ public class ClientLoanIntegrationTest {
}
}
+ @Test
+ public void testCreditBalanceRefundAfterMaturityWithReverseReplayOfRepayments() {
+ try {
+ GlobalConfigurationHelper.updateIsAutomaticExternalIdGenerationEnabled(this.requestSpec, this.responseSpec, true);
+ GlobalConfigurationHelper.updateIsBusinessDateEnabled(this.requestSpec, this.responseSpec, true);
+ businessDateHelper.updateBusinessDate(new BusinessDateRequest().type(BusinessDateType.BUSINESS_DATE.getName())
+ .date("2022.10.10").dateFormat("yyyy.MM.dd").locale("en"));
+
+ final Account assetAccount = this.accountHelper.createAssetAccount();
+ final Account incomeAccount = this.accountHelper.createIncomeAccount();
+ final Account expenseAccount = this.accountHelper.createExpenseAccount();
+ final Account overpaymentAccount = this.accountHelper.createLiabilityAccount();
+
+ final Integer loanProductID = createLoanProductWithPeriodicAccrualAccountingNoInterest(assetAccount, incomeAccount,
+ expenseAccount, overpaymentAccount);
+
+ final Integer clientID = ClientHelper.createClient(requestSpec, responseSpec, "01 January 2011");
+
+ final Integer loanID = applyForLoanApplication(clientID, loanProductID);
+
+ HashMap<String, Object> loanStatusHashMap = LoanStatusChecker.getStatusOfLoan(requestSpec, responseSpec, loanID);
+ LoanStatusChecker.verifyLoanIsPending(loanStatusHashMap);
+
+ loanStatusHashMap = this.loanTransactionHelper.approveLoan("02 September 2022", loanID);
+ LoanStatusChecker.verifyLoanIsApproved(loanStatusHashMap);
+ LoanStatusChecker.verifyLoanIsWaitingForDisbursal(loanStatusHashMap);
+
+ loanStatusHashMap = this.loanTransactionHelper.disburseLoanWithNetDisbursalAmount("03 September 2022", loanID, "1000");
+ LoanStatusChecker.verifyLoanIsActive(loanStatusHashMap);
+
+ this.loanTransactionHelper.makeRepayment("04 September 2022", Float.parseFloat("100"), loanID);
+ this.loanTransactionHelper.makeRepayment("05 September 2022", Float.parseFloat("1100"), loanID);
+
+ GetLoansLoanIdResponse loanDetails = this.loanTransactionHelper.getLoanDetails((long) loanID);
+ assertEquals(200.0, loanDetails.getTotalOverpaid());
+ assertTrue(loanDetails.getStatus().getOverpaid());
+
+ this.loanTransactionHelper.makeCreditBalanceRefund((long) loanID, new PostLoansLoanIdTransactionsRequest()
+ .transactionAmount(200.0).transactionDate("10 October 2022").dateFormat("dd MMMM yyyy").locale("en"));
+
+ loanDetails = this.loanTransactionHelper.getLoanDetails((long) loanID);
+ assertTrue(loanDetails.getStatus().getClosedObligationsMet());
+
+ assertEquals(2, loanDetails.getRepaymentSchedule().getPeriods().size());
+ assertEquals(1000, loanDetails.getRepaymentSchedule().getPeriods().get(1).getPrincipalDue());
+
+ assertEquals(100.0, loanDetails.getTransactions().get(1).getAmount());
+ assertEquals(100.0, loanDetails.getTransactions().get(1).getPrincipalPortion());
+ assertEquals(LocalDate.of(2022, 9, 4), loanDetails.getTransactions().get(1).getDate());
+ assertEquals(900.0, loanDetails.getTransactions().get(1).getOutstandingLoanBalance());
+ assertEquals(1100.0, loanDetails.getTransactions().get(2).getAmount());
+ assertEquals(900.0, loanDetails.getTransactions().get(2).getPrincipalPortion());
+ assertEquals(200.0, loanDetails.getTransactions().get(2).getOverpaymentPortion());
+ assertEquals(LocalDate.of(2022, 9, 5), loanDetails.getTransactions().get(2).getDate());
+ assertEquals(0.0, loanDetails.getTransactions().get(2).getOutstandingLoanBalance());
+ assertEquals(200.0, loanDetails.getTransactions().get(3).getAmount());
+ assertEquals(200.0, loanDetails.getTransactions().get(3).getOverpaymentPortion());
+ assertEquals(LocalDate.of(2022, 10, 10), loanDetails.getTransactions().get(3).getDate());
+ assertEquals(0.0, loanDetails.getTransactions().get(3).getOutstandingLoanBalance());
+
+ this.loanTransactionHelper.reverseLoanTransaction(loanDetails.getId(), loanDetails.getTransactions().get(1).getId(),
+ new PostLoansLoanIdTransactionsTransactionIdRequest().dateFormat("dd MMMM yyyy").transactionAmount(0.0)
+ .transactionDate("10 October 2022").locale("en"));
+
+ loanDetails = this.loanTransactionHelper.getLoanDetails((long) loanID);
+
+ assertEquals(100.0, loanDetails.getTransactions().get(1).getAmount());
+ assertEquals(100.0, loanDetails.getTransactions().get(1).getPrincipalPortion());
+ assertEquals(LocalDate.of(2022, 9, 4), loanDetails.getTransactions().get(1).getDate());
+ assertTrue(loanDetails.getTransactions().get(1).getManuallyReversed());
+
+ assertEquals(1100.0, loanDetails.getTransactions().get(2).getAmount());
+ assertEquals(1000.0, loanDetails.getTransactions().get(2).getPrincipalPortion());
+ assertEquals(100.0, loanDetails.getTransactions().get(2).getOverpaymentPortion());
+ assertEquals(LocalDate.of(2022, 9, 5), loanDetails.getTransactions().get(2).getDate());
+ assertEquals(0.0, loanDetails.getTransactions().get(2).getOutstandingLoanBalance());
+ assertEquals(1, loanDetails.getTransactions().get(2).getTransactionRelations().size());
+
+ assertEquals(200.0, loanDetails.getTransactions().get(3).getAmount());
+ assertEquals(100.0, loanDetails.getTransactions().get(3).getPrincipalPortion());
+ assertEquals(100.0, loanDetails.getTransactions().get(3).getOverpaymentPortion());
+ assertEquals(100.0, loanDetails.getTransactions().get(3).getOutstandingLoanBalance());
+ assertEquals(LocalDate.of(2022, 10, 10), loanDetails.getTransactions().get(3).getDate());
+ assertEquals(1, loanDetails.getTransactions().get(3).getTransactionRelations().size());
+
+ assertTrue(loanDetails.getStatus().getActive());
+
+ assertEquals(3, loanDetails.getRepaymentSchedule().getPeriods().size());
+ assertEquals(1000, loanDetails.getRepaymentSchedule().getPeriods().get(1).getPrincipalDue());
+ assertTrue(loanDetails.getRepaymentSchedule().getPeriods().get(1).getComplete());
+ assertEquals(200, loanDetails.getRepaymentSchedule().getPeriods().get(2).getPrincipalDue());
+ assertFalse(loanDetails.getRepaymentSchedule().getPeriods().get(2).getComplete());
+ assertEquals(100.0, loanDetails.getRepaymentSchedule().getPeriods().get(2).getPrincipalPaid());
+ assertEquals(100.0, loanDetails.getRepaymentSchedule().getPeriods().get(2).getPrincipalOutstanding());
+
+ } finally {
+ GlobalConfigurationHelper.updateIsAutomaticExternalIdGenerationEnabled(this.requestSpec, this.responseSpec, false);
+ GlobalConfigurationHelper.updateIsBusinessDateEnabled(this.requestSpec, this.responseSpec, false);
+ }
+ }
+
+ @Test
+ public void testCreditBalanceRefundBeforeMaturityWithReverseReplayOfRepaymentsAndRefund() {
+ try {
+ GlobalConfigurationHelper.updateIsAutomaticExternalIdGenerationEnabled(this.requestSpec, this.responseSpec, true);
+ GlobalConfigurationHelper.updateIsBusinessDateEnabled(this.requestSpec, this.responseSpec, true);
+ businessDateHelper.updateBusinessDate(new BusinessDateRequest().type(BusinessDateType.BUSINESS_DATE.getName())
+ .date("2022.10.10").dateFormat("yyyy.MM.dd").locale("en"));
+
+ final Account assetAccount = this.accountHelper.createAssetAccount();
+ final Account incomeAccount = this.accountHelper.createIncomeAccount();
+ final Account expenseAccount = this.accountHelper.createExpenseAccount();
+ final Account overpaymentAccount = this.accountHelper.createLiabilityAccount();
+
+ final Integer loanProductID = createLoanProductWithPeriodicAccrualAccountingNoInterest(assetAccount, incomeAccount,
+ expenseAccount, overpaymentAccount);
+
+ final Integer clientID = ClientHelper.createClient(requestSpec, responseSpec, "01 January 2011");
+
+ final Integer loanID = applyForLoanApplication(clientID, loanProductID);
+
+ HashMap<String, Object> loanStatusHashMap = LoanStatusChecker.getStatusOfLoan(requestSpec, responseSpec, loanID);
+ LoanStatusChecker.verifyLoanIsPending(loanStatusHashMap);
+
+ loanStatusHashMap = this.loanTransactionHelper.approveLoan("02 September 2022", loanID);
+ LoanStatusChecker.verifyLoanIsApproved(loanStatusHashMap);
+ LoanStatusChecker.verifyLoanIsWaitingForDisbursal(loanStatusHashMap);
+
+ loanStatusHashMap = this.loanTransactionHelper.disburseLoanWithNetDisbursalAmount("03 September 2022", loanID, "1000");
+ LoanStatusChecker.verifyLoanIsActive(loanStatusHashMap);
+
+ this.loanTransactionHelper.makeRepayment("04 September 2022", Float.parseFloat("500"), loanID);
+ this.loanTransactionHelper.makeRepayment("05 September 2022", Float.parseFloat("700"), loanID);
+
+ GetLoansLoanIdResponse loanDetails = this.loanTransactionHelper.getLoanDetails((long) loanID);
+ assertEquals(200.0, loanDetails.getTotalOverpaid());
+ assertTrue(loanDetails.getStatus().getOverpaid());
+
+ this.loanTransactionHelper.makeCreditBalanceRefund((long) loanID, new PostLoansLoanIdTransactionsRequest()
+ .transactionAmount(200.0).transactionDate("06 September 2022").dateFormat("dd MMMM yyyy").locale("en"));
+
+ this.loanTransactionHelper.makeMerchantIssuedRefund((long) loanID, new PostLoansLoanIdTransactionsRequest().locale("en")
+ .dateFormat("dd MMMM yyyy").transactionDate("07 September 2022").transactionAmount(500.0));
+
+ this.loanTransactionHelper.makeCreditBalanceRefund((long) loanID, new PostLoansLoanIdTransactionsRequest()
+ .transactionAmount(500.0).transactionDate("08 September 2022").dateFormat("dd MMMM yyyy").locale("en"));
+
+ loanDetails = this.loanTransactionHelper.getLoanDetails((long) loanID);
+ assertTrue(loanDetails.getStatus().getClosedObligationsMet());
+
+ assertEquals(2, loanDetails.getRepaymentSchedule().getPeriods().size());
+ assertEquals(1000, loanDetails.getRepaymentSchedule().getPeriods().get(1).getPrincipalDue());
+
+ assertEquals(500.0, loanDetails.getTransactions().get(1).getAmount());
+ assertEquals(500.0, loanDetails.getTransactions().get(1).getPrincipalPortion());
+ assertEquals(LocalDate.of(2022, 9, 4), loanDetails.getTransactions().get(1).getDate());
+ assertEquals(500.0, loanDetails.getTransactions().get(1).getOutstandingLoanBalance());
+
+ assertEquals(700.0, loanDetails.getTransactions().get(2).getAmount());
+ assertEquals(500.0, loanDetails.getTransactions().get(2).getPrincipalPortion());
+ assertEquals(200.0, loanDetails.getTransactions().get(2).getOverpaymentPortion());
+ assertEquals(LocalDate.of(2022, 9, 5), loanDetails.getTransactions().get(2).getDate());
+ assertEquals(0.0, loanDetails.getTransactions().get(2).getOutstandingLoanBalance());
+
+ assertEquals(200.0, loanDetails.getTransactions().get(3).getAmount());
+ assertEquals(200.0, loanDetails.getTransactions().get(3).getOverpaymentPortion());
+ assertEquals(LocalDate.of(2022, 9, 6), loanDetails.getTransactions().get(3).getDate());
+ assertEquals(0.0, loanDetails.getTransactions().get(3).getOutstandingLoanBalance());
+
+ assertEquals(500.0, loanDetails.getTransactions().get(4).getAmount());
+ assertEquals(500.0, loanDetails.getTransactions().get(4).getOverpaymentPortion());
+ assertEquals(LocalDate.of(2022, 9, 7), loanDetails.getTransactions().get(4).getDate());
+ assertEquals(0.0, loanDetails.getTransactions().get(4).getOutstandingLoanBalance());
+
+ assertEquals(500.0, loanDetails.getTransactions().get(5).getAmount());
+ assertEquals(500.0, loanDetails.getTransactions().get(5).getOverpaymentPortion());
+ assertEquals(LocalDate.of(2022, 9, 8), loanDetails.getTransactions().get(5).getDate());
+ assertEquals(0.0, loanDetails.getTransactions().get(5).getOutstandingLoanBalance());
+
+ this.loanTransactionHelper.reverseLoanTransaction(loanDetails.getId(), loanDetails.getTransactions().get(2).getId(),
+ new PostLoansLoanIdTransactionsTransactionIdRequest().dateFormat("dd MMMM yyyy").transactionAmount(0.0)
+ .transactionDate("07 September 2022").locale("en"));
+
+ loanDetails = this.loanTransactionHelper.getLoanDetails((long) loanID);
+
+ assertEquals(500.0, loanDetails.getTransactions().get(1).getAmount());
+ assertEquals(500.0, loanDetails.getTransactions().get(1).getPrincipalPortion());
+ assertEquals(LocalDate.of(2022, 9, 4), loanDetails.getTransactions().get(1).getDate());
+ assertEquals(500.0, loanDetails.getTransactions().get(1).getOutstandingLoanBalance());
+
+ assertEquals(700.0, loanDetails.getTransactions().get(2).getAmount());
+ assertEquals(500.0, loanDetails.getTransactions().get(2).getPrincipalPortion());
+ assertEquals(200.0, loanDetails.getTransactions().get(2).getOverpaymentPortion());
+ assertEquals(LocalDate.of(2022, 9, 5), loanDetails.getTransactions().get(2).getDate());
+ assertEquals(0.0, loanDetails.getTransactions().get(2).getOutstandingLoanBalance());
+ assertTrue(loanDetails.getTransactions().get(2).getManuallyReversed());
+
+ assertEquals(200.0, loanDetails.getTransactions().get(3).getAmount());
+ assertEquals(200.0, loanDetails.getTransactions().get(3).getPrincipalPortion());
+ assertEquals(LocalDate.of(2022, 9, 6), loanDetails.getTransactions().get(3).getDate());
+ assertEquals(700.0, loanDetails.getTransactions().get(3).getOutstandingLoanBalance());
+ assertEquals(1, loanDetails.getTransactions().get(3).getTransactionRelations().size());
+
+ assertEquals(500.0, loanDetails.getTransactions().get(4).getAmount());
+ assertEquals(500.0, loanDetails.getTransactions().get(4).getPrincipalPortion());
+ assertEquals(LocalDate.of(2022, 9, 7), loanDetails.getTransactions().get(4).getDate());
+ assertEquals(200.0, loanDetails.getTransactions().get(4).getOutstandingLoanBalance());
+ assertEquals(1, loanDetails.getTransactions().get(4).getTransactionRelations().size());
+
+ assertEquals(500.0, loanDetails.getTransactions().get(5).getAmount());
+ assertEquals(500.0, loanDetails.getTransactions().get(5).getPrincipalPortion());
+ assertEquals(LocalDate.of(2022, 9, 8), loanDetails.getTransactions().get(5).getDate());
+ assertEquals(700.0, loanDetails.getTransactions().get(5).getOutstandingLoanBalance());
+ assertEquals(1, loanDetails.getTransactions().get(5).getTransactionRelations().size());
+
+ assertTrue(loanDetails.getStatus().getActive());
+
+ assertEquals(2, loanDetails.getRepaymentSchedule().getPeriods().size());
+ assertEquals(1700, loanDetails.getRepaymentSchedule().getPeriods().get(1).getPrincipalDue());
+ assertFalse(loanDetails.getRepaymentSchedule().getPeriods().get(1).getComplete());
+ assertEquals(1000.0, loanDetails.getRepaymentSchedule().getPeriods().get(1).getPrincipalPaid());
+ assertEquals(700.0, loanDetails.getRepaymentSchedule().getPeriods().get(1).getPrincipalOutstanding());
+
+ } finally {
+ GlobalConfigurationHelper.updateIsAutomaticExternalIdGenerationEnabled(this.requestSpec, this.responseSpec, false);
+ GlobalConfigurationHelper.updateIsBusinessDateEnabled(this.requestSpec, this.responseSpec, false);
+ }
+ }
+
private Integer applyForLoanApplication(final Integer clientID, final Integer loanProductID) {
LOG.info("--------------------------------APPLYING FOR LOAN APPLICATION--------------------------------");
final String loanApplicationJSON = new LoanApplicationTestBuilder().withPrincipal("1000").withLoanTermFrequency("1")