diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/AccountValidationConfig.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/AccountValidationConfig.java index 2d874f69a..2ca750a2b 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/AccountValidationConfig.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/AccountValidationConfig.java @@ -61,6 +61,8 @@ public class AccountValidationConfig { CorrespondentAccountNewRequest::getAccount, AccountError.RequiredFieldEmpty, accountValue -> { + if (accountValue.isEmpty()) + return new EnumMessage(AccountError.RequiredFieldEmpty, "account"); Imdg accountImdg = context.obtainMap( IMDGDistributedNames.Map_Account, Account.class ); @@ -78,11 +80,12 @@ public class AccountValidationConfig { ServiceStatusDictionary.class, AccountError.RequiredFieldEmpty, AccountError.WrongFieldValue, - false, - statusValue -> { - if (ServiceStatus.Active.equalsByKey(statusValue.getCode())) return null; - return AccountError.WrongFieldValue; - }), + false +// , statusValue -> { +// if (ServiceStatus.Active.equalsByKey(statusValue.getCode())) return null; +// return AccountError.WrongFieldValue; +// } + ), DictionaryPresentRule.instance("accountType", CorrespondentAccountNewRequest::getAccountType, IMDGDistributedNames.Map_AccountTypeDictionary, @@ -92,7 +95,8 @@ public class AccountValidationConfig { accountType -> { if (AccountType.Corr.equalsByKey(accountType.getCode())) return null; return AccountError.WrongFieldValue; - }) + }), + new SameAccountValidationRule<>(AccountType.Corr, CorrespondentAccountNewRequest::getAccount) ); }; } @@ -146,7 +150,7 @@ public class AccountValidationConfig { // if (AccountType.Corr.equalsByKey(accountType.getCode())) return null; // return AccountError.WrongFieldValue; // } - ) + ) ); }; } diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/BankAccountValidationConfig.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/BankAccountValidationConfig.java index b739d058f..65ccc51bc 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/BankAccountValidationConfig.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/BankAccountValidationConfig.java @@ -20,10 +20,7 @@ import ru.spcex.clearing.validation.common.rules.specific.IdPresentSpecificRule; import ru.spcex.platform.classes.base.SpcexObjectBase; import ru.spcex.platform.enumeration.AccountStatus; import ru.spcex.platform.enumeration.AccountType; -import ru.spcex.platform.enumeration.ServiceStatus; import ru.spcex.platform.imdg.api.Imdg; -import ru.spcex.platform.imdg.api.predicate.ImdgPredicate; -import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder; import ru.spcex.platform.imdg.validation.ImdgValidationContext; import ru.spcex.platform.utils.enumeration.EnumMessage; import ru.spcex.platform.utils.validation.IValidator; @@ -60,22 +57,9 @@ public class BankAccountValidationConfig { false), FieldRequiredSpecificRule.instance("account", BankAccountNewRequest::getAccount, - AccountError.RequiredFieldEmpty, - accountValue -> { - Imdg accountImdg = context.obtainMap( - IMDGDistributedNames.Map_Account, Account.class - ); - ImdgPredicateBuilder pb = accountImdg.predicateBuilder(); - ImdgPredicate accountValuePredicate = pb.equals("account", accountValue); - ImdgPredicate accountStatusPredicate = pb.equals("status", ServiceStatus.Active.getKey()); - ImdgPredicate accountTypePredicate = pb.equals("accountType", AccountType.Bank.getKey()); - ImdgPredicate finalPredicate = pb.and(accountValuePredicate, - accountStatusPredicate, - accountTypePredicate); - Collection accounts = accountImdg.getCollectionObjectsByPredicate(finalPredicate); - if (accounts.isEmpty()) return null; - return new EnumMessage(AccountError.AccountAlreadyExist, accounts.stream().findFirst().get().getAccount()); - }), + AccountError.RequiredFieldEmpty + ), + new SameAccountValidationRule<>(AccountType.Bank, BankAccountNewRequest::getAccount), DictionaryPresentRule.instance("currency", BankAccountNewRequest::getCurrency, IMDGDistributedNames.Map_CurrencyCodeDictionary, diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ClearingAccountValidationConfig.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ClearingAccountValidationConfig.java index cc0d0974e..809c57bab 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ClearingAccountValidationConfig.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ClearingAccountValidationConfig.java @@ -21,7 +21,6 @@ import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.predicate.ImdgPredicate; import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder; import ru.spcex.platform.imdg.validation.ImdgValidationContext; -import ru.spcex.platform.utils.enumeration.EnumMessage; import ru.spcex.platform.utils.validation.IValidator; import ru.spcex.platform.utils.validation.ValidatorImpl; @@ -57,22 +56,8 @@ public class ClearingAccountValidationConfig { ), FieldRequiredSpecificRule.instance("account", ClearingAccountNewRequest::getAccount, - AccountError.RequiredFieldEmpty, - accountValue -> { - Imdg accountImdg = context.obtainMap( - IMDGDistributedNames.Map_Account, Account.class - ); - ImdgPredicateBuilder pb = accountImdg.predicateBuilder(); - ImdgPredicate accountValuePredicate = pb.equals("account", accountValue); - ImdgPredicate accountStatusPredicate = pb.equals("status", ServiceStatus.Active.getKey()); - ImdgPredicate accountTypePredicate = pb.equals("accountType", AccountType.Clrn.getKey()); - ImdgPredicate finalPredicate = pb.and(accountValuePredicate, - accountStatusPredicate, - accountTypePredicate); - Collection accounts = accountImdg.getCollectionObjectsByPredicate(finalPredicate); - if (accounts.isEmpty()) return null; - return new EnumMessage(AccountError.AccountAlreadyExist, accounts.stream().findFirst().get().getAccount()); - }), + AccountError.RequiredFieldEmpty), + new SameAccountValidationRule<>(AccountType.Clrn, ClearingAccountNewRequest::getAccount), DictionaryPresentRule.instance("clearingAccountType", ClearingAccountNewRequest::getClearingAccountType, IMDGDistributedNames.Map_ClearingAccountTypeDictionary, diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/DepoAccountValidationConfig.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/DepoAccountValidationConfig.java index a5b075d9c..3b3d9b4cd 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/DepoAccountValidationConfig.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/DepoAccountValidationConfig.java @@ -14,12 +14,8 @@ import ru.spcex.clearing.validation.common.rules.IdPresentRule; import ru.spcex.clearing.validation.common.rules.specific.FieldRequiredSpecificRule; import ru.spcex.platform.classes.base.SpcexObjectBase; import ru.spcex.platform.enumeration.AccountType; -import ru.spcex.platform.enumeration.ServiceStatus; import ru.spcex.platform.imdg.api.Imdg; -import ru.spcex.platform.imdg.api.predicate.ImdgPredicate; -import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder; import ru.spcex.platform.imdg.validation.ImdgValidationContext; -import ru.spcex.platform.utils.enumeration.EnumMessage; import ru.spcex.platform.utils.validation.IValidator; import ru.spcex.platform.utils.validation.ValidatorImpl; @@ -54,22 +50,8 @@ public class DepoAccountValidationConfig { ), FieldRequiredSpecificRule.instance("account", DepoAccountNewRequest::getAccount, - AccountError.RequiredFieldEmpty, - accountValue -> { - Imdg accountImdg = context.obtainMap( - IMDGDistributedNames.Map_Account, Account.class - ); - ImdgPredicateBuilder pb = accountImdg.predicateBuilder(); - ImdgPredicate accountValuePredicate = pb.equals("account", accountValue); - ImdgPredicate accountStatusPredicate = pb.equals("status", ServiceStatus.Active.getKey()); - ImdgPredicate accountTypePredicate = pb.equals("accountType", AccountType.Clrn.getKey()); - ImdgPredicate finalPredicate = pb.and(accountValuePredicate, - accountStatusPredicate, - accountTypePredicate); - Collection accounts = accountImdg.getCollectionObjectsByPredicate(finalPredicate); - if (accounts.isEmpty()) return null; - return new EnumMessage(AccountError.AccountAlreadyExist, accounts.stream().findFirst().get().getAccount()); - }), + AccountError.RequiredFieldEmpty), + new SameAccountValidationRule<>(AccountType.Depo, DepoAccountNewRequest::getAccount), FieldRequiredRule.instance("depoAccountType", DepoAccountNewRequest::getDepoAccountType, AccountError.RequiredFieldEmpty), diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/InformationAccountValidationConfig.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/InformationAccountValidationConfig.java index 0bde8aa47..0a5e30cfe 100644 --- a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/InformationAccountValidationConfig.java +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/InformationAccountValidationConfig.java @@ -11,21 +11,17 @@ import ru.spcex.clearing.account.errors.AccountError; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.clearing.platform.messaging.domain.cud.account.InformationAccountNewRequest; import ru.spcex.clearing.validation.common.rules.DictionaryPresentRule; +import ru.spcex.clearing.validation.common.rules.FieldNotEmptyRequiredRule; import ru.spcex.clearing.validation.common.rules.IdPresentRule; import ru.spcex.platform.classes.base.SpcexObjectBase; import ru.spcex.platform.enumeration.AccountType; -import ru.spcex.platform.enumeration.ServiceStatus; import ru.spcex.platform.enumeration.WorkflowStatus; import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.validation.ImdgValidationContext; -import ru.spcex.platform.utils.enumeration.EnumMessage; -import ru.spcex.platform.utils.validation.IValidationRule; import ru.spcex.platform.utils.validation.IValidator; import ru.spcex.platform.utils.validation.ValidatorImpl; -import java.util.Collection; import java.util.Map; -import java.util.Optional; import java.util.function.Consumer; import java.util.function.Function; @@ -57,32 +53,17 @@ public class InformationAccountValidationConfig { return AccountError.CompanyNotActive; return null; }), + FieldNotEmptyRequiredRule.instance("account", InformationAccountNewRequest::getStatus, + AccountError.RequiredFieldEmpty), DictionaryPresentRule.instance("status", InformationAccountNewRequest::getStatus, IMDGDistributedNames.Map_ServiceStatusDictionary, ServiceStatusDictionary.class, AccountError.RequiredFieldEmpty, AccountError.DictionaryNotFound, false), DictionaryPresentRule.instance("accountType", InformationAccountNewRequest::getAccountType, IMDGDistributedNames.Map_AccountTypeDictionary, AccountTypeDictionary.class, AccountError.RequiredFieldEmpty, AccountError.DictionaryNotFound, false), - new SameInfoAccountValidation() + new SameAccountValidationRule<>(AccountType.Info, InformationAccountNewRequest::getAccount) ); }; } - static class SameInfoAccountValidation implements IValidationRule> { - @Override - public Optional validate(ImdgValidationContext context) { - InformationAccountNewRequest req = context.getValidatedObject(); - Imdg accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class); - String accountType = AccountType.Info.getKey(); // or req.getAccountType() - Account existAccount = accountImdg.getFirstObjectByFieldValues(Map.of( - "account", req.getAccount(), - "accountType", accountType, - "status", ServiceStatus.Active.getKey() - )); - if (existAccount != null) { - return of(AccountError.AccountAlreadyExist, existAccount.getAccount()); - } - return empty(); - } - } } diff --git a/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/SameAccountValidationRule.java b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/SameAccountValidationRule.java new file mode 100644 index 000000000..e30fd631a --- /dev/null +++ b/clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/SameAccountValidationRule.java @@ -0,0 +1,46 @@ +package ru.spcex.clearing.account.config.validation; + +import ru.clearing.classes.statics.data.account.Account; +import ru.spcex.clearing.account.errors.AccountError; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.platform.enumeration.AccountType; +import ru.spcex.platform.enumeration.ServiceStatus; +import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicate; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder; +import ru.spcex.platform.imdg.validation.ImdgValidationContext; +import ru.spcex.platform.utils.enumeration.EnumMessage; +import ru.spcex.platform.utils.validation.IValidationRule; + +import java.util.Objects; +import java.util.Optional; +import java.util.function.Function; + +class SameAccountValidationRule implements IValidationRule> { + final String accountType; + final Function accountGetter; + + public SameAccountValidationRule(AccountType accountType, Function accountGetter) { + this.accountType = accountType.getKey(); // or req.getAccountType() + this.accountGetter = accountGetter; + Objects.requireNonNull(accountGetter); + } + + @Override + public Optional validate(ImdgValidationContext context) { + R req = context.getValidatedObject(); + Imdg accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class); + ImdgPredicateBuilder pb = accountImdg.predicateBuilder(); + ImdgPredicate query = pb.and( + pb.equals("account", accountGetter.apply(req)), // req.getAccount() + pb.equals("accountType", accountType), + pb.in("status", ServiceStatus.Active.getKey(), ServiceStatus.Reopened.getKey(), ServiceStatus.Appl.getKey()) + ); + Account existAccount = accountImdg.getFirstObjectByPredicate(query); + if (existAccount != null) { + return of(AccountError.AccountAlreadyExist, existAccount.getAccount()); + } + return empty(); + } + +} diff --git a/clearing-parent/clearing-validation/src/main/java/ru/spcex/clearing/validation/common/rules/DictionaryPresentRule.java b/clearing-parent/clearing-validation/src/main/java/ru/spcex/clearing/validation/common/rules/DictionaryPresentRule.java index 50ca677ab..5a9154105 100644 --- a/clearing-parent/clearing-validation/src/main/java/ru/spcex/clearing/validation/common/rules/DictionaryPresentRule.java +++ b/clearing-parent/clearing-validation/src/main/java/ru/spcex/clearing/validation/common/rules/DictionaryPresentRule.java @@ -108,11 +108,11 @@ public record DictionaryPresentRule(String fiel ImdgPredicate imdgPredicate = imdgPredicateBuilder.equals("code", enumCode); Collection fromMap = dictImdg.getCollectionObjectsByPredicate(imdgPredicate); if (fromMap.isEmpty()) { - return of(errorWrongDictionaryValue, fieldName); + return of(errorWrongDictionaryValue, enumCode, dictionaryClass.getSimpleName()); } D dictionaryFromMap = fromMap.iterator().next(); if (dictionaryFromMap == null) { - return of(errorWrongDictionaryValue, fieldName); + return of(errorWrongDictionaryValue, enumCode, dictionaryClass.getSimpleName()); } for (Function additionalCheck : additionalChecks) { IErrorEnumId validationError = additionalCheck.apply(dictionaryFromMap); diff --git a/clearing-parent/clearing-validation/src/main/java/ru/spcex/clearing/validation/common/rules/FieldNotEmptyRequiredRule.java b/clearing-parent/clearing-validation/src/main/java/ru/spcex/clearing/validation/common/rules/FieldNotEmptyRequiredRule.java new file mode 100644 index 000000000..6279bc88d --- /dev/null +++ b/clearing-parent/clearing-validation/src/main/java/ru/spcex/clearing/validation/common/rules/FieldNotEmptyRequiredRule.java @@ -0,0 +1,81 @@ +package ru.spcex.clearing.validation.common.rules; + + +import org.apache.commons.lang3.StringUtils; +import ru.spcex.platform.imdg.validation.ImdgValidationContext; +import ru.spcex.platform.utils.enumeration.EnumMessage; +import ru.spcex.platform.utils.enumeration.IErrorEnumId; +import ru.spcex.platform.utils.validation.IValidationRule; + +import java.util.Optional; +import java.util.function.Function; + +/** + * Проверка обязательности String поля (not null) + * + * @param fieldName Название поля + * @param getter Метод получения значения + * @param errorEmptyRequiredValue Ошибка, которая будет возвращена, если поле пустое + * @param additionalChecks Дополнительные проверки, связанные с этим полем + * @param required Флаг обязательности поля + * @param Класс проверяемого объекта + */ +public record FieldNotEmptyRequiredRule( + String fieldName, + Function getter, + IErrorEnumId errorEmptyRequiredValue, + boolean required, + Function[] additionalChecks +) implements IValidationRule> { + + /** + * @param fieldName Название поля + * @param getter Метод получения значения + * @param errorEmptyRequiredValue Ошибка, которая будет возвращена, если поле пустое + * @param additionalChecks Дополнительные проверки, связанные с этим полем + * @param required Флаг обязательности поля + * @param Класс проверяемого объекта + */ + @SafeVarargs + public static FieldNotEmptyRequiredRule instance(String fieldName, + Function getter, + IErrorEnumId errorEmptyRequiredValue, + boolean required, + Function... additionalChecks) { + if (required && errorEmptyRequiredValue == null) throw new IllegalArgumentException("Empty errorEmptyRequiredValue"); + return new FieldNotEmptyRequiredRule<>(fieldName, getter, errorEmptyRequiredValue, required, additionalChecks); + } + + /** + * @param fieldName Название поля + * @param getter Метод получения значения + * @param errorEmptyRequiredValue Ошибка, которая будет возвращена, если поле пустое + * @param additionalChecks Дополнительные проверки, связанные с этим полем + * @param Класс проверяемого объекта + */ + @SafeVarargs + public static FieldNotEmptyRequiredRule instance(String fieldName, + Function getter, + IErrorEnumId errorEmptyRequiredValue, + Function... additionalChecks) { + if (errorEmptyRequiredValue == null) throw new IllegalArgumentException("Empty errorEmptyRequiredValue"); + return new FieldNotEmptyRequiredRule<>(fieldName, getter, errorEmptyRequiredValue, true, additionalChecks); + } + + @Override + public Optional validate(ImdgValidationContext context) { + R validatedObject = context.getValidatedObject(); + String value = getter.apply(validatedObject); + if (required && (StringUtils.isEmpty(value))) return of(errorEmptyRequiredValue, fieldName); + for (Function additionalCheck : additionalChecks) { + IErrorEnumId validationError = additionalCheck.apply(value); + if (validationError != null) return of(validationError, value); + } + return empty(); + } + + @Override + public String ruleName() { + return getClass().getSimpleName() + "{" + fieldName + "}"; + } +}