diff --git a/fineract-accounting/src/main/resources/jpa/static-weaving/module/fineract-accounting/persistence.xml b/fineract-accounting/src/main/resources/jpa/static-weaving/module/fineract-accounting/persistence.xml index d1e6be5a80f..4d2ec850718 100644 --- a/fineract-accounting/src/main/resources/jpa/static-weaving/module/fineract-accounting/persistence.xml +++ b/fineract-accounting/src/main/resources/jpa/static-weaving/module/fineract-accounting/persistence.xml @@ -48,6 +48,7 @@ org.apache.fineract.portfolio.calendar.domain.Calendar org.apache.fineract.portfolio.calendar.domain.CalendarHistory org.apache.fineract.portfolio.client.domain.ClientIdentifier + org.apache.fineract.portfolio.delinquency.domain.DelinquencyMinimumPaymentPeriodAndRule org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucket org.apache.fineract.portfolio.delinquency.domain.DelinquencyRange org.apache.fineract.portfolio.group.domain.StaffAssignmentHistory @@ -86,6 +87,7 @@ false + diff --git a/fineract-branch/src/main/resources/jpa/static-weaving/module/fineract-branch/persistence.xml b/fineract-branch/src/main/resources/jpa/static-weaving/module/fineract-branch/persistence.xml index ee2b5fcfef2..104a6f94102 100644 --- a/fineract-branch/src/main/resources/jpa/static-weaving/module/fineract-branch/persistence.xml +++ b/fineract-branch/src/main/resources/jpa/static-weaving/module/fineract-branch/persistence.xml @@ -48,6 +48,7 @@ org.apache.fineract.portfolio.calendar.domain.Calendar org.apache.fineract.portfolio.calendar.domain.CalendarHistory org.apache.fineract.portfolio.client.domain.ClientIdentifier + org.apache.fineract.portfolio.delinquency.domain.DelinquencyMinimumPaymentPeriodAndRule org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucket org.apache.fineract.portfolio.delinquency.domain.DelinquencyRange org.apache.fineract.portfolio.group.domain.StaffAssignmentHistory @@ -93,6 +94,7 @@ false + diff --git a/fineract-charge/src/main/resources/jpa/static-weaving/module/fineract-charge/persistence.xml b/fineract-charge/src/main/resources/jpa/static-weaving/module/fineract-charge/persistence.xml index 7482e322cdd..a228f95026b 100644 --- a/fineract-charge/src/main/resources/jpa/static-weaving/module/fineract-charge/persistence.xml +++ b/fineract-charge/src/main/resources/jpa/static-weaving/module/fineract-charge/persistence.xml @@ -48,6 +48,7 @@ org.apache.fineract.portfolio.calendar.domain.Calendar org.apache.fineract.portfolio.calendar.domain.CalendarHistory org.apache.fineract.portfolio.client.domain.ClientIdentifier + org.apache.fineract.portfolio.delinquency.domain.DelinquencyMinimumPaymentPeriodAndRule org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucket org.apache.fineract.portfolio.delinquency.domain.DelinquencyRange org.apache.fineract.portfolio.group.domain.StaffAssignmentHistory @@ -86,6 +87,7 @@ false + diff --git a/fineract-cob/src/main/java/org/apache/fineract/cob/domain/AccountLock.java b/fineract-cob/src/main/java/org/apache/fineract/cob/domain/AccountLock.java index 5721b33e9a3..2b563a3e84e 100644 --- a/fineract-cob/src/main/java/org/apache/fineract/cob/domain/AccountLock.java +++ b/fineract-cob/src/main/java/org/apache/fineract/cob/domain/AccountLock.java @@ -27,6 +27,7 @@ import jakarta.persistence.PrePersist; import jakarta.persistence.Transient; import jakarta.persistence.Version; +import java.io.Serial; import java.io.Serializable; import java.time.LocalDate; import java.time.OffsetDateTime; @@ -38,47 +39,41 @@ import org.springframework.data.domain.Persistable; @Getter +@Setter @MappedSuperclass @NoArgsConstructor public abstract class AccountLock implements Persistable, Serializable { - protected static final long serialVersionUID = 2272591907035824317L; + @Serial + private static final long serialVersionUID = 1L; @Id - @Getter @Column(name = "loan_id", nullable = false) - protected Long loanId; + private Long loanId; @Version - @Getter @Column(name = "version") - protected Long version; + private Long version; @Enumerated(EnumType.STRING) - @Getter @Column(name = "lock_owner", nullable = false) - protected LockOwner lockOwner; + private LockOwner lockOwner; @Column(name = "lock_placed_on", nullable = false) - @Getter - protected OffsetDateTime lockPlacedOn; + private OffsetDateTime lockPlacedOn; @Column(name = "error") - @Getter - protected String error; + private String error; @Column(name = "stacktrace") - @Getter - protected String stacktrace; + private String stacktrace; @Column(name = "lock_placed_on_cob_business_date") - @Getter - protected LocalDate lockPlacedOnCobBusinessDate; + private LocalDate lockPlacedOnCobBusinessDate; @Transient @Setter(value = AccessLevel.NONE) - @Getter - protected boolean isNew = true; + private boolean isNew = true; @PrePersist @PostLoad @@ -88,7 +83,7 @@ void markNotNew() { @Override public Long getId() { - return getLoanId(); + return loanId; } public AccountLock(Long loanId, LockOwner lockOwner, LocalDate lockPlacedOnCobBusinessDate) { diff --git a/fineract-cob/src/main/java/org/apache/fineract/cob/service/BeforeStepLockingItemReaderHelper.java b/fineract-cob/src/main/java/org/apache/fineract/cob/service/BeforeStepLockingItemReaderHelper.java index c79d761829c..eacb0cfb06b 100644 --- a/fineract-cob/src/main/java/org/apache/fineract/cob/service/BeforeStepLockingItemReaderHelper.java +++ b/fineract-cob/src/main/java/org/apache/fineract/cob/service/BeforeStepLockingItemReaderHelper.java @@ -64,6 +64,6 @@ public LinkedBlockingQueue filterRemainingData(@NonNull StepExecution step private List getLoanIdsLockedWithChunkProcessingLock(List loanIds) { List accountLocks = new ArrayList<>( loanLockingService.findAllByLoanIdInAndLockOwner(loanIds, LockOwner.LOAN_COB_CHUNK_PROCESSING)); - return accountLocks.stream().map(T::getLoanId).toList(); + return accountLocks.stream().map(T::getId).toList(); } } diff --git a/fineract-cob/src/main/java/org/apache/fineract/cob/tasklet/ApplyCommonLockTasklet.java b/fineract-cob/src/main/java/org/apache/fineract/cob/tasklet/ApplyCommonLockTasklet.java index b1fcd63d446..3d3b1afec4b 100644 --- a/fineract-cob/src/main/java/org/apache/fineract/cob/tasklet/ApplyCommonLockTasklet.java +++ b/fineract-cob/src/main/java/org/apache/fineract/cob/tasklet/ApplyCommonLockTasklet.java @@ -83,7 +83,7 @@ public RepeatStatus execute(@NonNull StepContribution contribution, @NonNull Chu loanIdPartitions.forEach(loanIdPartition -> accountLocks.addAll(loanLockingService.findAllByLoanIdIn(loanIdPartition))); List toBeProcessedLoanIds = new ArrayList<>(loanIds); - List alreadyLockedAccountIds = accountLocks.stream().map(AccountLock::getLoanId).toList(); + List alreadyLockedAccountIds = accountLocks.stream().map(AccountLock::getId).toList(); toBeProcessedLoanIds.removeAll(alreadyLockedAccountIds); try { diff --git a/fineract-cob/src/main/resources/jpa/static-weaving/module/fineract-cob/persistence.xml b/fineract-cob/src/main/resources/jpa/static-weaving/module/fineract-cob/persistence.xml index 946e34b7079..9d0f5f35074 100644 --- a/fineract-cob/src/main/resources/jpa/static-weaving/module/fineract-cob/persistence.xml +++ b/fineract-cob/src/main/resources/jpa/static-weaving/module/fineract-cob/persistence.xml @@ -47,6 +47,7 @@ org.apache.fineract.portfolio.calendar.domain.Calendar org.apache.fineract.portfolio.calendar.domain.CalendarHistory org.apache.fineract.portfolio.client.domain.ClientIdentifier + org.apache.fineract.portfolio.delinquency.domain.DelinquencyMinimumPaymentPeriodAndRule org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucket org.apache.fineract.portfolio.delinquency.domain.DelinquencyRange org.apache.fineract.portfolio.group.domain.StaffAssignmentHistory @@ -65,10 +66,12 @@ org.apache.fineract.infrastructure.codes.domain.CodeValue - + org.apache.fineract.cob.domain.AccountLock + org.apache.fineract.cob.domain.BatchBusinessStep false + diff --git a/fineract-core/src/main/java/org/apache/fineract/infrastructure/core/serialization/FromJsonHelper.java b/fineract-core/src/main/java/org/apache/fineract/infrastructure/core/serialization/FromJsonHelper.java index 5006bec0719..902bbf358d2 100644 --- a/fineract-core/src/main/java/org/apache/fineract/infrastructure/core/serialization/FromJsonHelper.java +++ b/fineract-core/src/main/java/org/apache/fineract/infrastructure/core/serialization/FromJsonHelper.java @@ -329,4 +329,8 @@ public > T enumValueOfParameterNamed(String parameterName, fin "Enum value not exists: ", enumType.getName(), value)), e); } } + + public Integer extractIntegerNamed(String paramName, JsonObject element) { + return extractIntegerNamed(paramName, element, new HashSet<>()); + } } diff --git a/fineract-core/src/main/java/org/apache/fineract/portfolio/delinquency/domain/DelinquencyBucket.java b/fineract-core/src/main/java/org/apache/fineract/portfolio/delinquency/domain/DelinquencyBucket.java index 6bda1952377..58212582470 100644 --- a/fineract-core/src/main/java/org/apache/fineract/portfolio/delinquency/domain/DelinquencyBucket.java +++ b/fineract-core/src/main/java/org/apache/fineract/portfolio/delinquency/domain/DelinquencyBucket.java @@ -18,12 +18,16 @@ */ package org.apache.fineract.portfolio.delinquency.domain; +import jakarta.persistence.CascadeType; import jakarta.persistence.Column; import jakarta.persistence.Entity; +import jakarta.persistence.EnumType; +import jakarta.persistence.Enumerated; import jakarta.persistence.FetchType; import jakarta.persistence.JoinColumn; import jakarta.persistence.JoinTable; import jakarta.persistence.ManyToMany; +import jakarta.persistence.OneToOne; import jakarta.persistence.Table; import jakarta.persistence.UniqueConstraint; import jakarta.persistence.Version; @@ -48,6 +52,13 @@ public class DelinquencyBucket extends AbstractAuditableWithUTCDateTimeCustom ranges; + @OneToOne(mappedBy = "bucket", cascade = CascadeType.ALL, orphanRemoval = true) + private DelinquencyMinimumPaymentPeriodAndRule minimumPaymentPeriodAndRule; + + @Enumerated(EnumType.STRING) + @Column(name = "bucket_type") + private DelinquencyBucketType bucketType; + @Version private Long version; diff --git a/fineract-core/src/main/java/org/apache/fineract/portfolio/delinquency/domain/DelinquencyBucketType.java b/fineract-core/src/main/java/org/apache/fineract/portfolio/delinquency/domain/DelinquencyBucketType.java new file mode 100644 index 00000000000..86d37759300 --- /dev/null +++ b/fineract-core/src/main/java/org/apache/fineract/portfolio/delinquency/domain/DelinquencyBucketType.java @@ -0,0 +1,46 @@ +/** + * 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.domain; + +import java.util.Arrays; +import java.util.List; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import org.apache.fineract.infrastructure.core.data.StringEnumOptionData; + +@Getter +@RequiredArgsConstructor +public enum DelinquencyBucketType { + + REGULAR(1L, "bucketType.regular", "Reqular Loan Product"), // + WORKING_CAPITAL(2L, "bucketType.workingCapital", "Working Capital Loan Product"); + + private final Long id; + private final String code; + private final String description; + + public static List toStringEnumOptions() { + return Arrays.stream(values()).map(DelinquencyBucketType::toData).toList(); + } + + public StringEnumOptionData toData() { + return new StringEnumOptionData(name(), getCode(), getDescription()); + } +} diff --git a/fineract-core/src/main/java/org/apache/fineract/portfolio/delinquency/domain/DelinquencyFrequencyType.java b/fineract-core/src/main/java/org/apache/fineract/portfolio/delinquency/domain/DelinquencyFrequencyType.java new file mode 100644 index 00000000000..08b18abc8ff --- /dev/null +++ b/fineract-core/src/main/java/org/apache/fineract/portfolio/delinquency/domain/DelinquencyFrequencyType.java @@ -0,0 +1,48 @@ +/** + * 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.domain; + +import java.util.Arrays; +import java.util.List; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import org.apache.fineract.infrastructure.core.data.StringEnumOptionData; + +@Getter +@RequiredArgsConstructor +public enum DelinquencyFrequencyType { + + DAYS(0L, "delinquencyFrequencyType.days", "Days frequency"), // + WEEKS(1L, "delinquencyFrequencyType.weeks", "Week frequency"), // + MONTHS(2L, "delinquencyFrequencyType.months", "Month frequency"), // + YEARS(3L, "delinquencyFrequencyType.years", "Year frequency"); + + private final Long id; + private final String code; + private final String description; + + public static List toStringEnumOptions() { + return Arrays.stream(values()).map(DelinquencyFrequencyType::toData).toList(); + } + + public StringEnumOptionData toData() { + return new StringEnumOptionData(name(), getCode(), getDescription()); + } +} diff --git a/fineract-core/src/main/java/org/apache/fineract/portfolio/delinquency/domain/DelinquencyMinimumPaymentPeriodAndRule.java b/fineract-core/src/main/java/org/apache/fineract/portfolio/delinquency/domain/DelinquencyMinimumPaymentPeriodAndRule.java new file mode 100644 index 00000000000..2bbc44f0dbf --- /dev/null +++ b/fineract-core/src/main/java/org/apache/fineract/portfolio/delinquency/domain/DelinquencyMinimumPaymentPeriodAndRule.java @@ -0,0 +1,63 @@ +/** + * 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.domain; + +import jakarta.persistence.Column; +import jakarta.persistence.Entity; +import jakarta.persistence.EnumType; +import jakarta.persistence.Enumerated; +import jakarta.persistence.JoinColumn; +import jakarta.persistence.OneToOne; +import jakarta.persistence.Table; +import java.io.Serial; +import java.math.BigDecimal; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; +import org.apache.fineract.infrastructure.core.domain.AbstractAuditableWithUTCDateTimeCustom; + +@Getter +@Setter +@NoArgsConstructor +@Entity +@Table(name = "m_delinquency_payment_rule") +public class DelinquencyMinimumPaymentPeriodAndRule extends AbstractAuditableWithUTCDateTimeCustom { + + @Serial + private static final long serialVersionUID = -9204385885041120403L; + + @OneToOne + @JoinColumn(name = "bucket_id", nullable = false, unique = true) + private DelinquencyBucket bucket; + + @Column(name = "frequency", nullable = false) + private Integer frequency; + + @Enumerated(EnumType.STRING) + @Column(name = "frequency_type", nullable = false) + private DelinquencyFrequencyType frequencyType; + + @Column(name = "minimum_payment", scale = 6, precision = 19, nullable = false) + private BigDecimal minimumPayment; + + @Enumerated(EnumType.STRING) + @Column(name = "minimum_payment_type", nullable = false) + private DelinquencyMinimumPaymentType minimumPaymentType; +} diff --git a/fineract-core/src/main/java/org/apache/fineract/portfolio/delinquency/domain/DelinquencyMinimumPaymentType.java b/fineract-core/src/main/java/org/apache/fineract/portfolio/delinquency/domain/DelinquencyMinimumPaymentType.java new file mode 100644 index 00000000000..92b9915bf26 --- /dev/null +++ b/fineract-core/src/main/java/org/apache/fineract/portfolio/delinquency/domain/DelinquencyMinimumPaymentType.java @@ -0,0 +1,45 @@ +/** + * 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.domain; + +import java.util.Arrays; +import java.util.List; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import org.apache.fineract.infrastructure.core.data.StringEnumOptionData; + +@Getter +@RequiredArgsConstructor +public enum DelinquencyMinimumPaymentType { + + PERCENTAGE(1L, "delinquencyMinimumPayment.percentage", "Percentage payment type"), // + FLAT(2L, "delinquencyMinimumPayment.flat", "Flat payment type"); + + private final Long id; + private final String code; + private final String description; + + public static List toStringEnumOptions() { + return Arrays.stream(values()).map(DelinquencyMinimumPaymentType::toData).toList(); + } + + public StringEnumOptionData toData() { + return new StringEnumOptionData(name(), getCode(), getDescription()); + } +} diff --git a/fineract-core/src/main/resources/jpa/static-weaving/module/fineract-core/persistence.xml b/fineract-core/src/main/resources/jpa/static-weaving/module/fineract-core/persistence.xml index 4883cc15e81..7d877721793 100644 --- a/fineract-core/src/main/resources/jpa/static-weaving/module/fineract-core/persistence.xml +++ b/fineract-core/src/main/resources/jpa/static-weaving/module/fineract-core/persistence.xml @@ -48,6 +48,7 @@ org.apache.fineract.portfolio.calendar.domain.Calendar org.apache.fineract.portfolio.calendar.domain.CalendarHistory org.apache.fineract.portfolio.client.domain.ClientIdentifier + org.apache.fineract.portfolio.delinquency.domain.DelinquencyMinimumPaymentPeriodAndRule org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucket org.apache.fineract.portfolio.delinquency.domain.DelinquencyRange org.apache.fineract.portfolio.group.domain.StaffAssignmentHistory @@ -68,6 +69,7 @@ false + diff --git a/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/data/delinquency/DelinquencyBucketType.java b/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/data/delinquency/DelinquencyBucketType.java new file mode 100644 index 00000000000..3495b6ae2c8 --- /dev/null +++ b/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/data/delinquency/DelinquencyBucketType.java @@ -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.test.data.delinquency; + +import lombok.Getter; +import lombok.RequiredArgsConstructor; + +@Getter +@RequiredArgsConstructor +public enum DelinquencyBucketType { + + REGULAR(1L, "bucketType.regular", "Reqular Loan Product"), // + WORKING_CAPITAL(2L, "bucketType.workingCapital", "Working Capital Loan Product"); + + private final Long id; + private final String code; + private final String description; +} diff --git a/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/data/delinquency/DelinquencyFrequencyType.java b/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/data/delinquency/DelinquencyFrequencyType.java new file mode 100644 index 00000000000..5400f60b6df --- /dev/null +++ b/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/data/delinquency/DelinquencyFrequencyType.java @@ -0,0 +1,38 @@ +/** + * 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.data.delinquency; + +import lombok.Getter; +import lombok.RequiredArgsConstructor; + +@Getter +@RequiredArgsConstructor +public enum DelinquencyFrequencyType { + + DAYS(0L, "delinquencyFrequencyType.days", "Days frequency"), // + WEEKS(1L, "delinquencyFrequencyType.weeks", "Week frequency"), // + MONTHS(2L, "delinquencyFrequencyType.months", "Month frequency"), // + YEARS(3L, "delinquencyFrequencyType.years", "Year frequency"); + + private final Long id; + private final String code; + private final String description; + +} diff --git a/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/data/delinquency/DelinquencyMinimumPayment.java b/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/data/delinquency/DelinquencyMinimumPayment.java new file mode 100644 index 00000000000..f7d3331a96f --- /dev/null +++ b/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/data/delinquency/DelinquencyMinimumPayment.java @@ -0,0 +1,35 @@ +/** + * 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.data.delinquency; + +import lombok.Getter; +import lombok.RequiredArgsConstructor; + +@Getter +@RequiredArgsConstructor +public enum DelinquencyMinimumPayment { + + PERCENTAGE(1L, "delinquencyMinimumPayment.percentage", "Percentage payment type"), // + FLAT(2L, "delinquencyMinimumPayment.flat", "Flat payment type"); + + private final Long id; + private final String code; + private final String description; + +} diff --git a/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/factory/WorkingCapitalRequestFactory.java b/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/factory/WorkingCapitalRequestFactory.java index cf859ff45c1..3e577ad8afc 100644 --- a/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/factory/WorkingCapitalRequestFactory.java +++ b/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/factory/WorkingCapitalRequestFactory.java @@ -32,11 +32,16 @@ import java.util.ArrayList; import java.util.List; import lombok.RequiredArgsConstructor; +import org.apache.fineract.client.models.DelinquencyBucketRequest; +import org.apache.fineract.client.models.MinimumPaymentPeriodAndRule; import org.apache.fineract.client.models.PaymentAllocationOrder; import org.apache.fineract.client.models.PostAllowAttributeOverrides; import org.apache.fineract.client.models.PostPaymentAllocation; import org.apache.fineract.client.models.PostWorkingCapitalLoanProductsRequest; import org.apache.fineract.client.models.PutWorkingCapitalLoanProductsProductIdRequest; +import org.apache.fineract.test.data.delinquency.DelinquencyBucketType; +import org.apache.fineract.test.data.delinquency.DelinquencyFrequencyType; +import org.apache.fineract.test.data.delinquency.DelinquencyMinimumPayment; import org.apache.fineract.test.helper.Utils; import org.springframework.stereotype.Component; @@ -156,4 +161,16 @@ public static PostPaymentAllocation createPaymentAllocation(String transactionTy return paymentAllocationData; } + public DelinquencyBucketRequest defaultWorkingCapitalDelinquencyBucketRequest() { + return new DelinquencyBucketRequest() // + .name("DB-WCL-" + Utils.randomStringGenerator(8)) // + .bucketType(DelinquencyBucketType.WORKING_CAPITAL.name())// + .ranges(List.of(1L)) // + .minimumPaymentPeriodAndRule(new MinimumPaymentPeriodAndRule() // + .frequency(1) // + .minimumPaymentType(DelinquencyMinimumPayment.PERCENTAGE.name()) // + .frequencyType(DelinquencyFrequencyType.WEEKS.name()) // + .minimumPayment(new BigDecimal("1.23"))); + } + } diff --git a/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/helper/ErrorMessageHelper.java b/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/helper/ErrorMessageHelper.java index 387d57bcff3..5d34b506dc1 100644 --- a/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/helper/ErrorMessageHelper.java +++ b/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/helper/ErrorMessageHelper.java @@ -1044,4 +1044,16 @@ public static String paymentAllocationRulesInvalidValueFailure() { public static String workingCapitalLoanProductIdentifiedDoesNotExistFailure(String identifierId) { return String.format("Working Capital Loan Product with identifier %s does not exist", identifierId); } + + public static String workingCapitalDelinquencyBucketCreateDuplicateNameFailure(Long identifierId) { + return String.format("Data integrity issue with resource: %d", identifierId); + } + + public static String workingCapitalDelinquencyBucketNotFoundFailure(Long id) { + return String.format("Delinquency bucket with id `%d` is not found.", id); + } + + public static String workingCapitalDelinquencyBucketDoesntExistFailure(Long id) { + return String.format("Delinquency bucket with id `%d` does not exist.", id); + } } diff --git a/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/stepdef/common/WorkingCapitalLoanCobStepDef.java b/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/stepdef/common/WorkingCapitalLoanCobStepDef.java index 0b84fd1ff29..2b4c76ff609 100644 --- a/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/stepdef/common/WorkingCapitalLoanCobStepDef.java +++ b/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/stepdef/common/WorkingCapitalLoanCobStepDef.java @@ -77,7 +77,7 @@ public void afterWcCobScenario() { log.debug("After hook: cleaning up {} WC loan(s)", loanIds.size()); for (Long loanId : loanIds) { try { - wcLoanHelper.deleteById(loanId); + // wcLoanHelper.deleteById(loanId); log.debug("After hook: deleted WC loan id={}", loanId); } catch (Exception e) { log.warn("After hook: failed to delete WC loan id={}: {}", loanId, e.getMessage()); diff --git a/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/stepdef/loan/WorkingCapitalDelinquencyConfigStepDef.java b/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/stepdef/loan/WorkingCapitalDelinquencyConfigStepDef.java new file mode 100644 index 00000000000..db58d3062ff --- /dev/null +++ b/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/stepdef/loan/WorkingCapitalDelinquencyConfigStepDef.java @@ -0,0 +1,351 @@ +/** + * 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.stepdef.loan; + +import static org.apache.fineract.client.feign.util.FeignCalls.fail; +import static org.apache.fineract.client.feign.util.FeignCalls.ok; +import static org.assertj.core.api.Assertions.assertThat; + +import io.cucumber.java.en.Then; +import io.cucumber.java.en.When; +import java.math.BigDecimal; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.apache.fineract.client.feign.FineractFeignClient; +import org.apache.fineract.client.feign.util.CallFailedRuntimeException; +import org.apache.fineract.client.models.DelinquencyBucketRequest; +import org.apache.fineract.client.models.DelinquencyBucketResponse; +import org.apache.fineract.client.models.DelinquencyBucketTemplateResponse; +import org.apache.fineract.client.models.DelinquencyMinimumPaymentPeriodAndRuleResponse; +import org.apache.fineract.client.models.DelinquencyRangeResponse; +import org.apache.fineract.client.models.MinimumPaymentPeriodAndRule; +import org.apache.fineract.client.models.PostDelinquencyBucketResponse; +import org.apache.fineract.test.data.delinquency.DelinquencyBucketType; +import org.apache.fineract.test.data.delinquency.DelinquencyFrequencyType; +import org.apache.fineract.test.data.delinquency.DelinquencyMinimumPayment; +import org.apache.fineract.test.factory.WorkingCapitalRequestFactory; +import org.apache.fineract.test.helper.ErrorMessageHelper; +import org.apache.fineract.test.helper.Utils; +import org.apache.fineract.test.stepdef.AbstractStepDef; +import org.apache.fineract.test.support.TestContext; +import org.apache.fineract.test.support.TestContextKey; +import org.assertj.core.api.SoftAssertions; +import org.springframework.beans.factory.annotation.Autowired; + +@Slf4j +@RequiredArgsConstructor +public class WorkingCapitalDelinquencyConfigStepDef extends AbstractStepDef { + + @Autowired + private WorkingCapitalRequestFactory workingCapitalRequestFactory; + + private final FineractFeignClient fineractFeignClient; + + @When("Admin Calls Delinquency Template") + public void adminCallsDelinquencyTemplate() { + DelinquencyBucketTemplateResponse template = ok( + () -> fineractFeignClient.delinquencyRangeAndBucketsManagement().getBucketTemplate()); + assertThat(template).isNotNull(); + log.info("Template DelinquencyBucketData: {}", template); + } + + @Then("Get Delinquency Bucket With Template has the following values") + public void getDelinquencyBucketWithTemplateHasTheFollowingValues() { + Long id = TestContext.GLOBAL.get(TestContextKey.DELINQUENCY_BUCKET_ID); + DelinquencyBucketResponse delinquencyBucketData = ok( + () -> fineractFeignClient.delinquencyRangeAndBucketsManagement().getBucket(id, Map.of("template", "true"))); + log.info("Get Template for Delinquency Bucket Data: {}", delinquencyBucketData); + } + + @When("Admin creates WC Delinquency Bucket With Values") + public void adminCreatesWCDelinquencyBucketWithValues() { + DelinquencyBucketRequest delinquencyBucketRequest = new DelinquencyBucketRequest() // + .name("DB-WCL-" + Utils.randomStringGenerator(12)) // + .bucketType(DelinquencyBucketType.WORKING_CAPITAL.toString())// + .ranges(List.of(1L)) // + .minimumPaymentPeriodAndRule(new MinimumPaymentPeriodAndRule() // + .frequency(1) // + .minimumPaymentType(DelinquencyMinimumPayment.PERCENTAGE.name()) // + .frequencyType(DelinquencyFrequencyType.WEEKS.name()) // + .minimumPayment(BigDecimal.valueOf(1.23D))); // + PostDelinquencyBucketResponse ok = ok( + () -> fineractFeignClient.delinquencyRangeAndBucketsManagement().createBucket(delinquencyBucketRequest)); + assertThat(ok).isNotNull(); + assertThat(ok.getResourceId()).isNotNull(); + TestContext.GLOBAL.set(TestContextKey.DELINQUENCY_BUCKET_ID, ok.getResourceId()); + TestContext.GLOBAL.set(TestContextKey.DELINQUENCY_BUCKET_CREATE_REQUEST, delinquencyBucketRequest); + } + + @When("Admin creates WC Delinquency Bucket With Values for update") + public void adminCreatesWCDelinquencyBucketWithValuesForUpdate() { + DelinquencyBucketRequest delinquencyBucketRequest = workingCapitalRequestFactory.defaultWorkingCapitalDelinquencyBucketRequest() + .name("DB-WCL-" + Utils.randomStringGenerator(12)); // + PostDelinquencyBucketResponse ok = ok( + () -> fineractFeignClient.delinquencyRangeAndBucketsManagement().createBucket(delinquencyBucketRequest)); + assertThat(ok).isNotNull(); + assertThat(ok.getResourceId()).isNotNull(); + TestContext.GLOBAL.set(TestContextKey.DELINQUENCY_BUCKET_ID_FOR_UPDATE, ok.getResourceId()); + TestContext.GLOBAL.set(TestContextKey.DELINQUENCY_BUCKET_CREATE_REQUEST_FOR_UPDATE, delinquencyBucketRequest); + } + + @When("Admin failed to create WC Delinquency Bucket With duplicated name") + public void adminCreateWCDelinquencyBucketWithDuplicateNameFailure() { + Long delinquencyBucketIdForUpdate = TestContext.GLOBAL.get(TestContextKey.DELINQUENCY_BUCKET_ID_FOR_UPDATE); + DelinquencyBucketRequest delinquencyBucketRequestForUpdate = TestContext.GLOBAL + .get(TestContextKey.DELINQUENCY_BUCKET_CREATE_REQUEST_FOR_UPDATE); + String name = delinquencyBucketRequestForUpdate.getName(); + DelinquencyBucketRequest delinquencyBucketRequest = workingCapitalRequestFactory.defaultWorkingCapitalDelinquencyBucketRequest() + .name(name); // + String errorMessage = ErrorMessageHelper.workingCapitalDelinquencyBucketCreateDuplicateNameFailure(delinquencyBucketIdForUpdate); + checkCreateWCDelinquencyBucketWithInvalidDataFailure(delinquencyBucketRequest, errorMessage, 403); + } + + @Then("Admin failed to create a new WC Delinquency Bucket for field {string} with invalid data {string} results with an error {}") + public void createWCDelinquencyBucketWithInvalidDataFailed(String fieldName, String value, String errorMessage) { + final String workingCapitalDelinquencyBucketName = "DB-WCL-" + Utils.randomStringGenerator(12); // + final DelinquencyBucketRequest defaultWCDelinquencyBucketCreateRequest = workingCapitalRequestFactory + .defaultWorkingCapitalDelinquencyBucketRequest() // + .name(workingCapitalDelinquencyBucketName); // + + final DelinquencyBucketRequest wcDelinquencyBucketCreateRequestUpdated = setWCDelinquencyBucketCreateFieldValue( + defaultWCDelinquencyBucketCreateRequest, fieldName, value); + checkCreateWCDelinquencyBucketWithInvalidDataFailure(wcDelinquencyBucketCreateRequestUpdated, errorMessage, 400); + } + + @When("Admin modifies WC Delinquency Bucket With Values") + public void adminModifiesWCDelinquencyBucketWithValues() { + Long id = TestContext.GLOBAL.get(TestContextKey.DELINQUENCY_BUCKET_ID); + DelinquencyBucketResponse delinquencyBucketData = ok( + () -> fineractFeignClient.delinquencyRangeAndBucketsManagement().getBucket(id)); + DelinquencyBucketRequest delinquencyBucketRequest = new DelinquencyBucketRequest() // + .ranges(delinquencyBucketData.getRanges().stream().map(DelinquencyRangeResponse::getId).toList()) // + .name(delinquencyBucketData.getName()) // + .bucketType(DelinquencyBucketType.WORKING_CAPITAL.name())// + .minimumPaymentPeriodAndRule(new MinimumPaymentPeriodAndRule() // + .minimumPayment(BigDecimal.valueOf(7.89D)) // + .minimumPaymentType(DelinquencyMinimumPayment.FLAT.name()) // + .frequencyType(DelinquencyFrequencyType.YEARS.name()) // + .frequency(4) // + ); + ok(() -> fineractFeignClient.delinquencyRangeAndBucketsManagement().updateBucket(id, delinquencyBucketRequest)); + TestContext.GLOBAL.set(TestContextKey.DELINQUENCY_BUCKET_UPDATE_REQUEST, delinquencyBucketRequest); + } + + @Then("Admin failed to update WC Delinquency Bucket for field {string} with invalid data {string} results with an error {}") + public void updateWCDelinquencyBucketWithInvalidDataFailed(String fieldName, String value, String errorMessage) { + + Long delinquencyBucketIdForUpdate = TestContext.GLOBAL.get(TestContextKey.DELINQUENCY_BUCKET_ID_FOR_UPDATE); + DelinquencyBucketRequest delinquencyBucketRequestForUpdate = TestContext.GLOBAL + .get(TestContextKey.DELINQUENCY_BUCKET_CREATE_REQUEST_FOR_UPDATE); + String delinquencyBucketNameForUpdate = delinquencyBucketRequestForUpdate.getName(); + final DelinquencyBucketRequest defaultWCDelinquencyBucketCreateRequest = workingCapitalRequestFactory + .defaultWorkingCapitalDelinquencyBucketRequest().name(delinquencyBucketNameForUpdate); // + + final DelinquencyBucketRequest wcDelinquencyBucketCreateRequestUpdated = setWCDelinquencyBucketCreateFieldValue( + defaultWCDelinquencyBucketCreateRequest, fieldName, value); + checkUpdateWCDelinquencyBucketWithInvalidDataFailure(delinquencyBucketIdForUpdate, wcDelinquencyBucketCreateRequestUpdated, + errorMessage, 400); + } + + @When("Admin failed to update WC Delinquency Bucket With duplicated name") + public void adminUpdateWCDelinquencyBucketWithDuplicateNameFailure() { + Long delinquencyBucketIdForUpdate = TestContext.GLOBAL.get(TestContextKey.DELINQUENCY_BUCKET_ID_FOR_UPDATE); + Long delinquencyBucketId = TestContext.GLOBAL.get(TestContextKey.DELINQUENCY_BUCKET_ID); + DelinquencyBucketRequest delinquencyBucketRequestForUpdate = TestContext.GLOBAL + .get(TestContextKey.DELINQUENCY_BUCKET_CREATE_REQUEST); + String name = delinquencyBucketRequestForUpdate.getName(); + DelinquencyBucketRequest delinquencyBucketRequest = workingCapitalRequestFactory.defaultWorkingCapitalDelinquencyBucketRequest() // + .name(name); // + String errorMessage = ErrorMessageHelper.workingCapitalDelinquencyBucketCreateDuplicateNameFailure(delinquencyBucketId); + checkUpdateWCDelinquencyBucketWithInvalidDataFailure(delinquencyBucketIdForUpdate, delinquencyBucketRequest, errorMessage, 403); + } + + @Then("Check created Delinquency Bucket has the following values") + public void checkCreatedDelinquencyBucketHasTheFollowingValues() { + Long id = TestContext.GLOBAL.get(TestContextKey.DELINQUENCY_BUCKET_ID); + DelinquencyBucketResponse delinquencyBucketData = ok( + () -> fineractFeignClient.delinquencyRangeAndBucketsManagement().getBucket(id)); + DelinquencyBucketRequest delinquencyBucketRequest = TestContext.GLOBAL.get(TestContextKey.DELINQUENCY_BUCKET_CREATE_REQUEST); + checkDelinquencyBucketData(delinquencyBucketRequest, delinquencyBucketData); + log.info("Get DelinquencyBucketData : {} matches with create request data: {}", delinquencyBucketData, delinquencyBucketRequest); + } + + @Then("Check updated Delinquency Bucket has the following values") + public void checkUpdatedDelinquencyBucketHasTheFollowingValues() { + Long id = TestContext.GLOBAL.get(TestContextKey.DELINQUENCY_BUCKET_ID); + DelinquencyBucketResponse delinquencyBucketData = ok( + () -> fineractFeignClient.delinquencyRangeAndBucketsManagement().getBucket(id)); + DelinquencyBucketRequest delinquencyBucketRequest = TestContext.GLOBAL.get(TestContextKey.DELINQUENCY_BUCKET_UPDATE_REQUEST); + checkDelinquencyBucketData(delinquencyBucketRequest, delinquencyBucketData); + log.info("Get DelinquencyBucketData : {} matches with update request data: {}", delinquencyBucketData, delinquencyBucketRequest); + } + + @Then("Admin failed to retrieve WC Delinquency Bucket with id {int} that is not found") + public void adminRetrieveWCDelinquencyBucketAlreadyDeletedFailure(Integer id) { + checkRetrieveWCDelinquencyBucketNotFoundFailure(Long.valueOf(id)); + } + + @When("Admin deletes WC Delinquency Bucket With Values") + public void adminDeletesWCDelinquencyBucketWithValues() { + Long id = TestContext.GLOBAL.get(TestContextKey.DELINQUENCY_BUCKET_ID); + ok(() -> fineractFeignClient.delinquencyRangeAndBucketsManagement().deleteBucket(id)); + } + + @When("Admin deletes WC Delinquency Bucket With Values for update") + public void adminDeletesWCDelinquencyBucketWithValuesForUpdate() { + Long id = TestContext.GLOBAL.get(TestContextKey.DELINQUENCY_BUCKET_ID_FOR_UPDATE); + ok(() -> fineractFeignClient.delinquencyRangeAndBucketsManagement().deleteBucket(id)); + } + + @Then("Admin failed to delete WC Delinquency Bucket that is already deleted") + public void adminDeleteWCDelinquencyBucketAlreadyDeletedFailure() { + Long id = TestContext.GLOBAL.get(TestContextKey.DELINQUENCY_BUCKET_ID_FOR_UPDATE); + checkDeleteWCDelinquencyBucketDoesntExistFailure(id); + } + + @Then("Admin failed to delete WC Delinquency Bucket with id {int} that doesn't exist") + public void adminDeleteWCDelinquencyBucketAlreadyDeletedFailure(Integer id) { + checkDeleteWCDelinquencyBucketDoesntExistFailure(Long.valueOf(id)); + } + + @Then("Admin failed to retrieve WC Delinquency Bucket that is already deleted") + public void adminRetrieveWCDelinquencyBucketAlreadyDeletedFailure() { + Long id = TestContext.GLOBAL.get(TestContextKey.DELINQUENCY_BUCKET_ID_FOR_UPDATE); + checkRetrieveWCDelinquencyBucketNotFoundFailure(id); + } + + public void checkRetrieveWCDelinquencyBucketNotFoundFailure(Long id) { + CallFailedRuntimeException exception = fail(() -> fineractFeignClient.delinquencyRangeAndBucketsManagement().getBucket(id)); + String errorMessage = ErrorMessageHelper.workingCapitalDelinquencyBucketNotFoundFailure(id); + assertThat(exception.getStatus()).as(errorMessage).isEqualTo(404); + assertThat(exception.getDeveloperMessage()).contains(errorMessage); + } + + public void checkCreateWCDelinquencyBucketWithInvalidDataFailure(DelinquencyBucketRequest defaultWCDelinquencyBucketCreateRequest, + String errorMessage, int errorCode) { + CallFailedRuntimeException exception = fail( + () -> fineractFeignClient.delinquencyRangeAndBucketsManagement().createBucket(defaultWCDelinquencyBucketCreateRequest)); + assertThat(exception.getStatus()).as(ErrorMessageHelper.incorrectExpectedValueInResponse()).isEqualTo(errorCode); + assertThat(exception.getDeveloperMessage()).contains(errorMessage); + } + + public DelinquencyBucketRequest setWCDelinquencyBucketCreateFieldValue(DelinquencyBucketRequest delinquencyBucketRequest, + String fieldName, String fieldValue) { + if (fieldValue.equals("null")) { + fieldValue = null; + } + Integer valueInt = null; + BigDecimal valueBigDecimal = null; + if (fieldName.equalsIgnoreCase("frequency")) { + valueInt = fieldValue != null ? Integer.valueOf(fieldValue) : null; + } + if (fieldName.equalsIgnoreCase("minimumPayment")) { + valueBigDecimal = fieldValue != null ? new BigDecimal(fieldValue) : null; + } + List valueArrayList = new ArrayList<>(); + if (fieldName.equalsIgnoreCase("ranges")) { + assert fieldValue != null; + valueArrayList = fieldValue.equalsIgnoreCase("[]") ? new ArrayList<>() : new ArrayList<>(List.of(Long.valueOf(fieldValue))); + } + MinimumPaymentPeriodAndRule minimumPaymentPeriodAndRuleRequest = delinquencyBucketRequest.getMinimumPaymentPeriodAndRule(); + assert minimumPaymentPeriodAndRuleRequest != null; + + switch (fieldName) { + case "name": + delinquencyBucketRequest.setName(fieldValue); + break; + case "ranges": + delinquencyBucketRequest.setRanges(valueArrayList); + break; + case "bucketType": + delinquencyBucketRequest.setBucketType(fieldValue); + break; + case "minimumPaymentPeriodAndRule": + delinquencyBucketRequest.setMinimumPaymentPeriodAndRule(fieldValue == null ? null : minimumPaymentPeriodAndRuleRequest); + break; + case "frequency": + minimumPaymentPeriodAndRuleRequest.setFrequency(valueInt); + break; + case "frequencyType": + minimumPaymentPeriodAndRuleRequest.setFrequencyType(fieldValue); + break; + case "minimumPayment": + minimumPaymentPeriodAndRuleRequest.setMinimumPayment(valueBigDecimal); + break; + case "minimumPaymentType": + minimumPaymentPeriodAndRuleRequest.setMinimumPaymentType(fieldValue); + break; + default: + break; + } + return delinquencyBucketRequest; + } + + public void checkDelinquencyBucketData(DelinquencyBucketRequest delinquencyBucketRequest, + DelinquencyBucketResponse delinquencyBucketData) { + SoftAssertions assertions = new SoftAssertions(); + assertions.assertThat(delinquencyBucketRequest.getName()).isEqualTo(delinquencyBucketData.getName()); + assert delinquencyBucketRequest.getBucketType() != null; + assertions.assertThat(delinquencyBucketRequest.getBucketType()).isEqualTo(delinquencyBucketData.getBucketType().getId()); + + // minimum payment period and rule + MinimumPaymentPeriodAndRule minimumPaymentPeriodAndRuleRequest = delinquencyBucketRequest.getMinimumPaymentPeriodAndRule(); + DelinquencyMinimumPaymentPeriodAndRuleResponse minimumPaymentPeriodAndRuleResponse = delinquencyBucketData + .getMinimumPaymentPeriodAndRule(); + assert minimumPaymentPeriodAndRuleRequest != null; + assert minimumPaymentPeriodAndRuleResponse != null; + assertions.assertThat( + minimumPaymentPeriodAndRuleRequest.getMinimumPayment().compareTo(minimumPaymentPeriodAndRuleResponse.getMinimumPayment())) + .isEqualTo(0); + assert minimumPaymentPeriodAndRuleResponse.getMinimumPaymentType() != null; + assertions.assertThat(minimumPaymentPeriodAndRuleRequest.getMinimumPaymentType()) + .isEqualTo(minimumPaymentPeriodAndRuleResponse.getMinimumPaymentType().getId()); + assertions.assertThat(minimumPaymentPeriodAndRuleRequest.getFrequency()) + .isEqualTo(minimumPaymentPeriodAndRuleResponse.getFrequency()); + assert minimumPaymentPeriodAndRuleResponse.getFrequencyType() != null; + assertions.assertThat(minimumPaymentPeriodAndRuleRequest.getFrequencyType()) + .isEqualTo(minimumPaymentPeriodAndRuleResponse.getFrequencyType().getId()); + + // ranges + assert delinquencyBucketData.getRanges() != null; + assertions.assertThat(delinquencyBucketRequest.getRanges()) + .containsAll(delinquencyBucketData.getRanges().stream().map(DelinquencyRangeResponse::getId).toList()); + + assertions.assertAll(); + } + + public void checkUpdateWCDelinquencyBucketWithInvalidDataFailure(Long id, DelinquencyBucketRequest defaultWCDelinquencyBucketRequest, + String errorMessage, int errorCode) { + CallFailedRuntimeException exception = fail( + () -> fineractFeignClient.delinquencyRangeAndBucketsManagement().updateBucket(id, defaultWCDelinquencyBucketRequest)); + assertThat(exception.getStatus()).as(ErrorMessageHelper.incorrectExpectedValueInResponse()).isEqualTo(errorCode); + assertThat(exception.getDeveloperMessage()).contains(errorMessage); + } + + public void checkDeleteWCDelinquencyBucketDoesntExistFailure(Long id) { + CallFailedRuntimeException exception = fail(() -> fineractFeignClient.delinquencyRangeAndBucketsManagement().deleteBucket(id)); + String errorMessage = ErrorMessageHelper.workingCapitalDelinquencyBucketDoesntExistFailure(id); + assertThat(exception.getStatus()).as(errorMessage).isEqualTo(404); + assertThat(exception.getDeveloperMessage()).contains(errorMessage); + } + +} diff --git a/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/stepdef/loan/WorkingCapitalStepDef.java b/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/stepdef/loan/WorkingCapitalStepDef.java index f74b8d8163c..d8c06017f5a 100644 --- a/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/stepdef/loan/WorkingCapitalStepDef.java +++ b/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/stepdef/loan/WorkingCapitalStepDef.java @@ -46,7 +46,6 @@ import org.apache.fineract.test.helper.ErrorMessageHelper; import org.apache.fineract.test.helper.Utils; import org.apache.fineract.test.stepdef.AbstractStepDef; -import org.apache.fineract.test.support.TestContext; import org.apache.fineract.test.support.TestContextKey; import org.assertj.core.api.SoftAssertions; import org.springframework.beans.factory.annotation.Autowired; @@ -225,8 +224,8 @@ public void updateWorkingCapitalLoanProductWithMaxLengthDataFailed(String fieldN final PutWorkingCapitalLoanProductsProductIdRequest workingCapitalLoanProductUpdateRequestUpdated = setWorkingCapitalLoanProductsUpdateRequest( defaultWorkingCapitalLoanProductUpdateRequest, fieldName, value); - PostWorkingCapitalLoanProductsResponse workingCapitalLoanProductsResponse = TestContext.GLOBAL - .get(TestContextKey.DEFAULT_WORKING_CAPITAL_LOAN_PRODUCT_CREATE_RESPONSE_FOR_UPDATE_WCLP); + PostWorkingCapitalLoanProductsResponse workingCapitalLoanProductsResponse = testContext() + .get(TestContextKey.WORKING_CAPITAL_LOAN_PRODUCT_CREATE_RESPONSE); Long resourceId = workingCapitalLoanProductsResponse.getResourceId(); String errorMessage = ErrorMessageHelper.fieldValueMoreMaxLengthAllowedFailure(fieldName, maxAllowedLengthValue); @@ -235,8 +234,8 @@ public void updateWorkingCapitalLoanProductWithMaxLengthDataFailed(String fieldN @Then("Admin failed to update a new Working Capital Loan Product field {string} with zero incorrect value") public void updateWorkingCapitalLoanProductWithZeroValueDataFailed(String fieldName) { - PostWorkingCapitalLoanProductsResponse workingCapitalLoanProductsResponse = TestContext.GLOBAL - .get(TestContextKey.DEFAULT_WORKING_CAPITAL_LOAN_PRODUCT_CREATE_RESPONSE_FOR_UPDATE_WCLP); + PostWorkingCapitalLoanProductsResponse workingCapitalLoanProductsResponse = testContext() + .get(TestContextKey.WORKING_CAPITAL_LOAN_PRODUCT_CREATE_RESPONSE); Long resourceId = workingCapitalLoanProductsResponse.getResourceId(); String errorMessage = ErrorMessageHelper.fieldValueZeroValueFailure(fieldName); updateWorkingCapitalLoanProductWithInvalidDataFailure(resourceId, fieldName, "0", errorMessage); @@ -244,15 +243,15 @@ public void updateWorkingCapitalLoanProductWithZeroValueDataFailed(String fieldN @Then("Admin failed to update a new Working Capital Loan Product field {string} with invalid data {string} and got an error {string}") public void updateWorkingCapitalLoanProductWithInvalidDataFailed(String fieldName, String value, String errorMessage) { - final PostWorkingCapitalLoanProductsRequest workingCapitalProductForUpdateRequest = TestContext.GLOBAL - .get(TestContextKey.DEFAULT_WORKING_CAPITAL_LOAN_PRODUCT_CREATE_REQUEST_FOR_UPDATE_WCLP); + final PostWorkingCapitalLoanProductsRequest workingCapitalProductForUpdateRequest = testContext() + .get(TestContextKey.WORKING_CAPITAL_LOAN_PRODUCT_CREATE_REQUEST); String workingCapitalProductName = workingCapitalProductForUpdateRequest.getName(); final PutWorkingCapitalLoanProductsProductIdRequest defaultWorkingCapitalLoanProductUpdateRequest = workingCapitalRequestFactory .defaultWorkingCapitalLoanProductRequestUpdate() // .name(workingCapitalProductName); // - PostWorkingCapitalLoanProductsResponse workingCapitalLoanProductsResponse = TestContext.GLOBAL - .get(TestContextKey.DEFAULT_WORKING_CAPITAL_LOAN_PRODUCT_CREATE_RESPONSE_FOR_UPDATE_WCLP); + PostWorkingCapitalLoanProductsResponse workingCapitalLoanProductsResponse = testContext() + .get(TestContextKey.WORKING_CAPITAL_LOAN_PRODUCT_CREATE_RESPONSE); Long resourceId = workingCapitalLoanProductsResponse.getResourceId(); updateWorkingCapitalLoanProductWithInvalidDataFailure(defaultWorkingCapitalLoanProductUpdateRequest, resourceId, fieldName, value, errorMessage); @@ -263,8 +262,8 @@ public void updateWorkingCapitalLoanProductWithInvalidNumberPaymentAllocationFai final PutWorkingCapitalLoanProductsProductIdRequest defaultWorkingCapitalLoanProductUpdateRequest = new PutWorkingCapitalLoanProductsProductIdRequest() .paymentAllocation( workingCapitalRequestFactory.invalidNumberOfPaymentAllocationRulesForWorkingCapitalLoanProductUpdateRequest()); - PostWorkingCapitalLoanProductsResponse workingCapitalLoanProductsResponse = TestContext.GLOBAL - .get(TestContextKey.DEFAULT_WORKING_CAPITAL_LOAN_PRODUCT_CREATE_RESPONSE_FOR_UPDATE_WCLP); + PostWorkingCapitalLoanProductsResponse workingCapitalLoanProductsResponse = testContext() + .get(TestContextKey.WORKING_CAPITAL_LOAN_PRODUCT_CREATE_RESPONSE); Long resourceId = workingCapitalLoanProductsResponse.getResourceId(); String errorMessage = ErrorMessageHelper.paymentAllocationRulesInvalidNumberFailure(4); @@ -275,8 +274,8 @@ public void updateWorkingCapitalLoanProductWithInvalidNumberPaymentAllocationFai public void updateWorkingCapitalLoanProductWithInvalidPaymentAllocationFailed() { final PutWorkingCapitalLoanProductsProductIdRequest defaultWorkingCapitalLoanProductUpdateRequest = new PutWorkingCapitalLoanProductsProductIdRequest() .paymentAllocation(workingCapitalRequestFactory.invalidPaymentAllocationRulesForWorkingCapitalLoanProductUpdateRequest()); - PostWorkingCapitalLoanProductsResponse workingCapitalLoanProductsResponse = TestContext.GLOBAL - .get(TestContextKey.DEFAULT_WORKING_CAPITAL_LOAN_PRODUCT_CREATE_RESPONSE_FOR_UPDATE_WCLP); + PostWorkingCapitalLoanProductsResponse workingCapitalLoanProductsResponse = testContext() + .get(TestContextKey.WORKING_CAPITAL_LOAN_PRODUCT_CREATE_RESPONSE); Long resourceId = workingCapitalLoanProductsResponse.getResourceId(); String errorMessage = ErrorMessageHelper.paymentAllocationRulesInvalidValueFailure(); @@ -800,4 +799,5 @@ public void checkWorkingCapitalLoanProductDeleteFailure(Long productId) { assertThat(exception.getDeveloperMessage()) .contains(ErrorMessageHelper.workingCapitalLoanProductIdentifiedDoesNotExistFailure(String.valueOf(productId))); } + } diff --git a/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/support/TestContextKey.java b/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/support/TestContextKey.java index 2b3f9be13ee..d9ec674020c 100644 --- a/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/support/TestContextKey.java +++ b/fineract-e2e-tests-core/src/test/java/org/apache/fineract/test/support/TestContextKey.java @@ -325,4 +325,11 @@ public abstract class TestContextKey { public static final String WORKING_CAPITAL_LOAN_PRODUCT_CREATE_RESPONSE = "workingCapitalLoanProductCreateResponse"; public static final String WORKING_CAPITAL_LOAN_PRODUCT_UPDATE_REQUEST = "workingCapitalLoanProductUpdateRequest"; public static final String WORKING_CAPITAL_LOAN_PRODUCT_UPDATE_RESPONSE = "workingCapitalLoanProductUpdateResponse"; + public static final String DELINQUENCY_BUCKET_ID = "delinquencyBucketId"; + public static final String DELINQUENCY_BUCKET_CREATE_REQUEST = "delinquencyBucketCreateRequest"; + public static final String DELINQUENCY_BUCKET_UPDATE_REQUEST = "delinquencyBucketUpdateRequest"; + + public static final String DELINQUENCY_BUCKET_ID_FOR_UPDATE = "delinquencyBucketIdForUpdate"; + public static final String DELINQUENCY_BUCKET_CREATE_REQUEST_FOR_UPDATE = "delinquencyBucketCreateRequestForUpdate"; + public static final String DELINQUENCY_BUCKET_CREATE_RESPONSE_FOR_UPDATE_DUPLICATE = "delinquencyBucketUpdateRequestForUpdateDuplicate"; } diff --git a/fineract-e2e-tests-runner/src/test/java/org/apache/fineract/test/initializer/global/DelinquencyGlobalInitializerStep.java b/fineract-e2e-tests-runner/src/test/java/org/apache/fineract/test/initializer/global/DelinquencyGlobalInitializerStep.java index f022a26a941..bff27d8190d 100644 --- a/fineract-e2e-tests-runner/src/test/java/org/apache/fineract/test/initializer/global/DelinquencyGlobalInitializerStep.java +++ b/fineract-e2e-tests-runner/src/test/java/org/apache/fineract/test/initializer/global/DelinquencyGlobalInitializerStep.java @@ -21,6 +21,7 @@ import static org.apache.fineract.client.feign.util.FeignCalls.executeVoid; import static org.apache.fineract.client.feign.util.FeignCalls.ok; +import java.math.BigDecimal; import java.util.ArrayList; import java.util.Arrays; import java.util.List; @@ -28,11 +29,15 @@ import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; import org.apache.fineract.client.feign.FineractFeignClient; -import org.apache.fineract.client.models.DelinquencyBucketData; import org.apache.fineract.client.models.DelinquencyBucketRequest; -import org.apache.fineract.client.models.DelinquencyRangeData; +import org.apache.fineract.client.models.DelinquencyBucketResponse; import org.apache.fineract.client.models.DelinquencyRangeRequest; +import org.apache.fineract.client.models.DelinquencyRangeResponse; +import org.apache.fineract.client.models.MinimumPaymentPeriodAndRule; import org.apache.fineract.client.models.PostDelinquencyRangeResponse; +import org.apache.fineract.test.data.delinquency.DelinquencyBucketType; +import org.apache.fineract.test.data.delinquency.DelinquencyFrequencyType; +import org.apache.fineract.test.data.delinquency.DelinquencyMinimumPayment; import org.springframework.core.Ordered; import org.springframework.core.annotation.Order; import org.springframework.stereotype.Component; @@ -46,6 +51,7 @@ public class DelinquencyGlobalInitializerStep implements FineractGlobalInitializ public static final String DEFAULT_LOCALE = "en"; public static final List DEFAULT_DELINQUENCY_RANGES = Arrays.asList(1, 3, 30, 60, 90, 120, 150, 180, 240); public static final String DEFAULT_DELINQUENCY_BUCKET_NAME = "Default delinquency bucket"; + public static final String DEFAULT_WC_DELINQUENCY_BUCKET_NAME = "Default Working Capital delinquency bucket"; private final FineractFeignClient fineractClient; @@ -55,12 +61,13 @@ public class DelinquencyGlobalInitializerStep implements FineractGlobalInitializ public void initialize() { setDefaultDelinquencyRanges(); setDefaultDelinquencyBucket(); + setDefaultWCDelinquencyBucket(); } public void setDefaultDelinquencyRanges() { - List existingRanges; + List existingRanges; try { - existingRanges = fineractClient.delinquencyRangeAndBucketsManagement().getDelinquencyRanges(Map.of()); + existingRanges = fineractClient.delinquencyRangeAndBucketsManagement().getRanges(Map.of()); } catch (Exception e) { log.debug("Could not retrieve existing delinquency ranges, will create them", e); existingRanges = new ArrayList<>(); @@ -69,7 +76,7 @@ public void setDefaultDelinquencyRanges() { for (int i = 0; i < DEFAULT_DELINQUENCY_RANGES.size() - 1; i++) { String classification = "Delinquency range " + DEFAULT_DELINQUENCY_RANGES.get(i).toString(); - DelinquencyRangeData existingRange = existingRanges.stream().filter(r -> classification.equals(r.getClassification())) + DelinquencyRangeResponse existingRange = existingRanges.stream().filter(r -> classification.equals(r.getClassification())) .findFirst().orElse(null); if (existingRange != null) { @@ -88,13 +95,13 @@ public void setDefaultDelinquencyRanges() { postDelinquencyRangeRequest.maximumAgeDays(DEFAULT_DELINQUENCY_RANGES.get(i + 1)); } - PostDelinquencyRangeResponse response = ok(() -> fineractClient.delinquencyRangeAndBucketsManagement() - .createDelinquencyRange(postDelinquencyRangeRequest, Map.of())); + PostDelinquencyRangeResponse response = ok( + () -> fineractClient.delinquencyRangeAndBucketsManagement().createRange(postDelinquencyRangeRequest, Map.of())); createdRangeIds.add(response.getResourceId()); } String lastClassification = "Delinquency range " + DEFAULT_DELINQUENCY_RANGES.get(DEFAULT_DELINQUENCY_RANGES.size() - 1).toString(); - DelinquencyRangeData existingLastRange = existingRanges.stream().filter(r -> lastClassification.equals(r.getClassification())) + DelinquencyRangeResponse existingLastRange = existingRanges.stream().filter(r -> lastClassification.equals(r.getClassification())) .findFirst().orElse(null); if (existingLastRange != null) { @@ -109,14 +116,13 @@ public void setDefaultDelinquencyRanges() { lastRange.maximumAgeDays(null); PostDelinquencyRangeResponse lastResponse = ok( - () -> fineractClient.delinquencyRangeAndBucketsManagement().createDelinquencyRange(lastRange, Map.of())); + () -> fineractClient.delinquencyRangeAndBucketsManagement().createRange(lastRange, Map.of())); createdRangeIds.add(lastResponse.getResourceId()); } public void setDefaultDelinquencyBucket() { try { - List existingBuckets = fineractClient.delinquencyRangeAndBucketsManagement() - .getDelinquencyBuckets(Map.of()); + List existingBuckets = fineractClient.delinquencyRangeAndBucketsManagement().getBuckets(Map.of()); boolean bucketExists = existingBuckets.stream().anyMatch(b -> DEFAULT_DELINQUENCY_BUCKET_NAME.equals(b.getName())); if (bucketExists) { @@ -130,7 +136,30 @@ public void setDefaultDelinquencyBucket() { postDelinquencyBucketRequest.name(DEFAULT_DELINQUENCY_BUCKET_NAME); postDelinquencyBucketRequest.ranges(createdRangeIds); - executeVoid(() -> fineractClient.delinquencyRangeAndBucketsManagement().createDelinquencyBucket(postDelinquencyBucketRequest, - Map.of())); + executeVoid(() -> fineractClient.delinquencyRangeAndBucketsManagement().createBucket(postDelinquencyBucketRequest, Map.of())); + } + + public void setDefaultWCDelinquencyBucket() { + try { + List existingBuckets = fineractClient.delinquencyRangeAndBucketsManagement().getBuckets(Map.of()); + boolean bucketExists = existingBuckets.stream().anyMatch(b -> DEFAULT_WC_DELINQUENCY_BUCKET_NAME.equals(b.getName())); + + if (bucketExists) { + return; + } + } catch (Exception e) { + log.debug("Could not retrieve existing working capital delinquency buckets, will create default bucket", e); + } + + DelinquencyBucketRequest postDelinquencyBucketWCRequest = new DelinquencyBucketRequest().name(DEFAULT_WC_DELINQUENCY_BUCKET_NAME) + .bucketType(DelinquencyBucketType.WORKING_CAPITAL.name())// + .ranges(List.of(1L)) // + .minimumPaymentPeriodAndRule(new MinimumPaymentPeriodAndRule() // + .frequency(1) // + .minimumPaymentType(DelinquencyMinimumPayment.PERCENTAGE.name()) // + .frequencyType(DelinquencyFrequencyType.MONTHS.name()) // + .minimumPayment(BigDecimal.valueOf(1.23))); // + + executeVoid(() -> fineractClient.delinquencyRangeAndBucketsManagement().createBucket(postDelinquencyBucketWCRequest, Map.of())); } } diff --git a/fineract-e2e-tests-runner/src/test/resources/features/WorkingCapitalDelinquencyConfiguration.feature b/fineract-e2e-tests-runner/src/test/resources/features/WorkingCapitalDelinquencyConfiguration.feature new file mode 100644 index 00000000000..970b8d48359 --- /dev/null +++ b/fineract-e2e-tests-runner/src/test/resources/features/WorkingCapitalDelinquencyConfiguration.feature @@ -0,0 +1,72 @@ +@WorkingCapitalDelinquencyManagementFeature +Feature: Working Capital Delinquency Configuration + + @TestRailId:C72329 + Scenario: Verify Working Capital Delinquency Configuration CRUD - UC1 + When Admin Calls Delinquency Template + When Admin creates WC Delinquency Bucket With Values + Then Check created Delinquency Bucket has the following values + Then Get Delinquency Bucket With Template has the following values + When Admin modifies WC Delinquency Bucket With Values + Then Check updated Delinquency Bucket has the following values + When Admin deletes WC Delinquency Bucket With Values + + @TestRailId:C72330 + Scenario Outline: Verify Working Capital Delinquency Configuration create with invalid data shall outcome with error - UC2 + Then Admin failed to create a new WC Delinquency Bucket for field "" with invalid data results with an error + + Examples: + | wc_db_field_name_invalid | wc_db_field_value_invalid | wc_db_error_message | + | name | "null" | The parameter `name` is mandatory. | + | name | "" | The parameter `name` is mandatory. | + | ranges | "[]" | The parameter `ranges` cannot be empty. You must select at least one. | + | bucketType | "INVALID" | The parameter `bucketType` must be one of [ REGULAR, WORKING_CAPITAL ] . | + | minimumPayment | "-1" | The parameter `minimumPayment` must be greater than 0. | + | minimumPaymentType | "INVALID" | The parameter `minimumPaymentType` must be one of [ PERCENTAGE, FLAT ] . | + | frequencyType | "INVALID" | The parameter `frequencyType` must be one of [ DAYS, WEEKS, MONTHS, YEARS ] . | + | minimumPaymentPeriodAndRule | "null" | The parameter `minimumPaymentPeriodAndRule` is mandatory. | + + @TestRailId:C72331 + Scenario: Verify Working Capital Delinquency Configuration create validation with existing name outcomes with error - UC3 + When Admin creates WC Delinquency Bucket With Values for update + Then Admin failed to create WC Delinquency Bucket With duplicated name + + @TestRailId:C72332 + Scenario Outline: Verify Working Capital Delinquency Configuration update with invalid data shall outcome with error - UC4 + Then Admin failed to update WC Delinquency Bucket for field "" with invalid data results with an error + + Examples: + | wc_db_field_name_invalid | wc_db_field_value_invalid | wc_db_error_message | + | ranges | "[]" | The parameter `ranges` cannot be empty. You must select at least one. | + | bucketType | "INVALID" | The parameter `bucketType` must be one of [ REGULAR, WORKING_CAPITAL ] . | + | minimumPayment | "-1" | The parameter `minimumPayment` must be greater than 0. | + | minimumPaymentType | "INVALID" | The parameter `minimumPaymentType` must be one of [ PERCENTAGE, FLAT ] . | + | frequencyType | "INVALID" | The parameter `frequencyType` must be one of [ DAYS, WEEKS, MONTHS, YEARS ] . | + + @TestRailId:C72333 + Scenario: Verify Working Capital Delinquency Configuration update validation with existing name outcomes with error - UC5 + When Admin creates WC Delinquency Bucket With Values + Then Admin failed to update WC Delinquency Bucket With duplicated name + When Admin deletes WC Delinquency Bucket With Values + + @TestRailId:C72334 + Scenario: Verify deleting Working Capital Delinquency Configuration that is already deleted failure - UC6 + When Admin deletes WC Delinquency Bucket With Values for update + Then Admin failed to delete WC Delinquency Bucket that is already deleted + Then Admin failed to retrieve WC Delinquency Bucket that is already deleted + + @TestRailId:C72335 + Scenario Outline: Verify Working capital Delinquency Bucket delete with invalid data shall outcome with error - validation check with id - UC7 + Then Admin failed to delete WC Delinquency Bucket with id that doesn't exist + Examples: + | wcp_field_name_incorrect_value | + | 103284 | + | 0 | + + @TestRailId:C72336 + Scenario Outline: Verify Working capital Delinquency Bucket retrieve with invalid data shall outcome with error - validation check with id - UC8 + Then Admin failed to retrieve WC Delinquency Bucket with id that is not found + Examples: + | wcp_field_name_incorrect_value | + | 565465 | + | 0 | diff --git a/fineract-e2e-tests-runner/src/test/resources/features/WorkingCapitalLoanProduct.feature b/fineract-e2e-tests-runner/src/test/resources/features/WorkingCapitalLoanProduct.feature index 63c2acbc5cd..4ec75ee1611 100644 --- a/fineract-e2e-tests-runner/src/test/resources/features/WorkingCapitalLoanProduct.feature +++ b/fineract-e2e-tests-runner/src/test/resources/features/WorkingCapitalLoanProduct.feature @@ -47,6 +47,7 @@ Feature: WorkingCapitalLoanProduct @TestRailId:C70212 Scenario Outline: Verify Working capital Loan Product update with invalid data shall outcome with error - validation check with max allowed length - UC5 + When Admin creates a new Working Capital Loan Product Then Admin failed to update a new Working Capital Loan Product field "" with max length data while max allowed is Examples: @@ -70,6 +71,7 @@ Feature: WorkingCapitalLoanProduct @TestRailId:C70214 Scenario Outline: Verify Working capital Loan Product update with invalid data shall outcome with error - validation check with zero values - UC7 + When Admin creates a new Working Capital Loan Product Then Admin failed to update a new Working Capital Loan Product field "" with zero incorrect value Examples: @@ -94,6 +96,7 @@ Feature: WorkingCapitalLoanProduct @TestRailId:C70216 Scenario Outline: Verify Working capital Loan Product update with invalid data shall outcome with error - validation check with diff values - UC9 + When Admin creates a new Working Capital Loan Product Then Admin failed to update a new Working Capital Loan Product field "" with invalid data and got an error Examples: @@ -112,10 +115,12 @@ Feature: WorkingCapitalLoanProduct @TestRailId:C70219 Scenario: Verify Working capital Loan Product update with invalid data shall outcome with error - validation check with number of payment allocation rules - UC12 + When Admin creates a new Working Capital Loan Product Then Admin failed to update a new Working Capital Loan Product with invalid number of payment allocation rules @TestRailId:C70220 Scenario: Verify Working capital Loan Product update with invalid data shall outcome with error - validation check with payment allocation rules - UC13 + When Admin creates a new Working Capital Loan Product Then Admin failed to update a new Working Capital Loan Product with invalid value of payment allocation rules @TestRailId:C70221 diff --git a/fineract-investor/src/main/resources/jpa/static-weaving/module/fineract-investor/persistence.xml b/fineract-investor/src/main/resources/jpa/static-weaving/module/fineract-investor/persistence.xml index 3ecc879408b..f04a51c7a29 100644 --- a/fineract-investor/src/main/resources/jpa/static-weaving/module/fineract-investor/persistence.xml +++ b/fineract-investor/src/main/resources/jpa/static-weaving/module/fineract-investor/persistence.xml @@ -48,6 +48,7 @@ org.apache.fineract.portfolio.calendar.domain.Calendar org.apache.fineract.portfolio.calendar.domain.CalendarHistory org.apache.fineract.portfolio.client.domain.ClientIdentifier + org.apache.fineract.portfolio.delinquency.domain.DelinquencyMinimumPaymentPeriodAndRule org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucket org.apache.fineract.portfolio.delinquency.domain.DelinquencyRange org.apache.fineract.portfolio.group.domain.StaffAssignmentHistory @@ -154,9 +155,14 @@ org.apache.fineract.portfolio.floatingrates.domain.FloatingRate org.apache.fineract.portfolio.floatingrates.domain.FloatingRatePeriod + + org.apache.fineract.cob.domain.BatchBusinessStep + org.apache.fineract.cob.domain.AccountLock + false + diff --git a/fineract-loan-origination/src/main/resources/jpa/static-weaving/module/fineract-loan-origination/persistence.xml b/fineract-loan-origination/src/main/resources/jpa/static-weaving/module/fineract-loan-origination/persistence.xml index 61e9d53144a..02885df4e13 100644 --- a/fineract-loan-origination/src/main/resources/jpa/static-weaving/module/fineract-loan-origination/persistence.xml +++ b/fineract-loan-origination/src/main/resources/jpa/static-weaving/module/fineract-loan-origination/persistence.xml @@ -42,6 +42,7 @@ false + diff --git a/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/api/DelinquencyApiConstants.java b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/api/DelinquencyApiConstants.java index d4bd7d4108a..b6d9b34228d 100644 --- a/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/api/DelinquencyApiConstants.java +++ b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/api/DelinquencyApiConstants.java @@ -25,6 +25,12 @@ private DelinquencyApiConstants() { } public static final String NAME_PARAM_NAME = "name"; + public static final String BUCKET_TYPE_PARAM_NAME = "bucketType"; + public static final String MINIMUM_PAYMENT_PERIOD_AND_RULE_PARAM_NAME = "minimumPaymentPeriodAndRule"; + public static final String FREQUENCY_PARAM_NAME = "frequency"; + public static final String FREQUENCY_TYPE_PARAM_NAME = "frequencyType"; + public static final String MINIMUM_PAYMENT_PARAM_NAME = "minimumPayment"; + public static final String MINIMUM_PAYMENT_TYPE_PARAM_NAME = "minimumPaymentType"; public static final String CLASSIFICATION_PARAM_NAME = "classification"; public static final String RANGES_PARAM_NAME = "ranges"; public static final String MINIMUMAGEDAYS_PARAM_NAME = "minimumAgeDays"; diff --git a/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/api/DelinquencyApiResource.java b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/api/DelinquencyApiResource.java index 811c6b539fd..7076d23014f 100644 --- a/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/api/DelinquencyApiResource.java +++ b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/api/DelinquencyApiResource.java @@ -33,17 +33,25 @@ import jakarta.ws.rs.Path; import jakarta.ws.rs.PathParam; import jakarta.ws.rs.Produces; +import jakarta.ws.rs.core.Context; import jakarta.ws.rs.core.MediaType; +import jakarta.ws.rs.core.UriInfo; import java.util.List; import lombok.RequiredArgsConstructor; import org.apache.fineract.commands.domain.CommandWrapper; import org.apache.fineract.commands.service.CommandWrapperBuilder; import org.apache.fineract.commands.service.PortfolioCommandSourceWritePlatformService; import org.apache.fineract.infrastructure.core.data.CommandProcessingResult; +import org.apache.fineract.infrastructure.core.data.StringEnumOptionData; import org.apache.fineract.infrastructure.core.serialization.DefaultToApiJsonSerializer; import org.apache.fineract.infrastructure.security.service.PlatformSecurityContext; -import org.apache.fineract.portfolio.delinquency.data.DelinquencyBucketData; -import org.apache.fineract.portfolio.delinquency.data.DelinquencyRangeData; +import org.apache.fineract.portfolio.delinquency.api.data.DelinquencyBucketResponse; +import org.apache.fineract.portfolio.delinquency.api.data.DelinquencyBucketTemplateResponse; +import org.apache.fineract.portfolio.delinquency.api.data.DelinquencyRangeResponse; +import org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucketType; +import org.apache.fineract.portfolio.delinquency.domain.DelinquencyFrequencyType; +import org.apache.fineract.portfolio.delinquency.domain.DelinquencyMinimumPaymentType; +import org.apache.fineract.portfolio.delinquency.mapper.DelinquencyResponseMapper; import org.apache.fineract.portfolio.delinquency.service.DelinquencyReadPlatformService; import org.springframework.stereotype.Component; @@ -54,44 +62,44 @@ public class DelinquencyApiResource { private final PlatformSecurityContext securityContext; - private final DefaultToApiJsonSerializer jsonSerializerBucket; - private final DefaultToApiJsonSerializer jsonSerializerRange; + private final DefaultToApiJsonSerializer jsonSerializer; private final DelinquencyReadPlatformService readPlatformService; private final PortfolioCommandSourceWritePlatformService commandWritePlatformService; + private final DelinquencyResponseMapper delinquencyResponseMapper; public static final String DELINQUENCY_BUCKET = "DELINQUENCY_BUCKET"; @GET @Path("ranges") @Consumes({ MediaType.TEXT_HTML, MediaType.APPLICATION_JSON }) @Produces(MediaType.APPLICATION_JSON) - @Operation(summary = "List all Delinquency Ranges", description = "") - public List getDelinquencyRanges() { + @Operation(summary = "List all Delinquency Ranges", description = "", operationId = "getRanges") + public List getDelinquencyRanges() { securityContext.authenticatedUser().validateHasReadPermission(DELINQUENCY_BUCKET); - return this.readPlatformService.retrieveAllDelinquencyRanges(); + return delinquencyResponseMapper.mapRange(this.readPlatformService.retrieveAllDelinquencyRanges()); } @GET @Path("ranges/{delinquencyRangeId}") @Consumes({ MediaType.TEXT_HTML, MediaType.APPLICATION_JSON }) @Produces(MediaType.APPLICATION_JSON) - @Operation(summary = "Retrieve a specific Delinquency Range based on the Id", description = "") - public DelinquencyRangeData getDelinquencyRange( + @Operation(summary = "Retrieve a specific Delinquency Range based on the Id", description = "", operationId = "getRange") + public DelinquencyRangeResponse getDelinquencyRange( @PathParam("delinquencyRangeId") @Parameter(description = "delinquencyRangeId") final Long delinquencyRangeId) { securityContext.authenticatedUser().validateHasReadPermission(DELINQUENCY_BUCKET); - return this.readPlatformService.retrieveDelinquencyRange(delinquencyRangeId); + return delinquencyResponseMapper.mapRange(this.readPlatformService.retrieveDelinquencyRange(delinquencyRangeId)); } @POST @Path("ranges") @Consumes({ MediaType.APPLICATION_JSON }) @Produces({ MediaType.APPLICATION_JSON }) - @Operation(summary = "Create Delinquency Range", description = "") + @Operation(summary = "Create Delinquency Range", description = "", operationId = "createRange") @RequestBody(required = true, content = @Content(schema = @Schema(implementation = DelinquencyRangeRequest.class))) @ApiResponse(responseCode = "200", description = "OK", content = @Content(schema = @Schema(implementation = DelinquencyApiResourceSwagger.PostDelinquencyRangeResponse.class))) public CommandProcessingResult createDelinquencyRange(final DelinquencyRangeRequest delinquencyRangeRequest) { securityContext.authenticatedUser().validateHasCreatePermission(DELINQUENCY_BUCKET); final CommandWrapper commandRequest = new CommandWrapperBuilder().createDelinquencyRange() - .withJson(jsonSerializerRange.serialize(delinquencyRangeRequest)).build(); + .withJson(jsonSerializer.serialize(delinquencyRangeRequest)).build(); return commandWritePlatformService.logCommandSource(commandRequest); } @@ -100,7 +108,7 @@ public CommandProcessingResult createDelinquencyRange(final DelinquencyRangeRequ @Path("ranges/{delinquencyRangeId}") @Consumes({ MediaType.APPLICATION_JSON }) @Produces({ MediaType.APPLICATION_JSON }) - @Operation(summary = "Update Delinquency Range based on the Id", description = "") + @Operation(summary = "Update Delinquency Range based on the Id", description = "", operationId = "updateRange") @RequestBody(required = true, content = @Content(schema = @Schema(implementation = DelinquencyRangeRequest.class))) @ApiResponse(responseCode = "200", description = "OK", content = @Content(schema = @Schema(implementation = DelinquencyApiResourceSwagger.PutDelinquencyRangeResponse.class))) public CommandProcessingResult updateDelinquencyRange( @@ -108,7 +116,7 @@ public CommandProcessingResult updateDelinquencyRange( final DelinquencyRangeRequest delinquencyRangeRequest) { securityContext.authenticatedUser().validateHasUpdatePermission(DELINQUENCY_BUCKET); final CommandWrapper commandRequest = new CommandWrapperBuilder().updateDelinquencyRange(delinquencyRangeId) - .withJson(jsonSerializerRange.serialize(delinquencyRangeRequest)).build(); + .withJson(jsonSerializer.serialize(delinquencyRangeRequest)).build(); return commandWritePlatformService.logCommandSource(commandRequest); } @@ -117,7 +125,7 @@ public CommandProcessingResult updateDelinquencyRange( @Path("ranges/{delinquencyRangeId}") @Consumes({ MediaType.APPLICATION_JSON }) @Produces({ MediaType.APPLICATION_JSON }) - @Operation(summary = "Update Delinquency Range based on the Id", description = "") + @Operation(summary = "Update Delinquency Range based on the Id", description = "", operationId = "deleteRange") @ApiResponse(responseCode = "200", description = "OK", content = @Content(schema = @Schema(implementation = DelinquencyApiResourceSwagger.DeleteDelinquencyRangeResponse.class))) public CommandProcessingResult deleteDelinquencyRange( @PathParam("delinquencyRangeId") @Parameter(description = "delinquencyRangeId") final Long delinquencyRangeId) { @@ -127,39 +135,61 @@ public CommandProcessingResult deleteDelinquencyRange( return commandWritePlatformService.logCommandSource(commandRequest); } + @GET + @Path("buckets/template") + @Consumes({ MediaType.TEXT_HTML, MediaType.APPLICATION_JSON }) + @Produces(MediaType.APPLICATION_JSON) + @Operation(summary = "Template for Delinquency Buckets", description = "", operationId = "getBucketTemplate") + public DelinquencyBucketTemplateResponse getTemplate() { + securityContext.authenticatedUser().validateHasReadPermission(DELINQUENCY_BUCKET); + return handleTemplate(); + } + @GET @Path("buckets") @Consumes({ MediaType.TEXT_HTML, MediaType.APPLICATION_JSON }) @Produces(MediaType.APPLICATION_JSON) - @Operation(summary = "List all Delinquency Buckets", description = "") - public List getDelinquencyBuckets() { + @Operation(summary = "List all Delinquency Buckets", description = "", operationId = "getBuckets") + public List getDelinquencyBuckets() { securityContext.authenticatedUser().validateHasReadPermission(DELINQUENCY_BUCKET); - return this.readPlatformService.retrieveAllDelinquencyBuckets(); + return delinquencyResponseMapper.mapBucket(this.readPlatformService.retrieveAllDelinquencyBuckets()); } @GET @Path("buckets/{delinquencyBucketId}") @Consumes({ MediaType.TEXT_HTML, MediaType.APPLICATION_JSON }) @Produces(MediaType.APPLICATION_JSON) - @Operation(summary = "Retrieve a specific Delinquency Bucket based on the Id", description = "") - public DelinquencyBucketData getDelinquencyBucket( - @PathParam("delinquencyBucketId") @Parameter(description = "delinquencyBucketId") final Long delinquencyBucketId) { + @Operation(summary = "Retrieve a specific Delinquency Bucket based on the Id", description = "", operationId = "getBucket") + public DelinquencyBucketResponse getDelinquencyBucket( + @PathParam("delinquencyBucketId") @Parameter(description = "delinquencyBucketId") final Long delinquencyBucketId, + @Context final UriInfo uriInfo) { securityContext.authenticatedUser().validateHasReadPermission(DELINQUENCY_BUCKET); - return this.readPlatformService.retrieveDelinquencyBucket(delinquencyBucketId); + return delinquencyResponseMapper.mapBucket(this.readPlatformService.retrieveDelinquencyBucket(delinquencyBucketId)); + } + + private DelinquencyBucketTemplateResponse handleTemplate() { + + List ranges = delinquencyResponseMapper.mapRange(this.readPlatformService.retrieveAllDelinquencyRanges()); + List delinquencyBucketTypes = DelinquencyBucketType.toStringEnumOptions(); + List delinquencyFrequencyTypes = DelinquencyFrequencyType.toStringEnumOptions(); + List delinquencyMinimumPaymentTypes = DelinquencyMinimumPaymentType.toStringEnumOptions(); + + return new DelinquencyBucketTemplateResponse(ranges, delinquencyBucketTypes, delinquencyFrequencyTypes, + delinquencyMinimumPaymentTypes); } @POST @Path("buckets") @Consumes({ MediaType.APPLICATION_JSON }) @Produces({ MediaType.APPLICATION_JSON }) - @Operation(summary = "Create Delinquency Bucket", description = "") + @Operation(summary = "Create Delinquency Bucket", description = "", operationId = "createBucket") @RequestBody(required = true, content = @Content(schema = @Schema(implementation = DelinquencyBucketRequest.class))) @ApiResponse(responseCode = "200", description = "OK", content = @Content(schema = @Schema(implementation = DelinquencyApiResourceSwagger.PostDelinquencyBucketResponse.class))) public CommandProcessingResult createDelinquencyBucket(final DelinquencyBucketRequest delinquencyBucketRequest) { securityContext.authenticatedUser().validateHasCreatePermission(DELINQUENCY_BUCKET); final CommandWrapper commandRequest = new CommandWrapperBuilder().createDelinquencyBucket() - .withJson(jsonSerializerBucket.serialize(delinquencyBucketRequest)).build(); + .withJson(jsonSerializer.serialize(delinquencyBucketRequest)).build(); return commandWritePlatformService.logCommandSource(commandRequest); } @@ -168,7 +198,7 @@ public CommandProcessingResult createDelinquencyBucket(final DelinquencyBucketRe @Path("buckets/{delinquencyBucketId}") @Consumes({ MediaType.APPLICATION_JSON }) @Produces({ MediaType.APPLICATION_JSON }) - @Operation(summary = "Update Delinquency Bucket based on the Id", description = "") + @Operation(summary = "Update Delinquency Bucket based on the Id", description = "", operationId = "updateBucket") @RequestBody(required = true, content = @Content(schema = @Schema(implementation = DelinquencyBucketRequest.class))) @ApiResponse(responseCode = "200", description = "OK", content = @Content(schema = @Schema(implementation = DelinquencyApiResourceSwagger.PutDelinquencyBucketResponse.class))) @@ -177,7 +207,7 @@ public CommandProcessingResult updateDelinquencyBucket( final DelinquencyBucketRequest delinquencyBucketRequest) { securityContext.authenticatedUser().validateHasUpdatePermission(DELINQUENCY_BUCKET); final CommandWrapper commandRequest = new CommandWrapperBuilder().updateDelinquencyBucket(delinquencyBucketId) - .withJson(jsonSerializerBucket.serialize(delinquencyBucketRequest)).build(); + .withJson(jsonSerializer.serialize(delinquencyBucketRequest)).build(); return commandWritePlatformService.logCommandSource(commandRequest); } @@ -186,7 +216,7 @@ public CommandProcessingResult updateDelinquencyBucket( @Path("buckets/{delinquencyBucketId}") @Consumes({ MediaType.APPLICATION_JSON }) @Produces({ MediaType.APPLICATION_JSON }) - @Operation(summary = "Delete Delinquency Bucket based on the Id", description = "") + @Operation(summary = "Delete Delinquency Bucket based on the Id", description = "", operationId = "deleteBucket") @ApiResponse(responseCode = "200", description = "OK", content = @Content(schema = @Schema(implementation = DelinquencyApiResourceSwagger.DeleteDelinquencyBucketResponse.class))) public CommandProcessingResult deleteDelinquencyBucket( diff --git a/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/api/DelinquencyBucketRequest.java b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/api/DelinquencyBucketRequest.java index ed50e91709a..0d9b59ec281 100644 --- a/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/api/DelinquencyBucketRequest.java +++ b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/api/DelinquencyBucketRequest.java @@ -20,6 +20,7 @@ import java.io.Serial; import java.io.Serializable; +import java.math.BigDecimal; import java.util.List; import lombok.Getter; import lombok.NoArgsConstructor; @@ -35,4 +36,20 @@ public class DelinquencyBucketRequest implements Serializable { private String name; private List ranges; + private String bucketType; + private MinimumPaymentPeriodAndRule minimumPaymentPeriodAndRule; + + @Setter + @Getter + @NoArgsConstructor + public static class MinimumPaymentPeriodAndRule implements Serializable { + + @Serial + private static final long serialVersionUID = 1L; + + private Integer frequency; + private String frequencyType; + private BigDecimal minimumPayment; + private String minimumPaymentType; + } } diff --git a/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/api/data/DelinquencyBucketResponse.java b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/api/data/DelinquencyBucketResponse.java new file mode 100644 index 00000000000..28ef6ff47bb --- /dev/null +++ b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/api/data/DelinquencyBucketResponse.java @@ -0,0 +1,40 @@ +/** + * 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.api.data; + +import java.io.Serializable; +import java.util.List; +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.Setter; +import lombok.ToString; +import org.apache.fineract.infrastructure.core.data.StringEnumOptionData; + +@ToString +@AllArgsConstructor +@Getter +@Setter +public class DelinquencyBucketResponse implements Serializable { + + private Long id; + private String name; + private List ranges; + private StringEnumOptionData bucketType; + private DelinquencyMinimumPaymentPeriodAndRuleResponse minimumPaymentPeriodAndRule; +} diff --git a/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/api/data/DelinquencyBucketTemplateResponse.java b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/api/data/DelinquencyBucketTemplateResponse.java new file mode 100644 index 00000000000..8076bf17957 --- /dev/null +++ b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/api/data/DelinquencyBucketTemplateResponse.java @@ -0,0 +1,32 @@ +/** + * 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.api.data; + +import java.util.List; +import lombok.Data; +import org.apache.fineract.infrastructure.core.data.StringEnumOptionData; + +@Data +public class DelinquencyBucketTemplateResponse { + + private final List rangesOptions; + private final List bucketTypeOptions; + private final List frequencyTypeOptions; + private final List minimumPaymentOptions; +} diff --git a/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/api/data/DelinquencyMinimumPaymentPeriodAndRuleResponse.java b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/api/data/DelinquencyMinimumPaymentPeriodAndRuleResponse.java new file mode 100644 index 00000000000..9f64de7918f --- /dev/null +++ b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/api/data/DelinquencyMinimumPaymentPeriodAndRuleResponse.java @@ -0,0 +1,39 @@ +/** + * 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.api.data; + +import java.math.BigDecimal; +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.Setter; +import lombok.ToString; +import org.apache.fineract.infrastructure.core.data.StringEnumOptionData; + +@ToString +@AllArgsConstructor +@Getter +@Setter +public class DelinquencyMinimumPaymentPeriodAndRuleResponse { + + private Integer frequency; + private StringEnumOptionData frequencyType; + private BigDecimal minimumPayment; + private StringEnumOptionData minimumPaymentType; +} diff --git a/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/api/data/DelinquencyRangeResponse.java b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/api/data/DelinquencyRangeResponse.java new file mode 100644 index 00000000000..0378ba3063b --- /dev/null +++ b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/api/data/DelinquencyRangeResponse.java @@ -0,0 +1,37 @@ +/** + * 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.api.data; + +import java.io.Serializable; +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.Setter; +import lombok.ToString; + +@ToString +@AllArgsConstructor +@Getter +@Setter +public class DelinquencyRangeResponse implements Serializable { + + private Long id; + private String classification; + private Integer minimumAgeDays; + private Integer maximumAgeDays; +} diff --git a/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/data/DelinquencyBucketData.java b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/data/DelinquencyBucketData.java index b078343cf4b..f825d8460f6 100644 --- a/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/data/DelinquencyBucketData.java +++ b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/data/DelinquencyBucketData.java @@ -24,6 +24,7 @@ import lombok.Getter; import lombok.Setter; import lombok.ToString; +import org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucketType; @ToString @AllArgsConstructor @@ -34,5 +35,6 @@ public class DelinquencyBucketData implements Serializable { private Long id; private String name; private List ranges; - + private DelinquencyBucketType bucketType; + private DelinquencyMinimumPaymentPeriodAndRuleData minimumPaymentPeriodAndRule; } diff --git a/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/data/DelinquencyMinimumPaymentPeriodAndRuleData.java b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/data/DelinquencyMinimumPaymentPeriodAndRuleData.java new file mode 100644 index 00000000000..f00ae095b0d --- /dev/null +++ b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/data/DelinquencyMinimumPaymentPeriodAndRuleData.java @@ -0,0 +1,40 @@ +/** + * 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.data; + +import java.math.BigDecimal; +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.Setter; +import lombok.ToString; +import org.apache.fineract.portfolio.delinquency.domain.DelinquencyFrequencyType; +import org.apache.fineract.portfolio.delinquency.domain.DelinquencyMinimumPaymentType; + +@ToString +@AllArgsConstructor +@Getter +@Setter +public class DelinquencyMinimumPaymentPeriodAndRuleData { + + private Integer frequency; + private DelinquencyFrequencyType frequencyType; + private BigDecimal minimumPayment; + private DelinquencyMinimumPaymentType minimumPaymentType; +} diff --git a/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/domain/DelinquencyMinimumPaymentPeriodAndRuleRepository.java b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/domain/DelinquencyMinimumPaymentPeriodAndRuleRepository.java new file mode 100644 index 00000000000..a2524032779 --- /dev/null +++ b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/domain/DelinquencyMinimumPaymentPeriodAndRuleRepository.java @@ -0,0 +1,29 @@ +/** + * 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.domain; + +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.JpaSpecificationExecutor; +import org.springframework.data.repository.CrudRepository; + +public interface DelinquencyMinimumPaymentPeriodAndRuleRepository extends JpaRepository, + JpaSpecificationExecutor, CrudRepository { + +} diff --git a/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/mapper/DelinquencyBucketMapper.java b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/mapper/DelinquencyBucketMapper.java index 4b207c91aaa..408e48c4eae 100644 --- a/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/mapper/DelinquencyBucketMapper.java +++ b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/mapper/DelinquencyBucketMapper.java @@ -22,13 +22,18 @@ import org.apache.fineract.infrastructure.core.config.MapstructMapperConfig; import org.apache.fineract.portfolio.delinquency.data.DelinquencyBucketData; import org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucket; +import org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucketType; import org.mapstruct.Mapper; @Mapper(config = MapstructMapperConfig.class) -public interface DelinquencyBucketMapper { +public interface DelinquencyBucketMapper extends DelinquencyMinimumPaymentPeriodAndRuleMapper { DelinquencyBucketData map(DelinquencyBucket source); List map(List sources); + default String map(DelinquencyBucketType value) { + return value.name(); + } + } diff --git a/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/mapper/DelinquencyMinimumPaymentPeriodAndRuleMapper.java b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/mapper/DelinquencyMinimumPaymentPeriodAndRuleMapper.java new file mode 100644 index 00000000000..b0fc8886e96 --- /dev/null +++ b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/mapper/DelinquencyMinimumPaymentPeriodAndRuleMapper.java @@ -0,0 +1,31 @@ +/** + * 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.mapper; + +import org.apache.fineract.infrastructure.core.config.MapstructMapperConfig; +import org.apache.fineract.portfolio.delinquency.data.DelinquencyMinimumPaymentPeriodAndRuleData; +import org.apache.fineract.portfolio.delinquency.domain.DelinquencyMinimumPaymentPeriodAndRule; +import org.mapstruct.Mapper; + +@Mapper(config = MapstructMapperConfig.class) +public interface DelinquencyMinimumPaymentPeriodAndRuleMapper { + + DelinquencyMinimumPaymentPeriodAndRuleData map(DelinquencyMinimumPaymentPeriodAndRule source); +} diff --git a/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/mapper/DelinquencyResponseMapper.java b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/mapper/DelinquencyResponseMapper.java new file mode 100644 index 00000000000..a435767e61b --- /dev/null +++ b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/mapper/DelinquencyResponseMapper.java @@ -0,0 +1,55 @@ +/** + * 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.mapper; + +import java.util.List; +import org.apache.fineract.infrastructure.core.config.MapstructMapperConfig; +import org.apache.fineract.infrastructure.core.data.StringEnumOptionData; +import org.apache.fineract.portfolio.delinquency.api.data.DelinquencyBucketResponse; +import org.apache.fineract.portfolio.delinquency.api.data.DelinquencyRangeResponse; +import org.apache.fineract.portfolio.delinquency.data.DelinquencyBucketData; +import org.apache.fineract.portfolio.delinquency.data.DelinquencyRangeData; +import org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucketType; +import org.apache.fineract.portfolio.delinquency.domain.DelinquencyFrequencyType; +import org.apache.fineract.portfolio.delinquency.domain.DelinquencyMinimumPaymentType; +import org.mapstruct.Mapper; + +@Mapper(config = MapstructMapperConfig.class) +public interface DelinquencyResponseMapper { + + DelinquencyBucketResponse mapBucket(DelinquencyBucketData delinquencyBucketData); + + List mapBucket(List delinquencyBucketData); + + DelinquencyRangeResponse mapRange(DelinquencyRangeData delinquencyRangeData); + + List mapRange(List delinquencyRangeData); + + default StringEnumOptionData mapEnum(DelinquencyBucketType delinquencyBucketType) { + return delinquencyBucketType.toData(); + } + + default StringEnumOptionData mapEnum(DelinquencyFrequencyType delinquencyFrequencyType) { + return delinquencyFrequencyType.toData(); + } + + default StringEnumOptionData mapEnum(DelinquencyMinimumPaymentType delinquencyMinimumPaymentType) { + return delinquencyMinimumPaymentType.toData(); + } +} diff --git a/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/service/DelinquencyReadPlatformServiceImpl.java b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/service/DelinquencyReadPlatformServiceImpl.java index 9f29937e701..e7c44e41735 100644 --- a/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/service/DelinquencyReadPlatformServiceImpl.java +++ b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/service/DelinquencyReadPlatformServiceImpl.java @@ -46,6 +46,7 @@ import org.apache.fineract.portfolio.delinquency.domain.LoanDelinquencyTagHistory; import org.apache.fineract.portfolio.delinquency.domain.LoanDelinquencyTagHistoryRepository; import org.apache.fineract.portfolio.delinquency.domain.LoanInstallmentDelinquencyTagRepository; +import org.apache.fineract.portfolio.delinquency.exception.DelinquencyBucketNotFoundException; import org.apache.fineract.portfolio.delinquency.helper.DelinquencyEffectivePauseHelper; import org.apache.fineract.portfolio.delinquency.helper.InstallmentDelinquencyAggregator; import org.apache.fineract.portfolio.delinquency.mapper.DelinquencyBucketMapper; @@ -106,6 +107,9 @@ public List retrieveAllDelinquencyBuckets() { @Override public DelinquencyBucketData retrieveDelinquencyBucket(Long delinquencyBucketId) { + if (!repositoryBucket.existsById(delinquencyBucketId)) { + throw DelinquencyBucketNotFoundException.notFound(delinquencyBucketId); + } final DelinquencyBucket delinquencyBucket = repositoryBucket.getReferenceById(delinquencyBucketId); final DelinquencyBucketData delinquencyBucketData = mapperBucket.map(delinquencyBucket); delinquencyBucketData.setRanges(mapperRange.map(delinquencyBucket.getRanges())); @@ -117,10 +121,8 @@ public DelinquencyRangeData retrieveCurrentDelinquencyTag(Long loanId) { final Loan loan = this.loanRepository.getReferenceById(loanId); Optional optLoanDelinquencyTag = this.repositoryLoanDelinquencyTagHistory.findByLoanAndLiftedOnDate(loan, null); - if (optLoanDelinquencyTag.isPresent()) { - return mapperRange.map(optLoanDelinquencyTag.get().getDelinquencyRange()); - } - return null; + return optLoanDelinquencyTag.map(loanDelinquencyTagHistory -> mapperRange.map(loanDelinquencyTagHistory.getDelinquencyRange())) + .orElse(null); } @Override diff --git a/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/service/DelinquencyWritePlatformServiceImpl.java b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/service/DelinquencyWritePlatformServiceImpl.java index 392e2ce814b..fe101f79794 100644 --- a/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/service/DelinquencyWritePlatformServiceImpl.java +++ b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/service/DelinquencyWritePlatformServiceImpl.java @@ -42,6 +42,9 @@ import org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucketMappings; import org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucketMappingsRepository; import org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucketRepository; +import org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucketType; +import org.apache.fineract.portfolio.delinquency.domain.DelinquencyMinimumPaymentPeriodAndRule; +import org.apache.fineract.portfolio.delinquency.domain.DelinquencyMinimumPaymentPeriodAndRuleRepository; import org.apache.fineract.portfolio.delinquency.domain.DelinquencyRange; import org.apache.fineract.portfolio.delinquency.domain.DelinquencyRangeRepository; import org.apache.fineract.portfolio.delinquency.domain.LoanDelinquencyAction; @@ -50,6 +53,7 @@ import org.apache.fineract.portfolio.delinquency.domain.LoanDelinquencyTagHistoryRepository; import org.apache.fineract.portfolio.delinquency.domain.LoanInstallmentDelinquencyTagRepository; import org.apache.fineract.portfolio.delinquency.exception.DelinquencyBucketAgesOverlapedException; +import org.apache.fineract.portfolio.delinquency.exception.DelinquencyBucketNotFoundException; import org.apache.fineract.portfolio.delinquency.exception.DelinquencyRangeInvalidAgesException; import org.apache.fineract.portfolio.delinquency.helper.DelinquencyEffectivePauseHelper; import org.apache.fineract.portfolio.delinquency.validator.DelinquencyActionParseAndValidator; @@ -84,6 +88,7 @@ public class DelinquencyWritePlatformServiceImpl implements DelinquencyWritePlat private final DelinquencyEffectivePauseHelper delinquencyEffectivePauseHelper; private final BusinessEventNotifierService businessEventNotifierService; private final DelinquencyWritePlatformServiceHelper delinquencyHelper; + private final DelinquencyMinimumPaymentPeriodAndRuleRepository delinquencyMinimumPaymentPeriodAndRuleRepository; @Override public CommandProcessingResult createDelinquencyRange(JsonCommand command) { @@ -141,14 +146,24 @@ public CommandProcessingResult updateDelinquencyBucket(Long delinquencyBucketId, @Override public CommandProcessingResult deleteDelinquencyBucket(Long delinquencyBucketId, JsonCommand command) { - final DelinquencyBucket delinquencyBucket = repositoryBucket.getReferenceById(delinquencyBucketId); - if (delinquencyBucket != null) { + if (repositoryBucket.existsById(delinquencyBucketId)) { + final DelinquencyBucket delinquencyBucket = repositoryBucket.getReferenceById(delinquencyBucketId); Long delinquencyBucketLinked = this.loanProductRepository.countByDelinquencyBucket(delinquencyBucket); if (delinquencyBucketLinked > 0) { throw new PlatformDataIntegrityException("error.msg.data.integrity.issue.entity.linked", "Data integrity issue with resource: " + delinquencyBucket.getId()); } + + // Explicitly handle the minimum payment period and rule relationship + if (delinquencyBucket.getMinimumPaymentPeriodAndRule() != null) { + DelinquencyMinimumPaymentPeriodAndRule minimumPaymentPeriodAndRule = delinquencyBucket.getMinimumPaymentPeriodAndRule(); + delinquencyMinimumPaymentPeriodAndRuleRepository.delete(minimumPaymentPeriodAndRule); + } + repositoryBucket.delete(delinquencyBucket); + } else { + throw new DelinquencyBucketNotFoundException("error.msg.delinquency.bucket.id.not.exist", + "Delinquency bucket with id `" + delinquencyBucketId + "` does not exist.", delinquencyBucketId); } return new CommandProcessingResultBuilder().withCommandId(command.commandId()).withEntityId(delinquencyBucketId).build(); } @@ -338,7 +353,20 @@ private DelinquencyBucket createDelinquencyBucket(DelinquencyBucketData data, Ma if (delinquencyBucket.isEmpty()) { DelinquencyBucket newDelinquencyBucket = new DelinquencyBucket(data.getName()); + newDelinquencyBucket.setBucketType(data.getBucketType() != null ? data.getBucketType() : DelinquencyBucketType.REGULAR); + if (DelinquencyBucketType.WORKING_CAPITAL.equals(newDelinquencyBucket.getBucketType())) { + newDelinquencyBucket.setMinimumPaymentPeriodAndRule(new DelinquencyMinimumPaymentPeriodAndRule()); + newDelinquencyBucket.getMinimumPaymentPeriodAndRule().setBucket(newDelinquencyBucket); + newDelinquencyBucket.getMinimumPaymentPeriodAndRule().setFrequency(data.getMinimumPaymentPeriodAndRule().getFrequency()); + newDelinquencyBucket.getMinimumPaymentPeriodAndRule() + .setMinimumPaymentType(data.getMinimumPaymentPeriodAndRule().getMinimumPaymentType()); + newDelinquencyBucket.getMinimumPaymentPeriodAndRule() + .setFrequencyType(data.getMinimumPaymentPeriodAndRule().getFrequencyType()); + newDelinquencyBucket.getMinimumPaymentPeriodAndRule() + .setMinimumPayment(data.getMinimumPaymentPeriodAndRule().getMinimumPayment()); + } repositoryBucket.save(newDelinquencyBucket); + setDelinquencyBucketMappings(newDelinquencyBucket, data); return newDelinquencyBucket; } else { @@ -350,9 +378,60 @@ private DelinquencyBucket createDelinquencyBucket(DelinquencyBucketData data, Ma private DelinquencyBucket updateDelinquencyBucket(DelinquencyBucket delinquencyBucket, DelinquencyBucketData data, Map changes) { if (!data.getName().equalsIgnoreCase(delinquencyBucket.getName())) { + Optional existingEntityByName = repositoryBucket.findByName(data.getName()); + if (existingEntityByName.isPresent()) { + throw new PlatformDataIntegrityException("error.msg.data.integrity.issue.entity.duplicated", + "Data integrity issue with resource: " + existingEntityByName.get().getId()); + } delinquencyBucket.setName(data.getName()); changes.put(DelinquencyApiConstants.NAME_PARAM_NAME, data.getName()); } + if (!data.getBucketType().equals(delinquencyBucket.getBucketType())) { + changes.put(DelinquencyApiConstants.BUCKET_TYPE_PARAM_NAME, data.getBucketType()); + delinquencyBucket.setBucketType(data.getBucketType()); + } + if (delinquencyBucket.getBucketType().equals(DelinquencyBucketType.WORKING_CAPITAL)) { + if (delinquencyBucket.getMinimumPaymentPeriodAndRule() == null) { + delinquencyBucket.setMinimumPaymentPeriodAndRule(new DelinquencyMinimumPaymentPeriodAndRule()); + delinquencyBucket.getMinimumPaymentPeriodAndRule().setBucket(delinquencyBucket); + } + if (!data.getMinimumPaymentPeriodAndRule().getFrequency() + .equals(delinquencyBucket.getMinimumPaymentPeriodAndRule().getFrequency())) { + delinquencyBucket.getMinimumPaymentPeriodAndRule().setFrequency(data.getMinimumPaymentPeriodAndRule().getFrequency()); + changes.put(DelinquencyApiConstants.FREQUENCY_PARAM_NAME, + delinquencyBucket.getMinimumPaymentPeriodAndRule().getFrequency()); + } + if (!data.getMinimumPaymentPeriodAndRule().getFrequencyType() + .equals(delinquencyBucket.getMinimumPaymentPeriodAndRule().getFrequencyType())) { + delinquencyBucket.getMinimumPaymentPeriodAndRule() + .setFrequencyType(data.getMinimumPaymentPeriodAndRule().getFrequencyType()); + changes.put(DelinquencyApiConstants.FREQUENCY_TYPE_PARAM_NAME, + delinquencyBucket.getMinimumPaymentPeriodAndRule().getFrequencyType()); + } + if (!data.getMinimumPaymentPeriodAndRule().getMinimumPaymentType() + .equals(delinquencyBucket.getMinimumPaymentPeriodAndRule().getMinimumPaymentType())) { + changes.put(DelinquencyApiConstants.MINIMUM_PAYMENT_TYPE_PARAM_NAME, + delinquencyBucket.getMinimumPaymentPeriodAndRule().getMinimumPaymentType()); + delinquencyBucket.getMinimumPaymentPeriodAndRule() + .setMinimumPaymentType(data.getMinimumPaymentPeriodAndRule().getMinimumPaymentType()); + } + if (data.getMinimumPaymentPeriodAndRule().getMinimumPayment() + .compareTo(delinquencyBucket.getMinimumPaymentPeriodAndRule().getMinimumPayment()) != 0) { + changes.put(DelinquencyApiConstants.MINIMUM_PAYMENT_PARAM_NAME, + delinquencyBucket.getMinimumPaymentPeriodAndRule().getMinimumPayment()); + delinquencyBucket.getMinimumPaymentPeriodAndRule() + .setMinimumPayment(data.getMinimumPaymentPeriodAndRule().getMinimumPayment()); + } + } else { + if (delinquencyBucket.getMinimumPaymentPeriodAndRule() != null) { + changes.put(DelinquencyApiConstants.MINIMUM_PAYMENT_PERIOD_AND_RULE_PARAM_NAME, null); + DelinquencyMinimumPaymentPeriodAndRule minimumPaymentPeriodAndRule = delinquencyBucket.getMinimumPaymentPeriodAndRule(); + minimumPaymentPeriodAndRule.setBucket(null); + delinquencyBucket.setMinimumPaymentPeriodAndRule(null); + delinquencyMinimumPaymentPeriodAndRuleRepository.save(minimumPaymentPeriodAndRule); + delinquencyMinimumPaymentPeriodAndRuleRepository.delete(minimumPaymentPeriodAndRule); + } + } if (!changes.isEmpty()) { delinquencyBucket = repositoryBucket.save(delinquencyBucket); } @@ -363,7 +442,7 @@ private DelinquencyBucket updateDelinquencyBucket(DelinquencyBucket delinquencyB private void setDelinquencyBucketMappings(DelinquencyBucket delinquencyBucket, DelinquencyBucketData data) { List rangeIds = new ArrayList<>(); data.getRanges().forEach(dataRange -> rangeIds.add(dataRange.getId())); - + delinquencyBucket.setBucketType(data.getBucketType()); List ranges = repositoryRange.findAllById(rangeIds); validateDelinquencyRanges(ranges); List bucketMappings = repositoryBucketMappings.findByDelinquencyBucket(delinquencyBucket); diff --git a/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/starter/DelinquencyConfiguration.java b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/starter/DelinquencyConfiguration.java index 410f05e1958..022e3c4e47f 100644 --- a/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/starter/DelinquencyConfiguration.java +++ b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/starter/DelinquencyConfiguration.java @@ -22,6 +22,7 @@ import org.apache.fineract.infrastructure.event.business.service.BusinessEventNotifierService; import org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucketMappingsRepository; import org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucketRepository; +import org.apache.fineract.portfolio.delinquency.domain.DelinquencyMinimumPaymentPeriodAndRuleRepository; import org.apache.fineract.portfolio.delinquency.domain.DelinquencyRangeRepository; import org.apache.fineract.portfolio.delinquency.domain.LoanDelinquencyActionRepository; import org.apache.fineract.portfolio.delinquency.domain.LoanDelinquencyTagHistoryRepository; @@ -83,12 +84,13 @@ public DelinquencyWritePlatformService delinquencyWritePlatformService(Delinquen DelinquencyReadPlatformService delinquencyReadPlatformService, LoanDelinquencyActionRepository loanDelinquencyActionRepository, DelinquencyActionParseAndValidator delinquencyActionParseAndValidator, DelinquencyEffectivePauseHelper delinquencyEffectivePauseHelper, - DelinquencyWritePlatformServiceHelper delinquencyWritePlatformServiceHelper) { + DelinquencyWritePlatformServiceHelper delinquencyWritePlatformServiceHelper, + DelinquencyMinimumPaymentPeriodAndRuleRepository delinquencyMinimumPaymentPeriodAndRuleRepository) { return new DelinquencyWritePlatformServiceImpl(dataValidatorBucket, dataValidatorRange, repositoryRange, repositoryBucket, repositoryBucketMappings, loanDelinquencyTagRepository, loanRepository, loanProductRepository, loanDelinquencyDomainService, loanInstallmentDelinquencyTagRepository, delinquencyReadPlatformService, loanDelinquencyActionRepository, delinquencyActionParseAndValidator, delinquencyEffectivePauseHelper, businessEventNotifierService, - delinquencyWritePlatformServiceHelper); + delinquencyWritePlatformServiceHelper, delinquencyMinimumPaymentPeriodAndRuleRepository); } @Bean diff --git a/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/validator/DelinquencyBucketParseAndValidator.java b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/validator/DelinquencyBucketParseAndValidator.java index 93888f2962e..b37adeebc82 100644 --- a/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/validator/DelinquencyBucketParseAndValidator.java +++ b/fineract-loan/src/main/java/org/apache/fineract/portfolio/delinquency/validator/DelinquencyBucketParseAndValidator.java @@ -20,8 +20,10 @@ import com.google.gson.JsonObject; import jakarta.validation.constraints.NotNull; +import java.math.BigDecimal; import java.util.ArrayList; import java.util.List; +import java.util.Locale; import lombok.RequiredArgsConstructor; import org.apache.fineract.infrastructure.core.api.JsonCommand; import org.apache.fineract.infrastructure.core.data.DataValidatorBuilder; @@ -29,7 +31,11 @@ import org.apache.fineract.infrastructure.core.validator.ParseAndValidator; import org.apache.fineract.portfolio.delinquency.api.DelinquencyApiConstants; import org.apache.fineract.portfolio.delinquency.data.DelinquencyBucketData; +import org.apache.fineract.portfolio.delinquency.data.DelinquencyMinimumPaymentPeriodAndRuleData; import org.apache.fineract.portfolio.delinquency.data.DelinquencyRangeData; +import org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucketType; +import org.apache.fineract.portfolio.delinquency.domain.DelinquencyFrequencyType; +import org.apache.fineract.portfolio.delinquency.domain.DelinquencyMinimumPaymentType; import org.springframework.stereotype.Component; @RequiredArgsConstructor @@ -55,22 +61,79 @@ private DelinquencyBucketData validateAndParseUpdate(final DataValidatorBuilder } jsonHelper.checkForUnsupportedParameters(element, - List.of(DelinquencyApiConstants.NAME_PARAM_NAME, DelinquencyApiConstants.RANGES_PARAM_NAME)); + List.of(DelinquencyApiConstants.NAME_PARAM_NAME, DelinquencyApiConstants.RANGES_PARAM_NAME, + DelinquencyApiConstants.BUCKET_TYPE_PARAM_NAME, + DelinquencyApiConstants.MINIMUM_PAYMENT_PERIOD_AND_RULE_PARAM_NAME)); final String name = jsonHelper.extractStringNamed(DelinquencyApiConstants.NAME_PARAM_NAME, element); dataValidator.reset().parameter(DelinquencyApiConstants.NAME_PARAM_NAME).value(name).notBlank(); + final String bucketTypeParam = jsonHelper.extractStringNamed(DelinquencyApiConstants.BUCKET_TYPE_PARAM_NAME, element); + dataValidator.reset().parameter(DelinquencyApiConstants.BUCKET_TYPE_PARAM_NAME).value(bucketTypeParam).ignoreIfNull() + .isOneOfEnumValues(DelinquencyBucketType.class); + if (dataValidator.hasError()) { + return null; + } + DelinquencyBucketType bucketType = bucketTypeParam == null ? DelinquencyBucketType.REGULAR + : DelinquencyBucketType.valueOf(bucketTypeParam); + + ArrayList ranges = new ArrayList<>(); final String[] rangeIds = jsonHelper.extractArrayNamed(DelinquencyApiConstants.RANGES_PARAM_NAME, element); dataValidator.reset().parameter(DelinquencyApiConstants.RANGES_PARAM_NAME).value(rangeIds).notNull().arrayNotEmpty(); - ArrayList ranges = new ArrayList<>(); if (rangeIds != null) { for (String rangeId : rangeIds) { ranges.add(DelinquencyRangeData.reference(Long.parseLong(rangeId))); } } - return dataValidator.hasError() ? null : new DelinquencyBucketData(null, name, ranges); + + DelinquencyMinimumPaymentPeriodAndRuleData minimumPaymentPeriodAndRule = null; + if (DelinquencyBucketType.WORKING_CAPITAL.equals(bucketType)) { + JsonObject minimumPaymentPeriodAndRuleElement = jsonHelper + .extractJsonObjectNamed(DelinquencyApiConstants.MINIMUM_PAYMENT_PERIOD_AND_RULE_PARAM_NAME, element); + minimumPaymentPeriodAndRule = validateAndParseUpdateMinimumPaymentPeriodAndRule(dataValidator, + minimumPaymentPeriodAndRuleElement, jsonHelper); + + } + + return dataValidator.hasError() ? null : new DelinquencyBucketData(null, name, ranges, bucketType, minimumPaymentPeriodAndRule); + } + + private DelinquencyMinimumPaymentPeriodAndRuleData validateAndParseUpdateMinimumPaymentPeriodAndRule(DataValidatorBuilder dataValidator, + JsonObject element, FromJsonHelper jsonHelper) { + dataValidator.reset().parameter(DelinquencyApiConstants.MINIMUM_PAYMENT_PERIOD_AND_RULE_PARAM_NAME).value(element).notNull(); + if (element != null) { + Locale locale = jsonHelper.extractLocaleParameter(element); + Integer frequency = jsonHelper.extractIntegerNamed(DelinquencyApiConstants.FREQUENCY_PARAM_NAME, element); + dataValidator.reset().parameter(DelinquencyApiConstants.FREQUENCY_PARAM_NAME).value(frequency).notNull(); + + String frequencyType = jsonHelper.extractStringNamed(DelinquencyApiConstants.FREQUENCY_TYPE_PARAM_NAME, element); + dataValidator.reset().parameter(DelinquencyApiConstants.FREQUENCY_TYPE_PARAM_NAME).value(frequencyType).notNull() + .isOneOfEnumValues(DelinquencyFrequencyType.class); + if (dataValidator.hasError()) { + return null; + } + final DelinquencyFrequencyType delinquencyFrequencyType = DelinquencyFrequencyType.valueOf(frequencyType); + + BigDecimal minimumPayment = jsonHelper.extractBigDecimalNamed(DelinquencyApiConstants.MINIMUM_PAYMENT_PARAM_NAME, element, + locale); + dataValidator.reset().parameter(DelinquencyApiConstants.MINIMUM_PAYMENT_PARAM_NAME).value(minimumPayment).notNull() + .positiveAmount(); + + String minimumPaymentType = jsonHelper.extractStringNamed(DelinquencyApiConstants.MINIMUM_PAYMENT_TYPE_PARAM_NAME, element); + dataValidator.reset().parameter(DelinquencyApiConstants.MINIMUM_PAYMENT_TYPE_PARAM_NAME).value(minimumPaymentType).notNull() + .isOneOfEnumValues(DelinquencyMinimumPaymentType.class); + if (dataValidator.hasError()) { + return null; + } + final DelinquencyMinimumPaymentType delinquencyMinimumPayment = DelinquencyMinimumPaymentType.valueOf(minimumPaymentType); + + return dataValidator.hasError() ? null + : new DelinquencyMinimumPaymentPeriodAndRuleData(frequency, delinquencyFrequencyType, minimumPayment, + delinquencyMinimumPayment); + } + return null; } } diff --git a/fineract-loan/src/main/resources/jpa/static-weaving/module/fineract-loan/persistence.xml b/fineract-loan/src/main/resources/jpa/static-weaving/module/fineract-loan/persistence.xml index 8eb34963c21..e0633ec208a 100644 --- a/fineract-loan/src/main/resources/jpa/static-weaving/module/fineract-loan/persistence.xml +++ b/fineract-loan/src/main/resources/jpa/static-weaving/module/fineract-loan/persistence.xml @@ -48,6 +48,7 @@ org.apache.fineract.portfolio.calendar.domain.Calendar org.apache.fineract.portfolio.calendar.domain.CalendarHistory org.apache.fineract.portfolio.client.domain.ClientIdentifier + org.apache.fineract.portfolio.delinquency.domain.DelinquencyMinimumPaymentPeriodAndRule org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucket org.apache.fineract.portfolio.delinquency.domain.DelinquencyRange org.apache.fineract.portfolio.group.domain.StaffAssignmentHistory @@ -143,10 +144,14 @@ org.apache.fineract.portfolio.floatingrates.domain.FloatingRate org.apache.fineract.portfolio.floatingrates.domain.FloatingRatePeriod + + org.apache.fineract.cob.domain.BatchBusinessStep + org.apache.fineract.cob.domain.AccountLock false + diff --git a/fineract-progressive-loan/src/main/resources/jpa/static-weaving/module/fineract-progressive-loan/persistence.xml b/fineract-progressive-loan/src/main/resources/jpa/static-weaving/module/fineract-progressive-loan/persistence.xml index 27208079e4a..a9353334940 100644 --- a/fineract-progressive-loan/src/main/resources/jpa/static-weaving/module/fineract-progressive-loan/persistence.xml +++ b/fineract-progressive-loan/src/main/resources/jpa/static-weaving/module/fineract-progressive-loan/persistence.xml @@ -48,6 +48,7 @@ org.apache.fineract.portfolio.calendar.domain.Calendar org.apache.fineract.portfolio.calendar.domain.CalendarHistory org.apache.fineract.portfolio.client.domain.ClientIdentifier + org.apache.fineract.portfolio.delinquency.domain.DelinquencyMinimumPaymentPeriodAndRule org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucket org.apache.fineract.portfolio.delinquency.domain.DelinquencyRange org.apache.fineract.portfolio.group.domain.StaffAssignmentHistory @@ -148,6 +149,7 @@ false + diff --git a/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanproduct/service/LoanProductReadPlatformServiceImpl.java b/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanproduct/service/LoanProductReadPlatformServiceImpl.java index 895221d578a..f80846604d7 100644 --- a/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanproduct/service/LoanProductReadPlatformServiceImpl.java +++ b/fineract-provider/src/main/java/org/apache/fineract/portfolio/loanproduct/service/LoanProductReadPlatformServiceImpl.java @@ -45,6 +45,7 @@ import org.apache.fineract.portfolio.common.domain.DaysInYearCustomStrategyType; import org.apache.fineract.portfolio.common.service.CommonEnumerations; import org.apache.fineract.portfolio.delinquency.data.DelinquencyBucketData; +import org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucketType; import org.apache.fineract.portfolio.delinquency.service.DelinquencyReadPlatformService; import org.apache.fineract.portfolio.loanaccount.domain.LoanBuyDownFeeCalculationType; import org.apache.fineract.portfolio.loanaccount.domain.LoanBuyDownFeeIncomeType; @@ -549,7 +550,7 @@ public LoanProductData mapRow(@NonNull final ResultSet rs, @SuppressWarnings("un final Long delinquencyBucketId = JdbcSupport.getLong(rs, "delinquencyBucketId"); final String delinquencyBucketName = rs.getString("delinquencyBucketName"); final DelinquencyBucketData delinquencyBucket = new DelinquencyBucketData(delinquencyBucketId, delinquencyBucketName, - new ArrayList<>()); + new ArrayList<>(), DelinquencyBucketType.REGULAR, null); final String loanScheduleTypeStr = rs.getString("loanScheduleType"); final LoanScheduleType loanScheduleType = LoanScheduleType.valueOf(loanScheduleTypeStr); diff --git a/fineract-provider/src/main/resources/jpa/static-weaving/module/fineract-provider/persistence.xml b/fineract-provider/src/main/resources/jpa/static-weaving/module/fineract-provider/persistence.xml index 19f793c2b93..66009aba039 100644 --- a/fineract-provider/src/main/resources/jpa/static-weaving/module/fineract-provider/persistence.xml +++ b/fineract-provider/src/main/resources/jpa/static-weaving/module/fineract-provider/persistence.xml @@ -48,6 +48,7 @@ org.apache.fineract.portfolio.calendar.domain.Calendar org.apache.fineract.portfolio.calendar.domain.CalendarHistory org.apache.fineract.portfolio.client.domain.ClientIdentifier + org.apache.fineract.portfolio.delinquency.domain.DelinquencyMinimumPaymentPeriodAndRule org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucket org.apache.fineract.portfolio.delinquency.domain.DelinquencyRange org.apache.fineract.portfolio.group.domain.StaffAssignmentHistory @@ -215,10 +216,12 @@ org.apache.fineract.portfolio.workingcapitalloanproduct.domain.WorkingCapitalLoanProduct org.apache.fineract.portfolio.workingcapitalloanproduct.domain.WorkingCapitalLoanProductPaymentAllocationRule org.apache.fineract.portfolio.workingcapitalloanproduct.domain.WorkingCapitalLoanProductConfigurableAttributes - org.apache.fineract.portfolio.workingcapitalloan.domain.WorkingCapitalLoan - org.apache.fineract.portfolio.workingcapitalloan.domain.WorkingCapitalLoanBalance - org.apache.fineract.portfolio.workingcapitalloan.domain.WorkingCapitalLoanDisbursementDetails org.apache.fineract.portfolio.workingcapitalloan.domain.WorkingCapitalLoanPaymentAllocationRule + org.apache.fineract.portfolio.workingcapitalloan.domain.WorkingCapitalLoanNote + org.apache.fineract.portfolio.workingcapitalloan.domain.WorkingCapitalLoanDisbursementDetails + org.apache.fineract.portfolio.workingcapitalloan.domain.WorkingCapitalLoanBalance + org.apache.fineract.portfolio.workingcapitalloan.domain.WorkingCapitalLoan + org.apache.fineract.cob.domain.WorkingCapitalLoanAccountLock org.apache.fineract.portfolio.loanproduct.domain.AllocationTypeListConverter @@ -287,6 +290,7 @@ org.apache.fineract.cob.domain.BatchBusinessStep + org.apache.fineract.cob.domain.AccountLock org.apache.fineract.template.domain.Template @@ -362,6 +366,7 @@ false + diff --git a/fineract-provider/src/test/java/org/apache/fineract/portfolio/deliquency/DelinquencyWritePlatformServiceRangeChangeEventTest.java b/fineract-provider/src/test/java/org/apache/fineract/portfolio/deliquency/DelinquencyWritePlatformServiceRangeChangeEventTest.java index d692d1d9672..e74b9e70fd4 100644 --- a/fineract-provider/src/test/java/org/apache/fineract/portfolio/deliquency/DelinquencyWritePlatformServiceRangeChangeEventTest.java +++ b/fineract-provider/src/test/java/org/apache/fineract/portfolio/deliquency/DelinquencyWritePlatformServiceRangeChangeEventTest.java @@ -57,6 +57,7 @@ import org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucket; import org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucketMappingsRepository; import org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucketRepository; +import org.apache.fineract.portfolio.delinquency.domain.DelinquencyMinimumPaymentPeriodAndRuleRepository; import org.apache.fineract.portfolio.delinquency.domain.DelinquencyRange; import org.apache.fineract.portfolio.delinquency.domain.DelinquencyRangeRepository; import org.apache.fineract.portfolio.delinquency.domain.LoanDelinquencyAction; @@ -130,6 +131,8 @@ public class DelinquencyWritePlatformServiceRangeChangeEventTest { private LoanDelinquencyActionRepository loanDelinquencyActionRepository; @Mock private DelinquencyEffectivePauseHelper delinquencyEffectivePauseHelper; + @Mock + private DelinquencyMinimumPaymentPeriodAndRuleRepository delinquencyMinimumPaymentPeriodAndRuleRepository; private DelinquencyWritePlatformServiceHelper delinquencyWritePlatformServiceHelper; @@ -153,7 +156,7 @@ public void setUp() { repositoryBucketMappings, loanDelinquencyTagRepository, loanRepository, loanProductRepository, loanDelinquencyDomainService, loanInstallmentDelinquencyTagRepository, delinquencyReadPlatformService, loanDelinquencyActionRepository, delinquencyActionParseAndValidator, delinquencyEffectivePauseHelper, businessEventNotifierService, - delinquencyWritePlatformServiceHelper); + delinquencyWritePlatformServiceHelper, delinquencyMinimumPaymentPeriodAndRuleRepository); } @AfterAll diff --git a/fineract-rates/src/main/resources/jpa/static-weaving/module/fineract-rates/persistence.xml b/fineract-rates/src/main/resources/jpa/static-weaving/module/fineract-rates/persistence.xml index 61addd405f4..5607ab50a32 100644 --- a/fineract-rates/src/main/resources/jpa/static-weaving/module/fineract-rates/persistence.xml +++ b/fineract-rates/src/main/resources/jpa/static-weaving/module/fineract-rates/persistence.xml @@ -48,6 +48,7 @@ org.apache.fineract.portfolio.calendar.domain.Calendar org.apache.fineract.portfolio.calendar.domain.CalendarHistory org.apache.fineract.portfolio.client.domain.ClientIdentifier + org.apache.fineract.portfolio.delinquency.domain.DelinquencyMinimumPaymentPeriodAndRule org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucket org.apache.fineract.portfolio.delinquency.domain.DelinquencyRange org.apache.fineract.portfolio.group.domain.StaffAssignmentHistory @@ -72,6 +73,7 @@ false + diff --git a/fineract-report/src/main/resources/jpa/static-weaving/module/fineract-report/persistence.xml b/fineract-report/src/main/resources/jpa/static-weaving/module/fineract-report/persistence.xml index 4883cc15e81..7d877721793 100644 --- a/fineract-report/src/main/resources/jpa/static-weaving/module/fineract-report/persistence.xml +++ b/fineract-report/src/main/resources/jpa/static-weaving/module/fineract-report/persistence.xml @@ -48,6 +48,7 @@ org.apache.fineract.portfolio.calendar.domain.Calendar org.apache.fineract.portfolio.calendar.domain.CalendarHistory org.apache.fineract.portfolio.client.domain.ClientIdentifier + org.apache.fineract.portfolio.delinquency.domain.DelinquencyMinimumPaymentPeriodAndRule org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucket org.apache.fineract.portfolio.delinquency.domain.DelinquencyRange org.apache.fineract.portfolio.group.domain.StaffAssignmentHistory @@ -68,6 +69,7 @@ false + diff --git a/fineract-savings/src/main/resources/jpa/static-weaving/module/fineract-savings/persistence.xml b/fineract-savings/src/main/resources/jpa/static-weaving/module/fineract-savings/persistence.xml index 2c9e1ba7ba1..269fad43a18 100644 --- a/fineract-savings/src/main/resources/jpa/static-weaving/module/fineract-savings/persistence.xml +++ b/fineract-savings/src/main/resources/jpa/static-weaving/module/fineract-savings/persistence.xml @@ -48,6 +48,7 @@ org.apache.fineract.portfolio.calendar.domain.Calendar org.apache.fineract.portfolio.calendar.domain.CalendarHistory org.apache.fineract.portfolio.client.domain.ClientIdentifier + org.apache.fineract.portfolio.delinquency.domain.DelinquencyMinimumPaymentPeriodAndRule org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucket org.apache.fineract.portfolio.delinquency.domain.DelinquencyRange org.apache.fineract.portfolio.group.domain.StaffAssignmentHistory @@ -112,9 +113,14 @@ org.apache.fineract.portfolio.charge.domain.Charge + + org.apache.fineract.cob.domain.BatchBusinessStep + org.apache.fineract.cob.domain.AccountLock + false + diff --git a/fineract-tax/src/main/resources/jpa/static-weaving/module/fineract-tax/persistence.xml b/fineract-tax/src/main/resources/jpa/static-weaving/module/fineract-tax/persistence.xml index 4a482aecacb..af3127cd6f1 100644 --- a/fineract-tax/src/main/resources/jpa/static-weaving/module/fineract-tax/persistence.xml +++ b/fineract-tax/src/main/resources/jpa/static-weaving/module/fineract-tax/persistence.xml @@ -48,6 +48,7 @@ org.apache.fineract.portfolio.calendar.domain.Calendar org.apache.fineract.portfolio.calendar.domain.CalendarHistory org.apache.fineract.portfolio.client.domain.ClientIdentifier + org.apache.fineract.portfolio.delinquency.domain.DelinquencyMinimumPaymentPeriodAndRule org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucket org.apache.fineract.portfolio.delinquency.domain.DelinquencyRange org.apache.fineract.portfolio.group.domain.StaffAssignmentHistory @@ -74,6 +75,7 @@ false + diff --git a/fineract-working-capital-loan/src/main/resources/db/changelog/tenant/module/workingcapitalloan/module-changelog-master.xml b/fineract-working-capital-loan/src/main/resources/db/changelog/tenant/module/workingcapitalloan/module-changelog-master.xml index 7119772bfbd..47ef0f45d5d 100644 --- a/fineract-working-capital-loan/src/main/resources/db/changelog/tenant/module/workingcapitalloan/module-changelog-master.xml +++ b/fineract-working-capital-loan/src/main/resources/db/changelog/tenant/module/workingcapitalloan/module-changelog-master.xml @@ -29,4 +29,5 @@ + diff --git a/fineract-working-capital-loan/src/main/resources/db/changelog/tenant/module/workingcapitalloan/parts/0008_delinquency_for_working_capital_loans.xml b/fineract-working-capital-loan/src/main/resources/db/changelog/tenant/module/workingcapitalloan/parts/0008_delinquency_for_working_capital_loans.xml new file mode 100644 index 00000000000..39fd7dda484 --- /dev/null +++ b/fineract-working-capital-loan/src/main/resources/db/changelog/tenant/module/workingcapitalloan/parts/0008_delinquency_for_working_capital_loans.xml @@ -0,0 +1,151 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/fineract-working-capital-loan/src/main/resources/jpa/static-weaving/module/fineract-working-capital-loan/persistence.xml b/fineract-working-capital-loan/src/main/resources/jpa/static-weaving/module/fineract-working-capital-loan/persistence.xml index 155b665babc..70ca1834c57 100644 --- a/fineract-working-capital-loan/src/main/resources/jpa/static-weaving/module/fineract-working-capital-loan/persistence.xml +++ b/fineract-working-capital-loan/src/main/resources/jpa/static-weaving/module/fineract-working-capital-loan/persistence.xml @@ -31,14 +31,62 @@ org.eclipse.persistence.jpa.PersistenceProvider + + org.apache.fineract.useradministration.domain.Role + org.apache.fineract.portfolio.fund.domain.Fund + org.apache.fineract.organisation.workingdays.domain.WorkingDays + org.apache.fineract.useradministration.domain.Permission + org.apache.fineract.commands.domain.CommandSource + org.apache.fineract.useradministration.domain.AppUser + org.apache.fineract.accounting.glaccount.domain.GLAccount + org.apache.fineract.organisation.monetary.domain.OrganisationCurrency + org.apache.fineract.organisation.staff.domain.Staff + org.apache.fineract.portfolio.rate.domain.Rate + org.apache.fineract.organisation.monetary.domain.ApplicationCurrency + org.apache.fineract.portfolio.calendar.domain.CalendarInstance + org.apache.fineract.portfolio.paymentdetail.domain.PaymentDetail + org.apache.fineract.portfolio.calendar.domain.Calendar + org.apache.fineract.portfolio.calendar.domain.CalendarHistory + org.apache.fineract.portfolio.client.domain.ClientIdentifier + org.apache.fineract.portfolio.delinquency.domain.DelinquencyMinimumPaymentPeriodAndRule + org.apache.fineract.portfolio.delinquency.domain.DelinquencyBucket + org.apache.fineract.portfolio.delinquency.domain.DelinquencyRange + org.apache.fineract.portfolio.group.domain.StaffAssignmentHistory + org.apache.fineract.portfolio.group.domain.Group + org.apache.fineract.portfolio.client.domain.Client + org.apache.fineract.infrastructure.event.external.repository.domain.ExternalEventConfiguration + org.apache.fineract.portfolio.group.domain.GroupRole + org.apache.fineract.portfolio.paymenttype.domain.PaymentType + org.apache.fineract.portfolio.group.domain.GroupLevel + org.apache.fineract.infrastructure.event.external.repository.domain.ExternalEvent + org.apache.fineract.organisation.office.domain.Office + org.apache.fineract.organisation.holiday.domain.Holiday + org.apache.fineract.infrastructure.cache.domain.PlatformCache + org.apache.fineract.infrastructure.codes.domain.Code + org.apache.fineract.infrastructure.businessdate.domain.BusinessDate + org.apache.fineract.infrastructure.codes.domain.CodeValue + + org.apache.fineract.cob.domain.BatchBusinessStep + org.apache.fineract.cob.domain.AccountLock - + org.apache.fineract.portfolio.workingcapitalloanproduct.domain.WorkingCapitalLoanProduct + org.apache.fineract.portfolio.workingcapitalloanproduct.domain.WorkingCapitalLoanProductPaymentAllocationRule + org.apache.fineract.portfolio.workingcapitalloanproduct.domain.WorkingCapitalLoanProductConfigurableAttributes + org.apache.fineract.portfolio.workingcapitalloan.domain.WorkingCapitalLoanPaymentAllocationRule + org.apache.fineract.portfolio.workingcapitalloan.domain.WorkingCapitalLoanNote + org.apache.fineract.portfolio.workingcapitalloan.domain.WorkingCapitalLoanDisbursementDetails + org.apache.fineract.portfolio.workingcapitalloan.domain.WorkingCapitalLoanBalance + org.apache.fineract.portfolio.workingcapitalloan.domain.WorkingCapitalLoan + org.apache.fineract.cob.domain.WorkingCapitalLoanAccountLock + org.apache.fineract.portfolio.loanaccount.domain.LoanStatusConverter + org.apache.fineract.portfolio.workingcapitalloanproduct.domain.WorkingCapitalPaymentAllocationTypeListConverter false + diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/AdvancedPaymentAllocationLoanRepaymentScheduleTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/AdvancedPaymentAllocationLoanRepaymentScheduleTest.java index e3dd27a426e..44b674fcb6e 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/AdvancedPaymentAllocationLoanRepaymentScheduleTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/AdvancedPaymentAllocationLoanRepaymentScheduleTest.java @@ -6031,7 +6031,7 @@ public void uc156() { AtomicLong createdLoanChargeId = new AtomicLong(); final BigDecimal interestRatePerPeriod = BigDecimal.valueOf(11.32); final BigDecimal principalAmount = BigDecimal.valueOf(135.94); - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec, List.of(// + final Long delinquencyBucketId = DelinquencyBucketsHelper.createBucket(List.of(// Pair.of(1, 10), // Pair.of(11, 30), // Pair.of(31, 60), // @@ -6173,7 +6173,7 @@ public void uc157() { GetLoansLoanIdTransactions[] accrualActivityId = new GetLoansLoanIdTransactions[1]; final BigDecimal interestRatePerPeriod = BigDecimal.valueOf(11.32); final BigDecimal principalAmount = BigDecimal.valueOf(135.94); - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec, List.of(// + final Long delinquencyBucketId = DelinquencyBucketsHelper.createBucket(List.of(// Pair.of(1, 10), // Pair.of(11, 30), // Pair.of(31, 60), // diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/BaseLoanIntegrationTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/BaseLoanIntegrationTest.java index 9c3dff8fc7d..baf77653cc9 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/BaseLoanIntegrationTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/BaseLoanIntegrationTest.java @@ -399,7 +399,7 @@ protected PostLoanProductsRequest createOnePeriod30DaysLongNoInterestPeriodicAcc } protected PostLoanProductsRequest create4ICumulative() { - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); Assertions.assertNotNull(delinquencyBucketId); return new PostLoanProductsRequest().name(Utils.uniqueRandomStringGenerator("4I_PROGRESSIVE_", 6))// @@ -597,7 +597,7 @@ protected PutLoanProductsProductIdRequest update4IProgressive(String name, Strin } protected PostLoanProductsRequest create4IProgressive() { - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); Assertions.assertNotNull(delinquencyBucketId); return new PostLoanProductsRequest().name(Utils.uniqueRandomStringGenerator("4I_PROGRESSIVE_", 6))// diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/DelinquencyActionIntegrationTests.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/DelinquencyActionIntegrationTests.java index 12be1252a11..e53f63cc379 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/DelinquencyActionIntegrationTests.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/DelinquencyActionIntegrationTests.java @@ -438,7 +438,7 @@ private Long createLoanProductWith25PctDownPayment(boolean autoDownPaymentEnable private Long createLoanProductWith25PctDownPaymentAndDelinquencyBucket(boolean autoDownPaymentEnabled, boolean multiDisburseEnabled, boolean installmentLevelDelinquencyEnabled, Integer graceOnArrearsAging) { // Create DelinquencyBuckets - Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec, List.of(// + Long delinquencyBucketId = DelinquencyBucketsHelper.createBucket(List.of(// Pair.of(1, 3), // Pair.of(4, 10), // Pair.of(11, 60), // @@ -471,7 +471,7 @@ private Long createLoanProductWith25PctDownPaymentAndDelinquencyBucket(boolean a private Long createLoanProductWithDelinquencyBucketNoDownPayment(boolean multiDisburseEnabled, boolean installmentLevelDelinquencyEnabled, Integer graceOnArrearsAging) { - Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec, List.of(// + Long delinquencyBucketId = DelinquencyBucketsHelper.createBucket(List.of(// Pair.of(1, 3), // Pair.of(4, 10), // Pair.of(11, 60), // diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/DelinquencyAndChargebackIntegrationTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/DelinquencyAndChargebackIntegrationTest.java index bf6acf58e16..936a7b36edd 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/DelinquencyAndChargebackIntegrationTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/DelinquencyAndChargebackIntegrationTest.java @@ -36,7 +36,7 @@ import java.util.stream.Stream; import lombok.extern.slf4j.Slf4j; import org.apache.fineract.client.models.AdvancedPaymentData; -import org.apache.fineract.client.models.DelinquencyBucketData; +import org.apache.fineract.client.models.DelinquencyBucketResponse; import org.apache.fineract.client.models.DelinquencyRangeData; import org.apache.fineract.client.models.GetLoanProductsProductIdResponse; import org.apache.fineract.client.models.GetLoansLoanIdRepaymentPeriod; @@ -99,14 +99,13 @@ public void testLoanClassificationStepAsPartOfCOB(LoanProductTestBuilder loanPro final SchedulerJobHelper schedulerJobHelper = new SchedulerJobHelper(requestSpec); // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); // Client and Loan account creation final Integer clientId = ClientHelper.createClient(this.requestSpec, this.responseSpec, "01 January 2012"); final GetLoanProductsProductIdResponse getLoanProductsProductResponse = createLoanProduct(loanTransactionHelper, - Math.toIntExact(delinquencyBucket.getId()), loanProductTestBuilder); + delinquencyBucket.getId(), loanProductTestBuilder); assertNotNull(getLoanProductsProductResponse); // Older date to have more than one overdue installment @@ -221,14 +220,13 @@ public void testLoanClassificationStepAsPartOfCOBRepeated(LoanProductTestBuilder final SchedulerJobHelper schedulerJobHelper = new SchedulerJobHelper(requestSpec); // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); // Client and Loan account creation final Integer clientId = ClientHelper.createClient(this.requestSpec, this.responseSpec, "01 January 2012"); final GetLoanProductsProductIdResponse getLoanProductsProductResponse = createLoanProduct(loanTransactionHelper, - Math.toIntExact(delinquencyBucket.getId()), loanProductTestBuilder); + delinquencyBucket.getId(), loanProductTestBuilder); assertNotNull(getLoanProductsProductResponse); // Older date to have more than one overdue installment @@ -339,7 +337,7 @@ public void testLoanClassificationStepAsPartOfCOBRepeated(LoanProductTestBuilder } private GetLoanProductsProductIdResponse createLoanProduct(final LoanTransactionHelper loanTransactionHelper, - final Integer delinquencyBucketId, LoanProductTestBuilder loanProductTestBuilder) { + final Long delinquencyBucketId, LoanProductTestBuilder loanProductTestBuilder) { final HashMap loanProductMap = loanProductTestBuilder.build(null, delinquencyBucketId); final Integer loanProductId = loanTransactionHelper.getLoanProductId(Utils.convertToJson(loanProductMap)); return loanTransactionHelper.getLoanProduct(loanProductId); diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/DelinquencyBucketsIntegrationTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/DelinquencyBucketsIntegrationTest.java index 7ae353c749c..e0512854ec1 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/DelinquencyBucketsIntegrationTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/DelinquencyBucketsIntegrationTest.java @@ -26,6 +26,7 @@ import static org.junit.jupiter.api.Assertions.assertNotEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; import com.google.gson.Gson; @@ -40,12 +41,14 @@ import java.util.HashMap; import java.util.List; import lombok.extern.slf4j.Slf4j; -import org.apache.commons.lang3.tuple.Pair; import org.apache.fineract.client.models.BusinessDateResponse; import org.apache.fineract.client.models.DeleteDelinquencyBucketResponse; import org.apache.fineract.client.models.DeleteDelinquencyRangeResponse; -import org.apache.fineract.client.models.DelinquencyBucketData; +import org.apache.fineract.client.models.DelinquencyBucketRequest; +import org.apache.fineract.client.models.DelinquencyBucketResponse; import org.apache.fineract.client.models.DelinquencyRangeData; +import org.apache.fineract.client.models.DelinquencyRangeRequest; +import org.apache.fineract.client.models.DelinquencyRangeResponse; import org.apache.fineract.client.models.GetDelinquencyTagHistoryResponse; import org.apache.fineract.client.models.GetLoanProductsProductIdResponse; import org.apache.fineract.client.models.GetLoansLoanIdDelinquencySummary; @@ -66,6 +69,7 @@ import org.apache.fineract.client.models.PutGlobalConfigurationsRequest; import org.apache.fineract.client.models.PutLoanProductsProductIdRequest; import org.apache.fineract.client.models.PutLoanProductsProductIdResponse; +import org.apache.fineract.client.util.CallFailedRuntimeException; import org.apache.fineract.cob.data.JobBusinessStepConfigData; import org.apache.fineract.infrastructure.businessdate.domain.BusinessDateType; import org.apache.fineract.infrastructure.configuration.api.GlobalConfigurationConstants; @@ -109,18 +113,16 @@ public void setup() { @Test public void testCreateDelinquencyRanges() { // given - final String jsonRange = DelinquencyRangesHelper.getAsJSON(1, 3); - - // when - final PostDelinquencyRangeResponse delinquencyRangeResponse01 = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, - responseSpec, jsonRange); - final ArrayList ranges = DelinquencyRangesHelper.getDelinquencyRanges(requestSpec, responseSpec); + final PostDelinquencyRangeResponse delinquencyRangeResponse01 = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest() + .minimumAgeDays(1).maximumAgeDays(3).locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + final List ranges = DelinquencyRangesHelper.getRanges(); // then assertNotNull(delinquencyRangeResponse01); assertNotNull(ranges); assertFalse(ranges.isEmpty()); - DelinquencyRangeData range = ranges.stream().filter(r -> r.getId().equals(delinquencyRangeResponse01.getResourceId())).findFirst() + DelinquencyRangeResponse range = ranges.stream().filter(r -> r.getId().equals(delinquencyRangeResponse01.getResourceId())) + .findFirst() .orElseThrow(() -> new AssertionError("Range with id " + delinquencyRangeResponse01.getResourceId() + " not found")); assertEquals(1, range.getMinimumAgeDays(), "Expected Min Age Days to 1"); assertEquals(3, range.getMaximumAgeDays(), "Expected Max Age Days to 3"); @@ -129,19 +131,15 @@ public void testCreateDelinquencyRanges() { @Test public void testUpdateDelinquencyRanges() { // given - String jsonRange = DelinquencyRangesHelper.getAsJSON(1, 3); - final PostDelinquencyRangeResponse delinquencyRangeResponse01 = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, - responseSpec, jsonRange); - jsonRange = DelinquencyRangesHelper.getAsJSON(1, 7); - assertNotNull(delinquencyRangeResponse01); - + final PostDelinquencyRangeResponse delinquencyRangeResponse01 = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest() + .minimumAgeDays(1).maximumAgeDays(3).locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); // when - final PutDelinquencyRangeResponse delinquencyRangeResponse02 = DelinquencyRangesHelper.updateDelinquencyRange(requestSpec, - responseSpec, Math.toIntExact(delinquencyRangeResponse01.getResourceId()), jsonRange); - final DelinquencyRangeData range = DelinquencyRangesHelper.getDelinquencyRange(requestSpec, responseSpec, - Math.toIntExact(delinquencyRangeResponse01.getResourceId())); - final DeleteDelinquencyRangeResponse deleteDelinquencyRangeResponse = DelinquencyRangesHelper.deleteDelinquencyRange(requestSpec, - responseSpec, Math.toIntExact(delinquencyRangeResponse01.getResourceId())); + final PutDelinquencyRangeResponse delinquencyRangeResponse02 = DelinquencyRangesHelper + .updateRange(delinquencyRangeResponse01.getResourceId(), new DelinquencyRangeRequest().minimumAgeDays(1).maximumAgeDays(7) + .locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + final DelinquencyRangeResponse range = DelinquencyRangesHelper.getRange(delinquencyRangeResponse01.getResourceId()); + final DeleteDelinquencyRangeResponse deleteDelinquencyRangeResponse = DelinquencyRangesHelper + .deleteRange(delinquencyRangeResponse01.getResourceId()); // then assertNotNull(delinquencyRangeResponse02); @@ -155,32 +153,30 @@ public void testUpdateDelinquencyRanges() { @Test public void testDelinquencyBuckets() { // given - ArrayList rangeIds = new ArrayList<>(); - String jsonRange = DelinquencyRangesHelper.getAsJSON(1, 3); - PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, responseSpec, - jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); - jsonRange = DelinquencyRangesHelper.getAsJSON(4, 30); - // Create - delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, responseSpec, jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); - String jsonBucket = DelinquencyBucketsHelper.getAsJSON(rangeIds); - PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, - responseSpec, jsonBucket); + ArrayList rangeIds = new ArrayList<>(); + PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest() + .minimumAgeDays(1).maximumAgeDays(3).locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); + delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest().minimumAgeDays(4).maximumAgeDays(30) + .locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); + + PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper + .createBucket(new DelinquencyBucketRequest().name(Utils.randomStringGenerator("DLQ_B_", 10)).ranges(rangeIds)); // Update - jsonRange = DelinquencyRangesHelper.getAsJSON(31, 60); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); - jsonBucket = DelinquencyBucketsHelper.getAsJSON(rangeIds); - PutDelinquencyBucketResponse updateDelinquencyBucketResponse = DelinquencyBucketsHelper.updateDelinquencyBucket(requestSpec, - responseSpec, Math.toIntExact(Math.toIntExact(delinquencyBucketResponse.getResourceId())), jsonBucket); - delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, responseSpec, jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); + rangeIds.add(delinquencyRangeResponse.getResourceId()); + + PutDelinquencyBucketResponse updateDelinquencyBucketResponse = DelinquencyBucketsHelper.updateBucket( + delinquencyBucketResponse.getResourceId(), + new DelinquencyBucketRequest().name(Utils.randomStringGenerator("DLQ_B_", 10)).ranges(rangeIds)); + delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest().minimumAgeDays(31).maximumAgeDays(60) + .locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); // Read - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - Math.toIntExact(Math.toIntExact(delinquencyBucketResponse.getResourceId()))); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketResponse.getResourceId()); // when - final ArrayList bucketList = DelinquencyBucketsHelper.getDelinquencyBuckets(requestSpec, responseSpec); + final List bucketList = DelinquencyBucketsHelper.getBuckets(); // then assertNotNull(bucketList); @@ -193,24 +189,19 @@ public void testDelinquencyBuckets() { @Test public void testDelinquencyBucketDelete() { // given - ArrayList rangeIds = new ArrayList<>(); - String jsonRange = DelinquencyRangesHelper.getAsJSON(1, 3); - PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, responseSpec, - jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); - jsonRange = DelinquencyRangesHelper.getAsJSON(4, 30); - // Create - delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, responseSpec, jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); - String jsonBucket = DelinquencyBucketsHelper.getAsJSON(rangeIds); - PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, - responseSpec, jsonBucket); + ArrayList rangeIds = new ArrayList<>(); + final PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest() + .minimumAgeDays(1).maximumAgeDays(3).locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); + + PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper + .createBucket(new DelinquencyBucketRequest().name(Utils.randomStringGenerator("DLQ_B_", 10)).ranges(rangeIds)); // Delete - DeleteDelinquencyBucketResponse deleteDelinquencyBucketResponse = DelinquencyBucketsHelper.deleteDelinquencyBucket(requestSpec, - responseSpec, Math.toIntExact(Math.toIntExact(delinquencyBucketResponse.getResourceId()))); + DeleteDelinquencyBucketResponse deleteDelinquencyBucketResponse = DelinquencyBucketsHelper + .deleteBucket(delinquencyBucketResponse.getResourceId()); // when - final ArrayList bucketList = DelinquencyBucketsHelper.getDelinquencyBuckets(requestSpec, responseSpec); + final List bucketList = DelinquencyBucketsHelper.getBuckets(); // then assertNotNull(bucketList); @@ -221,42 +212,39 @@ public void testDelinquencyBucketDelete() { @Test public void testDelinquencyBucketsRangeAgeOverlaped() { // Given - ArrayList rangeIds = new ArrayList<>(); - String jsonRange = DelinquencyRangesHelper.getAsJSON(1, 3); - PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, responseSpec, - jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); - jsonRange = DelinquencyRangesHelper.getAsJSON(3, 30); - // Create - delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, responseSpec, jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); - String jsonBucket = DelinquencyBucketsHelper.getAsJSON(rangeIds); - final ResponseSpecification response403Spec = new ResponseSpecBuilder().expectStatusCode(403).build(); + ArrayList rangeIds = new ArrayList<>(); + PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest() + .minimumAgeDays(1).maximumAgeDays(3).locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); + delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest().minimumAgeDays(3).maximumAgeDays(30) + .locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); // When - DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, response403Spec, jsonBucket); + CallFailedRuntimeException exception = assertThrows(CallFailedRuntimeException.class, () -> { + DelinquencyBucketsHelper + .createBucket(new DelinquencyBucketRequest().name(Utils.randomStringGenerator("DLQ_B_", 10)).ranges(rangeIds)); + }); + assertEquals(403, exception.getResponse().code()); + } @Test public void testDelinquencyBucketsNameDuplication() { // Given - ArrayList rangeIds = new ArrayList<>(); - String jsonRange = DelinquencyRangesHelper.getAsJSON(1, 3); - PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, responseSpec, - jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); - jsonRange = DelinquencyRangesHelper.getAsJSON(4, 30); - // Create - delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, responseSpec, jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); - String jsonBucket = DelinquencyBucketsHelper.getAsJSON(rangeIds); - final ResponseSpecification response403Spec = new ResponseSpecBuilder().expectStatusCode(403).build(); - + ArrayList rangeIds = new ArrayList<>(); + PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest() + .minimumAgeDays(1).maximumAgeDays(3).locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); // When - DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec, jsonBucket); + String bucketName = Utils.randomStringGenerator("DLQ_B_", 10); + rangeIds.add(delinquencyRangeResponse.getResourceId()); + DelinquencyBucketsHelper.createBucket(new DelinquencyBucketRequest().name(bucketName).ranges(rangeIds)); - // Then - DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, response403Spec, jsonBucket); + // When + CallFailedRuntimeException exception = assertThrows(CallFailedRuntimeException.class, () -> { + DelinquencyBucketsHelper.createBucket(new DelinquencyBucketRequest().name(bucketName).ranges(rangeIds)); + }); + assertEquals(403, exception.getResponse().code()); } @Test @@ -264,32 +252,27 @@ public void testLoanProductCreationWithAndWithoutDelinquencyBucket() { // Given final LoanTransactionHelper loanTransactionHelper = new LoanTransactionHelper(this.requestSpec, this.responseSpec); - ArrayList rangeIds = new ArrayList<>(); + ArrayList rangeIds = new ArrayList<>(); // First Range - String jsonRange = DelinquencyRangesHelper.getAsJSON(1, 3); - PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, responseSpec, - jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); - jsonRange = DelinquencyRangesHelper.getAsJSON(4, 60); + PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest() + .minimumAgeDays(1).maximumAgeDays(3).locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); - DelinquencyRangeData range = DelinquencyRangesHelper.getDelinquencyRange(requestSpec, responseSpec, - Math.toIntExact(delinquencyRangeResponse.getResourceId())); + DelinquencyRangeResponse range = DelinquencyRangesHelper.getRange(delinquencyRangeResponse.getResourceId()); // Second Range - delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, responseSpec, jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); + delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest().minimumAgeDays(4).maximumAgeDays(60) + .locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); - range = DelinquencyRangesHelper.getDelinquencyRange(requestSpec, responseSpec, - Math.toIntExact(delinquencyRangeResponse.getResourceId())); + range = DelinquencyRangesHelper.getRange(delinquencyRangeResponse.getResourceId()); final String classificationExpected = range.getClassification(); log.info("Expected Delinquency Range classification after Disbursement {}", classificationExpected); - String jsonBucket = DelinquencyBucketsHelper.getAsJSON(rangeIds); - PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, - responseSpec, jsonBucket); + PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper + .createBucket(new DelinquencyBucketRequest().name(Utils.randomStringGenerator("DLQ_B_", 10)).ranges(rangeIds)); assertNotNull(delinquencyBucketResponse); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - Math.toIntExact(Math.toIntExact(delinquencyBucketResponse.getResourceId()))); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketResponse.getResourceId()); // Loan product creation without Delinquency bucket GetLoanProductsProductIdResponse getLoanProductResponse = createLoanProduct(loanTransactionHelper, null, null); @@ -297,7 +280,7 @@ public void testLoanProductCreationWithAndWithoutDelinquencyBucket() { assertNull(getLoanProductResponse.getDelinquencyBucket().getId()); // Loan product creation with Delinquency bucket - getLoanProductResponse = createLoanProduct(loanTransactionHelper, Math.toIntExact(delinquencyBucket.getId()), null); + getLoanProductResponse = createLoanProduct(loanTransactionHelper, delinquencyBucket.getId(), null); assertNotNull(getLoanProductResponse); log.info("Loan Product Bucket Name: {}", getLoanProductResponse.getDelinquencyBucket().getName()); assertEquals(getLoanProductResponse.getDelinquencyBucket().getName(), delinquencyBucket.getName()); @@ -324,37 +307,33 @@ public void testLoanClassificationRealtime() { final BusinessDateResponse businessDateResponse = this.businessDateHelper.getBusinessDateByType(requestSpec, responseSpec, BusinessDateType.BUSINESS_DATE); - ArrayList rangeIds = new ArrayList<>(); + ArrayList rangeIds = new ArrayList<>(); // First Range - String jsonRange = DelinquencyRangesHelper.getAsJSON(1, 3); - PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, - responseSpec, jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); - jsonRange = DelinquencyRangesHelper.getAsJSON(4, 60); + PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest() + .minimumAgeDays(1).maximumAgeDays(3).locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); - DelinquencyRangeData range = DelinquencyRangesHelper.getDelinquencyRange(requestSpec, responseSpec, - Math.toIntExact(delinquencyRangeResponse.getResourceId())); + DelinquencyRangeResponse range = DelinquencyRangesHelper.getRange(delinquencyRangeResponse.getResourceId()); // Second Range - delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, responseSpec, jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); + delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest().minimumAgeDays(4) + .maximumAgeDays(60).locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); - range = DelinquencyRangesHelper.getDelinquencyRange(requestSpec, responseSpec, - Math.toIntExact(delinquencyRangeResponse.getResourceId())); + range = DelinquencyRangesHelper.getRange(delinquencyRangeResponse.getResourceId()); final String classificationExpected = range.getClassification(); log.info("Expected Delinquency Range classification after Disbursement {}", classificationExpected); - String jsonBucket = DelinquencyBucketsHelper.getAsJSON(rangeIds); - PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, - responseSpec, jsonBucket); + PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper + .createBucket(new DelinquencyBucketRequest().name(Utils.randomStringGenerator("DLQ_B_", 10)).ranges(rangeIds)); assertNotNull(delinquencyBucketResponse); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - Math.toIntExact(Math.toIntExact(delinquencyBucketResponse.getResourceId()))); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper + .getBucket(delinquencyBucketResponse.getResourceId()); // Client and Loan account creation final Integer clientId = ClientHelper.createClient(this.requestSpec, this.responseSpec, "01 January 2012"); final GetLoanProductsProductIdResponse getLoanProductsProductResponse = createLoanProduct(loanTransactionHelper, - Math.toIntExact(delinquencyBucket.getId()), null); + delinquencyBucket.getId(), null); assertNotNull(getLoanProductsProductResponse); log.info("Loan Product Bucket Name: {}", getLoanProductsProductResponse.getDelinquencyBucket().getName()); assertEquals(getLoanProductsProductResponse.getDelinquencyBucket().getName(), delinquencyBucket.getName()); @@ -423,37 +402,33 @@ public void testLoanClassificationRealtimeWithCharges() { // Given final LoanTransactionHelper loanTransactionHelper = new LoanTransactionHelper(this.requestSpec, this.responseSpec); - ArrayList rangeIds = new ArrayList<>(); + ArrayList rangeIds = new ArrayList<>(); // First Range - String jsonRange = DelinquencyRangesHelper.getAsJSON(1, 3); - PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, - responseSpec, jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); - jsonRange = DelinquencyRangesHelper.getAsJSON(4, 60); + PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest() + .minimumAgeDays(1).maximumAgeDays(3).locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); - DelinquencyRangeData range = DelinquencyRangesHelper.getDelinquencyRange(requestSpec, responseSpec, - Math.toIntExact(delinquencyRangeResponse.getResourceId())); + DelinquencyRangeResponse range = DelinquencyRangesHelper.getRange(delinquencyRangeResponse.getResourceId()); // Second Range - delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, responseSpec, jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); + delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest().minimumAgeDays(4) + .maximumAgeDays(60).locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); - range = DelinquencyRangesHelper.getDelinquencyRange(requestSpec, responseSpec, - Math.toIntExact(delinquencyRangeResponse.getResourceId())); + range = DelinquencyRangesHelper.getRange(delinquencyRangeResponse.getResourceId()); final String classificationExpected = range.getClassification(); log.info("Expected Delinquency Range classification after Disbursement {}", classificationExpected); - String jsonBucket = DelinquencyBucketsHelper.getAsJSON(rangeIds); - PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, - responseSpec, jsonBucket); + PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper + .createBucket(new DelinquencyBucketRequest().name(Utils.randomStringGenerator("DLQ_B_", 10)).ranges(rangeIds)); assertNotNull(delinquencyBucketResponse); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - Math.toIntExact(Math.toIntExact(delinquencyBucketResponse.getResourceId()))); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper + .getBucket(delinquencyBucketResponse.getResourceId()); // Client and Loan account creation final Integer clientId = ClientHelper.createClient(this.requestSpec, this.responseSpec, "01 January 2012"); final GetLoanProductsProductIdResponse getLoanProductsProductResponse = createLoanProduct(loanTransactionHelper, - Math.toIntExact(delinquencyBucket.getId()), null); + delinquencyBucket.getId(), null); assertNotNull(getLoanProductsProductResponse); log.info("Loan Product Bucket Name: {}", getLoanProductsProductResponse.getDelinquencyBucket().getName()); assertEquals(getLoanProductsProductResponse.getDelinquencyBucket().getName(), delinquencyBucket.getName()); @@ -514,46 +489,40 @@ public void testLoanClassificationRealtimeOlderLoan() { // Given final LoanTransactionHelper loanTransactionHelper = new LoanTransactionHelper(this.requestSpec, this.responseSpec); - ArrayList rangeIds = new ArrayList<>(); + ArrayList rangeIds = new ArrayList<>(); // First Range - String jsonRange = DelinquencyRangesHelper.getAsJSON(4, 30); - PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, responseSpec, - jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); - DelinquencyRangeData range = DelinquencyRangesHelper.getDelinquencyRange(requestSpec, responseSpec, - Math.toIntExact(delinquencyRangeResponse.getResourceId())); + PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest() + .minimumAgeDays(4).maximumAgeDays(30).locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); + DelinquencyRangeResponse range = DelinquencyRangesHelper.getRange(delinquencyRangeResponse.getResourceId()); final String classificationExpected02 = range.getClassification(); log.info("Expected Delinquency Range classification after first repayment {}", classificationExpected02); // Second Range - jsonRange = DelinquencyRangesHelper.getAsJSON(31, 60); - delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, responseSpec, jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); + delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest().minimumAgeDays(31).maximumAgeDays(60) + .locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); - range = DelinquencyRangesHelper.getDelinquencyRange(requestSpec, responseSpec, - Math.toIntExact(delinquencyRangeResponse.getResourceId())); + range = DelinquencyRangesHelper.getRange(delinquencyRangeResponse.getResourceId()); final String classificationExpected01 = range.getClassification(); log.info("Expected Delinquency Range classification after Disbursement {}", classificationExpected01); // Third Range - jsonRange = DelinquencyRangesHelper.getAsJSON(61, 90); - delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, responseSpec, jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); + delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest().minimumAgeDays(61).maximumAgeDays(90) + .locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); - range = DelinquencyRangesHelper.getDelinquencyRange(requestSpec, responseSpec, - Math.toIntExact(delinquencyRangeResponse.getResourceId())); + range = DelinquencyRangesHelper.getRange(delinquencyRangeResponse.getResourceId()); - String jsonBucket = DelinquencyBucketsHelper.getAsJSON(rangeIds); - PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, - responseSpec, jsonBucket); + PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper + .createBucket(new DelinquencyBucketRequest().name(Utils.randomStringGenerator("DLQ_B_", 10)).ranges(rangeIds)); assertNotNull(delinquencyBucketResponse); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - Math.toIntExact(delinquencyBucketResponse.getResourceId())); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketResponse.getResourceId()); // Client and Loan account creation final Integer clientId = ClientHelper.createClient(this.requestSpec, this.responseSpec, "01 January 2012"); final GetLoanProductsProductIdResponse getLoanProductsProductResponse = createLoanProduct(loanTransactionHelper, - Math.toIntExact(delinquencyBucket.getId()), null); + delinquencyBucket.getId(), null); assertNotNull(getLoanProductsProductResponse); log.info("Loan Product Bucket Name: {}", getLoanProductsProductResponse.getDelinquencyBucket().getName()); assertEquals(getLoanProductsProductResponse.getDelinquencyBucket().getName(), delinquencyBucket.getName()); @@ -625,28 +594,24 @@ public void testLoanClassificationRealtimeWithReversedRepayment() { // Given final LoanTransactionHelper loanTransactionHelper = new LoanTransactionHelper(this.requestSpec, this.responseSpec); - ArrayList rangeIds = new ArrayList<>(); + ArrayList rangeIds = new ArrayList<>(); // First Range - String jsonRange = DelinquencyRangesHelper.getAsJSON(4, 30); - PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, responseSpec, - jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); - DelinquencyRangeData range = DelinquencyRangesHelper.getDelinquencyRange(requestSpec, responseSpec, - Math.toIntExact(delinquencyRangeResponse.getResourceId())); + PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest() + .minimumAgeDays(4).maximumAgeDays(30).locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); + DelinquencyRangeResponse range = DelinquencyRangesHelper.getRange(delinquencyRangeResponse.getResourceId()); final String classificationExpected = range.getClassification(); log.info("Expected Delinquency Range classification after first repayment {}", classificationExpected); - String jsonBucket = DelinquencyBucketsHelper.getAsJSON(rangeIds); - PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, - responseSpec, jsonBucket); + PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper + .createBucket(new DelinquencyBucketRequest().name(Utils.randomStringGenerator("DLQ_B_", 10)).ranges(rangeIds)); assertNotNull(delinquencyBucketResponse); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - Math.toIntExact(delinquencyBucketResponse.getResourceId())); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketResponse.getResourceId()); // Client and Loan account creation final Integer clientId = ClientHelper.createClient(this.requestSpec, this.responseSpec, "01 January 2012"); final GetLoanProductsProductIdResponse getLoanProductsProductResponse = createLoanProduct(loanTransactionHelper, - Math.toIntExact(delinquencyBucket.getId()), null); + delinquencyBucket.getId(), null); assertNotNull(getLoanProductsProductResponse); log.info("Loan Product Bucket Name: {}", getLoanProductsProductResponse.getDelinquencyBucket().getName()); assertEquals(getLoanProductsProductResponse.getDelinquencyBucket().getName(), delinquencyBucket.getName()); @@ -731,31 +696,32 @@ public void testLoanClassificationJob() { final LoanTransactionHelper loanTransactionHelper = new LoanTransactionHelper(this.requestSpec, this.responseSpec); final SchedulerJobHelper schedulerJobHelper = new SchedulerJobHelper(requestSpec); - ArrayList rangeIds = new ArrayList<>(); - String jsonRange = DelinquencyRangesHelper.getAsJSON(1, 3); - PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, - responseSpec, jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); - jsonRange = DelinquencyRangesHelper.getAsJSON(4, 60); - // Create - delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, responseSpec, jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); - - final DelinquencyRangeData range = DelinquencyRangesHelper.getDelinquencyRange(requestSpec, responseSpec, - Math.toIntExact(delinquencyRangeResponse.getResourceId())); + ArrayList rangeIds = new ArrayList<>(); + // First Range + PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest() + .minimumAgeDays(1).maximumAgeDays(3).locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); + + DelinquencyRangeResponse range = DelinquencyRangesHelper.getRange(delinquencyRangeResponse.getResourceId()); + + // Second Range + delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest().minimumAgeDays(4) + .maximumAgeDays(60).locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); + + range = DelinquencyRangesHelper.getRange(delinquencyRangeResponse.getResourceId()); final String classificationExpected = range.getClassification(); log.info("Expected Delinquency Range classification {}", classificationExpected); - String jsonBucket = DelinquencyBucketsHelper.getAsJSON(rangeIds); - PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, - responseSpec, jsonBucket); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - Math.toIntExact(delinquencyBucketResponse.getResourceId())); + PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper + .createBucket(new DelinquencyBucketRequest().name(Utils.randomStringGenerator("DLQ_B_", 10)).ranges(rangeIds)); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper + .getBucket(delinquencyBucketResponse.getResourceId()); // Client and Loan account creation final Integer clientId = ClientHelper.createClient(this.requestSpec, this.responseSpec, "01 January 2012"); final GetLoanProductsProductIdResponse getLoanProductsProductResponse = createLoanProduct(loanTransactionHelper, - Math.toIntExact(delinquencyBucket.getId()), null); + delinquencyBucket.getId(), null); assertNotNull(getLoanProductsProductResponse); log.info("Loan Product Bucket Name: {}", getLoanProductsProductResponse.getDelinquencyBucket().getName()); assertEquals(getLoanProductsProductResponse.getDelinquencyBucket().getName(), delinquencyBucket.getName()); @@ -823,30 +789,30 @@ public void testLoanClassificationStepAsPartOfCOB() { final LoanTransactionHelper loanTransactionHelper = new LoanTransactionHelper(this.requestSpec, this.responseSpec); final SchedulerJobHelper schedulerJobHelper = new SchedulerJobHelper(requestSpec); - ArrayList rangeIds = new ArrayList<>(); - String jsonRange = DelinquencyRangesHelper.getAsJSON(1, 3); - PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, - responseSpec, jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); - final DelinquencyRangeData range = DelinquencyRangesHelper.getDelinquencyRange(requestSpec, responseSpec, - Math.toIntExact(delinquencyRangeResponse.getResourceId())); + ArrayList rangeIds = new ArrayList<>(); + // First Range + PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest() + .minimumAgeDays(1).maximumAgeDays(3).locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); + + DelinquencyRangeResponse range = DelinquencyRangesHelper.getRange(delinquencyRangeResponse.getResourceId()); final String classificationExpected = range.getClassification(); - log.info("Expected Delinquency Range classification {}", classificationExpected); + // Second Range + delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest().minimumAgeDays(4) + .maximumAgeDays(60).locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); - jsonRange = DelinquencyRangesHelper.getAsJSON(4, 60); - delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, responseSpec, jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); + range = DelinquencyRangesHelper.getRange(delinquencyRangeResponse.getResourceId()); - String jsonBucket = DelinquencyBucketsHelper.getAsJSON(rangeIds); - PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, - responseSpec, jsonBucket); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - Math.toIntExact(delinquencyBucketResponse.getResourceId())); + PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper + .createBucket(new DelinquencyBucketRequest().name(Utils.randomStringGenerator("DLQ_B_", 10)).ranges(rangeIds)); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper + .getBucket(delinquencyBucketResponse.getResourceId()); // Client and Loan account creation final Integer clientId = ClientHelper.createClient(this.requestSpec, this.responseSpec, "01 January 2012"); final GetLoanProductsProductIdResponse getLoanProductsProductResponse = createLoanProduct(loanTransactionHelper, - Math.toIntExact(delinquencyBucket.getId()), null); + delinquencyBucket.getId(), null); assertNotNull(getLoanProductsProductResponse); log.info("Loan Product Bucket Name: {}", getLoanProductsProductResponse.getDelinquencyBucket().getName()); assertEquals(getLoanProductsProductResponse.getDelinquencyBucket().getName(), delinquencyBucket.getName()); @@ -924,30 +890,30 @@ public void testLoanClassificationToValidateNegatives() { final LoanTransactionHelper loanTransactionHelper = new LoanTransactionHelper(this.requestSpec, this.responseSpec); final SchedulerJobHelper schedulerJobHelper = new SchedulerJobHelper(requestSpec); - ArrayList rangeIds = new ArrayList<>(); - String jsonRange = DelinquencyRangesHelper.getAsJSON(1, 3); - PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, - responseSpec, jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); - final DelinquencyRangeData range = DelinquencyRangesHelper.getDelinquencyRange(requestSpec, responseSpec, - Math.toIntExact(delinquencyRangeResponse.getResourceId())); - final String classificationExpected = range.getClassification(); - log.info("Expected Delinquency Range classification {}", classificationExpected); + ArrayList rangeIds = new ArrayList<>(); + // First Range + PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest() + .minimumAgeDays(1).maximumAgeDays(3).locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); - jsonRange = DelinquencyRangesHelper.getAsJSON(4, 60); - delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, responseSpec, jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); + DelinquencyRangeResponse range = DelinquencyRangesHelper.getRange(delinquencyRangeResponse.getResourceId()); - String jsonBucket = DelinquencyBucketsHelper.getAsJSON(rangeIds); - PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, - responseSpec, jsonBucket); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - Math.toIntExact(delinquencyBucketResponse.getResourceId())); + // Second Range + delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest().minimumAgeDays(4) + .maximumAgeDays(60).locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); + + range = DelinquencyRangesHelper.getRange(delinquencyRangeResponse.getResourceId()); + + PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper + .createBucket(new DelinquencyBucketRequest().name(Utils.randomStringGenerator("DLQ_B_", 10)).ranges(rangeIds)); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper + .getBucket(delinquencyBucketResponse.getResourceId()); // Client and Loan account creation final Integer clientId = ClientHelper.createClient(this.requestSpec, this.responseSpec, "01 January 2012"); final GetLoanProductsProductIdResponse getLoanProductsProductResponse = createLoanProduct(loanTransactionHelper, - Math.toIntExact(delinquencyBucket.getId()), "3"); + delinquencyBucket.getId(), "3"); assertNotNull(getLoanProductsProductResponse); log.info("Loan Product Bucket Name: {}", getLoanProductsProductResponse.getDelinquencyBucket().getName()); assertEquals(getLoanProductsProductResponse.getDelinquencyBucket().getName(), delinquencyBucket.getName()); @@ -1001,30 +967,30 @@ public void testLoanClassificationUsingAgeingArrears() { final LoanTransactionHelper loanTransactionHelper = new LoanTransactionHelper(this.requestSpec, this.responseSpec); final SchedulerJobHelper schedulerJobHelper = new SchedulerJobHelper(requestSpec); - ArrayList rangeIds = new ArrayList<>(); - String jsonRange = DelinquencyRangesHelper.getAsJSON(1, 3); - PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, - responseSpec, jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); - final DelinquencyRangeData range = DelinquencyRangesHelper.getDelinquencyRange(requestSpec, responseSpec, - Math.toIntExact(delinquencyRangeResponse.getResourceId())); - final String classificationExpected = range.getClassification(); - log.info("Expected Delinquency Range classification {}", classificationExpected); + ArrayList rangeIds = new ArrayList<>(); + // First Range + PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest() + .minimumAgeDays(1).maximumAgeDays(3).locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); + + DelinquencyRangeResponse range = DelinquencyRangesHelper.getRange(delinquencyRangeResponse.getResourceId()); + + // Second Range + delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest().minimumAgeDays(4) + .maximumAgeDays(60).locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); - jsonRange = DelinquencyRangesHelper.getAsJSON(4, 60); - delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, responseSpec, jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); + range = DelinquencyRangesHelper.getRange(delinquencyRangeResponse.getResourceId()); - String jsonBucket = DelinquencyBucketsHelper.getAsJSON(rangeIds); - PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, - responseSpec, jsonBucket); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - Math.toIntExact(delinquencyBucketResponse.getResourceId())); + PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper + .createBucket(new DelinquencyBucketRequest().name(Utils.randomStringGenerator("DLQ_B_", 10)).ranges(rangeIds)); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper + .getBucket(delinquencyBucketResponse.getResourceId()); // Client and Loan account creation final Integer clientId = ClientHelper.createClient(this.requestSpec, this.responseSpec, "01 January 2012"); final GetLoanProductsProductIdResponse getLoanProductsProductResponse = createLoanProduct(loanTransactionHelper, - Math.toIntExact(delinquencyBucket.getId()), "3"); + delinquencyBucket.getId(), "3"); assertNotNull(getLoanProductsProductResponse); log.info("Loan Product Arrears: {}", getLoanProductsProductResponse.getInArrearsTolerance()); assertEquals(3, getLoanProductsProductResponse.getInArrearsTolerance()); @@ -1077,11 +1043,8 @@ public void testLoanClassificationUsingAgeingArrears() { @Test public void testDelinquencyWithPauseLettingPauseExpire() { runAt("01 January 2012", () -> { + Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); - Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec, List.of(// - Pair.of(1, 3), // - Pair.of(4, 60) // - )); LocalDate bussinesLocalDate = Utils.getDateAsLocalDate("01 January 2012"); final Integer clientId = ClientHelper.createClient(this.requestSpec, this.responseSpec, "01 January 2012"); @@ -1127,10 +1090,7 @@ public void testDelinquencyWithPauseLettingPauseExpire() { @Test public void testDelinquencyWithPauseResumeBeforePauseExpires() { runAt("01 January 2012", () -> { - Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec, List.of(// - Pair.of(1, 3), // - Pair.of(4, 60) // - )); + Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); LocalDate bussinesLocalDate = Utils.getDateAsLocalDate("01 January 2012"); final Integer clientId = ClientHelper.createClient(this.requestSpec, this.responseSpec, "01 January 2012"); @@ -1181,10 +1141,7 @@ public void testDelinquencyWithPauseResumeBeforePauseExpires() { public void testDelinquencyWithMultiplePausePeriods() { runAt("01 January 2012", () -> { - Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec, List.of(// - Pair.of(1, 3), // - Pair.of(4, 60) // - )); + Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); final Integer clientId = ClientHelper.createClient(this.requestSpec, this.responseSpec, "01 January 2012"); final GetLoanProductsProductIdResponse getLoanProductsProductResponse = createLoanProduct(loanTransactionHelper, @@ -1261,10 +1218,7 @@ private void verifyDelinquency(Integer loanId, String date, Double amount, int d @Test public void testDelinquencyWithMultiplePausePeriodsWithInstallmentLevelDelinquency() { runAt("01 January 2012", () -> { - Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec, List.of(// - Pair.of(1, 3), // - Pair.of(4, 60) // - )); + Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); final Integer clientId = ClientHelper.createClient(this.requestSpec, this.responseSpec, "01 January 2012"); final GetLoanProductsProductIdResponse getLoanProductsProductResponse = createLoanProductWithInstallmentLevelDelinquency( @@ -1356,24 +1310,21 @@ public void testLoanClassificationOnlyForActiveLoan() { // Given final LoanTransactionHelper loanTransactionHelper = new LoanTransactionHelper(this.requestSpec, this.responseSpec); - ArrayList rangeIds = new ArrayList<>(); + ArrayList rangeIds = new ArrayList<>(); // First Range - String jsonRange = DelinquencyRangesHelper.getAsJSON(4, 30); - PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, responseSpec, - jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); - - String jsonBucket = DelinquencyBucketsHelper.getAsJSON(rangeIds); - PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, - responseSpec, jsonBucket); + PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest() + .minimumAgeDays(4).maximumAgeDays(30).locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); + + PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper + .createBucket(new DelinquencyBucketRequest().name(Utils.randomStringGenerator("DLQ_B_", 10)).ranges(rangeIds)); assertNotNull(delinquencyBucketResponse); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - Math.toIntExact(delinquencyBucketResponse.getResourceId())); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketResponse.getResourceId()); // Client and Loan account creation final Integer clientId = ClientHelper.createClient(this.requestSpec, this.responseSpec, "01 January 2012"); final GetLoanProductsProductIdResponse getLoanProductsProductResponse = createLoanProduct(loanTransactionHelper, - Math.toIntExact(delinquencyBucket.getId()), null); + delinquencyBucket.getId(), null); assertNotNull(getLoanProductsProductResponse); final LocalDate todaysDate = Utils.getLocalDateOfTenant(); @@ -1417,24 +1368,22 @@ public void testLoanClassificationOnlyForActiveLoanWithCOB() { final LoanTransactionHelper loanTransactionHelper = new LoanTransactionHelper(this.requestSpec, this.responseSpec); final SchedulerJobHelper schedulerJobHelper = new SchedulerJobHelper(requestSpec); - ArrayList rangeIds = new ArrayList<>(); + ArrayList rangeIds = new ArrayList<>(); // First Range - String jsonRange = DelinquencyRangesHelper.getAsJSON(4, 30); - PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, - responseSpec, jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); - - String jsonBucket = DelinquencyBucketsHelper.getAsJSON(rangeIds); - PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, - responseSpec, jsonBucket); + PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest() + .minimumAgeDays(4).maximumAgeDays(30).locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); + + PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper + .createBucket(new DelinquencyBucketRequest().name(Utils.randomStringGenerator("DLQ_B_", 10)).ranges(rangeIds)); assertNotNull(delinquencyBucketResponse); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - Math.toIntExact(delinquencyBucketResponse.getResourceId())); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper + .getBucket(delinquencyBucketResponse.getResourceId()); // Client creation final Integer clientId = ClientHelper.createClient(this.requestSpec, this.responseSpec, operationDate); final GetLoanProductsProductIdResponse getLoanProductsProductResponse = createLoanProduct(loanTransactionHelper, - Math.toIntExact(delinquencyBucket.getId()), null); + delinquencyBucket.getId(), null); assertNotNull(getLoanProductsProductResponse); // Create Loan Application @@ -1467,27 +1416,23 @@ public void testLoanDelinquencyDataWithAmountPerPortions() { // Given final LoanTransactionHelper loanTransactionHelper = new LoanTransactionHelper(this.requestSpec, this.responseSpec); - ArrayList rangeIds = new ArrayList<>(); + ArrayList rangeIds = new ArrayList<>(); // First Range - String jsonRange = DelinquencyRangesHelper.getAsJSON(4, 30); - PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, responseSpec, - jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); - DelinquencyRangeData range = DelinquencyRangesHelper.getDelinquencyRange(requestSpec, responseSpec, - Math.toIntExact(delinquencyRangeResponse.getResourceId())); - - String jsonBucket = DelinquencyBucketsHelper.getAsJSON(rangeIds); - PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, - responseSpec, jsonBucket); + PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest() + .minimumAgeDays(4).maximumAgeDays(30).locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); + DelinquencyRangeResponse range = DelinquencyRangesHelper.getRange(delinquencyRangeResponse.getResourceId()); + + PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper + .createBucket(new DelinquencyBucketRequest().name(Utils.randomStringGenerator("DLQ_B_", 10)).ranges(rangeIds)); assertNotNull(delinquencyBucketResponse); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - Math.toIntExact(delinquencyBucketResponse.getResourceId())); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketResponse.getResourceId()); // Client and Loan account creation final Long clientId = clientHelper.createClient(ClientHelper.defaultClientCreationRequest()).getClientId(); final GetLoanProductsProductIdResponse getLoanProductsProductResponse = createLoanProduct(loanTransactionHelper, - Math.toIntExact(delinquencyBucket.getId()), null); + delinquencyBucket.getId(), null); assertNotNull(getLoanProductsProductResponse); log.info("Loan Product Bucket Name: {}", getLoanProductsProductResponse.getDelinquencyBucket().getName()); assertEquals(getLoanProductsProductResponse.getDelinquencyBucket().getName(), delinquencyBucket.getName()); @@ -1572,7 +1517,7 @@ public void testLoanDelinquencyDataWithAmountPerPortions() { } private GetLoanProductsProductIdResponse createLoanProduct(final LoanTransactionHelper loanTransactionHelper, - final Integer delinquencyBucketId, final String inArrearsTolerance) { + final Long delinquencyBucketId, final String inArrearsTolerance) { final HashMap loanProductMap = new LoanProductTestBuilder().withDaysInMonth("30").withDaysInYear("360") .withInArrearsTolerance(inArrearsTolerance).build(null, delinquencyBucketId); final Integer loanProductId = loanTransactionHelper.getLoanProductId(Utils.convertToJson(loanProductMap)); @@ -1580,7 +1525,7 @@ private GetLoanProductsProductIdResponse createLoanProduct(final LoanTransaction } private GetLoanProductsProductIdResponse createLoanProductWithInstallmentLevelDelinquency( - final LoanTransactionHelper loanTransactionHelper, final Integer delinquencyBucketId, final String inArrearsTolerance) { + final LoanTransactionHelper loanTransactionHelper, final Long delinquencyBucketId, final String inArrearsTolerance) { final HashMap loanProductMap = new LoanProductTestBuilder().withInArrearsTolerance(inArrearsTolerance).build(null, delinquencyBucketId); loanProductMap.put("enableInstallmentLevelDelinquency", true); diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/ExternalIdSupportIntegrationTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/ExternalIdSupportIntegrationTest.java index d9dc34eda5e..a0b123d5c7a 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/ExternalIdSupportIntegrationTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/ExternalIdSupportIntegrationTest.java @@ -34,7 +34,9 @@ import org.apache.fineract.client.models.BusinessDateUpdateRequest; import org.apache.fineract.client.models.DeleteLoansLoanIdChargesChargeIdResponse; import org.apache.fineract.client.models.DeleteLoansLoanIdResponse; -import org.apache.fineract.client.models.DelinquencyRangeData; +import org.apache.fineract.client.models.DelinquencyBucketRequest; +import org.apache.fineract.client.models.DelinquencyRangeRequest; +import org.apache.fineract.client.models.DelinquencyRangeResponse; import org.apache.fineract.client.models.GetDelinquencyTagHistoryResponse; import org.apache.fineract.client.models.GetLoansApprovalTemplateResponse; import org.apache.fineract.client.models.GetLoansLoanIdChargesChargeIdResponse; @@ -834,31 +836,27 @@ public void loan() { new BusinessDateHelper().updateBusinessDate(new BusinessDateUpdateRequest().type(BusinessDateUpdateRequest.TypeEnum.BUSINESS_DATE) .date("2022.10.10").dateFormat("yyyy.MM.dd").locale("en")); try { - ArrayList rangeIds = new ArrayList<>(); + ArrayList rangeIds = new ArrayList<>(); // First Range - String jsonRange = DelinquencyRangesHelper.getAsJSON(1, 3); - PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, - responseSpec, jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); - jsonRange = DelinquencyRangesHelper.getAsJSON(4, 60); - - DelinquencyRangeData range = DelinquencyRangesHelper.getDelinquencyRange(requestSpec, responseSpec, - Math.toIntExact(delinquencyRangeResponse.getResourceId())); + PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest() + .minimumAgeDays(1).maximumAgeDays(3).locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); + DelinquencyRangeResponse range = DelinquencyRangesHelper.getRange(delinquencyRangeResponse.getResourceId()); // Second Range - delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, responseSpec, jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); + delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest().minimumAgeDays(4) + .maximumAgeDays(60).locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); - String jsonBucket = DelinquencyBucketsHelper.getAsJSON(rangeIds); - PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, - responseSpec, jsonBucket); + PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper + .createBucket(new DelinquencyBucketRequest().name(Utils.randomStringGenerator("DLQ_B_", 10)).ranges(rangeIds)); final String loanProductJSON = new LoanProductTestBuilder().withPrincipal("1000").withRepaymentTypeAsMonth() .withRepaymentAfterEvery("1").withNumberOfRepayments("1").withRepaymentTypeAsMonth().withinterestRatePerPeriod("0") .withInterestRateFrequencyTypeAsMonths().withAmortizationTypeAsEqualPrincipalPayment() .withInterestTypeAsDecliningBalance().withAccountingRuleAsNone() .withInterestCalculationPeriodTypeAsRepaymentPeriod(true).withDaysInMonth("30").withDaysInYear("365") - .withMoratorium("0", "0").withDelinquencyBucket(Math.toIntExact(delinquencyBucketResponse.getResourceId())) + .withMoratorium("0", "0").withDelinquencyBucket(delinquencyBucketResponse.getResourceId()) .withInArrearsTolerance("1001").withMultiDisburse().withDisallowExpectedDisbursements(true).build(null); final Integer loanProductID = this.loanTransactionHelper.getLoanProductId(loanProductJSON); diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/InstallmentLevelDelinquencyAPIIntegrationTests.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/InstallmentLevelDelinquencyAPIIntegrationTests.java index 9d45bacf556..38ab34c0958 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/InstallmentLevelDelinquencyAPIIntegrationTests.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/InstallmentLevelDelinquencyAPIIntegrationTests.java @@ -54,7 +54,7 @@ public void testInstallmentLevelDelinquencyFourRangesInTheBucket() { Long clientId = clientHelper.createClient(ClientHelper.defaultClientCreationRequest()).getClientId(); // Create DelinquencyBuckets - Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec, List.of(// + Long delinquencyBucketId = DelinquencyBucketsHelper.createBucket(List.of(// Pair.of(1, 10), // Pair.of(11, 30), // Pair.of(31, 60), // @@ -117,7 +117,7 @@ public void testInstallmentLevelDelinquencyTwoRangesInTheBucket() { Long clientId = clientHelper.createClient(ClientHelper.defaultClientCreationRequest()).getClientId(); // Create DelinquencyBuckets - Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec, List.of(// + Long delinquencyBucketId = DelinquencyBucketsHelper.createBucket(List.of(// Pair.of(1, 60), // Pair.of(61, null)// )); @@ -167,7 +167,7 @@ public void testInstallmentLevelDelinquencyIsTurnedOff() { Long clientId = clientHelper.createClient(ClientHelper.defaultClientCreationRequest()).getClientId(); // Create DelinquencyBuckets - Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec, List.of(// + Long delinquencyBucketId = DelinquencyBucketsHelper.createBucket(List.of(// Pair.of(1, 60), // Pair.of(61, null)// )); @@ -206,7 +206,7 @@ public void testInstallmentLevelDelinquencyUpdatedWhenCOBIsExecuted() { Long clientId = clientHelper.createClient(ClientHelper.defaultClientCreationRequest()).getClientId(); // Create DelinquencyBuckets - Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec, List.of(// + Long delinquencyBucketId = DelinquencyBucketsHelper.createBucket(List.of(// Pair.of(1, 1), // Pair.of(2, null)// )); @@ -252,7 +252,7 @@ public void testInstallmentLevelDelinquencyTurnedOnForProductAndOffForLoan() { Long clientId = clientHelper.createClient(ClientHelper.defaultClientCreationRequest()).getClientId(); // Create DelinquencyBuckets - Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec, List.of(// + Long delinquencyBucketId = DelinquencyBucketsHelper.createBucket(List.of(// Pair.of(1, 10), // Pair.of(11, 30), // Pair.of(31, 60), // @@ -297,7 +297,7 @@ public void testInstallmentLevelDelinquencyTurnedOffForProductAndOnForLoan() { Long clientId = clientHelper.createClient(ClientHelper.defaultClientCreationRequest()).getClientId(); // Create DelinquencyBuckets - Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec, List.of(// + Long delinquencyBucketId = DelinquencyBucketsHelper.createBucket(List.of(// Pair.of(1, 10), // Pair.of(11, 30), // Pair.of(31, 60), // @@ -346,7 +346,7 @@ public void testLoanInheritsInstallmentLevelSettingFromLoanProductIfNotSet() { Long clientId = clientHelper.createClient(ClientHelper.defaultClientCreationRequest()).getClientId(); // Create DelinquencyBuckets - Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec, List.of(// + Long delinquencyBucketId = DelinquencyBucketsHelper.createBucket(List.of(// Pair.of(1, 10), // Pair.of(11, 30), // Pair.of(31, 60), // @@ -418,7 +418,7 @@ public void testLoanInstallmentLevelSettingModification() { Long clientId = clientHelper.createClient(ClientHelper.defaultClientCreationRequest()).getClientId(); // Create DelinquencyBuckets - Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec, List.of(// + Long delinquencyBucketId = DelinquencyBucketsHelper.createBucket(List.of(// Pair.of(1, 10), // Pair.of(11, 30), // Pair.of(31, 60), // @@ -515,7 +515,7 @@ public void testCalculateRepaymentScheduleWorksWithInstallmentLevelDelinquencySe Long clientId = clientHelper.createClient(ClientHelper.defaultClientCreationRequest()).getClientId(); // Create DelinquencyBuckets - Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec, List.of(// + Long delinquencyBucketId = DelinquencyBucketsHelper.createBucket(List.of(// Pair.of(1, 10), // Pair.of(11, 30), // Pair.of(31, 60), // diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccountArrearsAgeingCOBBusinessStepTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccountArrearsAgeingCOBBusinessStepTest.java index 47d0418030c..d084ec11e99 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccountArrearsAgeingCOBBusinessStepTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccountArrearsAgeingCOBBusinessStepTest.java @@ -30,7 +30,7 @@ import java.time.LocalDate; import java.util.HashMap; import java.util.UUID; -import org.apache.fineract.client.models.DelinquencyBucketData; +import org.apache.fineract.client.models.DelinquencyBucketResponse; import org.apache.fineract.client.models.GetLoanProductsProductIdResponse; import org.apache.fineract.client.models.GetLoansLoanIdResponse; import org.apache.fineract.client.models.GetLoansLoanIdSummary; @@ -87,9 +87,8 @@ public void loanArrearsAgeingCOBBusinessStepTest() { // create Loan Product // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); final GetLoanProductsProductIdResponse getLoanProductsProductResponse = createLoanProduct(loanTransactionHelper, delinquencyBucketId); @@ -146,7 +145,7 @@ public void loanArrearsAgeingCOBBusinessStepTest() { } private GetLoanProductsProductIdResponse createLoanProduct(final LoanTransactionHelper loanTransactionHelper, - final Integer delinquencyBucketId) { + final Long delinquencyBucketId) { final HashMap loanProductMap = new LoanProductTestBuilder().build(null, delinquencyBucketId); final Integer loanProductId = loanTransactionHelper.getLoanProductId(Utils.convertToJson(loanProductMap)); return loanTransactionHelper.getLoanProduct(loanProductId); diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccountChargeOffWithAdvancedPaymentAllocationTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccountChargeOffWithAdvancedPaymentAllocationTest.java index 998da433d83..57ae2e5db35 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccountChargeOffWithAdvancedPaymentAllocationTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccountChargeOffWithAdvancedPaymentAllocationTest.java @@ -688,7 +688,7 @@ private Integer createLoanProductWithPeriodicAccrualAccountingAndAdvancedPayment Assertions.assertNotNull(fundID); // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); String futureInstallmentAllocationRule = "NEXT_INSTALLMENT"; AdvancedPaymentData defaultAllocation = createDefaultPaymentAllocation(futureInstallmentAllocationRule); diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccountChargeReveseReplayWithAdvancedPaymentAllocationTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccountChargeReveseReplayWithAdvancedPaymentAllocationTest.java index 4d9bfc3b89e..514f72c50c3 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccountChargeReveseReplayWithAdvancedPaymentAllocationTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccountChargeReveseReplayWithAdvancedPaymentAllocationTest.java @@ -383,7 +383,7 @@ private Integer createLoanProductWithPeriodicAccrualAccounting(boolean advancedP Assertions.assertNotNull(fundID); // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); String futureInstallmentAllocationRule = "NEXT_INSTALLMENT"; diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccountCreditRefundPayoutWithChargebackTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccountCreditRefundPayoutWithChargebackTest.java index cf694e50256..c26315c6436 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccountCreditRefundPayoutWithChargebackTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccountCreditRefundPayoutWithChargebackTest.java @@ -30,7 +30,7 @@ import java.time.format.DateTimeFormatterBuilder; import java.util.HashMap; import java.util.UUID; -import org.apache.fineract.client.models.DelinquencyBucketData; +import org.apache.fineract.client.models.DelinquencyBucketResponse; import org.apache.fineract.client.models.GetLoanProductsProductIdResponse; import org.apache.fineract.client.models.GetLoansLoanIdTransactionsTransactionIdResponse; import org.apache.fineract.client.models.PostLoansLoanIdTransactionsRequest; @@ -76,9 +76,8 @@ public void loanCreditRefundPayoutGetCreatedWithChargebackTest() { String loanExternalIdStr = UUID.randomUUID().toString(); // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); // Client and Loan account creation @@ -134,7 +133,7 @@ public void loanCreditRefundPayoutGetCreatedWithChargebackTest() { } private GetLoanProductsProductIdResponse createLoanProduct(final LoanTransactionHelper loanTransactionHelper, - final Integer delinquencyBucketId) { + final Long delinquencyBucketId) { final HashMap loanProductMap = new LoanProductTestBuilder().build(null, delinquencyBucketId); final Integer loanProductId = loanTransactionHelper.getLoanProductId(Utils.convertToJson(loanProductMap)); return loanTransactionHelper.getLoanProduct(loanProductId); diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccountOverpaidDateStatusTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccountOverpaidDateStatusTest.java index 44d2d6234d8..417ff036fed 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccountOverpaidDateStatusTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccountOverpaidDateStatusTest.java @@ -32,7 +32,7 @@ import java.time.LocalDate; import java.util.HashMap; import java.util.UUID; -import org.apache.fineract.client.models.DelinquencyBucketData; +import org.apache.fineract.client.models.DelinquencyBucketResponse; import org.apache.fineract.client.models.GetLoanProductsProductIdResponse; import org.apache.fineract.client.models.GetLoansLoanIdResponse; import org.apache.fineract.client.models.PostLoansLoanIdTransactionsRequest; @@ -81,9 +81,8 @@ public void loanOverpaidDateStatusTest() { String loanExternalIdStr = UUID.randomUUID().toString(); // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); // Client and Loan account creation @@ -165,7 +164,7 @@ public void loanOverpaidDateStatusTest() { } private GetLoanProductsProductIdResponse createLoanProduct(final LoanTransactionHelper loanTransactionHelper, - final Integer delinquencyBucketId) { + final Long delinquencyBucketId) { final HashMap loanProductMap = new LoanProductTestBuilder().build(null, delinquencyBucketId); final Integer loanProductId = loanTransactionHelper.getLoanProductId(Utils.convertToJson(loanProductMap)); return loanTransactionHelper.getLoanProduct(loanProductId); diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccrualTransactionReversalTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccrualTransactionReversalTest.java index c1111793bdb..5ddcd1611b6 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccrualTransactionReversalTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanAccrualTransactionReversalTest.java @@ -33,7 +33,7 @@ import java.util.ArrayList; import java.util.HashMap; import java.util.UUID; -import org.apache.fineract.client.models.DelinquencyBucketData; +import org.apache.fineract.client.models.DelinquencyBucketResponse; import org.apache.fineract.client.models.GetLoanProductsProductIdResponse; import org.apache.fineract.client.models.PostLoansLoanIdTransactionsRequest; import org.apache.fineract.client.models.PostLoansLoanIdTransactionsResponse; @@ -90,9 +90,8 @@ public void testNoAccrualTransactionReversalForMultipleDisbursementWithChargeFor String loanExternalIdStr = UUID.randomUUID().toString(); // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); // Client and Loan account creation @@ -227,7 +226,7 @@ private GetLoanProductsProductIdResponse createLoanProductWithInterestRecalculat } private GetLoanProductsProductIdResponse createLoanProductWithMultipleDisbursement(final LoanTransactionHelper loanTransactionHelper, - final Integer delinquencyBucketId, final Account... accounts) { + final Long delinquencyBucketId, final Account... accounts) { final HashMap loanProductMap = new LoanProductTestBuilder().withPrincipal("1000").withRepaymentTypeAsMonth() .withRepaymentAfterEvery("1").withNumberOfRepayments("1").withRepaymentTypeAsMonth().withinterestRatePerPeriod("0") diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanChargeOffAccountingEntriesForReverseReplayedTransactionsTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanChargeOffAccountingEntriesForReverseReplayedTransactionsTest.java index a5a6999b592..5f19cd82e90 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanChargeOffAccountingEntriesForReverseReplayedTransactionsTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanChargeOffAccountingEntriesForReverseReplayedTransactionsTest.java @@ -39,7 +39,7 @@ public void testJournalEntriesForChargeOffLoanWithMultipleReverseReplay() { Long clientId = clientHelper.createClient(ClientHelper.defaultClientCreationRequest()).getClientId(); // Create DelinquencyBuckets - Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec, List.of(// + Long delinquencyBucketId = DelinquencyBucketsHelper.createBucket(List.of(// Pair.of(1, 10), // Pair.of(11, 30), // Pair.of(31, 60), // diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanChargeSpecificDueDateTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanChargeSpecificDueDateTest.java index b6220c5b6eb..03d9222d332 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanChargeSpecificDueDateTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanChargeSpecificDueDateTest.java @@ -791,14 +791,14 @@ public void testApplyLoanSpecificDueDatePenaltyAccrualWithDisbursementDateWithMu } private GetLoanProductsProductIdResponse createLoanProduct(final LoanTransactionHelper loanTransactionHelper, - final Integer delinquencyBucketId) { + final Long delinquencyBucketId) { final HashMap loanProductMap = new LoanProductTestBuilder().build(null, delinquencyBucketId); final Integer loanProductId = loanTransactionHelper.getLoanProductId(Utils.convertToJson(loanProductMap)); return loanTransactionHelper.getLoanProduct(loanProductId); } private GetLoanProductsProductIdResponse createLoanProductWithPeriodicAccrual(final LoanTransactionHelper loanTransactionHelper, - final Integer delinquencyBucketId) { + final Long delinquencyBucketId) { final Account assetAccount = this.accountHelper.createAssetAccount(); final Account incomeAccount = this.accountHelper.createIncomeAccount(); final Account expenseAccount = this.accountHelper.createExpenseAccount(); diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanChargebackOnPaymentTypeRepaymentTransactionsTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanChargebackOnPaymentTypeRepaymentTransactionsTest.java index 4ecf5d69cae..319a4306cdd 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanChargebackOnPaymentTypeRepaymentTransactionsTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanChargebackOnPaymentTypeRepaymentTransactionsTest.java @@ -36,7 +36,7 @@ import java.util.concurrent.atomic.AtomicInteger; import java.util.stream.Stream; import org.apache.fineract.client.models.AdvancedPaymentData; -import org.apache.fineract.client.models.DelinquencyBucketData; +import org.apache.fineract.client.models.DelinquencyBucketResponse; import org.apache.fineract.client.models.GetLoanProductsProductIdResponse; import org.apache.fineract.client.models.GetLoansLoanIdResponse; import org.apache.fineract.client.models.GetLoansLoanIdTransactionsTransactionIdResponse; @@ -87,9 +87,8 @@ public void loanTransactionChargebackForPaymentTypeRepaymentTransactionTest(Loan String loanExternalIdStr = UUID.randomUUID().toString(); // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); // Client and Loan account creation @@ -223,9 +222,8 @@ public void loanChargebackNotAllowedForReversedPaymentTypeRepaymentTest(LoanProd String loanExternalIdStr = UUID.randomUUID().toString(); // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); // Client and Loan account creation @@ -252,7 +250,7 @@ public void loanChargebackNotAllowedForReversedPaymentTypeRepaymentTest(LoanProd } private GetLoanProductsProductIdResponse createLoanProduct(final LoanTransactionHelper loanTransactionHelper, - final Integer delinquencyBucketId, LoanProductTestBuilder loanProductTestBuilder) { + final Long delinquencyBucketId, LoanProductTestBuilder loanProductTestBuilder) { final HashMap loanProductMap = loanProductTestBuilder.build(null, delinquencyBucketId); final Integer loanProductId = loanTransactionHelper.getLoanProductId(Utils.convertToJson(loanProductMap)); return loanTransactionHelper.getLoanProduct(loanProductId); diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanDelinquencyDetailsNextPaymentDateConfigurationTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanDelinquencyDetailsNextPaymentDateConfigurationTest.java index 85fcaae9b4e..81f0c7361af 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanDelinquencyDetailsNextPaymentDateConfigurationTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanDelinquencyDetailsNextPaymentDateConfigurationTest.java @@ -258,7 +258,7 @@ private void verifyLoanDelinquencyNextPaymentDate(Long loanId, String nextPaymen private Long createLoanProductWith25PctDownPaymentAndDelinquencyBucket(boolean autoDownPaymentEnabled, boolean multiDisburseEnabled, boolean installmentLevelDelinquencyEnabled, Integer graceOnArrearsAging) { // Create DelinquencyBuckets - Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec, List.of(// + Long delinquencyBucketId = DelinquencyBucketsHelper.createBucket(List.of(// Pair.of(1, 3), // Pair.of(4, 10), // Pair.of(11, 60), // diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanDelinquencyForNonActiveAccountsTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanDelinquencyForNonActiveAccountsTest.java index cf74254400d..a20446b23d9 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanDelinquencyForNonActiveAccountsTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanDelinquencyForNonActiveAccountsTest.java @@ -44,7 +44,7 @@ public void testDelinquencyCalculationsForRejectedLoanAccount() { Long clientId = clientHelper.createClient(ClientHelper.defaultClientCreationRequest()).getClientId(); // Create DelinquencyBuckets - Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec, List.of(// + Long delinquencyBucketId = DelinquencyBucketsHelper.createBucket(List.of(// Pair.of(1, 10), // Pair.of(11, 30), // Pair.of(31, 60), // @@ -88,7 +88,7 @@ public void testDelinquencyCalculationsForRejectedLoanAccountCOBTest() { Long clientId = clientHelper.createClient(ClientHelper.defaultClientCreationRequest()).getClientId(); // Create DelinquencyBuckets - Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec, List.of(// + Long delinquencyBucketId = DelinquencyBucketsHelper.createBucket(List.of(// Pair.of(1, 10), // Pair.of(11, 30), // Pair.of(31, 60), // @@ -142,7 +142,7 @@ public void testDelinquencyCalculationsForClosedLoanAccount() { Long clientId = clientHelper.createClient(ClientHelper.defaultClientCreationRequest()).getClientId(); // Create DelinquencyBuckets - Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec, List.of(// + Long delinquencyBucketId = DelinquencyBucketsHelper.createBucket(List.of(// Pair.of(1, 10), // Pair.of(11, 30), // Pair.of(31, 60), // @@ -186,7 +186,7 @@ public void testDelinquencyCalculationsForOverPaidLoanAccount() { Long clientId = clientHelper.createClient(ClientHelper.defaultClientCreationRequest()).getClientId(); // Create DelinquencyBuckets - Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec, List.of(// + Long delinquencyBucketId = DelinquencyBucketsHelper.createBucket(List.of(// Pair.of(1, 10), // Pair.of(11, 30), // Pair.of(31, 60), // diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanDownPaymentTransactionTypeTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanDownPaymentTransactionTypeTest.java index cda74573a00..1638cf17aef 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanDownPaymentTransactionTypeTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanDownPaymentTransactionTypeTest.java @@ -31,7 +31,7 @@ import java.time.format.DateTimeFormatterBuilder; import java.util.HashMap; import java.util.UUID; -import org.apache.fineract.client.models.DelinquencyBucketData; +import org.apache.fineract.client.models.DelinquencyBucketResponse; import org.apache.fineract.client.models.GetLoanProductsProductIdResponse; import org.apache.fineract.client.models.GetLoansLoanIdTransactionsTransactionIdResponse; import org.apache.fineract.client.models.PostLoansLoanIdTransactionsRequest; @@ -74,9 +74,8 @@ public void loanDownPaymentTransactionTypeTest() { String loanExternalIdStr = UUID.randomUUID().toString(); // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); // client creation final Integer clientId = clientHelper.createClient(ClientHelper.defaultClientCreationRequest()).getClientId().intValue(); @@ -147,7 +146,7 @@ public void loanDownPaymentTransactionTypeTest() { } private GetLoanProductsProductIdResponse createLoanProduct(final LoanTransactionHelper loanTransactionHelper, - final Integer delinquencyBucketId) { + final Long delinquencyBucketId) { final HashMap loanProductMap = new LoanProductTestBuilder().build(null, delinquencyBucketId); final Integer loanProductId = loanTransactionHelper.getLoanProductId(Utils.convertToJson(loanProductMap)); return loanTransactionHelper.getLoanProduct(loanProductId); diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanLastRepaymentDetailsTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanLastRepaymentDetailsTest.java index b56eb87046d..b52abca4588 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanLastRepaymentDetailsTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanLastRepaymentDetailsTest.java @@ -32,7 +32,7 @@ import java.time.format.DateTimeFormatterBuilder; import java.util.HashMap; import java.util.UUID; -import org.apache.fineract.client.models.DelinquencyBucketData; +import org.apache.fineract.client.models.DelinquencyBucketResponse; import org.apache.fineract.client.models.GetLoanProductsProductIdResponse; import org.apache.fineract.client.models.GetLoansLoanIdResponse; import org.apache.fineract.client.models.PostLoansLoanIdTransactionsRequest; @@ -74,9 +74,8 @@ public void loanLastRepaymentDetailsTestClosedLoan() { String loanExternalIdStr = UUID.randomUUID().toString(); // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); // Client and Loan account creation @@ -129,9 +128,8 @@ public void loanLastRepaymentDetailsTestOverpaidLoan() { String loanExternalIdStr = UUID.randomUUID().toString(); // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); // Client and Loan account creation @@ -178,7 +176,7 @@ public void loanLastRepaymentDetailsTestOverpaidLoan() { } private GetLoanProductsProductIdResponse createLoanProduct(final LoanTransactionHelper loanTransactionHelper, - final Integer delinquencyBucketId) { + final Long delinquencyBucketId) { final HashMap loanProductMap = new LoanProductTestBuilder().build(null, delinquencyBucketId); final Integer loanProductId = loanTransactionHelper.getLoanProductId(Utils.convertToJson(loanProductMap)); return loanTransactionHelper.getLoanProduct(loanProductId); diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanPayOffAddChargeWithRefundTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanPayOffAddChargeWithRefundTest.java index bd7c1e0d458..9bd1fe9f93f 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanPayOffAddChargeWithRefundTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanPayOffAddChargeWithRefundTest.java @@ -32,7 +32,7 @@ import java.time.format.DateTimeFormatterBuilder; import java.util.HashMap; import java.util.UUID; -import org.apache.fineract.client.models.DelinquencyBucketData; +import org.apache.fineract.client.models.DelinquencyBucketResponse; import org.apache.fineract.client.models.GetLoanProductsProductIdResponse; import org.apache.fineract.client.models.GetLoansLoanIdResponse; import org.apache.fineract.client.models.PostLoansLoanIdTransactionsRequest; @@ -53,8 +53,6 @@ public class LoanPayOffAddChargeWithRefundTest { private ResponseSpecification responseSpec; - private ResponseSpecification responseSpecErr400; - private ResponseSpecification responseSpecErr503; private RequestSpecification requestSpec; private ClientHelper clientHelper; private LoanTransactionHelper loanTransactionHelper; @@ -66,8 +64,6 @@ public void setup() { this.requestSpec = new RequestSpecBuilder().setContentType(ContentType.JSON).build(); this.requestSpec.header("Authorization", "Basic " + Utils.loginIntoServerAndGetBase64EncodedAuthenticationKey()); this.responseSpec = new ResponseSpecBuilder().expectStatusCode(200).build(); - this.responseSpecErr400 = new ResponseSpecBuilder().expectStatusCode(400).build(); - this.responseSpecErr503 = new ResponseSpecBuilder().expectStatusCode(503).build(); this.loanTransactionHelper = new LoanTransactionHelper(this.requestSpec, this.responseSpec); this.clientHelper = new ClientHelper(this.requestSpec, this.responseSpec); } @@ -78,9 +74,8 @@ public void loanAddChargeForPaidOffLoanWithRefundTest() { String loanExternalIdStr = UUID.randomUUID().toString(); // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); // Client and Loan account creation @@ -137,7 +132,7 @@ public void loanAddChargeForPaidOffLoanWithRefundTest() { } private GetLoanProductsProductIdResponse createLoanProduct(final LoanTransactionHelper loanTransactionHelper, - final Integer delinquencyBucketId) { + final Long delinquencyBucketId) { final HashMap loanProductMap = new LoanProductTestBuilder().build(null, delinquencyBucketId); final Integer loanProductId = loanTransactionHelper.getLoanProductId(Utils.convertToJson(loanProductMap)); return loanTransactionHelper.getLoanProduct(loanProductId); diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanPostChargeOffScenariosTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanPostChargeOffScenariosTest.java index a8daadc703e..7172dbcebff 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanPostChargeOffScenariosTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanPostChargeOffScenariosTest.java @@ -1154,7 +1154,7 @@ private Integer createLoanProductWithPeriodicAccrualAccounting() { Assertions.assertNotNull(fundID); // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); PostLoanProductsRequest loanProductsRequest = new PostLoanProductsRequest().name(name)// .shortName(shortName)// diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanProductChargeOffReasonMappingsTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanProductChargeOffReasonMappingsTest.java index 52aeb6a863b..0dde91cc76a 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanProductChargeOffReasonMappingsTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanProductChargeOffReasonMappingsTest.java @@ -122,7 +122,7 @@ private PostLoanProductsRequest loanProductsRequest(Long chargeOffReasonId, Long final Integer fundId = createFund(requestSpec, responseSpec); Assertions.assertNotNull(fundId); - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); Assertions.assertNotNull(delinquencyBucketId); return new PostLoanProductsRequest()// diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanProductRepaymentStartDateConfigurationTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanProductRepaymentStartDateConfigurationTest.java index ebae054890e..01882cee8bd 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanProductRepaymentStartDateConfigurationTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanProductRepaymentStartDateConfigurationTest.java @@ -29,7 +29,7 @@ import java.time.LocalDate; import java.util.HashMap; import java.util.UUID; -import org.apache.fineract.client.models.DelinquencyBucketData; +import org.apache.fineract.client.models.DelinquencyBucketResponse; import org.apache.fineract.client.models.GetLoanProductsProductIdResponse; import org.apache.fineract.client.models.GetLoansLoanIdResponse; import org.apache.fineract.client.models.PutGlobalConfigurationsRequest; @@ -72,9 +72,8 @@ public void loanProductWithRepaymentStartDateTypeConfigurationCreateAndModifyTes // create product with repayment start date configuration, get , modify // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); final Integer repaymentStartDateType = 2; @@ -105,9 +104,8 @@ public void loanProductWithNoRepaymentStartDateTypeConfigurationDefaultsToDisbur // create loan product with no configuration for repayment start date and verify that it is disbursement date by // default // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); final Integer repaymentStartDateType = null; @@ -462,7 +460,7 @@ private PutLoanProductsProductIdResponse updateLoanProduct(LoanTransactionHelper } private Integer createLoanProductWithRepaymentStartDateTypeConfiguration(final LoanTransactionHelper loanTransactionHelper, - final Integer delinquencyBucketId, final Integer repaymentStartDateType) { + final Long delinquencyBucketId, final Integer repaymentStartDateType) { final HashMap loanProductMap = new LoanProductTestBuilder().withRepaymentStartDateType(repaymentStartDateType) .build(null, delinquencyBucketId); final Integer loanProductId = loanTransactionHelper.getLoanProductId(Utils.convertToJson(loanProductMap)); diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanProductWithDownPaymentConfigurationTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanProductWithDownPaymentConfigurationTest.java index b5e7b8e593c..6ee0bfaabed 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanProductWithDownPaymentConfigurationTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanProductWithDownPaymentConfigurationTest.java @@ -29,7 +29,7 @@ import java.math.BigDecimal; import java.util.ArrayList; import java.util.HashMap; -import org.apache.fineract.client.models.DelinquencyBucketData; +import org.apache.fineract.client.models.DelinquencyBucketResponse; import org.apache.fineract.client.models.GetLoanProductsProductIdResponse; import org.apache.fineract.client.models.PutLoanProductsProductIdRequest; import org.apache.fineract.client.models.PutLoanProductsProductIdResponse; @@ -59,9 +59,8 @@ public void setup() { @Test public void loanProductCreationWithDownPaymentConfigurationTest() { // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); // down-payment configuration Boolean enableDownPayment = true; @@ -82,9 +81,8 @@ public void loanProductCreationWithDownPaymentConfigurationTest() { @Test public void loanProductUpdateWithEnableDownPaymentConfigurationTest() { // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); // Loan Product without enable down payment configuration GetLoanProductsProductIdResponse getLoanProductsProductResponse = createLoanProduct(loanTransactionHelper, delinquencyBucketId); assertNotNull(getLoanProductsProductResponse); @@ -107,9 +105,8 @@ public void loanProductEnableDownPaymentConfigurationValidationTests() { final LoanTransactionHelper validationErrorHelper = new LoanTransactionHelper(this.requestSpec, errorResponse); // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); // down-payment configuration Boolean enableDownPayment = true; @@ -185,14 +182,14 @@ private PutLoanProductsProductIdResponse updateLoanProduct(LoanTransactionHelper } private GetLoanProductsProductIdResponse createLoanProduct(final LoanTransactionHelper loanTransactionHelper, - final Integer delinquencyBucketId) { + final Long delinquencyBucketId) { final HashMap loanProductMap = new LoanProductTestBuilder().build(null, delinquencyBucketId); final Integer loanProductId = loanTransactionHelper.getLoanProductId(Utils.convertToJson(loanProductMap)); return loanTransactionHelper.getLoanProduct(loanProductId); } private Integer createLoanProductWithDownPaymentConfiguration(final LoanTransactionHelper loanTransactionHelper, - final Integer delinquencyBucketId, Boolean enableDownPayment, String disbursedAmountPercentageForDownPayment, + final Long delinquencyBucketId, Boolean enableDownPayment, String disbursedAmountPercentageForDownPayment, Boolean enableAutoRepaymentForDownPayment) { final HashMap loanProductMap = new LoanProductTestBuilder() .withEnableDownPayment(enableDownPayment, disbursedAmountPercentageForDownPayment, enableAutoRepaymentForDownPayment) diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanProductWithRepaymentDueEventConfigurationTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanProductWithRepaymentDueEventConfigurationTest.java index d2502ccf969..4832f348cda 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanProductWithRepaymentDueEventConfigurationTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanProductWithRepaymentDueEventConfigurationTest.java @@ -28,7 +28,7 @@ import io.restassured.specification.ResponseSpecification; import java.util.HashMap; import java.util.UUID; -import org.apache.fineract.client.models.DelinquencyBucketData; +import org.apache.fineract.client.models.DelinquencyBucketResponse; import org.apache.fineract.client.models.GetLoanProductsProductIdResponse; import org.apache.fineract.client.models.PutLoanProductsProductIdRequest; import org.apache.fineract.client.models.PutLoanProductsProductIdResponse; @@ -63,9 +63,8 @@ public void loanProductCreationWithDueDaysConfigurationForRepaymentEventTest() { String loanExternalIdStr = UUID.randomUUID().toString(); // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); // event days configuration Integer dueDaysForRepaymentEvent = 1; @@ -90,9 +89,8 @@ public void loanProductUpdateWithDueDaysConfigurationForRepaymentEventTest() { String loanExternalIdStr = UUID.randomUUID().toString(); // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); // Client and Loan account creation @@ -118,14 +116,14 @@ private PutLoanProductsProductIdResponse updateLoanProduct(LoanTransactionHelper } private GetLoanProductsProductIdResponse createLoanProduct(final LoanTransactionHelper loanTransactionHelper, - final Integer delinquencyBucketId) { + final Long delinquencyBucketId) { final HashMap loanProductMap = new LoanProductTestBuilder().build(null, delinquencyBucketId); final Integer loanProductId = loanTransactionHelper.getLoanProductId(Utils.convertToJson(loanProductMap)); return loanTransactionHelper.getLoanProduct(loanProductId); } private Integer createLoanProductWithDueDaysForRepaymentEvent(final LoanTransactionHelper loanTransactionHelper, - final Integer delinquencyBucketId, Integer dueDaysForRepaymentEvent, Integer overDueDaysForRepaymentEvent) { + final Long delinquencyBucketId, Integer dueDaysForRepaymentEvent, Integer overDueDaysForRepaymentEvent) { final HashMap loanProductMap = new LoanProductTestBuilder().withDueDaysForRepaymentEvent(dueDaysForRepaymentEvent) .withOverDueDaysForRepaymentEvent(overDueDaysForRepaymentEvent).build(null, delinquencyBucketId); final Integer loanProductId = loanTransactionHelper.getLoanProductId(Utils.convertToJson(loanProductMap)); diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanRepaymentScheduleWithDownPaymentTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanRepaymentScheduleWithDownPaymentTest.java index 8a4dd11f8ba..5573596f778 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanRepaymentScheduleWithDownPaymentTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanRepaymentScheduleWithDownPaymentTest.java @@ -29,7 +29,7 @@ import java.util.HashMap; import java.util.List; import java.util.UUID; -import org.apache.fineract.client.models.DelinquencyBucketData; +import org.apache.fineract.client.models.DelinquencyBucketResponse; import org.apache.fineract.client.models.GetLoanProductsProductIdResponse; import org.apache.fineract.client.models.GetLoansLoanIdRepaymentPeriod; import org.apache.fineract.client.models.GetLoansLoanIdResponse; @@ -74,9 +74,8 @@ public class LoanRepaymentScheduleWithDownPaymentTest extends BaseLoanIntegratio public void loanRepaymentScheduleWithSimpleDisbursementAndDownPayment() { String loanExternalIdStr = UUID.randomUUID().toString(); - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); Boolean enableDownPayment = true; BigDecimal disbursedAmountPercentageForDownPayment = BigDecimal.valueOf(25); @@ -120,9 +119,8 @@ public void loanRepaymentScheduleWithSimpleDisbursementAndDownPayment() { public void loanRepaymentScheduleWithSimpleDisbursementAndAutoRepaymentDownPayment() { String loanExternalIdStr = UUID.randomUUID().toString(); - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); Boolean enableDownPayment = true; BigDecimal disbursedAmountPercentageForDownPayment = BigDecimal.valueOf(25); @@ -169,9 +167,8 @@ public void loanRepaymentScheduleWithSimpleDisbursementAndAutoRepaymentDownPayme public void loanRepaymentScheduleWithMultiDisbursementProductOneDisbursementAndDownPayment() { String loanExternalIdStr = UUID.randomUUID().toString(); - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); Boolean enableDownPayment = true; BigDecimal disbursedAmountPercentageForDownPayment = BigDecimal.valueOf(25); @@ -215,9 +212,8 @@ public void loanRepaymentScheduleWithMultiDisbursementProductOneDisbursementAndD public void loanRepaymentScheduleWithMultiDisbursementProductTwoDisbursementAndDownPayment() { String loanExternalIdStr = UUID.randomUUID().toString(); - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); Boolean enableDownPayment = true; BigDecimal disbursedAmountPercentageForDownPayment = BigDecimal.valueOf(25); @@ -266,9 +262,8 @@ public void loanRepaymentScheduleWithMultiDisbursementProductTwoDisbursementAndD public void loanRepaymentScheduleWithMultiDisbursementProductTwoDisbursementAndAutoRepaymentDownPayment() { String loanExternalIdStr = UUID.randomUUID().toString(); - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); Boolean enableDownPayment = true; BigDecimal disbursedAmountPercentageForDownPayment = BigDecimal.valueOf(25); @@ -321,9 +316,8 @@ public void loanRepaymentScheduleWithMultiDisbursementProductTwoDisbursementAndA public void loanRepaymentScheduleWithMultiDisbursementProductOneDisbursementAndThreeRepaymentsAndDownPayment() { String loanExternalIdStr = UUID.randomUUID().toString(); - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); Boolean enableDownPayment = true; BigDecimal disbursedAmountPercentageForDownPayment = BigDecimal.valueOf(25); @@ -394,9 +388,8 @@ public void loanRepaymentScheduleWithMultiDisbursementProductOneDisbursementAndT public void loanRepaymentScheduleWithMultiDisbursementProductTwoDisbursementAndThreeRepaymentsAndDownPayment() { String loanExternalIdStr = UUID.randomUUID().toString(); - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); Boolean enableDownPayment = true; BigDecimal disbursedAmountPercentageForDownPayment = BigDecimal.valueOf(25); @@ -482,9 +475,8 @@ public void loanRepaymentScheduleWithMultiDisbursementProductTwoDisbursementAndT public void loanRepaymentScheduleWithChargeAndDownPayment() { String loanExternalIdStr = UUID.randomUUID().toString(); - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); Boolean enableDownPayment = true; BigDecimal disbursedAmountPercentageForDownPayment = BigDecimal.valueOf(25); @@ -546,9 +538,8 @@ public void loanRepaymentScheduleWithChargeAndDownPayment() { public void loanRepaymentScheduleWithMultiDisbursementProductTwoDisbursementAndThreeRepaymentsAndDownPaymentAndCharge() { String loanExternalIdStr = UUID.randomUUID().toString(); - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); Boolean enableDownPayment = true; BigDecimal disbursedAmountPercentageForDownPayment = BigDecimal.valueOf(25); @@ -649,9 +640,8 @@ public void loanRepaymentScheduleWithMultiDisbursementProductTwoDisbursementAndT public void loanRepaymentScheduleWithChargeAndInterestAndDownPayment() { String loanExternalIdStr = UUID.randomUUID().toString(); - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); Boolean enableDownPayment = true; BigDecimal disbursedAmountPercentageForDownPayment = BigDecimal.valueOf(25); @@ -715,9 +705,8 @@ public void loanRepaymentScheduleWithChargeAndInterestAndDownPayment() { public void loanRepaymentScheduleWithMultiDisbursementProductTwoDisbursementAndThreeRepaymentsAndDownPaymentAndChargeAndInterest() { String loanExternalIdStr = UUID.randomUUID().toString(); - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); Boolean enableDownPayment = true; BigDecimal disbursedAmountPercentageForDownPayment = BigDecimal.valueOf(25); @@ -834,9 +823,8 @@ public void testDelinquencyRangeOnDownPaymentInstallment() { BusinessDateHelper.updateBusinessDate(requestSpec, responseSpec, BusinessDateType.BUSINESS_DATE, businessDate); String loanExternalIdStr = UUID.randomUUID().toString(); - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); Boolean enableDownPayment = true; BigDecimal disbursedAmountPercentageForDownPayment = BigDecimal.valueOf(25); @@ -895,9 +883,8 @@ public void loanApplicationCreationWithLoanProductWithEnableDownPaymentConfigura String loanExternalIdStr = UUID.randomUUID().toString(); // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); // down-payment configuration Boolean enableDownPayment = true; @@ -937,9 +924,8 @@ public void loanApplicationWithLoanProductWithEnableDownPaymentConfigurationDoes String loanExternalIdStr = UUID.randomUUID().toString(); // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); // down-payment configuration Boolean enableDownPayment = true; @@ -1019,9 +1005,8 @@ public void loanApplicationWithLoanProductWithEnableDownPaymentAndEnableAutoRepa String loanExternalIdStr = UUID.randomUUID().toString(); // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); // down-payment configuration Boolean enableDownPayment = true; @@ -1148,9 +1133,8 @@ public void loanApplicationWithLoanProductWithEnableDownPaymentAndDisableAutoRep String loanExternalIdStr = UUID.randomUUID().toString(); // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); // down-payment configuration Boolean enableDownPayment = true; @@ -1641,9 +1625,8 @@ public void downPaymentOnOverpaidCumulativeLoan() { public void loanRepaymentScheduleWithSimpleDisbursementAndWithoutAutoPayment() { String loanExternalIdStr = UUID.randomUUID().toString(); - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); Boolean enableDownPayment = true; BigDecimal disbursedAmountPercentageForDownPayment = BigDecimal.valueOf(25); @@ -1751,7 +1734,7 @@ private Integer createLoanAccountMultipleRepaymentsDisbursement(final Integer cl } private GetLoanProductsProductIdResponse createLoanProductWithDownPaymentConfigurationAndAccrualAccounting( - LoanTransactionHelper loanTransactionHelper, Integer delinquencyBucketId, Boolean enableDownPayment, + LoanTransactionHelper loanTransactionHelper, Long delinquencyBucketId, Boolean enableDownPayment, String disbursedAmountPercentageForDownPayment, boolean enableAutoRepaymentForDownPayment, final Account... accounts) { final String loanProductJSON = new LoanProductTestBuilder().withPrincipal("1000").withRepaymentTypeAsMonth() .withRepaymentAfterEvery("1").withNumberOfRepayments("1").withRepaymentTypeAsMonth().withinterestRatePerPeriod("0") @@ -1794,7 +1777,7 @@ private GetLoanProductsProductIdResponse createLoanProductWithEnableDownPaymentA } private Integer createLoanProductWithDownPaymentConfiguration(final LoanTransactionHelper loanTransactionHelper, - final Integer delinquencyBucketId, Boolean enableDownPayment, String disbursedAmountPercentageForDownPayment, + final Long delinquencyBucketId, Boolean enableDownPayment, String disbursedAmountPercentageForDownPayment, Boolean enableAutoRepaymentForDownPayment, boolean multiDisbursement) { HashMap loanProductMap; if (multiDisbursement) { diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanTransactionAccrualActivityPostingTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanTransactionAccrualActivityPostingTest.java index b3281aa4f41..e14ea9d1856 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanTransactionAccrualActivityPostingTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanTransactionAccrualActivityPostingTest.java @@ -1442,7 +1442,7 @@ private PostLoanProductsRequest loanProductsRequestInterestDecliningBalanceDaily final Integer fundId = createFund(requestSpec, responseSpec); Assertions.assertNotNull(fundId); - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); Assertions.assertNotNull(delinquencyBucketId); return new PostLoanProductsRequest()// diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanTransactionChargebackTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanTransactionChargebackTest.java index 9c9d89ff19f..9e3ae6f3e57 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanTransactionChargebackTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanTransactionChargebackTest.java @@ -41,7 +41,7 @@ import org.apache.fineract.client.models.AdvancedPaymentData; import org.apache.fineract.client.models.CreditAllocationData; import org.apache.fineract.client.models.CreditAllocationOrder; -import org.apache.fineract.client.models.DelinquencyBucketData; +import org.apache.fineract.client.models.DelinquencyBucketResponse; import org.apache.fineract.client.models.DelinquencyRangeData; import org.apache.fineract.client.models.GetLoanProductsProductIdResponse; import org.apache.fineract.client.models.GetLoansLoanIdRepaymentPeriod; @@ -1391,9 +1391,8 @@ public void testS7ChargebacksOnMaturityDate() { private Integer createAccounts(final Integer daysToSubtract, final Integer numberOfRepayments, final boolean withJournalEntries, LoanProductTestBuilder loanProductTestBuilder) { // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); // Client and Loan account creation final Integer clientId = ClientHelper.createClient(this.requestSpec, this.responseSpec, "01 January 2012"); @@ -1412,7 +1411,7 @@ private Integer createAccounts(final Integer daysToSubtract, final Integer numbe } private GetLoanProductsProductIdResponse createLoanProduct(final LoanTransactionHelper loanTransactionHelper, - final Integer delinquencyBucketId, final boolean withJournalEntries, LoanProductTestBuilder loanProductTestBuilder) { + final Long delinquencyBucketId, final boolean withJournalEntries, LoanProductTestBuilder loanProductTestBuilder) { final HashMap loanProductMap; if (withJournalEntries) { loanProductMap = loanProductTestBuilder diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanTransactionFullAmountChargebackForOverpaidLoanTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanTransactionFullAmountChargebackForOverpaidLoanTest.java index 4d8b72e9ab3..2088b56cc55 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanTransactionFullAmountChargebackForOverpaidLoanTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanTransactionFullAmountChargebackForOverpaidLoanTest.java @@ -36,7 +36,7 @@ import java.util.concurrent.atomic.AtomicInteger; import java.util.stream.Stream; import org.apache.fineract.client.models.AdvancedPaymentData; -import org.apache.fineract.client.models.DelinquencyBucketData; +import org.apache.fineract.client.models.DelinquencyBucketResponse; import org.apache.fineract.client.models.GetLoanProductsProductIdResponse; import org.apache.fineract.client.models.GetLoansLoanIdResponse; import org.apache.fineract.client.models.GetLoansLoanIdTransactionsTransactionIdResponse; @@ -89,9 +89,8 @@ public void loanTransactionChargebackOfFullAmountForOverpaidLoanTest(LoanProduct String loanExternalIdStr = UUID.randomUUID().toString(); // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); // Client and Loan account creation @@ -163,7 +162,7 @@ public void loanTransactionChargebackOfFullAmountForOverpaidLoanTest(LoanProduct } private GetLoanProductsProductIdResponse createLoanProduct(final LoanTransactionHelper loanTransactionHelper, - final Integer delinquencyBucketId, LoanProductTestBuilder loanProductTestBuilder) { + final Long delinquencyBucketId, LoanProductTestBuilder loanProductTestBuilder) { final HashMap loanProductMap = loanProductTestBuilder.build(null, delinquencyBucketId); final Integer loanProductId = loanTransactionHelper.getLoanProductId(Utils.convertToJson(loanProductMap)); return loanTransactionHelper.getLoanProduct(loanProductId); diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanTransactionReverseReplayRelationTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanTransactionReverseReplayRelationTest.java index e5a86741042..065e4a951d5 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanTransactionReverseReplayRelationTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanTransactionReverseReplayRelationTest.java @@ -31,7 +31,7 @@ import java.time.format.DateTimeFormatterBuilder; import java.util.HashMap; import java.util.UUID; -import org.apache.fineract.client.models.DelinquencyBucketData; +import org.apache.fineract.client.models.DelinquencyBucketResponse; import org.apache.fineract.client.models.GetLoanProductsProductIdResponse; import org.apache.fineract.client.models.GetLoanTransactionRelation; import org.apache.fineract.client.models.GetLoansLoanIdTransactionsTransactionIdResponse; @@ -78,9 +78,8 @@ public void loanTransactionReverseReplayRelationTest() { String loanExternalIdStr = UUID.randomUUID().toString(); // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); // Client and Loan account creation @@ -132,7 +131,7 @@ public void loanTransactionReverseReplayRelationTest() { } private GetLoanProductsProductIdResponse createLoanProduct(final LoanTransactionHelper loanTransactionHelper, - final Integer delinquencyBucketId) { + final Long delinquencyBucketId) { final HashMap loanProductMap = new LoanProductTestBuilder().build(null, delinquencyBucketId); final Integer loanProductId = loanTransactionHelper.getLoanProductId(Utils.convertToJson(loanProductMap)); return loanTransactionHelper.getLoanProduct(loanProductId); diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanTransactionSummaryTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanTransactionSummaryTest.java index f379e169d9c..54c7a6c504a 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanTransactionSummaryTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/LoanTransactionSummaryTest.java @@ -32,7 +32,7 @@ import java.util.HashMap; import java.util.UUID; import lombok.extern.slf4j.Slf4j; -import org.apache.fineract.client.models.DelinquencyBucketData; +import org.apache.fineract.client.models.DelinquencyBucketResponse; import org.apache.fineract.client.models.GetLoanProductsProductIdResponse; import org.apache.fineract.client.models.GetLoansLoanIdResponse; import org.apache.fineract.client.models.GetLoansLoanIdSummary; @@ -79,9 +79,8 @@ public void loanTransactionSummaryTest() { String loanExternalIdStr = UUID.randomUUID().toString(); // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); // Client and Loan account creation final Integer clientId = clientHelper.createClient(ClientHelper.defaultClientCreationRequest()).getClientId().intValue(); @@ -207,9 +206,8 @@ public void lastRepaymentAmountTest() { String loanExternalIdStr = UUID.randomUUID().toString(); // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - delinquencyBucketId); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper.getBucket(delinquencyBucketId); // Client and Loan account creation @@ -244,7 +242,7 @@ public void lastRepaymentAmountTest() { } private GetLoanProductsProductIdResponse createLoanProduct(final LoanTransactionHelper loanTransactionHelper, - final Integer delinquencyBucketId) { + final Long delinquencyBucketId) { final HashMap loanProductMap = new LoanProductTestBuilder().build(null, delinquencyBucketId); final Integer loanProductId = loanTransactionHelper.getLoanProductId(Utils.convertToJson(loanProductMap)); return loanTransactionHelper.getLoanProduct(loanProductId); diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/RepaymentReverseExternalIdTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/RepaymentReverseExternalIdTest.java index 2eaa1cef5fb..56899809999 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/RepaymentReverseExternalIdTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/RepaymentReverseExternalIdTest.java @@ -152,7 +152,7 @@ private PostLoanProductsRequest loanProductsRequest() { final Integer fundId = createFund(requestSpec, responseSpec); Assertions.assertNotNull(fundId); - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); Assertions.assertNotNull(delinquencyBucketId); return new PostLoanProductsRequest()// diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/UndoRepaymentWithDownPaymentIntegrationTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/UndoRepaymentWithDownPaymentIntegrationTest.java index 1c8107a0505..2385a8261d2 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/UndoRepaymentWithDownPaymentIntegrationTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/UndoRepaymentWithDownPaymentIntegrationTest.java @@ -231,7 +231,7 @@ private Integer createLoanProductWithPeriodicAccrualAccountingAndAdvancedPayment Assertions.assertNotNull(fundID); // Delinquency Bucket - final Integer delinquencyBucketId = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); + final Long delinquencyBucketId = DelinquencyBucketsHelper.createDefaultBucket(); String futureInstallmentAllocationRule = "NEXT_INSTALLMENT"; AdvancedPaymentData defaultAllocation = createDefaultPaymentAllocation(futureInstallmentAllocationRule); diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/WorkingCapitalLoanApplicationCRUDTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/WorkingCapitalLoanApplicationCRUDTest.java index 8a47cf14fe2..b733aee5474 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/WorkingCapitalLoanApplicationCRUDTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/WorkingCapitalLoanApplicationCRUDTest.java @@ -69,7 +69,7 @@ static void initDelinquency() { requestSpec.header("Authorization", "Basic " + Utils.loginIntoServerAndGetBase64EncodedAuthenticationKey()); requestSpec.header("Fineract-Platform-TenantId", "default"); responseSpec = new ResponseSpecBuilder().expectStatusCode(200).build(); - delinquencyBucketId = (long) DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); + delinquencyBucketId = (long) DelinquencyBucketsHelper.createDefaultBucket(); fundId = (long) FundsResourceHandler.createFund(requestSpec, responseSpec); } diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/WorkingCapitalLoanApplicationValidationTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/WorkingCapitalLoanApplicationValidationTest.java index 8aa3969cbfa..f37f67eeade 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/WorkingCapitalLoanApplicationValidationTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/WorkingCapitalLoanApplicationValidationTest.java @@ -62,7 +62,7 @@ static void initDelinquency() { requestSpec.header("Authorization", "Basic " + Utils.loginIntoServerAndGetBase64EncodedAuthenticationKey()); requestSpec.header("Fineract-Platform-TenantId", "default"); responseSpec = new ResponseSpecBuilder().expectStatusCode(200).build(); - delinquencyBucketId = (long) DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, responseSpec); + delinquencyBucketId = (long) DelinquencyBucketsHelper.createDefaultBucket(); } @Test diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/common/loans/LoanProductTestBuilder.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/common/loans/LoanProductTestBuilder.java index fda6f19ac9e..57926bec6a4 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/common/loans/LoanProductTestBuilder.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/common/loans/LoanProductTestBuilder.java @@ -154,7 +154,7 @@ public class LoanProductTestBuilder { private String fixedPrincipalPercentagePerInstallment; private String installmentAmountInMultiplesOf; private boolean canDefineInstallmentAmount; - private Integer delinquencyBucketId; + private Long delinquencyBucketId; private Integer dueDaysForRepaymentEvent = null; private Integer overDueDaysForRepaymentEvent = null; private boolean enableDownPayment = false; @@ -181,7 +181,7 @@ public String build(final String chargeId) { return new Gson().toJson(map); } - public HashMap build(final String chargeId, final Integer delinquencyBucketId) { + public HashMap build(final String chargeId, final Long delinquencyBucketId) { final HashMap map = new HashMap<>(); if (chargeId != null) { @@ -371,7 +371,7 @@ public LoanProductTestBuilder withInstallmentAmountInMultiplesOf(String installm return this; } - public LoanProductTestBuilder withDelinquencyBucket(Integer delinquencyBucketId) { + public LoanProductTestBuilder withDelinquencyBucket(Long delinquencyBucketId) { this.delinquencyBucketId = delinquencyBucketId; return this; } diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/common/products/DelinquencyBucketsHelper.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/common/products/DelinquencyBucketsHelper.java index 56bd39dce11..b77ef582299 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/common/products/DelinquencyBucketsHelper.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/common/products/DelinquencyBucketsHelper.java @@ -19,161 +19,75 @@ package org.apache.fineract.integrationtests.common.products; import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertTrue; -import com.google.common.reflect.TypeToken; -import com.google.gson.Gson; -import io.restassured.specification.RequestSpecification; -import io.restassured.specification.ResponseSpecification; -import java.lang.reflect.Type; import java.util.ArrayList; -import java.util.HashMap; import java.util.List; import lombok.extern.slf4j.Slf4j; import org.apache.commons.lang3.tuple.Pair; import org.apache.fineract.client.models.DeleteDelinquencyBucketResponse; -import org.apache.fineract.client.models.DelinquencyBucketData; +import org.apache.fineract.client.models.DelinquencyBucketRequest; +import org.apache.fineract.client.models.DelinquencyBucketResponse; import org.apache.fineract.client.models.DelinquencyRangeData; +import org.apache.fineract.client.models.DelinquencyRangeRequest; import org.apache.fineract.client.models.GetLoansLoanIdDelinquencySummary; import org.apache.fineract.client.models.GetLoansLoanIdResponse; import org.apache.fineract.client.models.PostDelinquencyBucketResponse; -import org.apache.fineract.client.models.PostDelinquencyRangeResponse; import org.apache.fineract.client.models.PutDelinquencyBucketResponse; -import org.apache.fineract.client.util.JSON; +import org.apache.fineract.client.util.Calls; +import org.apache.fineract.integrationtests.common.FineractClientHelper; import org.apache.fineract.integrationtests.common.Utils; @Slf4j public class DelinquencyBucketsHelper { - private static final String DELINQUENCY_BUCKETS_URL = "/fineract-provider/api/v1/delinquency/buckets"; - private static final Gson GSON = new JSON().getGson(); - protected DelinquencyBucketsHelper() {} - // TODO: Rewrite to use fineract-client instead! - // Example: org.apache.fineract.integrationtests.common.loans.LoanTransactionHelper.disburseLoan(java.lang.Long, - // org.apache.fineract.client.models.PostLoansLoanIdRequest) - @Deprecated(forRemoval = true) - public static ArrayList getDelinquencyBuckets(final RequestSpecification requestSpec, - final ResponseSpecification responseSpec) { - String response = Utils.performServerGet(requestSpec, responseSpec, DELINQUENCY_BUCKETS_URL + "?" + Utils.TENANT_IDENTIFIER); - - Type delinquencyBucketListType = new TypeToken>() {}.getType(); - return GSON.fromJson(response, delinquencyBucketListType); - } - - // TODO: Rewrite to use fineract-client instead! - // Example: org.apache.fineract.integrationtests.common.loans.LoanTransactionHelper.disburseLoan(java.lang.Long, - // org.apache.fineract.client.models.PostLoansLoanIdRequest) - @Deprecated(forRemoval = true) - public static DelinquencyBucketData getDelinquencyBucket(final RequestSpecification requestSpec, - final ResponseSpecification responseSpec, final Integer resourceId) { - String response = Utils.performServerGet(requestSpec, responseSpec, - DELINQUENCY_BUCKETS_URL + "/" + resourceId + "?" + Utils.TENANT_IDENTIFIER); - return GSON.fromJson(response, DelinquencyBucketData.class); - } - - // TODO: Rewrite to use fineract-client instead! - // Example: org.apache.fineract.integrationtests.common.loans.LoanTransactionHelper.disburseLoan(java.lang.Long, - // org.apache.fineract.client.models.PostLoansLoanIdRequest) - @Deprecated(forRemoval = true) - public static PostDelinquencyBucketResponse createDelinquencyBucket(final RequestSpecification requestSpec, - final ResponseSpecification responseSpec, final String json) { - log.info("JSON: {}", json); - final String response = Utils.performServerPost(requestSpec, responseSpec, DELINQUENCY_BUCKETS_URL + "?" + Utils.TENANT_IDENTIFIER, - json, null); - return GSON.fromJson(response, PostDelinquencyBucketResponse.class); + public static List getBuckets() { + return Calls.ok(FineractClientHelper.getFineractClient().delinquencyRangeAndBucketsManagement.getBuckets()); } - // TODO: Rewrite to use fineract-client instead! - // Example: org.apache.fineract.integrationtests.common.loans.LoanTransactionHelper.disburseLoan(java.lang.Long, - // org.apache.fineract.client.models.PostLoansLoanIdRequest) - @Deprecated(forRemoval = true) - public static PutDelinquencyBucketResponse updateDelinquencyBucket(final RequestSpecification requestSpec, - final ResponseSpecification responseSpec, final Integer resourceId, final String json) { - log.info("JSON: {}", json); - final String response = Utils.performServerPut(requestSpec, responseSpec, - DELINQUENCY_BUCKETS_URL + "/" + resourceId + "?" + Utils.TENANT_IDENTIFIER, json, null); - return GSON.fromJson(response, PutDelinquencyBucketResponse.class); + public static DelinquencyBucketResponse getBucket(Long id) { + return Calls.ok(FineractClientHelper.getFineractClient().delinquencyRangeAndBucketsManagement.getBucket(id)); } - // TODO: Rewrite to use fineract-client instead! - // Example: org.apache.fineract.integrationtests.common.loans.LoanTransactionHelper.disburseLoan(java.lang.Long, - // org.apache.fineract.client.models.PostLoansLoanIdRequest) - @Deprecated(forRemoval = true) - public static DeleteDelinquencyBucketResponse deleteDelinquencyBucket(final RequestSpecification requestSpec, - final ResponseSpecification responseSpec, final Integer resourceId) { - final String response = Utils.performServerDelete(requestSpec, responseSpec, - DELINQUENCY_BUCKETS_URL + "/" + resourceId + "?" + Utils.TENANT_IDENTIFIER, Utils.emptyJson(), null); - return GSON.fromJson(response, DeleteDelinquencyBucketResponse.class); + public static Long createDefaultBucket() { + Long range1Id = Calls + .ok(FineractClientHelper.getFineractClient().delinquencyRangeAndBucketsManagement.createRange(new DelinquencyRangeRequest() + .classification(Utils.randomStringGenerator("DLQ_R_", 10)).minimumAgeDays(1).maximumAgeDays(3).locale("en"))) + .getResourceId(); + Long range2Id = Calls + .ok(FineractClientHelper.getFineractClient().delinquencyRangeAndBucketsManagement.createRange(new DelinquencyRangeRequest() + .classification(Utils.randomStringGenerator("DLQ_R_", 10)).minimumAgeDays(4).maximumAgeDays(60).locale("en"))) + .getResourceId(); + return Calls + .ok(FineractClientHelper.getFineractClient().delinquencyRangeAndBucketsManagement.createBucket( + new DelinquencyBucketRequest().name(Utils.randomStringGenerator("DLQ_B_", 10)).ranges(List.of(range1Id, range2Id)))) + .getResourceId(); } - // TODO: Rewrite to use fineract-client instead! - // Example: org.apache.fineract.integrationtests.common.loans.LoanTransactionHelper.disburseLoan(java.lang.Long, - // org.apache.fineract.client.models.PostLoansLoanIdRequest) - @Deprecated(forRemoval = true) - public static String getAsJSON(final List rangeIds) { - final HashMap map = new HashMap<>(); - map.put("name", Utils.uniqueRandomStringGenerator("Delinquency_Bucket_", 4)); - map.put("ranges", rangeIds.toArray()); - return new Gson().toJson(map); + public static PostDelinquencyBucketResponse createBucket(DelinquencyBucketRequest bucket) { + return Calls.ok(FineractClientHelper.getFineractClient().delinquencyRangeAndBucketsManagement.createBucket(bucket)); } - // TODO: Rewrite to use fineract-client instead! - // Example: org.apache.fineract.integrationtests.common.loans.LoanTransactionHelper.disburseLoan(java.lang.Long, - // org.apache.fineract.client.models.PostLoansLoanIdRequest) - @Deprecated(forRemoval = true) - public static Integer createDelinquencyBucket(final RequestSpecification requestSpec, final ResponseSpecification responseSpec, - List> ranges) { - List rangeIds = ranges.stream().map(r -> createDelinquencyRange(requestSpec, responseSpec, r)).toList(); - String jsonBucket = DelinquencyBucketsHelper.getAsJSON(rangeIds); - PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, - responseSpec, jsonBucket); - assertNotNull(delinquencyBucketResponse); - return Math.toIntExact(delinquencyBucketResponse.getResourceId()); + public static Long createBucket(List> rangesDef) { + List rangeIds = new ArrayList<>(); + rangesDef.forEach(range -> { + rangeIds.add(Calls.ok(FineractClientHelper.getFineractClient().delinquencyRangeAndBucketsManagement + .createRange(new DelinquencyRangeRequest().classification(Utils.randomStringGenerator("DLQ_R_", 10)) + .minimumAgeDays(range.getLeft()).maximumAgeDays(range.getRight()).locale("en"))) + .getResourceId()); + }); + return createBucket(new DelinquencyBucketRequest().name(Utils.randomStringGenerator("DLQ_B_", 10)).ranges(rangeIds)) + .getResourceId(); } - // TODO: Rewrite to use fineract-client instead! - // Example: org.apache.fineract.integrationtests.common.loans.LoanTransactionHelper.disburseLoan(java.lang.Long, - // org.apache.fineract.client.models.PostLoansLoanIdRequest) - @Deprecated(forRemoval = true) - public static Integer createDelinquencyRange(final RequestSpecification requestSpec, final ResponseSpecification responseSpec, - Pair range) { - String jsonRange = DelinquencyRangesHelper.getAsJSON(range.getLeft(), range.getRight()); - PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, responseSpec, - jsonRange); - return Math.toIntExact(delinquencyRangeResponse.getResourceId()); + public static PutDelinquencyBucketResponse updateBucket(Long id, DelinquencyBucketRequest bucket) { + return Calls.ok(FineractClientHelper.getFineractClient().delinquencyRangeAndBucketsManagement.updateBucket(id, bucket)); } - // TODO: Rewrite to use fineract-client instead! - // Example: org.apache.fineract.integrationtests.common.loans.LoanTransactionHelper.disburseLoan(java.lang.Long, - // org.apache.fineract.client.models.PostLoansLoanIdRequest) - @Deprecated(forRemoval = true) - public static Integer createDelinquencyBucket(final RequestSpecification requestSpec, final ResponseSpecification responseSpec) { - ArrayList rangeIds = new ArrayList<>(); - - // First Range - String jsonRange = DelinquencyRangesHelper.getAsJSON(1, 3); - PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, responseSpec, - jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); - jsonRange = DelinquencyRangesHelper.getAsJSON(4, 60); - DelinquencyRangeData range = DelinquencyRangesHelper.getDelinquencyRange(requestSpec, responseSpec, - Math.toIntExact(delinquencyRangeResponse.getResourceId())); - - // Second Range - delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, responseSpec, jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); - range = DelinquencyRangesHelper.getDelinquencyRange(requestSpec, responseSpec, - Math.toIntExact(delinquencyRangeResponse.getResourceId())); - - String jsonBucket = DelinquencyBucketsHelper.getAsJSON(rangeIds); - PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, - responseSpec, jsonBucket); - assertNotNull(delinquencyBucketResponse); - - return Math.toIntExact(delinquencyBucketResponse.getResourceId()); + public static DeleteDelinquencyBucketResponse deleteBucket(Long id) { + return Calls.ok(FineractClientHelper.getFineractClient().delinquencyRangeAndBucketsManagement.deleteBucket(id)); } public static void evaluateLoanCollectionData(GetLoansLoanIdResponse getLoansLoanIdResponse, Integer pastDueDays, diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/common/products/DelinquencyRangesHelper.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/common/products/DelinquencyRangesHelper.java index db48ebe0995..7362370f7fe 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/common/products/DelinquencyRangesHelper.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/common/products/DelinquencyRangesHelper.java @@ -18,102 +18,37 @@ */ package org.apache.fineract.integrationtests.common.products; -import com.google.common.reflect.TypeToken; -import com.google.gson.Gson; -import io.restassured.specification.RequestSpecification; -import io.restassured.specification.ResponseSpecification; -import java.lang.reflect.Type; -import java.util.ArrayList; -import java.util.HashMap; +import java.util.List; import org.apache.fineract.client.models.DeleteDelinquencyRangeResponse; -import org.apache.fineract.client.models.DelinquencyRangeData; +import org.apache.fineract.client.models.DelinquencyRangeRequest; +import org.apache.fineract.client.models.DelinquencyRangeResponse; import org.apache.fineract.client.models.PostDelinquencyRangeResponse; import org.apache.fineract.client.models.PutDelinquencyRangeResponse; -import org.apache.fineract.client.util.JSON; -import org.apache.fineract.integrationtests.common.Utils; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; +import org.apache.fineract.client.util.Calls; +import org.apache.fineract.integrationtests.common.FineractClientHelper; public class DelinquencyRangesHelper { - private static final String DELINQUENCY_RANGES_URL = "/fineract-provider/api/v1/delinquency/ranges"; - private static final Gson GSON = new JSON().getGson(); - - private static final Logger LOG = LoggerFactory.getLogger(DelinquencyRangesHelper.class); - protected DelinquencyRangesHelper() {} - // TODO: Rewrite to use fineract-client instead! - // Example: org.apache.fineract.integrationtests.common.loans.LoanTransactionHelper.disburseLoan(java.lang.Long, - // org.apache.fineract.client.models.PostLoansLoanIdRequest) - @Deprecated(forRemoval = true) - public static ArrayList getDelinquencyRanges(final RequestSpecification requestSpec, - final ResponseSpecification responseSpec) { - String response = Utils.performServerGet(requestSpec, responseSpec, DELINQUENCY_RANGES_URL + "?" + Utils.TENANT_IDENTIFIER); - - Type delinquencyRangeListType = new TypeToken>() {}.getType(); - return GSON.fromJson(response, delinquencyRangeListType); + public static List getRanges() { + return Calls.ok(FineractClientHelper.getFineractClient().delinquencyRangeAndBucketsManagement.getRanges()); } - // TODO: Rewrite to use fineract-client instead! - // Example: org.apache.fineract.integrationtests.common.loans.LoanTransactionHelper.disburseLoan(java.lang.Long, - // org.apache.fineract.client.models.PostLoansLoanIdRequest) - @Deprecated(forRemoval = true) - public static DelinquencyRangeData getDelinquencyRange(final RequestSpecification requestSpec, final ResponseSpecification responseSpec, - final Integer resourceId) { - String response = Utils.performServerGet(requestSpec, responseSpec, - DELINQUENCY_RANGES_URL + "/" + resourceId + "?" + Utils.TENANT_IDENTIFIER); - LOG.info("----- {}", response); - return GSON.fromJson(response, DelinquencyRangeData.class); + public static DelinquencyRangeResponse getRange(Long id) { + return Calls.ok(FineractClientHelper.getFineractClient().delinquencyRangeAndBucketsManagement.getRange(id)); } - // TODO: Rewrite to use fineract-client instead! - // Example: org.apache.fineract.integrationtests.common.loans.LoanTransactionHelper.disburseLoan(java.lang.Long, - // org.apache.fineract.client.models.PostLoansLoanIdRequest) - @Deprecated(forRemoval = true) - public static PostDelinquencyRangeResponse createDelinquencyRange(final RequestSpecification requestSpec, - final ResponseSpecification responseSpec, final String json) { - final String response = Utils.performServerPost(requestSpec, responseSpec, DELINQUENCY_RANGES_URL + "?" + Utils.TENANT_IDENTIFIER, - json, null); - LOG.info("----- {}", response); - return GSON.fromJson(response, PostDelinquencyRangeResponse.class); + public static PostDelinquencyRangeResponse createRange(DelinquencyRangeRequest delinquencyRangeData) { + return Calls.ok(FineractClientHelper.getFineractClient().delinquencyRangeAndBucketsManagement.createRange(delinquencyRangeData)); } - // TODO: Rewrite to use fineract-client instead! - // Example: org.apache.fineract.integrationtests.common.loans.LoanTransactionHelper.disburseLoan(java.lang.Long, - // org.apache.fineract.client.models.PostLoansLoanIdRequest) - @Deprecated(forRemoval = true) - public static PutDelinquencyRangeResponse updateDelinquencyRange(final RequestSpecification requestSpec, - final ResponseSpecification responseSpec, final Integer resourceId, final String json) { - final String response = Utils.performServerPut(requestSpec, responseSpec, - DELINQUENCY_RANGES_URL + "/" + resourceId + "?" + Utils.TENANT_IDENTIFIER, json, null); - LOG.info("----- {}", response); - return GSON.fromJson(response, PutDelinquencyRangeResponse.class); + public static PutDelinquencyRangeResponse updateRange(Long id, DelinquencyRangeRequest delinquencyRangeData) { + return Calls + .ok(FineractClientHelper.getFineractClient().delinquencyRangeAndBucketsManagement.updateRange(id, delinquencyRangeData)); } - // TODO: Rewrite to use fineract-client instead! - // Example: org.apache.fineract.integrationtests.common.loans.LoanTransactionHelper.disburseLoan(java.lang.Long, - // org.apache.fineract.client.models.PostLoansLoanIdRequest) - @Deprecated(forRemoval = true) - public static DeleteDelinquencyRangeResponse deleteDelinquencyRange(final RequestSpecification requestSpec, - final ResponseSpecification responseSpec, final Integer resourceId) { - final String response = Utils.performServerDelete(requestSpec, responseSpec, - DELINQUENCY_RANGES_URL + "/" + resourceId + "?" + Utils.TENANT_IDENTIFIER, Utils.emptyJson(), null); - LOG.info("----- {}", response); - return GSON.fromJson(response, DeleteDelinquencyRangeResponse.class); + public static DeleteDelinquencyRangeResponse deleteRange(Long id) { + return Calls.ok(FineractClientHelper.getFineractClient().delinquencyRangeAndBucketsManagement.deleteRange(id)); } - - // TODO: Rewrite to use fineract-client instead! - // Example: org.apache.fineract.integrationtests.common.loans.LoanTransactionHelper.disburseLoan(java.lang.Long, - // org.apache.fineract.client.models.PostLoansLoanIdRequest) - @Deprecated(forRemoval = true) - public static String getAsJSON(Integer minimumAgeDays, Integer maximumAgeDays) { - final HashMap map = new HashMap<>(); - map.put("classification", Utils.uniqueRandomStringGenerator("Delinquency__" + minimumAgeDays + "_" + maximumAgeDays + "__", 4)); - map.put("minimumAgeDays", minimumAgeDays); - map.put("maximumAgeDays", maximumAgeDays); - map.put("locale", "en"); - return new Gson().toJson(map); - } - } diff --git a/integration-tests/src/test/java/org/apache/fineract/integrationtests/inlinecob/InlineLoanCOBTest.java b/integration-tests/src/test/java/org/apache/fineract/integrationtests/inlinecob/InlineLoanCOBTest.java index 1cebde1ed8d..391e11ccea7 100644 --- a/integration-tests/src/test/java/org/apache/fineract/integrationtests/inlinecob/InlineLoanCOBTest.java +++ b/integration-tests/src/test/java/org/apache/fineract/integrationtests/inlinecob/InlineLoanCOBTest.java @@ -36,8 +36,10 @@ import lombok.extern.slf4j.Slf4j; import org.apache.fineract.batch.domain.BatchRequest; import org.apache.fineract.batch.domain.BatchResponse; -import org.apache.fineract.client.models.DelinquencyBucketData; -import org.apache.fineract.client.models.DelinquencyRangeData; +import org.apache.fineract.client.models.DelinquencyBucketRequest; +import org.apache.fineract.client.models.DelinquencyBucketResponse; +import org.apache.fineract.client.models.DelinquencyRangeRequest; +import org.apache.fineract.client.models.DelinquencyRangeResponse; import org.apache.fineract.client.models.GetDelinquencyTagHistoryResponse; import org.apache.fineract.client.models.GetLoansLoanIdResponse; import org.apache.fineract.client.models.PostDelinquencyBucketResponse; @@ -162,34 +164,30 @@ public void testInlineCOBCatchUpLoans() { ChargesHelper.getLoanOverdueFeeJSONWithCalculationTypePercentage("1")); Assertions.assertNotNull(overdueFeeChargeId); - ArrayList rangeIds = new ArrayList<>(); + ArrayList rangeIds = new ArrayList<>(); // First Range - String jsonRange = DelinquencyRangesHelper.getAsJSON(1, 3); - PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, - responseSpec, jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); - jsonRange = DelinquencyRangesHelper.getAsJSON(4, 60); + PostDelinquencyRangeResponse delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest() + .minimumAgeDays(1).maximumAgeDays(3).locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); - DelinquencyRangeData range = DelinquencyRangesHelper.getDelinquencyRange(requestSpec, responseSpec, - Math.toIntExact(delinquencyRangeResponse.getResourceId())); + DelinquencyRangeResponse range = DelinquencyRangesHelper.getRange(delinquencyRangeResponse.getResourceId()); // Second Range - delinquencyRangeResponse = DelinquencyRangesHelper.createDelinquencyRange(requestSpec, responseSpec, jsonRange); - rangeIds.add(Math.toIntExact(delinquencyRangeResponse.getResourceId())); + delinquencyRangeResponse = DelinquencyRangesHelper.createRange(new DelinquencyRangeRequest().minimumAgeDays(4) + .maximumAgeDays(60).locale("en").classification(Utils.randomStringGenerator("DLQ_R_", 10))); + rangeIds.add(delinquencyRangeResponse.getResourceId()); - range = DelinquencyRangesHelper.getDelinquencyRange(requestSpec, responseSpec, - Math.toIntExact(delinquencyRangeResponse.getResourceId())); + range = DelinquencyRangesHelper.getRange(delinquencyRangeResponse.getResourceId()); final String classificationExpected = range.getClassification(); log.info("Expected Delinquency Range classification after Disbursement {}", classificationExpected); - String jsonBucket = DelinquencyBucketsHelper.getAsJSON(rangeIds); - PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper.createDelinquencyBucket(requestSpec, - responseSpec, jsonBucket); + PostDelinquencyBucketResponse delinquencyBucketResponse = DelinquencyBucketsHelper + .createBucket(new DelinquencyBucketRequest().name(Utils.randomStringGenerator("DLQ_B_", 10)).ranges(rangeIds)); assertNotNull(delinquencyBucketResponse); - final DelinquencyBucketData delinquencyBucket = DelinquencyBucketsHelper.getDelinquencyBucket(requestSpec, responseSpec, - Math.toIntExact(delinquencyBucketResponse.getResourceId())); + final DelinquencyBucketResponse delinquencyBucket = DelinquencyBucketsHelper + .getBucket(delinquencyBucketResponse.getResourceId()); - final Integer loanProductID = createLoanProduct(loanTransactionHelper, Math.toIntExact(delinquencyBucket.getId())); + final Integer loanProductID = createLoanProduct(loanTransactionHelper, delinquencyBucket.getId()); Assertions.assertNotNull(loanProductID); HashMap loanStatusHashMap; @@ -524,7 +522,7 @@ private Integer createLoanProduct(final String chargeId) { return this.loanTransactionHelper.getLoanProductId(loanProductJSON); } - private Integer createLoanProduct(final LoanTransactionHelper loanTransactionHelper, final Integer delinquencyBucketId) { + private Integer createLoanProduct(final LoanTransactionHelper loanTransactionHelper, final Long delinquencyBucketId) { final HashMap loanProductMap = new LoanProductTestBuilder().build(null, delinquencyBucketId); return loanTransactionHelper.getLoanProductId(Utils.convertToJson(loanProductMap)); }