http://jira.mfd.msk:8088/browse/CLS-74 validation

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

@@ -4,12 +4,13 @@ import org.springframework.beans.factory.annotation.Autowired;
 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.AccountBalance;
 import ru.clearing.classes.statics.data.company.Company;
+import ru.clearing.classes.statics.data.company.CompanySymbols;
 import ru.clearing.classes.statics.data.sdf.SDf01;
+import ru.clearing.classes.statics.data.sdf.SDf09;
 import ru.clearing.classes.statics.data.sdf.SDf16;
-import ru.spcex.clearing.balance.validation.AccountBalanceValidation;
+import ru.spcex.clearing.balance.validation.*;
-import ru.spcex.clearing.balance.validation.AccountBalanceValidationRule;
-import ru.spcex.clearing.balance.validation.Sdf01ValidationRule;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.platform.classes.base.SpcexObjectBase;
 import ru.spcex.platform.imdg.api.Imdg;
@@ -33,6 +34,8 @@ public class ValidationConfig {
         BiConsumer<String, Class<? extends SpcexObjectBase>> addImdg = (s, aClass) -> imdgs.put(s, imdgProvider.getImdg(s, aClass));
         addImdg.accept(IMDGDistributedNames.Map_Account, Account.class);
         addImdg.accept(IMDGDistributedNames.Map_Company, Company.class);
+        addImdg.accept(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class);
+        addImdg.accept(IMDGDistributedNames.Map_AccountBalance, AccountBalance.class);
     }
 
     /**
@@ -42,9 +45,8 @@ public class ValidationConfig {
         return imdgs.get(key);
     }
 
-    @Autowired
     @Bean("sdf01Validator")
-    public Function<SDf01, IValidator> sdf01Validator(ImdgProvider imdgProvider) {
+    public Function<SDf01, IValidator> sdf01Validator() {
         return sDf01 -> {
             ImdgValidationContext<SDf01> context = new ImdgValidationContext<>();
             context.setValidatedObject(sDf01);
@@ -56,7 +58,7 @@ public class ValidationConfig {
                     Sdf01ValidationRule.AccountPresent,
                     Sdf01ValidationRule.CurrencyCode,
                     Sdf01ValidationRule.CurrentDateOnly,
-                    Sdf01ValidationRule.Market,
+                    MarketIsUValidationRule.instance,
                     Sdf01ValidationRule.accountType);
         };
     }
@@ -74,11 +76,30 @@ public class ValidationConfig {
                     Sdf01ValidationRule.AccountPresent,
                     Sdf01ValidationRule.CurrencyCode,
                     Sdf01ValidationRule.CurrentDateOnly,
-                    Sdf01ValidationRule.Market,
+                    MarketIsUValidationRule.instance,
                     Sdf01ValidationRule.accountType);
         };
     }
 
+    @Bean("sdf09Validator")
+    public Function<SDf09, IValidator> sdf09Validator() {
+        return sDf09 -> {
+            ImdgValidationContext<SDf09> context = new ImdgValidationContext<>();
+            context.setValidatedObject(sDf09);
+            Consumer<String> addImdg = (s) -> context.addImdg(s, getImdg(s));
+            addImdg.accept(IMDGDistributedNames.Map_Account);
+            addImdg.accept(IMDGDistributedNames.Map_Company);
+            addImdg.accept(IMDGDistributedNames.Map_CompanySymbols);
+            addImdg.accept(IMDGDistributedNames.Map_AccountBalance);
+            return new ValidatorImpl<>(context,
+                    Sdf09ValidationRule.CompanyPresent,
+                    Sdf09ValidationRule.AccountPresent,
+                    MarketIsUValidationRule.instance,
+                    Sdf09ValidationRule.BalanceEnough
+            );
+        };
+    }
+
     @Autowired
     @Bean("accountBalanceValidator")
     public Function<AccountBalanceValidation, IValidator> accountBalanceValidator(ImdgProvider imdgProvider) {

clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/errors/BalanceError.java

@@ -9,7 +9,8 @@ public enum BalanceError implements IEnumId {
     WrongMarket(5215L),
     WrongAccount(5215L),
     AccountNotPresent(5217L),
-    AccountNotActive(5218L)
+    AccountNotActive(5218L),
+    BalanceNotEnough(5222L),
     ;
     private final Long id;
 

clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/MarketIsUValidationRule.java

@@ -0,0 +1,23 @@
+package ru.spcex.clearing.balance.validation;
+
+import ru.spcex.clearing.balance.errors.BalanceError;
+import ru.spcex.platform.classes.base.interfaces.WithMarket;
+import ru.spcex.platform.imdg.validation.ImdgValidationContext;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.validation.IValidationRule;
+
+import java.util.Optional;
+
+public class MarketIsUValidationRule implements IValidationRule<ImdgValidationContext<WithMarket>> {
+
+    public static final MarketIsUValidationRule instance = new MarketIsUValidationRule();
+
+    @Override
+    public Optional<EnumMessage> validate(ImdgValidationContext<WithMarket> context) {
+        WithMarket validatedObject = context.getValidatedObject();
+        if (!"U".equals(validatedObject.getMarket())) {
+            return of(BalanceError.WrongMarket);
+        }
+        return empty();
+    }
+}

clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/Sdf01ValidationRule.java

@@ -65,16 +65,6 @@ public enum Sdf01ValidationRule implements IValidationRule<ImdgValidationContext
             return empty();
         }
     },
-    Market() {
-        @Override
-        public Optional<EnumMessage> validate(ImdgValidationContext<SDf01> context) {
-            SDf01 sdf01 = context.getValidatedObject();
-            if (!"U".equals(sdf01.getMarket())) {
-                return of(BalanceError.WrongMarket);
-            }
-            return empty();
-        }
-    },
     accountType() {
         @Override
         public Optional<EnumMessage> validate(ImdgValidationContext<SDf01> context) {

clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/Sdf09ValidationRule.java

@@ -0,0 +1,89 @@
+package ru.spcex.clearing.balance.validation;
+
+import ru.clearing.classes.statics.data.account.Account;
+import ru.clearing.classes.statics.data.account.AccountBalance;
+import ru.clearing.classes.statics.data.company.Company;
+import ru.clearing.classes.statics.data.company.CompanySymbols;
+import ru.clearing.classes.statics.data.sdf.SDf09;
+import ru.spcex.clearing.balance.errors.BalanceError;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.platform.enumeration.AccountType;
+import ru.spcex.platform.enumeration.CompanySymbol;
+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 java.math.BigDecimal;
+import java.util.Map;
+import java.util.Optional;
+
+public enum Sdf09ValidationRule implements IValidationRule<ImdgValidationContext<SDf09>> {
+    CompanyPresent() {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<SDf09> context) {
+            SDf09 sdf09 = context.getValidatedObject();
+            Imdg<CompanySymbols> companySymbolImdg = context.obtainMap(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class);
+            Imdg<Company> companyImdg = context.obtainMap(IMDGDistributedNames.Map_Company, Company.class);
+            CompanySymbols symbol = companySymbolImdg
+                    .getSingleObjectByFieldValues(Map.of("companySymbol", CompanySymbol.INN.getKey(),
+                            "companySymbolValue", sdf09.getInn()));
+            Company company = companyImdg.getSingleObjectByID(symbol.getCompanyId());
+
+            if (company == null) {
+                return of( BalanceError.CompanyNotFound);
+            }
+            context.storeObject(ValidationStored.Company, company);
+            return empty();
+        }
+    },
+    AccountPresent() {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<SDf09> context) {
+            SDf09 sdf09 = context.getValidatedObject();
+            Imdg<Account> accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
+            Account account = accountImdg.getSingleObjectByFieldValues(Map.of("account", sdf09.getAccount(),
+                    "accountType", AccountType.Clrn.getKey()));
+            if (account == null) {
+                return of(BalanceError.AccountNotPresent);
+            }
+            context.storeObject(ValidationStored.Account, account);
+            return empty();
+        }
+    },
+    Market() {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<SDf09> context) {
+            SDf09 sdf09 = context.getValidatedObject();
+            if (!"U".equals(sdf09.getMarket())) {
+                return of(BalanceError.WrongMarket);
+            }
+            return empty();
+        }
+    },
+    BalanceEnough() {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<SDf09> context) {
+            SDf09 validatedObject = context.getValidatedObject();
+            if (validatedObject.getSum().compareTo(BigDecimal.ZERO) >= 0) {
+                return empty();
+            }
+            Imdg<AccountBalance> balanceImdg = context.obtainMap(IMDGDistributedNames.Map_AccountBalance, AccountBalance.class);
+            AccountBalance balance = balanceImdg.getSingleObjectByFieldValues(Map.of("account", validatedObject.getAccount(),
+                    "accountType", AccountType.Clrn.getKey()));
+            if (balance == null) {
+                return of(BalanceError.BalanceNotEnough);
+            }
+            if (balance.getFreeBalanceAmount().compareTo(validatedObject.getSum()) < 0) {
+                return of(BalanceError.BalanceNotEnough);
+            }
+            return empty();
+        }
+    }
+    ;
+
+    @Override
+    public String ruleName() {
+        return "Sdf09ValidationRule." + name();
+    }
+}

clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/sdf/SDf01.java

@@ -3,6 +3,7 @@ package ru.clearing.classes.statics.data.sdf;
 import ru.clearing.classes.ConstSerializable;
 import ru.spcex.platform.classes.base.SpcexObjectBase;
 import ru.spcex.platform.classes.base.interfaces.WithAccount;
+import ru.spcex.platform.classes.base.interfaces.WithMarket;
 
 import java.time.Instant;
 
@@ -11,7 +12,7 @@ import java.time.Instant;
  * <p>
  * DB table: S_DF01
  **/
