BankAccountValidationConfig

clearing-parent/account-service/pom.xml

@@ -65,6 +65,14 @@
             <artifactId>spring-boot-test</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>ru.spcex.clearing</groupId>
+            <artifactId>security-util</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>ru.spcex.clearing</groupId>
+            <artifactId>clearing-validation</artifactId>
+        </dependency>
 
     </dependencies>
 

clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/BeanConfiguration.java

@@ -0,0 +1,26 @@
+package ru.spcex.clearing.account.config;
+
+import org.springframework.beans.factory.config.ConfigurableBeanFactory;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Scope;
+import ru.spcex.clearing.account.errors.AccountError;
+import ru.spcex.clearing.util.security.UserRoleVerification;
+import ru.spcex.platform.enumeration.UserRole;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.utils.enumeration.IMessageResolver;
+import ru.spcex.platform.utils.enumeration.SimpleMessageResolver;
+
+@Configuration
+public class BeanConfiguration {
+    @Bean
+    public IMessageResolver messageResolver() {
+        return new SimpleMessageResolver();
+    }
+
+    @Bean
+    @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
+    public UserRoleVerification userRoleVerification(ImdgProvider imdgProvider, IMessageResolver messageResolver) {
+        return new UserRoleVerification(imdgProvider, messageResolver, UserRole.Admin, AccountError.UserVerifyDenial);
+    }
+}

clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/ErrorResolverConfig.java

@@ -1,14 +0,0 @@
-package ru.spcex.clearing.account.config;
-
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import ru.spcex.platform.utils.enumeration.IMessageResolver;
-import ru.spcex.platform.utils.enumeration.SimpleMessageResolver;
-
-@Configuration
-public class ErrorResolverConfig {
-    @Bean
-    public IMessageResolver messageResolver() {
-        return new SimpleMessageResolver();
-    }
-}

clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/BankAccountValidationConfig.java

