Fix Loan Delinquency Classification after Repayment

2022-11-21 13:49:45 +01:00
parent 36a81580be
commit 4f9f71da9b
14 changed files with 531 additions and 258 deletions
@@ -18,15 +18,10 @@
 */
 package org.apache.fineract.portfolio.delinquency.service;

-import java.math.BigDecimal;
-import java.time.LocalDate;
 import java.util.Collection;
 import java.util.List;
 import java.util.Optional;
-import java.util.Set;
 import lombok.RequiredArgsConstructor;
-import org.apache.fineract.infrastructure.core.service.DateUtils;
-import org.apache.fineract.organisation.monetary.domain.MonetaryCurrency;
 import org.apache.fineract.portfolio.delinquency.data.DelinquencyBucketData;
 import org.apache.fineract.portfolio.delinquency.data.DelinquencyRangeData;
 import org.apache.fineract.portfolio.delinquency.data.LoanDelinquencyTagHistoryData;
@@ -41,11 +36,8 @@ import org.apache.fineract.portfolio.delinquency.mapper.DelinquencyRangeMapper;
 import org.apache.fineract.portfolio.delinquency.mapper.LoanDelinquencyTagMapper;
 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.LoanRepository;
 import org.apache.fineract.portfolio.loanaccount.domain.LoanTransaction;
-import org.apache.fineract.portfolio.loanaccount.domain.LoanTransactionToRepaymentScheduleMapping;
-import org.apache.fineract.portfolio.loanaccount.domain.LoanTransactionType;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;

@@ -61,6 +53,7 @@ public class DelinquencyReadPlatformServiceImpl implements DelinquencyReadPlatfo
    private final DelinquencyBucketMapper mapperBucket;
    private final LoanDelinquencyTagMapper mapperLoanDelinquencyTagHistory;
    private final LoanRepository loanRepository;