-public class SDf01 extends SpcexObjectBase implements WithAccount {
+public class SDf01 extends SpcexObjectBase implements WithAccount, WithMarket {
     private static final long serialVersionUID = ConstSerializable.serialVersionUID;
 
     private String curr_code;

clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/sdf/SDf09.java

@@ -3,6 +3,7 @@ package ru.clearing.classes.statics.data.sdf;
 import ru.clearing.classes.ConstSerializable;
 import ru.spcex.platform.classes.base.SpcexObjectBase;
 import ru.spcex.platform.classes.base.interfaces.WithAccount;
+import ru.spcex.platform.classes.base.interfaces.WithMarket;
 
 import java.math.BigDecimal;
 import java.time.Instant;
@@ -12,7 +13,7 @@ import java.time.Instant;
  * <p>
  * DB table: S_DF08
  **/
-public class SDf09 extends SpcexObjectBase implements WithAccount {
+public class SDf09 extends SpcexObjectBase implements WithAccount, WithMarket {
     private static final long serialVersionUID = ConstSerializable.serialVersionUID;
 
     private String account;

clearing-parent/classes/src/main/java/ru/clearing/classes/statics/data/sdf/SDf16.java

@@ -3,6 +3,7 @@ package ru.clearing.classes.statics.data.sdf;
 import ru.clearing.classes.ConstSerializable;
 import ru.spcex.platform.classes.base.SpcexObjectBase;
 import ru.spcex.platform.classes.base.interfaces.WithAccount;
+import ru.spcex.platform.classes.base.interfaces.WithMarket;
 
 import java.math.BigDecimal;
 import java.time.Instant;
@@ -12,7 +13,7 @@ import java.time.Instant;
  * <p>
  * DB table: S_DF16
  **/
-public class SDf16 extends SpcexObjectBase implements WithAccount {
+public class SDf16 extends SpcexObjectBase implements WithAccount, WithMarket {
     private static final long serialVersionUID = ConstSerializable.serialVersionUID;
 
     private String account;

platform-parent/platform-classes-base/src/main/java/ru/spcex/platform/classes/base/interfaces/WithMarket.java

@@ -0,0 +1,5 @@
+package ru.spcex.platform.classes.base.interfaces;
+
+public interface WithMarket {
+    String getMarket();
+}

platform-parent/platform-enum/src/main/java/ru/spcex/platform/enumeration/CompanySymbol.java

@@ -0,0 +1,18 @@
+package ru.spcex.platform.enumeration;
+
+import ru.spcex.platform.utils.enumeration.IEnumKey;
+
+public enum CompanySymbol implements IEnumKey {
+    INN("INN");
+
+    private final String key;
+
+    CompanySymbol(String key) {
+        this.key = key;
+    }
+
+    @Override
+    public String getKey() {
+        return key;
+    }
+}