@@ -0,0 +1,214 @@
+package ru.spcex.clearing.account.config.validation;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import ru.clearing.classes.statics.data.account.Account;
+import ru.clearing.classes.statics.data.account.BankAccount;
+import ru.clearing.classes.statics.data.company.Company;
+import ru.clearing.platform.dictionary.CurrencyCodeDictionary;
+import ru.spcex.clearing.account.errors.AccountError;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.BankAccountNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.BankAccountUpdateRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest;
+import ru.spcex.clearing.validation.common.rules.DictionaryPresentRule;
+import ru.spcex.clearing.validation.common.rules.EnumPresentRule;
+import ru.spcex.clearing.validation.common.rules.FieldRequiredRule;
+import ru.spcex.clearing.validation.common.rules.IdPresentRule;
+import ru.spcex.platform.classes.base.SpcexObjectBase;
+import ru.spcex.platform.enumeration.CurrencyCode;
+import ru.spcex.platform.enumeration.Status;
+import ru.spcex.platform.enumeration.WorkflowStatus;
+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.validation.IValidator;
+import ru.spcex.platform.utils.validation.ValidatorImpl;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+@Configuration
+public class BankAccountValidationConfig {
+
+    @Bean("bankAccountNewRequestValidator")
+    public Function<BankAccountNewRequest, IValidator> bankAccountNewRequestValidator(
+            Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation
+    ) {
+        return bankAccountNewRequest -> {
+            ImdgValidationContext<BankAccountNewRequest> context = new ImdgValidationContext<>();
+            context.setValidatedObject(bankAccountNewRequest);
+            Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
+            addImdg.accept(IMDGDistributedNames.Map_Account);
+            addImdg.accept(IMDGDistributedNames.Map_BankAccount);
+            addImdg.accept(IMDGDistributedNames.Map_Company);
+            addImdg.accept(IMDGDistributedNames.Map_CurrencyCodeDictionary);
+            return new ValidatorImpl<>(context,
+                    IdPresentRule.instance("companyId",
+                            BankAccountNewRequest::getCompanyId,
+                            IMDGDistributedNames.Map_Company,
+                            Company.class,
+                            AccountError.RequiredFieldEmpty,
+                            AccountError.CompanyNotFound,
+                            company -> WorkflowStatus.Active.getKey().equals(company.getWorkflowStatus()) ? null : AccountError.CompanyNotActive),
+                    FieldRequiredRule.instance("account",
+                            BankAccountNewRequest::getAccount,
+                            AccountError.RequiredFieldEmpty,
+                            accountValue -> {
+                                Imdg<Account> accountImdg = context.obtainMap(
+                                        IMDGDistributedNames.Map_Account, Account.class
+                                );
+                                ImdgPredicateBuilder pb = accountImdg.predicateBuilder();
+                                ImdgPredicate accountValuePredicate = pb.equals("account", accountValue);
+                                ImdgPredicate accountStatusPredicate = pb.equals("accountStatus", Status.Active.getKey());
+                                ImdgPredicate finalPredicate = pb.and(accountValuePredicate, accountStatusPredicate);
+                                Collection<Account> accounts = accountImdg.getCollectionObjectsByPredicate(finalPredicate);
+                                if (accounts.isEmpty()) return null;
+                                return AccountError.AccountAlreadyExist;
+                            }),
+                    EnumPresentRule.instance("currency",
+                            BankAccountNewRequest::getCurrency,
+                            CurrencyCode.values(),
+                            AccountError.WrongFieldValue,
+                            AccountError.RequiredFieldEmpty),
+                    DictionaryPresentRule.instance("currency",
+                            BankAccountNewRequest::getCurrency,
+                            IMDGDistributedNames.Map_CurrencyCodeDictionary,
+                            CurrencyCodeDictionary.class,
+                            AccountError.RequiredFieldEmpty,
+                            AccountError.WrongFieldValue),
+                    FieldRequiredRule.instance("bankIdentificationCode",
+                            BankAccountNewRequest::getBankIdentificationCode,
+                            AccountError.RequiredFieldEmpty),
+                    FieldRequiredRule.instance("bankName",
+                            BankAccountNewRequest::getBankName,
+                            AccountError.RequiredFieldEmpty),
+                    FieldRequiredRule.instance("destination",
+                            BankAccountNewRequest::getDestination,
+                            AccountError.RequiredFieldEmpty),
+                    FieldRequiredRule.instance("correspondentAccount",
+                            BankAccountNewRequest::getCorrespondentAccount,
+                            AccountError.RequiredFieldEmpty,
+                            false,
+                            correspondentAccount -> {
+                                String currency = bankAccountNewRequest.getCurrency();
+                                if (CurrencyCode.RUB.getKey().equalsIgnoreCase(currency) && correspondentAccount == null)
+                                    return AccountError.RequiredFieldEmpty;
+                                return null;
+                            }),
+                    FieldRequiredRule.instance("correspondentAccountName",
+                            BankAccountNewRequest::getCorrespondentAccountName,
+                            AccountError.RequiredFieldEmpty,
+                            false,
+                            correspondentAccountName -> {
+                                String currency = bankAccountNewRequest.getCurrency();
+                                if (CurrencyCode.RUB.getKey().equalsIgnoreCase(currency) && correspondentAccountName == null)
+                                    return AccountError.RequiredFieldEmpty;
+                                return null;
+                            }),
+                    FieldRequiredRule.instance("taxpayerIdentificationNumber",
+                            BankAccountNewRequest::getTaxpayerIdentificationNumber,
+                            AccountError.RequiredFieldEmpty,
+                            false,
+                            taxpayerIdentificationNumber -> {
+                                String currency = bankAccountNewRequest.getCurrency();
+                                if (CurrencyCode.RUB.getKey().equalsIgnoreCase(currency) && taxpayerIdentificationNumber == null)
+                                    return AccountError.RequiredFieldEmpty;
+                                return null;
+                            }),
+                    FieldRequiredRule.instance("taxRegistrationReasonCode",
+                            BankAccountNewRequest::getTaxRegistrationReasonCode,
+                            AccountError.RequiredFieldEmpty,
+                            false,
+                            taxRegistrationReasonCode -> {
+                                String currency = bankAccountNewRequest.getCurrency();
+                                if (CurrencyCode.RUB.getKey().equalsIgnoreCase(currency) && taxRegistrationReasonCode == null)
+                                    return AccountError.RequiredFieldEmpty;
+                                return null;
+                            })
+            );
+        };
+    }
+
+    @Bean("bankAccountUpdateRequestValidator")
+    public Function<BankAccountUpdateRequest, IValidator> bankAccountUpdateRequestValidator(
+            Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation
+    ) {
+        return bankAccountUpdateRequest -> {
+            ImdgValidationContext<BankAccountUpdateRequest> context = new ImdgValidationContext<>();
+            context.setValidatedObject(bankAccountUpdateRequest);
+            Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
+            addImdg.accept(IMDGDistributedNames.Map_Account);
+            addImdg.accept(IMDGDistributedNames.Map_CurrencyCodeDictionary);
+            addImdg.accept(IMDGDistributedNames.Map_BankAccount);
+            addImdg.accept(IMDGDistributedNames.Map_Company);
+            return new ValidatorImpl<>(context,
+                    IdPresentRule.instance("id",
+                            BankAccountUpdateRequest::getId,
+                            IMDGDistributedNames.Map_BankAccount,
+                            BankAccount.class,
+                            AccountError.RequiredFieldEmpty,
+                            AccountError.BankAccountNotFound,
+                            bankAccount -> {
+                                Long accountId = bankAccount.getAccountId();
+                                Imdg<Account> accountImdg = context.obtainMap(
+                                        IMDGDistributedNames.Map_Account, Account.class
+                                );
+                                Account account = accountImdg.getSingleObjectByID(accountId);
+                                if (account == null) return AccountError.BankAccountNotFound;
+                                if (!WorkflowStatus.Active.getKey().equalsIgnoreCase(account.getAccountStatus()))
+                                    return AccountError.AccountNotActive;
+                                return null;
+                            }),
+                    EnumPresentRule.instance("currency",
+                            BankAccountUpdateRequest::getCurrency,
+                            CurrencyCode.values(),
+                            false,
+                            AccountError.WrongFieldValue,
+                            AccountError.RequiredFieldEmpty),
+                    DictionaryPresentRule.instance("currency",
+                            BankAccountUpdateRequest::getCurrency,
+                            IMDGDistributedNames.Map_CurrencyCodeDictionary,
+                            CurrencyCodeDictionary.class,
+                            AccountError.RequiredFieldEmpty,
+                            AccountError.WrongFieldValue,
+                            false)
+            );
+        };
+    }
+
+    @Bean("bankAccountUpdateRequestValidator")
+    public Function<CommonDeleteRequest, IValidator> bankAccountDeleteRequestValidator(
+            Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation
+    ) {
+        return bankAccountDeleteRequest -> {
+            ImdgValidationContext<CommonDeleteRequest> context = new ImdgValidationContext<>();
+            context.setValidatedObject(bankAccountDeleteRequest);
+            Consumer<String> addImdg = (s) -> context.addImdg(s, imdgForValidation.get(s));
+            addImdg.accept(IMDGDistributedNames.Map_BankAccount);
+            return new ValidatorImpl<>(context,
+                    IdPresentRule.instance("id",
+                            CommonDeleteRequest::getId,
+                            IMDGDistributedNames.Map_BankAccount,
+                            BankAccount.class,
+                            AccountError.RequiredFieldEmpty,
+                            AccountError.BankAccountNotFound,
+                            bankAccount -> {
+                                Long accountId = bankAccount.getAccountId();
+                                Imdg<Account> accountImdg = context.obtainMap(
+                                        IMDGDistributedNames.Map_Account, Account.class
+                                );
+                                Account account = accountImdg.getSingleObjectByID(accountId);
+                                if (account == null) return AccountError.BankAccountNotFound;
+                                if (!WorkflowStatus.Active.getKey().equalsIgnoreCase(account.getAccountStatus()))
+                                    return AccountError.AccountNotActive;
+                                return null;
+                            })
+            );
+        };
+    }
+
+}

clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/config/validation/ValidationConfig.java

@@ -0,0 +1,43 @@
+package ru.spcex.clearing.account.config.validation;
+
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import ru.clearing.classes.statics.data.account.Account;
+import ru.clearing.classes.statics.data.account.BankAccount;
+import ru.clearing.classes.statics.data.company.Company;
+import ru.clearing.platform.dictionary.CurrencyCodeDictionary;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.validation.common.ValidationHelper;
+import ru.spcex.platform.classes.base.SpcexObjectBase;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.utils.enumeration.IMessageResolver;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.BiConsumer;
+
+@Configuration
+public class ValidationConfig {
+
+    @Bean("imdgForValidation")
+    public Map<String, Imdg<? extends SpcexObjectBase>> imdgForValidation(ImdgProvider imdgProvider) {
+        final Map<String, Imdg<? extends SpcexObjectBase>> imdg = new HashMap<>();
+        BiConsumer<String, Class<? extends SpcexObjectBase>> addImdg = (s, aClass) -> imdg.put(s, imdgProvider.getImdg(s, aClass));
+
+        addImdg.accept(IMDGDistributedNames.Map_Company, Company.class);
+        addImdg.accept(IMDGDistributedNames.Map_Account, Account.class);
+        addImdg.accept(IMDGDistributedNames.Map_BankAccount, BankAccount.class);
+        addImdg.accept(IMDGDistributedNames.Map_CurrencyCodeDictionary, CurrencyCodeDictionary.class);
+
+        return imdg;
+    }
+
+    @Bean("validationHelper")
+    public ValidationHelper validationHelper(IMessageResolver messageResolver) {
+        return new ValidationHelper(messageResolver);
+    }
+
+}
+

clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/errors/AccountError.java

@@ -3,12 +3,16 @@ package ru.spcex.clearing.account.errors;
 import ru.spcex.platform.utils.enumeration.IErrorEnumId;
 
 public enum AccountError implements IErrorEnumId {
+    UserVerifyDenial(5001L),
+    RequiredFieldEmpty(5002L),
     WrongFieldValue(5004L),
     AccountAlreadyExist(5010L),
+    BankAccountNotFound(5011L),
+    AccountNotActive(5012L),
     CompanyNotFound(5013L),
     CompanyNotActive(5014L),
-
     ;
+
     private final Long id;
 
     AccountError(Long id) {

clearing-parent/account-service/src/main/java/ru/spcex/clearing/account/service/AccountService.java

@@ -43,7 +43,7 @@ public class AccountService extends QueueConsumer implements InitializingBean {
         init();
     }
 
-    private void accountNew(BaseRequest<AccountSdf01Request> userRequest) {
+    public void accountNew(BaseRequest<AccountSdf01Request> userRequest) {
         AccountSdf01Request req = userRequest.getRequestPayload();
         log.debug("AccountSdf01Request received");
         List<AccountSdfToStatementRequestPart> accountToStatement = new ArrayList<>();
@@ -60,11 +60,11 @@ public class AccountService extends QueueConsumer implements InitializingBean {
         log.debug("successfully processed, grouping id={}, processed number={}", req.getGroupingSdf01Id(), accountToStatement.size());
     }
 
-    private void accountUpdateWithBrake(BaseRequest<AccountSdf01Request> userRequest) {
+    public void accountUpdateWithBrake(BaseRequest<AccountSdf01Request> userRequest) {
 
     }
 
-    private AccountSdfToStatementRequestPart responsePart(Long sdf01Id) {
+    public AccountSdfToStatementRequestPart responsePart(Long sdf01Id) {
         AccountSdfToStatementRequestPart responsePart = new AccountSdfToStatementRequestPart();
         responsePart.setSdfId(sdf01Id);
         responsePart.setErrorCode(null);
@@ -72,7 +72,7 @@ public class AccountService extends QueueConsumer implements InitializingBean {
         return responsePart;
     }
 
-    private void sendStatementRequestBack(Long groupingSdf01Id, List<AccountSdfToStatementRequestPart> results) {
+    public void sendStatementRequestBack(Long groupingSdf01Id, List<AccountSdfToStatementRequestPart> results) {
         StatementRequest request = new StatementRequest();
         request.setGroupId(groupingSdf01Id);
         request.setAccountCreationResults(results);