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;
+    }
+
 }
@@ -21,11 +21,11 @@ package org.apache.fineract.portfolio.deliquency;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyIterable;
-import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;

+import java.math.BigDecimal;
 import java.time.LocalDate;
 import java.time.ZoneId;
 import java.util.Arrays;
@@ -46,13 +46,14 @@ import org.apache.fineract.portfolio.delinquency.domain.DelinquencyRange;
 import org.apache.fineract.portfolio.delinquency.domain.DelinquencyRangeRepository;
 import org.apache.fineract.portfolio.delinquency.domain.LoanDelinquencyTagHistoryRepository;
 import org.apache.fineract.portfolio.delinquency.service.DelinquencyWritePlatformServiceImpl;
+import org.apache.fineract.portfolio.delinquency.service.LoanDelinquencyDomainService;
 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.LoanRepositoryWrapper;
 import org.apache.fineract.portfolio.loanproduct.domain.LoanProduct;
-import org.apache.fineract.portfolio.loanproduct.domain.LoanProductRelatedDetail;
 import org.apache.fineract.portfolio.loanproduct.domain.LoanProductRepository;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -84,6 +85,8 @@ public class DelinquencyWritePlatformServiceRangeChangeEventTest {
    private LoanProductRepository loanProductRepository;
    @Mock
    private BusinessEventNotifierService businessEventNotifierService;
+    @Mock
+    private LoanDelinquencyDomainService loanDelinquencyDomainService;
    @InjectMocks
    private DelinquencyWritePlatformServiceImpl underTest;

@@ -101,7 +104,6 @@ public class DelinquencyWritePlatformServiceRangeChangeEventTest {
        // given
        Loan loanForProcessing = Mockito.mock(Loan.class);
        LoanProduct loanProduct = Mockito.mock(LoanProduct.class);
-        LoanProductRelatedDetail loanProductRelatedDetail = Mockito.mock(LoanProductRelatedDetail.class);
        DelinquencyRange range1 = DelinquencyRange.instance("Range1", 1, 2);
        range1.setId(1L);
        DelinquencyRange range2 = DelinquencyRange.instance("Range30", 3, 30);
@@ -113,14 +115,13 @@ public class DelinquencyWritePlatformServiceRangeChangeEventTest {
        LocalDate overDueSinceDate = DateUtils.getBusinessLocalDate().minusDays(2);
        LoanScheduleDelinquencyData loanScheduleDelinquencyData = new LoanScheduleDelinquencyData(1L, overDueSinceDate, 1L,
                loanForProcessing);
+        CollectionData collectionData = new CollectionData(BigDecimal.ZERO, 2L, null, 2L, overDueSinceDate, BigDecimal.ZERO, null, null);

        when(loanForProcessing.getLoanProduct()).thenReturn(loanProduct);
        when(loanProduct.getDelinquencyBucket()).thenReturn(delinquencyBucket);
-        when(loanProduct.getLoanProductRelatedDetail()).thenReturn(loanProductRelatedDetail);
-        when(loanProductRelatedDetail.getGraceOnArrearsAgeing()).thenReturn(1);
        when(loanForProcessing.hasDelinquencyBucket()).thenReturn(true);
        when(loanDelinquencyTagRepository.findByLoanAndLiftedOnDate(any(), any())).thenReturn(Optional.empty());
-        when(repositoryRange.getReferenceById(anyLong())).thenReturn(range1);
+        when(loanDelinquencyDomainService.getOverdueCollectionData(loanForProcessing)).thenReturn(collectionData);

        // when
        underTest.applyDelinquencyTagToLoan(loanScheduleDelinquencyData);
@@ -137,7 +138,6 @@ public class DelinquencyWritePlatformServiceRangeChangeEventTest {
        // given
        Loan loanForProcessing = Mockito.mock(Loan.class);
        LoanProduct loanProduct = Mockito.mock(LoanProduct.class);
-        LoanProductRelatedDetail loanProductRelatedDetail = Mockito.mock(LoanProductRelatedDetail.class);

        DelinquencyRange range1 = DelinquencyRange.instance("Range1", 1, 2);
        range1.setId(1L);
@@ -154,10 +154,9 @@ public class DelinquencyWritePlatformServiceRangeChangeEventTest {

        when(loanForProcessing.getLoanProduct()).thenReturn(loanProduct);
        when(loanProduct.getDelinquencyBucket()).thenReturn(delinquencyBucket);
-        when(loanProduct.getLoanProductRelatedDetail()).thenReturn(loanProductRelatedDetail);
-        when(loanProductRelatedDetail.getGraceOnArrearsAgeing()).thenReturn(1);
        when(loanForProcessing.hasDelinquencyBucket()).thenReturn(true);
        when(loanDelinquencyTagRepository.findByLoanAndLiftedOnDate(any(), any())).thenReturn(Optional.empty());
+        when(loanDelinquencyDomainService.getOverdueCollectionData(loanForProcessing)).thenReturn(CollectionData.template());

        // when
        underTest.applyDelinquencyTagToLoan(loanScheduleDelinquencyData);
@@ -165,7 +164,6 @@ public class DelinquencyWritePlatformServiceRangeChangeEventTest {
        // then
        verify(loanDelinquencyTagRepository, times(0)).saveAllAndFlush(anyIterable());
        verify(businessEventNotifierService, times(0)).notifyPostBusinessEvent(any());
-
    }

    @Test
@@ -0,0 +1,185 @@
+/**
+ * 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.deliquency;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.when;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.time.LocalDate;
+import java.time.ZoneId;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import org.apache.fineract.infrastructure.businessdate.domain.BusinessDateType;
+import org.apache.fineract.infrastructure.configuration.domain.ConfigurationDomainService;
+import org.apache.fineract.infrastructure.core.domain.FineractPlatformTenant;
+import org.apache.fineract.infrastructure.core.service.DateUtils;
+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.delinquency.service.LoanDelinquencyDomainServiceImpl;
+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.apache.fineract.portfolio.loanproduct.domain.LoanProduct;
+import org.apache.fineract.portfolio.loanproduct.domain.LoanProductRelatedDetail;
+import org.apache.fineract.portfolio.paymentdetail.domain.PaymentDetail;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+@ExtendWith(MockitoExtension.class)
+public class LoanDelinquencyDomainServiceTest {
+
+    @Mock
+    private LoanProductRelatedDetail loanProductRelatedDetail;
+    @Mock
+    private ConfigurationDomainService staticConfigurationDomainService;
+    @Mock
+    private MoneyHelper moneyHelper;
+    @Mock
+    private Loan loan;
+    @Mock
+    private LoanProduct loanProduct;
+    @InjectMocks
+    private LoanDelinquencyDomainServiceImpl underTest;
+
+    private LocalDate businessDate;
+    private MonetaryCurrency currency;
+    private MockedStatic<MoneyHelper> moneyHelperStatic;
+
+    private final BigDecimal principal = BigDecimal.valueOf(1000);
+    private final BigDecimal zeroAmount = BigDecimal.ZERO;
+
+    @BeforeEach
+    public void setUp() {
+        ThreadLocalContextUtil.setTenant(new FineractPlatformTenant(1L, "default", "Default", "Asia/Kolkata", null));
+        ThreadLocalContextUtil
+                .setBusinessDates(new HashMap<>(Map.of(BusinessDateType.BUSINESS_DATE, LocalDate.now(ZoneId.systemDefault()))));
+
+        businessDate = DateUtils.getBusinessLocalDate();
+        currency = new MonetaryCurrency("USD", 2, null);
+
+        moneyHelperStatic = Mockito.mockStatic(MoneyHelper.class);
+        moneyHelperStatic.when(() -> MoneyHelper.getRoundingMode()).thenReturn(RoundingMode.UP);
+    }
+
+    @AfterEach
+    public void deregister() {
+        moneyHelperStatic.close();
+    }
+
+    @Test
+    public void givenLoanAccountWithoutOverdueThenCalculateDelinquentData() {
+        // given
+        final LocalDate fromDate = businessDate.minusMonths(1);
+        final LocalDate dueDate = businessDate;
+        List<LoanRepaymentScheduleInstallment> repaymentScheduleInstallments = Arrays.asList(new LoanRepaymentScheduleInstallment(loan, 1,
+                fromDate, dueDate, principal, zeroAmount, zeroAmount, zeroAmount, false, new HashSet<>(), zeroAmount));
+
+        // when
+        when(loanProductRelatedDetail.getGraceOnArrearsAgeing()).thenReturn(0);
+        when(loanProduct.getLoanProductRelatedDetail()).thenReturn(loanProductRelatedDetail);
+        when(loan.getLoanProduct()).thenReturn(loanProduct);
+        when(loan.getRepaymentScheduleInstallments()).thenReturn(repaymentScheduleInstallments);
+        when(loan.getCurrency()).thenReturn(currency);
+
+        CollectionData collectionData = underTest.getOverdueCollectionData(loan);
+
+        // then
+        assertEquals(0L, collectionData.getDelinquentDays());
+        assertEquals(null, collectionData.getDelinquentDate());
+        assertEquals(collectionData.getDelinquentDays(), collectionData.getPastDueDays());
+
+    }
+
+    @Test
+    public void givenLoanAccountWithOverdueThenCalculateDelinquentData() {
+        // given
+        final Long daysDiff = 2L;
+        final LocalDate fromDate = businessDate.minusMonths(1).minusDays(daysDiff);
+        final LocalDate dueDate = businessDate.minusDays(daysDiff);
+        List<LoanRepaymentScheduleInstallment> repaymentScheduleInstallments = Arrays.asList(new LoanRepaymentScheduleInstallment(loan, 1,
+                fromDate, dueDate, principal, zeroAmount, zeroAmount, zeroAmount, false, new HashSet<>(), zeroAmount));
+
+        // when
+        when(loanProductRelatedDetail.getGraceOnArrearsAgeing()).thenReturn(0);
+        when(loanProduct.getLoanProductRelatedDetail()).thenReturn(loanProductRelatedDetail);
+        when(loan.getLoanProduct()).thenReturn(loanProduct);
+        when(loan.getRepaymentScheduleInstallments()).thenReturn(repaymentScheduleInstallments);
+        when(loan.getCurrency()).thenReturn(currency);
+
+        CollectionData collectionData = underTest.getOverdueCollectionData(loan);
+
+        // then
+        assertEquals(daysDiff, collectionData.getDelinquentDays());
+        assertEquals(dueDate, collectionData.getDelinquentDate());
+        assertEquals(collectionData.getDelinquentDays(), collectionData.getPastDueDays());
+
+    }
+
+    @Test
+    public void givenLoanAccountWithoutOverdueWithChargebackThenCalculateDelinquentData() {
+        // given
+        PaymentDetail paymentDetail = Mockito.mock(PaymentDetail.class);
+        Long daysDiff = 2L;
+        final LocalDate fromDate = businessDate.minusMonths(1).plusDays(daysDiff);
+        final LocalDate dueDate = businessDate.plusDays(daysDiff);
+        final LocalDate transactionDate = businessDate.minusDays(daysDiff);
+
+        final Money zeroMoney = Money.zero(currency);
+        LoanRepaymentScheduleInstallment installment = new LoanRepaymentScheduleInstallment(loan, 1, fromDate, dueDate, principal,
+                zeroAmount, zeroAmount, zeroAmount, false, new HashSet<>(), zeroAmount);
+        LoanTransaction loanTransaction = LoanTransaction.chargeback(null, Money.of(currency, principal), paymentDetail, transactionDate,
+                null);
+        installment.getLoanTransactionToRepaymentScheduleMappings().add(LoanTransactionToRepaymentScheduleMapping
+                .createFrom(loanTransaction, installment, zeroMoney, zeroMoney, zeroMoney, zeroMoney));
+
+        List<LoanRepaymentScheduleInstallment> repaymentScheduleInstallments = Arrays.asList(installment);
+
+        // when
+        when(loanProductRelatedDetail.getGraceOnArrearsAgeing()).thenReturn(0);
+        when(loanProduct.getLoanProductRelatedDetail()).thenReturn(loanProductRelatedDetail);
+        when(loan.getLoanProduct()).thenReturn(loanProduct);
+        when(loan.getRepaymentScheduleInstallments()).thenReturn(repaymentScheduleInstallments);
+        when(loan.getCurrency()).thenReturn(currency);
+
+        CollectionData collectionData = underTest.getOverdueCollectionData(loan);
+
+        // then
+        assertEquals(0L, collectionData.getDelinquentDays());
+        assertEquals(null, collectionData.getDelinquentDate());
+        assertEquals(collectionData.getDelinquentDays(), collectionData.getPastDueDays());
+
+    }
+
+}