+    private final LoanDelinquencyDomainService loanDelinquencyDomainService;

    @Override
    public Collection<DelinquencyRangeData> retrieveAllDelinquencyRanges() {
@@ -109,89 +102,21 @@ public class DelinquencyReadPlatformServiceImpl implements DelinquencyReadPlatfo

    @Override
    public CollectionData calculateLoanCollectionData(final Long loanId) {
-        final LocalDate businessDate = DateUtils.getBusinessLocalDate();
        final Optional<Loan> optLoan = this.loanRepository.findById(loanId);

        CollectionData collectionData = CollectionData.template();
        if (optLoan.isPresent()) {
            final Loan loan = optLoan.get();

+            collectionData = loanDelinquencyDomainService.getOverdueCollectionData(loan);
            collectionData.setAvailableDisbursementAmount(loan.getApprovedPrincipal().subtract(loan.getDisbursedAmount()));
            collectionData.setNextPaymentDueDate(loan.possibleNextRepaymentDate());

-            final MonetaryCurrency currency = loan.getCurrency();
-            BigDecimal delinquentAmount = BigDecimal.ZERO;
-            // Overdue Days calculation
-            Long overdueDays = 0L;
-            LocalDate overdueSinceDate = null;
-            final List<LoanTransaction> chargebackTransactions = loan.retrieveListOfTransactionsByType(LoanTransactionType.CHARGEBACK);
-            for (LoanTransaction loanTransaction : chargebackTransactions) {
-                Set<LoanTransactionToRepaymentScheduleMapping> loanTransactionToRepaymentScheduleMappings = loanTransaction
-                        .getLoanTransactionToRepaymentScheduleMappings();
-                LoanTransactionToRepaymentScheduleMapping loanTransactionToRepaymentScheduleMapping = loanTransactionToRepaymentScheduleMappings
-                        .iterator().next();
-                if (!loanTransactionToRepaymentScheduleMapping.getLoanRepaymentScheduleInstallment().isPrincipalCompleted(currency)) {
-                    overdueSinceDate = loanTransaction.getTransactionDate();
-                    break;
-                }
-            }
-
-            final List<LoanRepaymentScheduleInstallment> installments = loan.getRepaymentScheduleInstallments();
-            if (overdueSinceDate == null) {
-                for (LoanRepaymentScheduleInstallment installment : installments) {
-                    if (installment.isNotFullyPaidOff()) {
-                        overdueSinceDate = installment.getDueDate();
-                        break;
-                    }
-                }
-            }
-
-            Integer graceDays = 0;
-            if (overdueSinceDate != null) {
-                if (loan.loanProduct().getLoanProductConfigurableAttributes().getGraceOnArrearsAgingBoolean()) {
-                    graceDays = loan.loanProduct().getLoanProductRelatedDetail().getGraceOnArrearsAgeing();
-                    if (graceDays == null) {
-                        graceDays = 0;
-                    }
-                    overdueSinceDate = overdueSinceDate.plusDays(graceDays);
-                }
-                overdueDays = DateUtils.getDifferenceInDays(overdueSinceDate, businessDate);
-                if (overdueDays < 0) {
-                    overdueDays = 0L;
-                }
-                collectionData.setDelinquentDate(overdueSinceDate);
-            }
-
-            collectionData.setPastDueDays(overdueDays);
-            if (overdueDays > 0) {
-                collectionData.setDelinquentDays(overdueDays - graceDays);
-            }
-
            final LoanTransaction lastRepaymenTransaction = loan.getLastRepaymentTransaction();
            if (lastRepaymenTransaction != null) {
                collectionData.setLastPaymentDate(lastRepaymenTransaction.getTransactionDate());
                collectionData.setLastPaymentAmount(lastRepaymenTransaction.getAmount());
            }
-
-            // Calculate Delinquency Amount
-            for (LoanRepaymentScheduleInstallment installment : installments) {
-                if (installment.getDueDate().isBefore(businessDate)) {
-                    delinquentAmount = delinquentAmount.add(installment.getTotalOutstanding(currency).getAmount());
-                }
-            }
-            for (LoanTransaction loanTransaction : chargebackTransactions) {
-                Set<LoanTransactionToRepaymentScheduleMapping> loanTransactionToRepaymentScheduleMappings = loanTransaction
-                        .getLoanTransactionToRepaymentScheduleMappings();
-                for (LoanTransactionToRepaymentScheduleMapping loanTransactionToRepaymentScheduleMapping : loanTransactionToRepaymentScheduleMappings) {
-                    LoanRepaymentScheduleInstallment loanRepaymentScheduleInstallment = loanTransactionToRepaymentScheduleMapping
-                            .getLoanRepaymentScheduleInstallment();
-                    if (!loanRepaymentScheduleInstallment.isPrincipalCompleted(currency)) {
-                        delinquentAmount = delinquentAmount.add(loanTransaction.getAmount());
-                    }
-                }
-            }
-
-            collectionData.setDelinquentAmount(delinquentAmount);
        }

        return collectionData;
@@ -18,7 +18,6 @@
 */
 package org.apache.fineract.portfolio.delinquency.service;

-import java.time.LocalDate;
 import org.apache.fineract.infrastructure.core.api.JsonCommand;
 import org.apache.fineract.infrastructure.core.data.CommandProcessingResult;
 import org.apache.fineract.portfolio.loanaccount.data.LoanScheduleDelinquencyData;
@@ -48,6 +47,4 @@ public interface DelinquencyWritePlatformService {

    void applyDelinquencyTagToLoan(LoanScheduleDelinquencyData loanDelinquencyData);

-    LocalDate getOverdueSinceDate(Loan loan, LocalDate businessDate, Integer graceOnArrearAgeing);
-
 }
@@ -35,7 +35,6 @@ import org.apache.fineract.infrastructure.core.exception.PlatformDataIntegrityEx
 import org.apache.fineract.infrastructure.core.service.DateUtils;
 import org.apache.fineract.infrastructure.event.business.domain.loan.LoanDelinquencyRangeChangeBusinessEvent;
 import org.apache.fineract.infrastructure.event.business.service.BusinessEventNotifierService;
-import org.apache.fineract.organisation.monetary.domain.MonetaryCurrency;
 import org.apache.fineract.portfolio.delinquency.api.DelinquencyApiConstants;
 import org.apache.fineract.portfolio.delinquency.data.DelinquencyBucketData;
 import org.apache.fineract.portfolio.delinquency.data.DelinquencyRangeData;
@@ -51,13 +50,10 @@ import org.apache.fineract.portfolio.delinquency.exception.DelinquencyBucketAges
 import org.apache.fineract.portfolio.delinquency.exception.DelinquencyRangeInvalidAgesException;
 import org.apache.fineract.portfolio.delinquency.validator.DelinquencyBucketParseAndValidator;
 import org.apache.fineract.portfolio.delinquency.validator.DelinquencyRangeParseAndValidator;
+import org.apache.fineract.portfolio.loanaccount.data.CollectionData;
 import org.apache.fineract.portfolio.loanaccount.data.LoanScheduleDelinquencyData;
 import org.apache.fineract.portfolio.loanaccount.domain.Loan;
-import org.apache.fineract.portfolio.loanaccount.domain.LoanRepaymentScheduleInstallment;
 import org.apache.fineract.portfolio.loanaccount.domain.LoanRepositoryWrapper;
-import org.apache.fineract.portfolio.loanaccount.domain.LoanTransaction;
-import org.apache.fineract.portfolio.loanaccount.domain.LoanTransactionToRepaymentScheduleMapping;
-import org.apache.fineract.portfolio.loanaccount.domain.LoanTransactionType;
 import org.apache.fineract.portfolio.loanproduct.domain.LoanProductRepository;
 import org.springframework.stereotype.Service;

@@ -76,6 +72,7 @@ public class DelinquencyWritePlatformServiceImpl implements DelinquencyWritePlat
    private final LoanRepositoryWrapper loanRepository;
    private final LoanProductRepository loanProductRepository;
    private final BusinessEventNotifierService businessEventNotifierService;
+    private final LoanDelinquencyDomainService loanDelinquencyDomainService;

    @Override
    public CommandProcessingResult createDelinquencyRange(JsonCommand command) {
@@ -147,66 +144,13 @@ public class DelinquencyWritePlatformServiceImpl implements DelinquencyWritePlat

    @Override
    public LoanScheduleDelinquencyData calculateDelinquencyData(LoanScheduleDelinquencyData loanScheduleDelinquencyData) {
-        final LocalDate businessDate = DateUtils.getBusinessLocalDate();
        Loan loan = loanScheduleDelinquencyData.getLoan();
        if (loan == null) {
            loan = this.loanRepository.findOneWithNotFoundDetection(loanScheduleDelinquencyData.getLoanId());
        }
-
-        final Integer graceOnArrearAgeing = loan.getLoanProduct().getLoanProductRelatedDetail().getGraceOnArrearsAgeing();
-        final LocalDate overdueSinceDate = getOverdueSinceDate(loan, businessDate, graceOnArrearAgeing);
-        final Long overdueDays = calculateOverdueDays(businessDate, overdueSinceDate);
-        return new LoanScheduleDelinquencyData(loan.getId(), overdueSinceDate, overdueDays, loan);
-    }
-
-    @Override
-    public LocalDate getOverdueSinceDate(final Loan loan, final LocalDate businessDate, final Integer graceOnArrearAgeing) {
-        LoanRepaymentScheduleInstallment loanRepaymentSchedule = null;
-        for (LoanRepaymentScheduleInstallment installment : loan.getRepaymentScheduleInstallments()) {
-            if (installment.getDueDate().isBefore(businessDate) && installment.isNotFullyPaidOff()) {
-                loanRepaymentSchedule = installment;
-                break;
-            }
-        }
-
-        LocalDate overdueSinceDate = null;
-        final MonetaryCurrency loanCurrency = loan.getCurrency();
-        final List<LoanTransaction> loanTransactions = loan.retrieveListOfTransactionsByType(LoanTransactionType.CHARGEBACK);
-        if (loanRepaymentSchedule != null) {
-            // Default Due date
-            overdueSinceDate = loanRepaymentSchedule.getDueDate();
-        }
-
-        // If there is some Loan Transaction Chargeback
-        for (LoanTransaction loanTransaction : loanTransactions) {
-            if (loanTransaction.getLoanTransactionToRepaymentScheduleMappings().iterator().hasNext()) {
-                final LoanTransactionToRepaymentScheduleMapping transactionMapping = loanTransaction
-                        .getLoanTransactionToRepaymentScheduleMappings().iterator().next();
-
-                if (transactionMapping != null
-                        && !transactionMapping.getLoanRepaymentScheduleInstallment().isPrincipalCompleted(loanCurrency)) {
-                    overdueSinceDate = loanTransaction.getTransactionDate();
-                    break;
-                }
-            }
-        }
-
-        // Include grace days If It's defined
-        if (overdueSinceDate != null && graceOnArrearAgeing != null) {
-            overdueSinceDate = overdueSinceDate.plusDays(graceOnArrearAgeing.longValue());
-        }
-        return overdueSinceDate;
-    }
-
-    private Long calculateOverdueDays(final LocalDate businessDate, LocalDate overdueSinceDate) {
-        Long overdueDays = 0L;
-        if (overdueSinceDate != null) {
-            overdueDays = DateUtils.getDifferenceInDays(overdueSinceDate, businessDate);
-            if (overdueDays < 0) {
-                overdueDays = 0L;
-            }
-        }
-        return overdueDays;
+        final CollectionData collectionData = loanDelinquencyDomainService.getOverdueCollectionData(loan);
+        log.debug("Delinquency {}", collectionData);
+        return new LoanScheduleDelinquencyData(loan.getId(), collectionData.getDelinquentDate(), collectionData.getDelinquentDays(), loan);
    }

    @Override
@@ -216,13 +160,8 @@ public class DelinquencyWritePlatformServiceImpl implements DelinquencyWritePlat
        final Loan loan = this.loanRepository.findOneWithNotFoundDetection(loanId);
        final DelinquencyBucket delinquencyBucket = loan.getLoanProduct().getDelinquencyBucket();
        if (delinquencyBucket != null) {
-            final LocalDate businessDate = DateUtils.getBusinessLocalDate();
-
-            final Integer graceOnArrearAgeing = loan.getLoanProduct().getLoanProductRelatedDetail().getGraceOnArrearsAgeing();
-            final LocalDate overdueSinceDate = getOverdueSinceDate(loan, businessDate, graceOnArrearAgeing);
-
-            final Long overdueDays = calculateOverdueDays(businessDate, overdueSinceDate);
-            changes = lookUpDelinquencyRange(loan, delinquencyBucket, overdueDays);
+            final CollectionData collectionData = loanDelinquencyDomainService.getOverdueCollectionData(loan);
+            changes = lookUpDelinquencyRange(loan, delinquencyBucket, collectionData.getDelinquentDays());
        }
        return new CommandProcessingResultBuilder().withCommandId(command.commandId()).withEntityId(loan.getId()).with(changes).build();
    }
@@ -231,17 +170,10 @@ public class DelinquencyWritePlatformServiceImpl implements DelinquencyWritePlat
    public void applyDelinquencyTagToLoan(LoanScheduleDelinquencyData loanDelinquencyData) {
        final Loan loan = loanDelinquencyData.getLoan();
        if (loan.hasDelinquencyBucket()) {
-            final LocalDate businessDate = DateUtils.getBusinessLocalDate();
            final DelinquencyBucket delinquencyBucket = loan.getLoanProduct().getDelinquencyBucket();
-            final Integer graceOnArrearAgeing = loan.getLoanProduct().getLoanProductRelatedDetail().getGraceOnArrearsAgeing();
-
-            LocalDate overdueSinceDate = loanDelinquencyData.getOverdueSinceDate();
-            if (overdueSinceDate == null) {
-                getOverdueSinceDate(loan, businessDate, graceOnArrearAgeing);
-            }
-
-            final Long overdueDays = calculateOverdueDays(businessDate, overdueSinceDate);
-            lookUpDelinquencyRange(loan, delinquencyBucket, overdueDays);
+            final CollectionData collectionData = loanDelinquencyDomainService.getOverdueCollectionData(loan);
+            log.debug("Delinquency {}", collectionData);
+            lookUpDelinquencyRange(loan, delinquencyBucket, collectionData.getDelinquentDays());
        }
    }

@@ -0,0 +1,34 @@
+/**
+ * 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.delinquency.service;
+
+import org.apache.fineract.portfolio.loanaccount.data.CollectionData;
+import org.apache.fineract.portfolio.loanaccount.domain.Loan;
+
+public interface LoanDelinquencyDomainService {
+
+    /**
+     * This method is to calculate the Overdue date and other properties, If the loan is overdue or If there is some
+     * Charge back transaction
+     *
+     * @param loan
+     */
+    CollectionData getOverdueCollectionData(Loan loan);
+
+}
@@ -0,0 +1,136 @@
+/**
+ * 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.delinquency.service;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import javax.transaction.Transactional;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.fineract.infrastructure.core.service.DateUtils;
+import org.apache.fineract.organisation.monetary.domain.MonetaryCurrency;
+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;
+
+@Slf4j
+@Service
+public class LoanDelinquencyDomainServiceImpl implements LoanDelinquencyDomainService {
+
+    @Override
+    @Transactional
+    public CollectionData getOverdueCollectionData(final Loan loan) {
+        final LocalDate businessDate = DateUtils.getBusinessLocalDate();
+
+        final MonetaryCurrency loanCurrency = loan.getCurrency();
+        LocalDate overdueSinceDate = null;
+        CollectionData collectionData = CollectionData.template();
+        BigDecimal amountAvailable = BigDecimal.ZERO;
+        BigDecimal outstandingAmount = BigDecimal.ZERO;
+        boolean oldestOverdueInstallment = false;
+        boolean overdueSinceDateWasSet = false;
+        boolean firstNotYetDueInstallment = false;
+
+        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());
+                    outstandingAmount = outstandingAmount.add(installment.getTotalOutstanding(loanCurrency).getAmount());
+                    if (!oldestOverdueInstallment) {
+                        log.debug("Oldest installment {} {}", installment.getInstallmentNumber(), installment.getDueDate());
+                        oldestOverdueInstallment = true;
+                        overdueSinceDate = installment.getDueDate();
+                        overdueSinceDateWasSet = true;
+
+                        amountAvailable = installment.getTotalPaid(loanCurrency).getAmount();
+
+                        for (LoanTransactionToRepaymentScheduleMapping mappingInstallment : installment
+                                .getLoanTransactionToRepaymentScheduleMappings()) {
+                            final LoanTransaction loanTransaction = mappingInstallment.getLoanTransaction();
+                            if (loanTransaction.isChargeback()) {
+                                amountAvailable = amountAvailable.subtract(loanTransaction.getAmount());
+                                if (amountAvailable.compareTo(BigDecimal.ZERO) < 0) {
+                                    overdueSinceDate = loanTransaction.getTransactionDate();
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+            } 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;
+                        }
+                    }
+                }
+
+                if (amountAvailable.compareTo(BigDecimal.ZERO) < 0) {
+                    outstandingAmount = outstandingAmount.add(amountAvailable.abs());
+                }
+            }
+        }
+
+        Integer graceDays = 0;
+        if (loan.getLoanProduct().getLoanProductRelatedDetail().getGraceOnArrearsAgeing() != null) {
+            graceDays = loan.getLoanProduct().getLoanProductRelatedDetail().getGraceOnArrearsAgeing();
+            if (graceDays == null) {
+                graceDays = 0;
+            }
+        }
+        log.debug("Loan id {} with overdue since date {} and outstanding amount {}", loan.getId(), overdueSinceDate, outstandingAmount);
+
+        Long overdueDays = 0L;
+        if (overdueSinceDate != null) {
+            overdueSinceDate = overdueSinceDate.plusDays(graceDays.longValue());
+            collectionData.setDelinquentDate(overdueSinceDate);
+            overdueDays = DateUtils.getDifferenceInDays(overdueSinceDate, businessDate);
+            if (overdueDays < 0) {
+                overdueDays = 0L;
+            }
+            collectionData.setPastDueDays(overdueDays);
+        }
+        collectionData.setDelinquentAmount(outstandingAmount);
+
+        if (overdueDays > 0) {
+            collectionData.setDelinquentDays(overdueDays - graceDays);
+        }
+        log.debug("Result: {}", collectionData.toString());
+        return collectionData;
+    }
+
+}
@@ -23,8 +23,10 @@ import java.time.LocalDate;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.Setter;
+import lombok.ToString;

@AllArgsConstructor
+@ToString
@Getter
@Setter
 public final class CollectionData {
@@ -140,6 +140,9 @@ public class LoanRepaymentScheduleInstallment extends AbstractAuditableWithUTCDa
    @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.LAZY, mappedBy = "installment")
    private Set<LoanInstallmentCharge> installmentCharges = new HashSet<>();

+    @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.LAZY, mappedBy = "installment")
+    private Set<LoanTransactionToRepaymentScheduleMapping> loanTransactionToRepaymentScheduleMappings = new HashSet<>();
+
    public LoanRepaymentScheduleInstallment() {
        this.installmentNumber = null;
        this.fromDate = null;
@@ -894,4 +897,8 @@ public class LoanRepaymentScheduleInstallment extends AbstractAuditableWithUTCDa
        return (this.installmentNumber == 1);
    }

+    public Set<LoanTransactionToRepaymentScheduleMapping> getLoanTransactionToRepaymentScheduleMappings() {
+        return this.loanTransactionToRepaymentScheduleMappings;
+    }
+
 }