Merge pull request #5760 from openMF/FINERACT-2455/working-capital-transaction-type-repayment

FINERACT-2455: WC - Transaction Type - Repayment

Author: galovics

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

@@ -872,6 +872,14 @@ public CommandWrapperBuilder updateDiscountWorkingCapitalLoanApplication(final L
         return this;
     }
 
+    public CommandWrapperBuilder repaymentWorkingCapitalLoanTransaction(final Long loanId) {
+        this.actionName = ACTION_REPAYMENT;
+        this.entityName = ENTITY_WORKINGCAPITALLOAN;
+        this.entityId = loanId;
+        this.href = "/working-capital-loans/" + loanId + "/transactions?command=repayment";
+        return this;
+    }
+
     public CommandWrapperBuilder createClientIdentifier(final Long clientId) {
         this.actionName = ACTION_CREATE;
         this.entityName = ENTITY_CLIENTIDENTIFIER;

fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/factory/WorkingCapitalRequestFactory.java

@@ -41,6 +41,7 @@
 import org.apache.fineract.client.models.PostPaymentAllocation;
 import org.apache.fineract.client.models.PostWorkingCapitalLoanProductsRequest;
 import org.apache.fineract.client.models.PostWorkingCapitalLoanProductsRequest.AccountingRuleEnum;
+import org.apache.fineract.client.models.PostWorkingCapitalLoanTransactionsRequest;
 import org.apache.fineract.client.models.PutWorkingCapitalLoanProductsProductIdRequest;
 import org.apache.fineract.client.models.WorkingCapitalBreachRequest;
 import org.apache.fineract.test.data.accounttype.AccountTypeResolver;
@@ -245,6 +246,12 @@ public WorkingCapitalBreachRequest defaultWorkingCapitalBreachRequest() {
                 .breachAmount(DEFAULT_WC_BREACH_AMOUNT);
     }
 
+    public PostWorkingCapitalLoanTransactionsRequest defaultWorkingCapitalLoanRepaymentRequest() {
+        return new PostWorkingCapitalLoanTransactionsRequest() //
+                .dateFormat(DATE_FORMAT) //
+                .locale(LOCALE_EN);
+    }
+
     private Long getWCDelinquencyBucketIdByName(String bucketName) {
         try {
             List<DelinquencyBucketResponse> buckets = fineractClient.delinquencyRangeAndBucketsManagement().getBuckets(Map.of());

fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/helper/WorkingCapitalScheduleMatcher.java

@@ -0,0 +1,80 @@
+/**
+ * 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.test.helper;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.time.LocalDate;
+
+public final class WorkingCapitalScheduleMatcher {
+
+    private WorkingCapitalScheduleMatcher() {}
+
+    public static boolean isBlank(final String value) {
+        return value == null || value.isBlank();
+    }
+
+    public static boolean matchesInteger(final Integer actual, final String expected) {
+        if (isBlank(expected)) {
+            return actual == null;
+        }
+        return actual != null && actual.equals(Integer.valueOf(expected));
+    }
+
+    public static boolean matchesLong(final Long actual, final String expected) {
+        if (isBlank(expected)) {
+            return actual == null;
+        }
+        return actual != null && actual.equals(Long.valueOf(expected));
+    }
+
+    public static boolean matchesDate(final LocalDate actual, final String expected) {
+        if (isBlank(expected)) {
+            return actual == null;
+        }
+        return actual != null && actual.equals(LocalDate.parse(expected));
+    }
+
+    public static boolean matchesFormattedDate(final String actualFormatted, final String expected) {
+        if (isBlank(expected)) {
+            return actualFormatted == null;
+        }
+        return expected.equals(actualFormatted);
+    }
+
+    public static boolean matchesDecimal(final BigDecimal actual, final String expected) {
+        if (isBlank(expected)) {
+            return actual == null;
+        }
+        if (actual == null) {
+            return false;
+        }
+        return actual.compareTo(new BigDecimal(expected)) == 0;
+    }
+
+    public static boolean matchesDecimalWithScale(final BigDecimal actual, final String expected, final int scale) {
+        if (isBlank(expected)) {
+            return actual == null;
+        }
+        if (actual == null) {
+            return false;
+        }
+        return actual.setScale(scale, RoundingMode.HALF_UP).compareTo(new BigDecimal(expected).setScale(scale, RoundingMode.HALF_UP)) == 0;
+    }
+}

fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/stepdef/loan/WorkingCapitalAmortizationScheduleStepDef.java

@@ -35,6 +35,7 @@
 import org.apache.fineract.client.models.ProjectedAmortizationScheduleData;
 import org.apache.fineract.client.models.ProjectedAmortizationScheduleGenerateRequest;
 import org.apache.fineract.client.models.ProjectedAmortizationSchedulePaymentData;
+import org.apache.fineract.test.helper.WorkingCapitalScheduleMatcher;
 import org.apache.fineract.test.stepdef.AbstractStepDef;
 import org.apache.fineract.test.support.TestContext;
 import org.apache.fineract.test.support.TestContextKey;
@@ -147,49 +148,46 @@ private void verifyPaymentDetails(final DataTable dataTable) {
 
     private static void assertDecimal(final SoftAssertions assertions, final String field, final BigDecimal actual,
             final String expectedStr) {
-        if (expectedStr == null || expectedStr.isBlank()) {
+        if (WorkingCapitalScheduleMatcher.isBlank(expectedStr)) {
             return;
         }
-        final BigDecimal expected = new BigDecimal(expectedStr);
-        assertions.assertThat(actual).as(field).isNotNull();
-        if (actual != null) {
-            assertions.assertThat(actual.compareTo(expected)).as("%s: expected=%s actual=%s", field, expected, actual).isEqualTo(0);
-        }
+        assertions.assertThat(WorkingCapitalScheduleMatcher.matchesDecimal(actual, expectedStr))
+                .as("%s: expected=%s actual=%s", field, expectedStr, actual).isTrue();
     }
 
     private static void assertNullableDecimal(final SoftAssertions assertions, final String field, final BigDecimal actual,
             final String expectedStr) {
-        if (expectedStr == null || expectedStr.isBlank()) {
+        if (WorkingCapitalScheduleMatcher.isBlank(expectedStr)) {
             assertions.assertThat(actual).as(field + " should be null").isNull();
             return;
         }
         assertDecimal(assertions, field, actual, expectedStr);
     }
 
     private static void assertInt(final SoftAssertions assertions, final String field, final Integer actual, final String expectedStr) {
-        if (expectedStr == null || expectedStr.isBlank()) {
+        if (WorkingCapitalScheduleMatcher.isBlank(expectedStr)) {
             return;
         }
-        assertions.assertThat(actual).as(field).isEqualTo(Integer.parseInt(expectedStr));
+        assertions.assertThat(WorkingCapitalScheduleMatcher.matchesInteger(actual, expectedStr)).as(field).isTrue();
     }
 
     private static void assertLong(final SoftAssertions assertions, final String field, final Long actual, final String expectedStr) {
-        if (expectedStr == null || expectedStr.isBlank()) {
+        if (WorkingCapitalScheduleMatcher.isBlank(expectedStr)) {
             return;
         }
-        assertions.assertThat(actual).as(field).isEqualTo(Long.parseLong(expectedStr));
+        assertions.assertThat(WorkingCapitalScheduleMatcher.matchesLong(actual, expectedStr)).as(field).isTrue();
     }
 
     private static void assertDate(final SoftAssertions assertions, final String field, final LocalDate actual, final String expectedStr) {
-        if (expectedStr == null || expectedStr.isBlank()) {
+        if (WorkingCapitalScheduleMatcher.isBlank(expectedStr)) {
             return;
         }
-        assertions.assertThat(actual).as(field).isEqualTo(LocalDate.parse(expectedStr));
+        assertions.assertThat(WorkingCapitalScheduleMatcher.matchesDate(actual, expectedStr)).as(field).isTrue();
     }
 
     private static void assertOptionalDecimal(final SoftAssertions assertions, final String field, final BigDecimal actual,
             final String expectedStr) {
-        if (expectedStr == null || expectedStr.isBlank()) {
+        if (WorkingCapitalScheduleMatcher.isBlank(expectedStr)) {
             assertions.assertThat(actual).as(field + " should not be null").isNotNull();
             return;
         }