DDS: vouchers, maker-checker approvals, payout & close, Sundry GL, closure tab, fixes

fineract-core/src/main/java/org/apache/fineract/commands/service/CommandSourceService.java

@@ -164,12 +164,24 @@ public class CommandSourceService {
                 || "SHAREPRODUCT".equalsIgnoreCase(commandSource.getEntityName())
                 || "FIXEDDEPOSITPRODUCT".equalsIgnoreCase(commandSource.getEntityName())
                 || "USER".equalsIgnoreCase(commandSource.getEntityName())
-                || "ROLE".equalsIgnoreCase(commandSource.getEntityName())) {
+                || "ROLE".equalsIgnoreCase(commandSource.getEntityName())
+                || isDdsEntity(commandSource.getEntityName())) {
             return false;
         }
         return true;
     }
 
+    /**
+     * The DDS module's maker-checker entities. A super user's DDS work goes to a checker like anyone
+     * else's: DDS moves customers' money, and every such move is to be approved by a second person.
+     */
+    public static boolean isDdsEntity(final String entityName) {
+        return entityName != null && switch (entityName.toUpperCase()) {
+            case "PARTY", "AGENT", "PARTYTRANSACTION", "DDSACCOUNTTYPE", "COMMISSIONSLAB", "DDSBATCH", "DDSCOLLECTIONENTRY" -> true;
+            default -> false;
+        };
+    }
+
     private void sanitizeJson(@NonNull CommandSource commandSource, Set<String> sanitizeKeys) {
         if (sanitizeKeys == null || sanitizeKeys.isEmpty()) {
             return;

fineract-core/src/main/java/org/apache/fineract/commands/service/CommandWrapperBuilder.java

@@ -737,6 +737,14 @@ public class CommandWrapperBuilder {
         return this;
     }
 
+    public CommandWrapperBuilder prematureCloseOverrideParty(final Long partyId) {
+        this.actionName = "PREMATURECLOSEOVERRIDE";
+        this.entityName = "PARTY";
+        this.entityId = partyId;
+        this.href = "/dds/parties/" + partyId + "?command=prematurecloseoverride";
+        return this;
+    }
+
     public CommandWrapperBuilder createDdsAccountType() {
         this.actionName = "CREATE";
         this.entityName = "DDSACCOUNTTYPE";

fineract-core/src/main/java/org/apache/fineract/commands/service/PortfolioCommandSourceWritePlatformServiceImpl.java

@@ -123,7 +123,9 @@ public class PortfolioCommandSourceWritePlatformServiceImpl implements Portfolio
         AppUser appUser = this.context.authenticatedUser();
         String permissionCode = commandSource.getPermissionCode();
         appUser.validateHasCheckerPermissionTo(permissionCode);
-        if (!configurationService.isSameMakerCheckerEnabled() && !appUser.isCheckerSuperUser()) {
+        // A DDS entry is never checked by the user who made it, super user or not - see CommandSourceService.isDdsEntity.
+        if (!configurationService.isSameMakerCheckerEnabled()
+                && (!appUser.isCheckerSuperUser() || CommandSourceService.isDdsEntity(commandSource.getEntityName()))) {
             AppUser maker = commandSource.getMaker();
             if (maker == null) {
                 throw new UnsupportedCommandException(permissionCode, "Maker user is missing.");

fineract-core/src/main/java/org/apache/fineract/portfolio/dds/accounttype/data/DdsAccountTypeData.java

@@ -53,6 +53,8 @@ public final class DdsAccountTypeData implements Serializable {
     private final Integer prematureLockinMonths;
     private final BigDecimal prematureInterestReduction;
     private final BigDecimal prematureAgentCommissionPenalty;
+    /** The scheme's annual interest rate, which an account opened on it takes. */
+    private final BigDecimal interestRate;
     private final Boolean active;
     private final LocalDateTime createdDate;
     private final LocalDateTime lastModifiedDate;

fineract-core/src/main/java/org/apache/fineract/portfolio/dds/accounttype/domain/DdsAccountType.java

@@ -104,6 +104,13 @@ public class DdsAccountType extends AbstractAuditableCustom {
     @Column(name = "premature_agent_commission_penalty", scale = 6, precision = 19, nullable = false)
     private BigDecimal prematureAgentCommissionPenalty;
 
+    /**
+     * The scheme's annual interest rate. Mandatory: an account opened on the scheme takes this rate,
+     * rather than one typed at the counter for each customer.
+     */
+    @Column(name = "interest_rate", scale = 6, precision = 19, nullable = false)
+    private BigDecimal interestRate;
+
     /**
      * An account type is retired by deactivating it, never by deleting: Parties are opened against
      * it, so removing the row would orphan every account already using it. Inactive types stay out
@@ -130,6 +137,7 @@ public class DdsAccountType extends AbstractAuditableCustom {
         this.prematureLockinMonths = valueOr(command, "prematureLockinMonths", DEFAULT_LOCKIN_MONTHS);
         this.prematureInterestReduction = valueOr(command, "prematureInterestReduction", DEFAULT_INTEREST_REDUCTION);
         this.prematureAgentCommissionPenalty = valueOr(command, "prematureAgentCommissionPenalty", DEFAULT_AGENT_PENALTY);
+        this.interestRate = command.bigDecimalValueOfParameterNamed("interestRate");
         // A newly created account type is available for use straight away.
         this.active = !command.parameterExists("active") || command.booleanPrimitiveValueOfParameterNamed("active");
     }
@@ -241,6 +249,13 @@ public class DdsAccountType extends AbstractAuditableCustom {
             this.prematureAgentCommissionPenalty = newValue == null ? BigDecimal.ZERO : newValue;
         }
 
+        // The scheme's rate - every open account on it follows it (see the account type service).
+        if (command.parameterExists("interestRate") && command.isChangeInBigDecimalParameterNamed("interestRate", this.interestRate)) {
+            final BigDecimal newValue = command.bigDecimalValueOfParameterNamed("interestRate");
+            actualChanges.put("interestRate", newValue);
+            this.interestRate = newValue;
+        }
+
         if (command.isChangeInBooleanParameterNamed("active", this.active)) {
             final boolean newValue = command.booleanPrimitiveValueOfParameterNamed("active");
             actualChanges.put("active", newValue);

fineract-core/src/main/java/org/apache/fineract/portfolio/dds/collection/data/CollectionEntryData.java

@@ -60,4 +60,7 @@ public class CollectionEntryData {
     private final String status;
     private final LocalDate settledOn;
     private final Long partyTransactionId;
+    /** Days paid ahead, or days of arrears cleared - empty on an ordinary day's collection. */
+    private final Integer advanceDays;
+    private final Integer arrearsDays;
 }

fineract-core/src/main/java/org/apache/fineract/portfolio/dds/collection/domain/CollectionEntry.java

@@ -106,6 +106,21 @@ public class CollectionEntry extends AbstractAuditableCustom {
     @Column(name = "party_transaction_id")
     private Long partyTransactionId;
 
+    /**
+     * The application of the cashier's DDS receipts that settled this entry, when it was settled that
+     * way - see 0517, which records which vouchers it used. A plain id for the same reason as the
+     * transaction.
+     */
+    @Column(name = "receipt_application_id")
+    private Long receiptApplicationId;
+
+    /** Days paid ahead, or days of arrears cleared - see 0520. Both empty on an ordinary day's collection. */
+    @Column(name = "advance_days")
+    private Integer advanceDays;
+
+    @Column(name = "arrears_days")
+    private Integer arrearsDays;
+
     protected CollectionEntry() {
         //
     }
@@ -123,6 +138,12 @@ public class CollectionEntry extends AbstractAuditableCustom {
         this.status = PENDING;
     }
 
+    /** Records what the collection covers beyond today, once its amount has been checked against it. */
+    public void covering(final Integer advanceDays, final Integer arrearsDays) {
+        this.advanceDays = advanceDays;
+        this.arrearsDays = arrearsDays;
+    }
+
     public boolean isPending() {
         return PENDING.equals(this.status);
     }
@@ -140,6 +161,12 @@ public class CollectionEntry extends AbstractAuditableCustom {
         this.partyTransactionId = partyTransactionId;
     }
 
+    /** Settled against the cashier's receipts: the same as {@link #markSettled}, and which application did it. */
+    public void markSettledByReceipt(final LocalDate settledOn, final Long partyTransactionId, final Long receiptApplicationId) {
+        markSettled(settledOn, partyTransactionId);
+        this.receiptApplicationId = receiptApplicationId;
+    }
+
     /** Withdraws a line that was never posted. Kept, not deleted - the agent wrote it, so it stands. */
     public void markCancelled() {
         this.status = CANCELLED;

fineract-core/src/main/java/org/apache/fineract/portfolio/dds/party/data/PartyData.java

@@ -76,6 +76,8 @@ public final class PartyData implements Serializable {
      */
     private final String subTypeDescription;
     private final String partyCode;
+    /** The DDS account's own number. */
+    private final String accountNo;
     private final String lastAccount;
     private final Boolean nominal;
     private final String aadharNo;

fineract-core/src/main/java/org/apache/fineract/portfolio/dds/party/domain/Party.java

@@ -100,6 +100,10 @@ public class Party extends AbstractAuditableCustom {
     @Column(name = "party_code", length = 20, nullable = false)
     private String partyCode;
 
+    /** The DDS account's own number - see 0514. Given once the party has an id, and never changed. */
+    @Column(name = "account_no", length = 20)
+    private String accountNo;
+
     @Column(name = "last_account", length = 50)
     private String lastAccount;
 
@@ -380,6 +384,16 @@ public class Party extends AbstractAuditableCustom {
         recalculateTerm();
     }
 
+    /**
+     * Takes the scheme's interest rate. The rate belongs to the scheme, not to the counter: it is set
+     * when the account is opened or moved to another scheme, and again on every open account whenever
+     * the bank changes the scheme's rate, with the maturity figure worked out again on it.
+     */
+    public void takeSchemeRate(final BigDecimal schemeRate) {
+        this.interestRate = schemeRate == null ? BigDecimal.ZERO : schemeRate;
+        recalculateTerm();
+    }
+
     /**
      * Works out the maturity date and amount from the terms just set.
      *
@@ -478,6 +492,13 @@ public class Party extends AbstractAuditableCustom {
         this.savingsAccountId = savingsAccountId;
     }
 
+    /** Numbers the account from its id, the same way 0514 numbered the accounts already open. */
+    public void assignAccountNo() {
+        if (this.accountNo == null && getId() != null) {
+            this.accountNo = "DDS" + String.format("%09d", getId());
+        }
+    }
+
     public BigDecimal credit(final BigDecimal amount) {
         this.currentBalance = this.currentBalance.add(amount);
         return this.currentBalance;
@@ -670,11 +691,8 @@ public class Party extends AbstractAuditableCustom {
             this.days = newValue;
         }
 
-        if (command.isChangeInBigDecimalParameterNamed("interestRate", this.interestRate)) {
-            final BigDecimal newValue = command.bigDecimalValueOfParameterNamed("interestRate");
-            actualChanges.put("interestRate", newValue);
-            this.interestRate = newValue;
-        }
+        // The rate is not edited here: it is the scheme's, taken when the account is opened or moved
+        // to another scheme - see takeSchemeRate.
 
         stringChange(command, actualChanges, "ledgerNo", this.ledgerNo, v -> this.ledgerNo = v);
         stringChange(command, actualChanges, "withdrawType", this.withdrawType, v -> this.withdrawType = v);

fineract-core/src/main/java/org/apache/fineract/portfolio/dds/transaction/data/PartyTransactionData.java

@@ -49,4 +49,6 @@ public final class PartyTransactionData implements Serializable {
     private final String tokenNo;
     private final String description;
     private final BigDecimal balanceAfterTransaction;
+    /** The DDS voucher this line moved under, e.g. DDS/29092026/0001; empty on lines from before vouchers. */
+    private final String voucherNo;
 }

fineract-core/src/main/java/org/apache/fineract/portfolio/dds/transaction/domain/PartyTransaction.java

@@ -22,6 +22,7 @@ import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
 import jakarta.persistence.JoinColumn;
 import jakarta.persistence.ManyToOne;
+import jakarta.persistence.PostPersist;
 import jakarta.persistence.Table;
 import java.math.BigDecimal;
 import java.time.LocalDate;
@@ -29,6 +30,7 @@ import lombok.Getter;
 import org.apache.fineract.infrastructure.core.domain.AbstractAuditableCustom;
 import org.apache.fineract.organisation.agent.domain.Agent;
 import org.apache.fineract.portfolio.dds.party.domain.Party;
+import org.apache.fineract.portfolio.dds.voucher.DdsVoucherScope;
 
 /**
  * A single posted entry on the DDS ledger: a Party's day's collection ("Party Tran", direction
@@ -107,4 +109,14 @@ public class PartyTransaction extends AbstractAuditableCustom {
         this.description = description;
         this.balanceAfterTransaction = balanceAfterTransaction;
     }
+
+    /**
+     * Notes this line against the operation that wrote it, so the operation's voucher number can be
+     * stamped on it. The voucher number itself is not mapped here: it is written once, by SQL, after
+     * the voucher is raised, and a mapped field would be written back as null by any later save.
+     */
+    @PostPersist
+    private void recordInVoucherScope() {
+        DdsVoucherScope.recordPartyTransaction(getId());
+    }
 }

fineract-core/src/main/java/org/apache/fineract/portfolio/dds/voucher/DdsVoucherScope.java

@@ -0,0 +1,105 @@
+/**
+ * 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.dds.voucher;
+
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * What one DDS operation moved, gathered while it runs so a single voucher can be raised for it at
+ * the end.
+ *
+ * A payout, an early closure, a posting run or a transfer each writes several ledger legs and
+ * passbook lines from several places - the interest brought up to date, the recovery, the payout
+ * itself. The voucher is the slip for the whole operation, not for each leg, so the legs are noted
+ * here as they are written and turned into one voucher when the operation finishes.
+ *
+ * Held per thread, since an operation runs on one thread from start to finish - including a posting
+ * run handed to a background thread, which opens its own scope there. Outside a scope nothing is
+ * recorded.
+ */
+public final class DdsVoucherScope {
+
+    /** A voucher side with no ledger leg behind it - a move between two accounts on the same GL. */
+    public record Line(String entryType, Long glAccountId, String partyName, String accountNo, BigDecimal amount, String description) {}
+
+    private static final ThreadLocal<DdsVoucherScope> CURRENT = new ThreadLocal<>();
+
+    private final Set<String> ledgerTransactionIds = new LinkedHashSet<>();
+    private final List<Long> partyTransactionIds = new ArrayList<>();
+    private final List<Line> extraLines = new ArrayList<>();
+
+    private DdsVoucherScope() {}
+
+    /** The scope now open on this thread, or null. */
+    public static DdsVoucherScope current() {
+        return CURRENT.get();
+    }
+
+    /** Opens a scope on this thread. The caller must {@link #close} it. */
+    public static DdsVoucherScope open() {
+        final DdsVoucherScope scope = new DdsVoucherScope();
+        CURRENT.set(scope);
+        return scope;
+    }
+
+    public static void close() {
+        CURRENT.remove();
+    }
+
+    /** Notes a ledger transaction written for the operation in progress. */
+    public static void recordLedgerTransaction(final String transactionId) {
+        final DdsVoucherScope scope = CURRENT.get();
+        if (scope != null && transactionId != null) {
+            scope.ledgerTransactionIds.add(transactionId);
+        }
+    }
+
+    /** Notes a passbook line written for the operation in progress, so it can carry the voucher number. */
+    public static void recordPartyTransaction(final Long partyTransactionId) {
+        final DdsVoucherScope scope = CURRENT.get();
+        if (scope != null && partyTransactionId != null) {
+            scope.partyTransactionIds.add(partyTransactionId);
+        }
+    }
+
+    /** Adds a voucher side the ledger does not show - see {@link Line}. */
+    public static void addLine(final Line line) {
+        final DdsVoucherScope scope = CURRENT.get();
+        if (scope != null && line != null) {
+            scope.extraLines.add(line);
+        }
+    }
+
+    public Set<String> getLedgerTransactionIds() {
+        return Collections.unmodifiableSet(this.ledgerTransactionIds);
+    }
+
+    public List<Long> getPartyTransactionIds() {
+        return Collections.unmodifiableList(this.partyTransactionIds);
+    }
+
+    public List<Line> getExtraLines() {
+        return Collections.unmodifiableList(this.extraLines);
+    }
+}