imdg http://git.mfd.msk/mfd/clearing/-/issues/24 Убрал использование мапы Map_Security. Требует перетестирования многого, мёрж отложен до написания тестов

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

@@ -32,34 +32,39 @@ import ru.spcex.clearing.util.security.UserRoleVerification;
 import ru.spcex.clearing.validation.common.rules.DictionaryPresentRule;
 import ru.spcex.clearing.validation.common.rules.FieldRequiredRule;
 import ru.spcex.clearing.validation.common.rules.IdPresentRule;
+import ru.spcex.clearing.validation.common.rules.SecurityPresentRule;
 import ru.spcex.platform.enumeration.ClearingCategory;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.imdg.validation.ImdgValidationContext;
 import ru.spcex.platform.imdg.validation.LogPrefixId;
 import ru.spcex.platform.imdg.validation.rule.PresentById;
+import ru.spcex.platform.utils.collection.Pair;
 import ru.spcex.platform.utils.enumeration.IMessageResolver;
 import ru.spcex.platform.utils.validation.IValidator;
 import ru.spcex.platform.utils.validation.ValidatorImpl;
 
+import java.util.Arrays;
+import java.util.List;
 import java.util.function.BiFunction;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 
 @Configuration
 public class ValidationConfig {
 
     Imdg<Relation> imdgRelation;
     Imdg<Company> imdgCompany;
-    Imdg<FixedIncomeSecurity> fixedIncomeSecurityImdg;
+    List<Pair<String, Imdg<Security>>> imdgSecurities;
-    Imdg<EquitySecurity> equitySecurityImdg;
+    Imdg<MoneyMarketSecurity> imdgMoneyMarketSecurity;
+//    Imdg<FixedIncomeSecurity> fixedIncomeSecurityImdg;
+//    Imdg<EquitySecurity> equitySecurityImdg;
 
     Imdg<CompanySymbols> imdgCompanySymbols;
     Imdg<Registry> imdgRegistry;
     Imdg<Account> imdgAccount;
     Imdg<DepoAccount> imdgDepoAccount;
     Imdg<AccountBalance> imdgAccountBalance;
-    Imdg<Security> imdgSecurity;
-    Imdg<MoneyMarketSecurity> imdgMoneyMarketSecurity;
     Imdg<TradingClearingRegistry> imdgTradingClearingRegistry;
     Imdg<Session> imdgSession;
     Imdg<SectionDictionary> imdgSectionDictionary;
@@ -74,13 +79,13 @@ public class ValidationConfig {
         this.imdgRegistry = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
         this.imdgAccount = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
         this.imdgAccountBalance = imdgProvider.getImdg(IMDGDistributedNames.Map_AccountBalance, AccountBalance.class);
-        this.imdgSecurity = imdgProvider.getImdg(IMDGDistributedNames.Map_Security, Security.class);
+        imdgSecurities = Arrays.stream(SecurityPresentRule.SUB_SECURITY_MAP_NAMES).map(sMapName -> new Pair<>(sMapName, imdgProvider.getImdg(sMapName, Security.class))).collect(Collectors.toList());
         this.imdgTradingClearingRegistry = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
         this.imdgSession = imdgProvider.getImdg(IMDGDistributedNames.Map_Session, Session.class);
         this.imdgSectionDictionary = imdgProvider.getImdg(IMDGDistributedNames.Map_SectionDictionary, SectionDictionary.class);
         this.imdgMoneyMarketSecurity = imdgProvider.getImdg(IMDGDistributedNames.Map_MoneyMarketSecurity, MoneyMarketSecurity.class);
-        this.fixedIncomeSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, FixedIncomeSecurity.class);
+//        this.fixedIncomeSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, FixedIncomeSecurity.class);
-        this.equitySecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_EquitySecurity, EquitySecurity.class);
+//        this.equitySecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_EquitySecurity, EquitySecurity.class);
         this.imdgStatement = imdgProvider.getImdg(IMDGDistributedNames.Map_Statement, Statement.class);
         this.imdgDepoAccount = imdgProvider.getImdg(IMDGDistributedNames.Map_DepoAccount, DepoAccount.class);
         this.imdgInOutDirection = imdgProvider.getImdg(IMDGDistributedNames.Map_InOutDirectionDictionary, InOutDirectionDictionary.class);
@@ -118,12 +123,10 @@ public class ValidationConfig {
         return sTrades -> {
             ImdgValidationContext<STrades> context = new ImdgValidationContext<>();
             context.setValidatedObject(sTrades);
-            context.addImdg(IMDGDistributedNames.Map_Security, imdgSecurity);
+            for (Pair<String, Imdg<Security>> item: imdgSecurities)
+                context.addImdg(item.getFirst(), item.getSecond());
             context.addImdg(IMDGDistributedNames.Map_Company, imdgCompany);
             context.addImdg(IMDGDistributedNames.Map_TradingClearingRegistry, imdgTradingClearingRegistry);
-            context.addImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, fixedIncomeSecurityImdg);
-            context.addImdg(IMDGDistributedNames.Map_MoneyMarketSecurity, imdgMoneyMarketSecurity);
-            context.addImdg(IMDGDistributedNames.Map_EquitySecurity, equitySecurityImdg);
             context.setLogPrefix(LogPrefixId.INSTANCE);
             return new ValidatorImpl<>(context,
                     STradesValidationRule.SecurityPresentFond,
@@ -138,7 +141,8 @@ public class ValidationConfig {
         return sTrades -> {
             ImdgValidationContext<STrades> context = new ImdgValidationContext<>();
             context.setValidatedObject(sTrades);
-            context.addImdg(IMDGDistributedNames.Map_Security, imdgSecurity);
+            for (Pair<String, Imdg<Security>> item: imdgSecurities)
+                context.addImdg(item.getFirst(), item.getSecond());
             context.addImdg(IMDGDistributedNames.Map_MoneyMarketSecurity, imdgMoneyMarketSecurity);
             context.addImdg(IMDGDistributedNames.Map_Company, imdgCompany);
             context.addImdg(IMDGDistributedNames.Map_TradingClearingRegistry, imdgTradingClearingRegistry);
@@ -211,9 +215,8 @@ public class ValidationConfig {
             context.setValidatedObject(sDf21);
             context.addImdg(IMDGDistributedNames.Map_Account, imdgAccount);
             context.addImdg(IMDGDistributedNames.Map_Company, imdgCompany);
-            context.addImdg(IMDGDistributedNames.Map_MoneyMarketSecurity, imdgMoneyMarketSecurity);
+            for (Pair<String, Imdg<Security>> item: imdgSecurities)
-            context.addImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, fixedIncomeSecurityImdg);
+                context.addImdg(item.getFirst(), item.getSecond());
-            context.addImdg(IMDGDistributedNames.Map_EquitySecurity, equitySecurityImdg);
             context.addImdg(IMDGDistributedNames.Map_Registry, imdgRegistry);
             context.setLogPrefix(LogPrefixId.INSTANCE);
             return new ValidatorImpl<>(context,
@@ -250,8 +253,8 @@ public class ValidationConfig {
             context.setValidatedObject(sDf08);
             context.addImdg(IMDGDistributedNames.Map_Account, imdgAccount);
             context.addImdg(IMDGDistributedNames.Map_Company, imdgCompany);
-            context.addImdg(IMDGDistributedNames.Map_EquitySecurity, equitySecurityImdg);
+//            for (Pair<String, Imdg<Security>> item: imdgSecurities)
-            context.addImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, fixedIncomeSecurityImdg);
+//                context.addImdg(item.getFirst(), item.getSecond());
             context.setLogPrefix(LogPrefixId.INSTANCE);
             return new ValidatorImpl<>(context,
                     Sdf08NewValidationRule.AccountPresent, Sdf08NewValidationRule.InstrumentPresent
@@ -292,9 +295,8 @@ public class ValidationConfig {
             context.addImdg(IMDGDistributedNames.Map_Account, imdgAccount);
             context.addImdg(IMDGDistributedNames.Map_DepoAccount, imdgDepoAccount);
             context.addImdg(IMDGDistributedNames.Map_TradingClearingRegistry, imdgTradingClearingRegistry);
-            context.addImdg(IMDGDistributedNames.Map_FixedIncomeSecurity , fixedIncomeSecurityImdg);
+            for (Pair<String, Imdg<Security>> item: imdgSecurities)
-            context.addImdg(IMDGDistributedNames.Map_MoneyMarketSecurity , imdgMoneyMarketSecurity);
+                context.addImdg(item.getFirst(), item.getSecond());
-            context.addImdg(IMDGDistributedNames.Map_EquitySecurity , equitySecurityImdg);
             context.addImdg(IMDGDistributedNames.Map_CompanySymbols, imdgCompanySymbols);
             context.addImdg(IMDGDistributedNames.Map_Company, imdgCompany);
             context.addImdg(IMDGDistributedNames.Map_Registry, imdgRegistry);
@@ -400,9 +402,8 @@ public class ValidationConfig {
             ctx.addImdg(IMDGDistributedNames.Map_Account, imdgAccount);
             ctx.addImdg(IMDGDistributedNames.Map_TradingClearingRegistry, imdgTradingClearingRegistry);
             ctx.addImdg(IMDGDistributedNames.Map_Registry, imdgRegistry);
-            ctx.addImdg(IMDGDistributedNames.Map_FixedIncomeSecurity , fixedIncomeSecurityImdg);
+            for (Pair<String, Imdg<Security>> item: imdgSecurities)
-            ctx.addImdg(IMDGDistributedNames.Map_MoneyMarketSecurity , imdgMoneyMarketSecurity);
+                ctx.addImdg(item.getFirst(), item.getSecond());
-            ctx.addImdg(IMDGDistributedNames.Map_EquitySecurity , equitySecurityImdg);
             return new ValidatorImpl<>(ctx,
                     Sdf20ValidationRule.Fields,
                     Sdf20ValidationRule.AccountPresent,

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/PaymentInstructionBuilder.java

@@ -12,6 +12,7 @@ import ru.spcex.platform.enumeration.InOutDirection;
 import ru.spcex.platform.enumeration.RegistryDesignation;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.imdg.api.predicate.specific.SecuritySelector;
 
 import java.math.BigDecimal;
 import java.time.Instant;
@@ -50,7 +51,7 @@ public class PaymentInstructionBuilder {
         Imdg<Account> accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
         Imdg<Company> companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
         Imdg<CompanySymbols> companySymbolsImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class);
-        Imdg<Security> securityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Security, Security.class);
+        SecuritySelector<Security> securityImdg = new SecuritySelector<>(imdgProvider, Security.class);
 
         Optional<Registry> registryLM = registries.stream()
                 .filter(rgst -> RegistryDesignation.L.equalsByKey(rgst.getRegistryDesignation()))
@@ -87,7 +88,7 @@ public class PaymentInstructionBuilder {
             if (account != null) {
                 paymentInstruction.setCreditLeg_account(account.getAccount());
             }
-            Security security = securityImdg.getSingleObjectByID(registry.getSecurityId());
+            Security security = securityImdg.selectSecurityById(registry.getSecurityId());
             if (security != null) {
                 paymentInstruction.setCreditLeg_securityId(security.getId());
             }
@@ -121,7 +122,7 @@ public class PaymentInstructionBuilder {
                 paymentInstruction.setDebitLeg_account(account.getAccount());
             }
             paymentInstruction.setDebitLeg_amount(amount);
-            Security security = securityImdg.getSingleObjectByID(registry.getSecurityId());
+            Security security = securityImdg.selectSecurityById(registry.getSecurityId());
             if (security != null) {
                 paymentInstruction.setDebitLeg_securityId(security.getId());
             }

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/PaymentInstructionBuilderFinalMkrDeals.java

@@ -37,7 +37,6 @@ public class PaymentInstructionBuilderFinalMkrDeals {
     private Imdg<Account> accountImdg;
     private Imdg<Company> companyImdg;
     private Imdg<CompanySymbols> companySymbolsImdg;
-    private Imdg<Security> securityImdg;
     private Long sessionId;
     private BigDecimal amount;
     protected LocalDate documentNumberResetAt;
@@ -53,7 +52,6 @@ public class PaymentInstructionBuilderFinalMkrDeals {
         this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
         this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
         this.companySymbolsImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class);
-        this.securityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Security, Security.class);
     }
 
     public PaymentInstructionBuilderFinalMkrDeals lm_t(Registry lm_t) {

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/RegistryBuilder.java

@@ -33,7 +33,6 @@ public class RegistryBuilder {
 
     private final Imdg<ClearingAccount> clearingAccountImdg;
     private final Imdg<TradingClearingRegistry> tradingClearingRegistryImdg;
-    private final Imdg<Security> securityImdg;
     private final Imdg<FixedIncomeSecurity> fixedIncomeSecurityImdg;
     private final Imdg<MoneyMarketSecurity> moneyMarketSecurityImdg;
     private final Imdg<EquitySecurity> equitySecurityImdg;
@@ -48,7 +47,6 @@ public class RegistryBuilder {
         this.imdgProvider = imdgProvider;
         this.clearingAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class);
         this.tradingClearingRegistryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
-        this.securityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Security, Security.class);
         this.fixedIncomeSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, FixedIncomeSecurity.class);
         this.moneyMarketSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_MoneyMarketSecurity, MoneyMarketSecurity.class);
         this.equitySecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_EquitySecurity, EquitySecurity.class);

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/builder/RegistrySecurityBuilder.java

@@ -33,7 +33,6 @@ public class RegistrySecurityBuilder {
 
     private final Imdg<ClearingAccount> clearingAccountImdg;
     private final Imdg<TradingClearingRegistry> tradingClearingRegistryImdg;
-    private final Imdg<Security> securityImdg;
     private final Imdg<FixedIncomeSecurity> fixedIncomeSecurityImdg;
     private final Imdg<MoneyMarketSecurity> moneyMarketSecurityImdg;
     private final Imdg<EquitySecurity> equitySecurityImdg;
@@ -48,7 +47,6 @@ public class RegistrySecurityBuilder {
         this.imdgProvider = imdgProvider;
         this.clearingAccountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_ClearingAccount, ClearingAccount.class);
         this.tradingClearingRegistryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_TradingClearingRegistry, TradingClearingRegistry.class);
-        this.securityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Security, Security.class);
         this.fixedIncomeSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, FixedIncomeSecurity.class);
         this.moneyMarketSecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_MoneyMarketSecurity, MoneyMarketSecurity.class);
         this.equitySecurityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_EquitySecurity, EquitySecurity.class);

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf01Executor.java

@@ -58,7 +58,6 @@ public class Sdf01Executor extends AbstractExecutor<SDf01> {
     private final ImdgProvider imdgProvider;
     private final Imdg<ClearingAccount> clearingAccountImdg;
     private final Imdg<TradingClearingRegistry> tradingClearingRegistryImdg;
-    private final Imdg<Security> securityImdg;
     private final Imdg<Currency> currencyImdg;
     private final Imdg<SDf01> sdf01Imdg;
     private final Imdg<SDf02> sdf02Imdg;
@@ -78,7 +77,6 @@ public class Sdf01Executor extends AbstractExecutor<SDf01> {
         this.sDf01Validator = sDf01Validator;
         this.imdgProvider = imdgProvider;
         this.messageResolver = messageResolver;
-        this.securityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Security, Security.class);
         this.sdf02Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf02, SDf02.class);
         this.sdf01Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf01, SDf01.class);
         this.kafkaSender = kafkaSender;

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf21Executor.java

@@ -64,7 +64,6 @@ public class Sdf21Executor extends AbstractExecutor<SDf21> {
     private final Imdg<TradingClearingRegistry> tradingClearingRegistryImdg;
     private final Imdg<Account> accountImdg;
     private final Imdg<Company> companyImdg;
-    private final Imdg<Security> securityImdg;
     private final Imdg<Currency> currencyImdg;
     private final SecuritySelector<Security> scrSlct;
     private final AnltSearcher anltSearcher;
@@ -91,7 +90,6 @@ public class Sdf21Executor extends AbstractExecutor<SDf21> {
         this.scrSlct = new SecuritySelector<>(imdgProvider, Security.class);
         this.anltSearcher = anltSearcher;
         this.messageResolver = messageResolver;
-        this.securityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Security, Security.class);
     }
 
     //todo доделать контроль sdf01 и sdf57

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/service/executors/Sdf57Executor.java

@@ -77,7 +77,6 @@ public class Sdf57Executor extends AbstractExecutor<SDf57> {
     private final Imdg<TradingClearingRegistry> tradingClearingRegistryImdg;
     private final Imdg<Account> accountImdg;
     private final Imdg<Company> companyImdg;
-    private final Imdg<Security> securityImdg;
     private final Imdg<Currency> currencyImdg;
     private final AnltSearcher anltSearcher;
     private final IMessageResolver messageResolver;
@@ -106,7 +105,6 @@ public class Sdf57Executor extends AbstractExecutor<SDf57> {
         this.errorResolver = errorResolver;
         this.anltSearcher = anltSearcher;
         this.messageResolver = messageResolver;
-        this.securityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Security, Security.class);
         this.dmiService = dmiService;
         this.timeService = timeService;
         this.kafka = kafka;

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/FormingPaymentInstruction.java

@@ -31,6 +31,7 @@ import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
 import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
 import ru.spcex.platform.imdg.api.predicate.specific.RegistryCodeSqlBuilder;
+import ru.spcex.platform.imdg.api.predicate.specific.SecuritySelector;
 import ru.spcex.platform.utils.enumeration.IEnumKey;
 import ru.spcex.platform.utils.enumeration.IMessageResolver;
 import ru.spcex.platform.utils.enumeration.SimpleMessageResolver;
@@ -53,7 +54,7 @@ public class FormingPaymentInstruction implements ISessionStage {
     private ImdgId idGenerator;
     private Imdg<Registry> registryImdg;
     private Imdg<PaymentInstruction> paymentInstructionImdg;
-    private Imdg<Security> securityImdg;
+    private SecuritySelector<Security> securitySelector;
     private Imdg<Account> accountImdg;
     private Imdg<Company> companyImdg;
     private Imdg<SDf03> sDf03Imdg;
@@ -69,7 +70,7 @@ public class FormingPaymentInstruction implements ISessionStage {
         this.imdgProvider = imdgProvider;
         this.idGenerator = imdgProvider.getImdgIdGenerator();
         this.registryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
-        this.securityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Security, Security.class);
+        this.securitySelector = new SecuritySelector<>(imdgProvider, Security.class);
         this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
         this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
         this.sDf03Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf03, SDf03.class);
@@ -278,7 +279,7 @@ public class FormingPaymentInstruction implements ISessionStage {
         List<SDf03> sDf03Created = new ArrayList<>();
         List<SDf12> sDf12Created = new ArrayList<>();
         for (PaymentInstruction paymentInstruction : formedPaymentInstructions) {
-            Security security = securityImdg.getSingleObjectByID(paymentInstruction.getCreditLeg_securityId());
+            Security security = securitySelector.selectSecurityById(paymentInstruction.getCreditLeg_securityId());
             Account account = accountImdg.getSingleObjectByID(paymentInstruction.getCreditLeg_accountId());
             if (InstrumentType.CRNC.equalsByKey(security.getInstrumentType()) &&
                     List.of(AccountType.Corr, AccountType.Clrn, AccountType.Info).contains(IEnumKey.getEnumByKey(AccountType.class, account.getAccountType()))) {

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/FormingPaymentInstructionAssets.java

@@ -57,7 +57,6 @@ public class FormingPaymentInstructionAssets implements ISessionStage {
     private ImdgId idGenerator;
     private Imdg<Registry> registryImdg;
     private Imdg<PaymentInstruction> paymentInstructionImdg;
-    private Imdg<Security> securityImdg;
     private Imdg<Account> accountImdg;
     private Imdg<Company> companyImdg;
     private Imdg<SDf03> sDf03Imdg;
@@ -77,7 +76,6 @@ public class FormingPaymentInstructionAssets implements ISessionStage {
         this.imdgProvider = imdgProvider;
         this.idGenerator = imdgProvider.getImdgIdGenerator();
         this.registryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
-        this.securityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Security, Security.class);
         this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
         this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
         this.sDf03Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf03, SDf03.class);
@@ -316,7 +314,7 @@ public class FormingPaymentInstructionAssets implements ISessionStage {
         List<SDf12> sDf12Created = new ArrayList<>();
         for (PaymentInstruction paymentInstruction : formedPaymentInstructions) {
             Account account = accountImdg.getSingleObjectByID(paymentInstruction.getCreditLeg_accountId());
-            Security security = securityImdg.getSingleObjectByID(paymentInstruction.getCreditLeg_securityId());
+            Security security = securitySelector.selectSecurityById(paymentInstruction.getCreditLeg_securityId());
             if (List.of(AccountType.Corr, AccountType.Clrn, AccountType.Tran, AccountType.Anlt, AccountType.Info)
                     .contains(IEnumKey.getEnumByKey(AccountType.class, account.getAccountType()))) {
                 //если info подставить anlt (единственный счет в системе)

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/FormingPaymentInstructionDealsFinalMkr.java

@@ -33,6 +33,7 @@ import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
 import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
 import ru.spcex.platform.imdg.api.predicate.specific.RegistryCodeSqlBuilder;
+import ru.spcex.platform.imdg.api.predicate.specific.SecuritySelector;
 import ru.spcex.platform.utils.collection.Pair;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
 import ru.spcex.platform.utils.enumeration.IEnumKey;
@@ -59,7 +60,7 @@ public class FormingPaymentInstructionDealsFinalMkr implements ISessionStage {
     private ImdgId idGenerator;
     private Imdg<Registry> registryImdg;
     private Imdg<PaymentInstruction> paymentInstructionImdg;
-    private Imdg<Security> securityImdg;
+    private SecuritySelector<Security> securitySelector;
     private Imdg<Account> accountImdg;
     private Imdg<Company> companyImdg;
     private Imdg<SDf03> sDf03Imdg;
@@ -77,7 +78,7 @@ public class FormingPaymentInstructionDealsFinalMkr implements ISessionStage {
         this.imdgProvider = imdgProvider;
         this.idGenerator = imdgProvider.getImdgIdGenerator();
         this.registryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
-        this.securityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Security, Security.class);
+        this.securitySelector = new SecuritySelector<>(imdgProvider, Security.class);
         this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
         this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
         this.sDf03Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf03, SDf03.class);
@@ -237,7 +238,7 @@ public class FormingPaymentInstructionDealsFinalMkr implements ISessionStage {
         List<SDf12> sDf12Created = new ArrayList<>();
         for (PaymentInstruction paymentInstruction : formedPaymentInstructions) {
             Account account = accountImdg.getSingleObjectByID(paymentInstruction.getCreditLeg_accountId());
-            Security security = securityImdg.getSingleObjectByID(paymentInstruction.getCreditLeg_securityId());
+            Security security = securitySelector.selectSecurityById(paymentInstruction.getCreditLeg_securityId());
             if (List.of(AccountType.Corr, AccountType.Clrn, AccountType.Tran, AccountType.Anlt, AccountType.Info)
                     .contains(IEnumKey.getEnumByKey(AccountType.class, account.getAccountType()))) {
                 //если info подставить anlt (единственный счет в системе)

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/FormingPaymentInstructionDepositReturn.java

@@ -59,7 +59,6 @@ public class FormingPaymentInstructionDepositReturn implements ISessionStage {
     private final ImdgId idGenerator;
     private final Imdg<Registry> registryImdg;
     private final Imdg<PaymentInstruction> paymentInstructionImdg;
-    private final Imdg<Security> securityImdg;
     private final Imdg<Account> accountImdg;
     private final Imdg<Company> companyImdg;
     private final Imdg<SDf03> sDf03Imdg;
@@ -75,7 +74,6 @@ public class FormingPaymentInstructionDepositReturn implements ISessionStage {
         this.imdgProvider = imdgProvider;
         this.idGenerator = imdgProvider.getImdgIdGenerator();
         this.registryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
-        this.securityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Security, Security.class);
         this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
         this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
         this.sDf03Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf03, SDf03.class);

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/FormingPaymentInstructionReturnMkr.java

@@ -34,6 +34,7 @@ import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
 import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
 import ru.spcex.platform.imdg.api.predicate.specific.RegistryCodeSqlBuilder;
+import ru.spcex.platform.imdg.api.predicate.specific.SecuritySelector;
 import ru.spcex.platform.utils.collection.Pair;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
 import ru.spcex.platform.utils.enumeration.IEnumKey;
@@ -57,7 +58,7 @@ public class FormingPaymentInstructionReturnMkr implements ISessionStage {
     private ImdgId idGenerator;
     private Imdg<Registry> registryImdg;
     private Imdg<PaymentInstruction> paymentInstructionImdg;
-    private Imdg<Security> securityImdg;
+    private SecuritySelector<Security> securitySelector;
     private Imdg<Account> accountImdg;
     private Imdg<Company> companyImdg;
     private Imdg<SDf03> sDf03Imdg;
@@ -72,7 +73,7 @@ public class FormingPaymentInstructionReturnMkr implements ISessionStage {
         this.imdgProvider = imdgProvider;
         this.idGenerator = imdgProvider.getImdgIdGenerator();
         this.registryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
-        this.securityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Security, Security.class);
+        this.securitySelector = new SecuritySelector<>(imdgProvider, Security.class);
         this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
         this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
         this.sDf03Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf03, SDf03.class);
@@ -228,7 +229,7 @@ public class FormingPaymentInstructionReturnMkr implements ISessionStage {
         List<SDf03> sDf03Created = new ArrayList<>();
         List<SDf12> sDf12Created = new ArrayList<>();
         for (PaymentInstruction paymentInstruction : formedPaymentInstructions) {
-            Security security = securityImdg.getSingleObjectByID(paymentInstruction.getCreditLeg_securityId());
+            Security security = securitySelector.selectSecurityById(paymentInstruction.getCreditLeg_securityId());
             Account account = accountImdg.getSingleObjectByID(paymentInstruction.getCreditLeg_accountId());
             if (InstrumentType.CRNC.equalsByKey(security.getInstrumentType()) &&
                     List.of(AccountType.Corr, AccountType.Clrn).contains(IEnumKey.getEnumByKey(AccountType.class, account.getAccountType()))) {

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/FormingPaymentInstructionSecondaryT0.java

@@ -60,7 +60,6 @@ public class FormingPaymentInstructionSecondaryT0 implements ISessionStage {
     private ImdgId idGenerator;
     private Imdg<Registry> registryImdg;
     private Imdg<PaymentInstruction> paymentInstructionImdg;
-    private Imdg<Security> securityImdg;
     private Imdg<Account> accountImdg;
     private Imdg<Company> companyImdg;
     private Imdg<SDf03> sDf03Imdg;
@@ -78,7 +77,6 @@ public class FormingPaymentInstructionSecondaryT0 implements ISessionStage {
         this.imdgProvider = imdgProvider;
         this.idGenerator = imdgProvider.getImdgIdGenerator();
         this.registryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
-        this.securityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Security, Security.class);
         this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
         this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
         this.sDf03Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf03, SDf03.class);
@@ -233,7 +231,7 @@ public class FormingPaymentInstructionSecondaryT0 implements ISessionStage {
         List<SDf12> sDf12Created = new ArrayList<>();
         for (PaymentInstruction paymentInstruction : formedPaymentInstructions) {
             Account account = accountImdg.getSingleObjectByID(paymentInstruction.getCreditLeg_accountId());
-            Security security = securityImdg.getSingleObjectByID(paymentInstruction.getCreditLeg_securityId());
+            Security security = securitySelector.selectSecurityById(paymentInstruction.getCreditLeg_securityId());
             if (List.of(AccountType.Corr, AccountType.Clrn, AccountType.Tran, AccountType.Anlt, AccountType.Info)
                     .contains(IEnumKey.getEnumByKey(AccountType.class, account.getAccountType()))) {
                 sDf03Created.add(sdf03Creator.create(paymentInstruction));

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/FormingPaymentInstructionSecurities.java

@@ -62,7 +62,6 @@ public class FormingPaymentInstructionSecurities implements ISessionStage {
     private ImdgId idGenerator;
     private Imdg<Registry> registryImdg;
     private Imdg<PaymentInstruction> paymentInstructionImdg;
-    private Imdg<Security> securityImdg;
     private Imdg<Account> accountImdg;
     private Imdg<Company> companyImdg;
     private Imdg<SDf03> sDf03Imdg;
@@ -81,7 +80,6 @@ public class FormingPaymentInstructionSecurities implements ISessionStage {
         this.imdgProvider = imdgProvider;
         this.idGenerator = imdgProvider.getImdgIdGenerator();
         this.registryImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
-        this.securityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Security, Security.class);
         this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
         this.companyImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
         this.sDf03Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf03, SDf03.class);
@@ -331,7 +329,7 @@ public class FormingPaymentInstructionSecurities implements ISessionStage {
         List<SDf12> sDf12Created = new ArrayList<>();
         for (PaymentInstruction paymentInstruction : formedPaymentInstructions) {
             Account account = accountImdg.getSingleObjectByID(paymentInstruction.getCreditLeg_accountId());
-            Security security = securityImdg.getSingleObjectByID(paymentInstruction.getCreditLeg_securityId());
+            Security security = securitySelector.selectSecurityById(paymentInstruction.getCreditLeg_securityId());
             if (List.of(AccountType.Corr, AccountType.Clrn, AccountType.Tran, AccountType.Anlt, AccountType.Info)
                     .contains(IEnumKey.getEnumByKey(AccountType.class, account.getAccountType()))) {
                 sDf03Created.add(sdf03Creator.create(paymentInstruction));

clearing-parent/clearing-service/src/main/java/ru/spcex/clearing/session/stage/impl/Sdf03And12Sender.java

@@ -21,6 +21,7 @@ import ru.spcex.platform.enumeration.InstrumentType;
 import ru.spcex.platform.enumeration.SdfTable;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.imdg.api.predicate.specific.SecuritySelector;
 import ru.spcex.platform.utils.enumeration.IEnumKey;
 
 import java.util.ArrayList;
@@ -31,7 +32,7 @@ import java.util.List;
 public class Sdf03And12Sender {
     private final Logger log = LoggerFactory.getLogger(getClass());
     private final ImdgProvider imdgProvider;
-    private final Imdg<Security> securityImdg;
+    private final SecuritySelector<Security> securitySelector;
     private final Imdg<Account> accountImdg;
     private final Imdg<SDf03> sDf03Imdg;
     private final Imdg<SDf12> sDf12Imdg;
@@ -43,7 +44,7 @@ public class Sdf03And12Sender {
                                           KafkaSender kafkaSender, Sdf03Creator sdf03Creator, Sdf12Creator sdf12Creator, RegistryManager rgsMng) {
         this.kafkaSender = kafkaSender;
         this.imdgProvider = imdgProvider;
-        this.securityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Security, Security.class);
+        this.securitySelector = new SecuritySelector<>(imdgProvider, Security.class);
         this.accountImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
         this.sDf03Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf03, SDf03.class);
         this.sDf12Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf12, SDf12.class);
@@ -57,7 +58,7 @@ public class Sdf03And12Sender {
         List<SDf12> sDf12Created = new ArrayList<>();
         for (PaymentInstruction paymentInstruction : formedPaymentInstructions) {
             Account account = accountImdg.getSingleObjectByID(paymentInstruction.getCreditLeg_accountId());
-            Security security = securityImdg.getSingleObjectByID(paymentInstruction.getCreditLeg_securityId());
+            Security security = securitySelector.selectSecurityById(paymentInstruction.getCreditLeg_securityId());
             if (List.of(AccountType.Corr, AccountType.Clrn, AccountType.Tran, AccountType.Anlt, AccountType.Info)
                     .contains(IEnumKey.getEnumByKey(AccountType.class, account.getAccountType()))) {
                 sDf03Created.add(sdf03Creator.create(paymentInstruction));

clearing-parent/clearing-service/src/test/java/ru/spcex/clearing/service/execution/ExecutionDepositComponentTest.java

@@ -46,7 +46,7 @@ class ExecutionDepositComponentTest extends AbstractClearingTest {
         executionDepositComponent.resetTradingDay();
         this.todayInstant = executionDepositComponent.tradingDay;
         this.sTradeImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_STrades, STrades.class);
-        this.securityImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_Security, Security.class);
+        this.securityImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, Security.class);
         this.executionDepositImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_ExecutionDeposit, ExecutionDeposit.class);
         this.companyImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_Company, Company.class);
         this.accountImdg = hazelcastServiceTest.getImdg(IMDGDistributedNames.Map_Account, Account.class);

clearing-parent/clearing-validation/src/main/java/ru/spcex/clearing/validation/common/rules/SecurityPresentRule.java

@@ -0,0 +1,116 @@
+package ru.spcex.clearing.validation.common.rules;
+
+import ru.clearing.classes.statics.data.instrument.issue.EquitySecurity;
+import ru.clearing.classes.statics.data.instrument.issue.FixedIncomeSecurity;
+import ru.clearing.classes.statics.data.security.MoneyMarketSecurity;
+import ru.clearing.classes.statics.data.security.Security;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.platform.imdg.api.predicate.specific.SecuritySelector;
+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.Objects;
+import java.util.Optional;
+import java.util.function.Function;
+
+/**
+ * Проверка наличия связанного Security по Id в базе
+ *
+ * @param <R> Класс проверяемого объекта
+ */
+public record SecurityPresentRule<R>(
+        String fieldName,
+        Function<R, Long> idGetter,
+        IErrorEnumId errorEmptyRequiredValue,
+        IErrorEnumId errorIdNotPresent,
+        boolean required,
+        Function<Security, IErrorEnumId>[] additionalChecks
+) implements IValidationRule<ImdgValidationContext<R>> {
+    public static String[] SUB_SECURITY_MAP_NAMES = {
+            IMDGDistributedNames.Map_FixedIncomeSecurity,
+            IMDGDistributedNames.Map_MoneyMarketSecurity,
+            IMDGDistributedNames.Map_EquitySecurity
+    };
+
+    /**
+     * @param fieldName               Название поля, содержащего Id
+     * @param idGetter                Метод получения Id
+     * @param errorEmptyRequiredValue Ошибка, которая будет возвращена, если поле пустое
+     * @param errorIdNotPresent       Ошибка, которая будет возвращена, если Id не найден
+     * @param required                Флаг обязательности
+     * @param additionalChecks        Дополнительные проверки, которые можно провести со связанным объектом
+     * @param <R>                     Класс проверяемого объекта
+     */
+    @SafeVarargs
+    public static <R> SecurityPresentRule<R> instance(String fieldName,
+                                                                                    Function<R, Long> idGetter,
+                                                                                    IErrorEnumId errorEmptyRequiredValue,
+                                                                                    IErrorEnumId errorIdNotPresent,
+                                                                                    boolean required,
+                                                                                    Function<Security, IErrorEnumId>... additionalChecks) {
+        if (required)
+            Objects.requireNonNull(errorEmptyRequiredValue, "errorEmptyRequiredValue");
+        Objects.requireNonNull(errorIdNotPresent, "errorIdNotPresent");
+        return new SecurityPresentRule<>(fieldName,
+                idGetter,
+                errorEmptyRequiredValue,
+                errorIdNotPresent,
+                required,
+                additionalChecks);
+    }
+
+    /**
+     * @param fieldName               Название поля, содержащего Id
+     * @param idGetter                Метод получения Id
+     * @param errorEmptyRequiredValue Ошибка, которая будет возвращена, если поле пустое
+     * @param errorIdNotPresent       Ошибка, которая будет возвращена, если Id не найден
+     * @param additionalChecks        Дополнительные проверки, которые можно провести со связанным объектом
+     * @param <R>                     Класс проверяемого объекта
+     * @param <V>                     Класс связанного объекта
+     */
+    @SafeVarargs
+    public static <R, V extends Security> SecurityPresentRule<R> instance(String fieldName,
+                                                                                    Function<R, Long> idGetter,
+                                                                                    IErrorEnumId errorEmptyRequiredValue,
+                                                                                    IErrorEnumId errorIdNotPresent,
+                                                                                    Function<Security, IErrorEnumId>... additionalChecks) {
+        Objects.requireNonNull(errorEmptyRequiredValue, "errorEmptyRequiredValue");
+        Objects.requireNonNull(errorIdNotPresent, "errorIdNotPresent");
+        return new SecurityPresentRule<>(fieldName,
+                idGetter,
+                errorEmptyRequiredValue,
+                errorIdNotPresent,
+                true,
+                additionalChecks);
+    }
+
+    @Override
+    public Optional<EnumMessage> validate(ImdgValidationContext<R> context) {
+        R validatedObject = context.getValidatedObject();
+        Long id = idGetter.apply(validatedObject);
+        if (id == null) return required ? of(errorEmptyRequiredValue, fieldName) : empty();
+        SecuritySelector<Security> securitySelector = new SecuritySelector<Security>(
+                context.obtainMap(IMDGDistributedNames.Map_FixedIncomeSecurity, Security.class),
+                context.obtainMap(IMDGDistributedNames.Map_MoneyMarketSecurity, Security.class),
+                context.obtainMap(IMDGDistributedNames.Map_EquitySecurity, Security.class)
+        ); // see SUB_SECURITY_MAP_NAMES - поддерживать в актуальном состоянии.
+
+        Security fromMap = securitySelector.selectSecurityById(id);
+        if (fromMap == null) {
+            return of(errorIdNotPresent, id, fieldName);
+        }
+        for (Function<Security, IErrorEnumId> additionalCheck : additionalChecks) {
+            IErrorEnumId validationError = additionalCheck.apply(fromMap);
+            if (validationError != null)
+                return of(validationError, id, fieldName);
+        }
+        return empty();
+    }
+
+    @Override
+    public String ruleName() {
+        return getClass().getSimpleName() + "{" + fieldName + "}";
+    }
+}

clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/businessobject/SecurityMapStore.java

@@ -9,6 +9,7 @@ import ru.spcex.platform.utils.time.TimeUtil;
 
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.util.Map;
 
 // Abstract table: ASecurityHistoryMapStore
 @Component
@@ -72,4 +73,9 @@ public class SecurityMapStore extends TemplateMapStore<Security> {
         return args;
     }
 
+    @Override
+    public void store(Map<Long, Security> map) {
+        // do not store, read only (deprecated map)
+    }
+
 }

clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/AdmittedLiabilitiesRegisterService.java

@@ -23,6 +23,7 @@ import ru.spcex.platform.enumeration.RegistryStatus;
 import ru.spcex.platform.enumeration.RegistryUnit;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.imdg.api.predicate.specific.SecuritySelector;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
 import ru.spcex.platform.utils.validation.IValidator;
 
@@ -42,7 +43,7 @@ public class AdmittedLiabilitiesRegisterService extends QueueConsumer implements
     private final Imdg<AdmittedLiabilitiesRegister> admittedLiabilitiesRegisterMap;
     private final Imdg<Registry> registryMap;
     private final Imdg<Company> companyMap;
-    private final Imdg<Security> securityMap;
+    private final SecuritySelector<Security> securitySelector;
     private final Function<Map<String, ?>, IValidator> fieldValuesValidator;
 
     @Autowired
@@ -54,7 +55,7 @@ public class AdmittedLiabilitiesRegisterService extends QueueConsumer implements
         this.admittedLiabilitiesRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_AdmittedLiabilitiesRegister, AdmittedLiabilitiesRegister.class);
         this.registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
         this.companyMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
-        this.securityMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Security, Security.class);
+        this.securitySelector = new SecuritySelector<>(imdgProvider, Security.class);
         this.fieldValuesValidator = fieldValuesValidator;
     }
 
@@ -90,7 +91,7 @@ public class AdmittedLiabilitiesRegisterService extends QueueConsumer implements
         log.trace("Started generating AdmittedLiabilitiesRegister entity...");
         AdmittedLiabilitiesRegister admittedLiabilitiesRegister = new AdmittedLiabilitiesRegister();
         Company company = companyMap.getFirstObjectByFieldValues(Map.of("id", 1L));
-        Security security = securityMap.getFirstObjectByFieldValues(Map.of("id", registry.getSecurityId()));
+        Security security = securitySelector.selectSecurityById(registry.getSecurityId());
         String securitySymbol = security != null ? security.getSecuritySymbol() : null;
         String securityFullName = security != null ? security.getShortName() : null;
         String companyFullName = security != null ? company.getFullName() : null;

clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/CoveredLiabilitiesRegisterService.java

@@ -23,6 +23,7 @@ import ru.spcex.platform.enumeration.RegistryStatus;
 import ru.spcex.platform.enumeration.RegistryUnit;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.imdg.api.predicate.specific.SecuritySelector;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
 import ru.spcex.platform.utils.validation.IValidator;
 
@@ -42,7 +43,7 @@ public class CoveredLiabilitiesRegisterService extends QueueConsumer implements
     private final Imdg<CoveredLiabilitiesRegister> coveredLiabilitiesRegisterMap;
     private final Imdg<Registry> registryMap;
     private final Imdg<Company> companyMap;
-    private final Imdg<Security> securityMap;
+    private final SecuritySelector<Security> securitySelector;
     private final Function<Map<String, ?>, IValidator> fieldValuesValidator;
 
     @Autowired
@@ -54,7 +55,7 @@ public class CoveredLiabilitiesRegisterService extends QueueConsumer implements
         this.coveredLiabilitiesRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_CoveredLiabilitiesRegister, CoveredLiabilitiesRegister.class);
         this.registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
         this.companyMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
-        this.securityMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Security, Security.class);
+        this.securitySelector = new SecuritySelector<>(imdgProvider, Security.class);
         this.fieldValuesValidator = fieldValuesValidator;
     }
 
@@ -91,7 +92,7 @@ public class CoveredLiabilitiesRegisterService extends QueueConsumer implements
         log.trace("insert CoveredLiabilitiesRegister in map...");
         CoveredLiabilitiesRegister coveredLiabilitiesRegister = new CoveredLiabilitiesRegister();
         Company company = companyMap.getFirstObjectByFieldValues(Map.of("id", 1L));
-        Security security = securityMap.getFirstObjectByFieldValues(Map.of("id", registry.getSecurityId()));
+        Security security = securitySelector.selectSecurityById(registry.getSecurityId());
         String securitySymbol = security != null ? security.getSecuritySymbol() : null;
         String securityFullName = security != null ? security.getShortName() : null;
         String companyFullName = security != null ? company.getFullName() : null;

clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/config/validation/PlannerTemplateValidationConfig.java

@@ -16,6 +16,7 @@ import ru.spcex.clearing.scheduler.error.ValidationError;
 import ru.spcex.clearing.scheduler.validation.rules.common.DictionaryPresentRule;
 import ru.spcex.clearing.scheduler.validation.rules.common.EnumPresentRule;
 import ru.spcex.clearing.scheduler.validation.rules.common.IdPresentRule;
+import ru.spcex.clearing.validation.common.rules.SecurityPresentRule;
 import ru.spcex.platform.classes.base.SpcexObjectBase;
 import ru.spcex.platform.enumeration.Section;
 import ru.spcex.platform.enumeration.WorkflowStatus;
@@ -41,7 +42,8 @@ public class PlannerTemplateValidationConfig {
             addImdg.accept(IMDGDistributedNames.Map_TaskStatusDictionary);
             addImdg.accept(IMDGDistributedNames.Map_SessionTypeDictionary);
             addImdg.accept(IMDGDistributedNames.Map_Company);
-            addImdg.accept(IMDGDistributedNames.Map_Security);
+            for (String securityMap: SecurityPresentRule.SUB_SECURITY_MAP_NAMES)
+                addImdg.accept(securityMap);
             return new ValidatorImpl<>(context,
                     DictionaryPresentRule.instance("task",
                             PlannerTemplateNewRequest::getTask,
@@ -71,10 +73,9 @@ public class PlannerTemplateValidationConfig {
                             ValidationError.CompanyNotFound,
                             false,
                             company -> WorkflowStatus.Active.equalsByKey(company.getWorkflowStatus()) ? null : ValidationError.CompanyNotActive),
-                    IdPresentRule.instance("securityId",
+                    SecurityPresentRule.instance("securityId",
                             PlannerTemplateNewRequest::getSecurityId,
-                            IMDGDistributedNames.Map_Security,
+                            ValidationError.EmptyRequiredValue,
-                            Security.class,
                             ValidationError.SecurityNotFound,
                             false,
                             security -> WorkflowStatus.Active.equalsByKey(security.getWorkflowStatus()) ? null : ValidationError.SecurityNotActive)
@@ -93,7 +94,8 @@ public class PlannerTemplateValidationConfig {
             addImdg.accept(IMDGDistributedNames.Map_SessionTypeDictionary);
             addImdg.accept(IMDGDistributedNames.Map_PlannerTemplate);
             addImdg.accept(IMDGDistributedNames.Map_Company);
-            addImdg.accept(IMDGDistributedNames.Map_Security);
+            for (String securityMap: SecurityPresentRule.SUB_SECURITY_MAP_NAMES)
+                addImdg.accept(securityMap);
             return new ValidatorImpl<>(context,
                     IdPresentRule.instance("id",
                             PlannerTemplateUpdateRequest::getId,
@@ -130,10 +132,9 @@ public class PlannerTemplateValidationConfig {
                             ValidationError.CompanyNotFound,
                             false,
                             company -> WorkflowStatus.Active.equalsByKey(company.getWorkflowStatus()) ? null : ValidationError.CompanyNotActive),
-                    IdPresentRule.instance("securityId",
+                    SecurityPresentRule.instance("securityId",
                             PlannerTemplateUpdateRequest::getSecurityId,
-                            IMDGDistributedNames.Map_Security,
+                            ValidationError.EmptyRequiredValue,
-                            Security.class,
                             ValidationError.SecurityNotFound,
                             false,
                             security -> WorkflowStatus.Active.equalsByKey(security.getWorkflowStatus()) ? null : ValidationError.SecurityNotActive)

clearing-parent/scheduler-service/src/main/java/ru/spcex/clearing/scheduler/config/validation/PlannerValidationConfig.java

@@ -14,6 +14,7 @@ import ru.spcex.clearing.platform.messaging.domain.cud.schedule.PlannerNewReques
 import ru.spcex.clearing.platform.messaging.domain.cud.schedule.PlannerUpdateRequest;
 import ru.spcex.clearing.scheduler.error.ValidationError;
 import ru.spcex.clearing.scheduler.validation.rules.common.*;
+import ru.spcex.clearing.validation.common.rules.SecurityPresentRule;
 import ru.spcex.platform.classes.base.SpcexObjectBase;
 import ru.spcex.platform.enumeration.Section;
 import ru.spcex.platform.enumeration.WorkflowStatus;
@@ -22,7 +23,6 @@ import ru.spcex.platform.imdg.validation.ImdgValidationContext;
 import ru.spcex.platform.utils.validation.IValidator;
 import ru.spcex.platform.utils.validation.ValidatorImpl;
 
-import java.time.LocalDate;
 import java.util.Map;
 import java.util.function.Consumer;
 import java.util.function.Function;
@@ -40,7 +40,8 @@ public class PlannerValidationConfig {
             addImdg.accept(IMDGDistributedNames.Map_SessionTypeDictionary);
             addImdg.accept(IMDGDistributedNames.Map_TaskStatusDictionary);
             addImdg.accept(IMDGDistributedNames.Map_Company);
-            addImdg.accept(IMDGDistributedNames.Map_Security);
+            for (String securityMap: SecurityPresentRule.SUB_SECURITY_MAP_NAMES)
+                addImdg.accept(securityMap);
             return new ValidatorImpl<>(context,
                     DictionaryPresentRule.instance("task",
                             PlannerNewRequest::getTask,
@@ -72,10 +73,9 @@ public class PlannerValidationConfig {
                             ValidationError.CompanyNotFound,
                             false,
                             company -> WorkflowStatus.Active.equalsByKey(company.getWorkflowStatus()) ? null : ValidationError.CompanyNotActive),
-                    IdPresentRule.instance("securityId",
+                    SecurityPresentRule.instance("securityId",
                             PlannerNewRequest::getSecurityId,
-                            IMDGDistributedNames.Map_Security,
+                            ValidationError.EmptyRequiredValue,
-                            Security.class,
                             ValidationError.SecurityNotFound,
                             false,
                             security -> WorkflowStatus.Active.equalsByKey(security.getWorkflowStatus()) ? null : ValidationError.SecurityNotActive)
@@ -94,7 +94,8 @@ public class PlannerValidationConfig {
             addImdg.accept(IMDGDistributedNames.Map_Planner);
             addImdg.accept(IMDGDistributedNames.Map_TaskStatusDictionary);
             addImdg.accept(IMDGDistributedNames.Map_Company);
-            addImdg.accept(IMDGDistributedNames.Map_Security);
+            for (String securityMap: SecurityPresentRule.SUB_SECURITY_MAP_NAMES)
+                addImdg.accept(securityMap);
             return new ValidatorImpl<>(context,
                     IdPresentRule.instance("id",
                             PlannerUpdateRequest::getId,
@@ -134,10 +135,9 @@ public class PlannerValidationConfig {
                             ValidationError.CompanyNotFound,
                             false,
                             company -> WorkflowStatus.Active.equalsByKey(company.getWorkflowStatus()) ? null : ValidationError.CompanyNotActive),
-                    IdPresentRule.instance("securityId",
+                    SecurityPresentRule.instance("securityId",
                             PlannerUpdateRequest::getSecurityId,
-                            IMDGDistributedNames.Map_Security,
+                            ValidationError.EmptyRequiredValue,
-                            Security.class,
                             ValidationError.SecurityNotFound,
                             false,
                             security -> WorkflowStatus.Active.equalsByKey(security.getWorkflowStatus()) ? null : ValidationError.SecurityNotActive)

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

@@ -17,6 +17,7 @@ import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.scheduler.error.ValidationError;
 import ru.spcex.clearing.util.security.UserRoleVerification;
 import ru.spcex.clearing.validation.common.ValidationHelper;
+import ru.spcex.clearing.validation.common.rules.SecurityPresentRule;
 import ru.spcex.platform.classes.base.SpcexObjectBase;
 import ru.spcex.platform.enumeration.UserRole;
 import ru.spcex.platform.imdg.api.Imdg;
@@ -40,7 +41,8 @@ public class ValidationConfig {
         addImdg.accept(IMDGDistributedNames.Map_ClearingCalendar, ClearingCalendar.class);
         addImdg.accept(IMDGDistributedNames.Map_TaskStatusDictionary, TaskStatusDictionary.class);
         addImdg.accept(IMDGDistributedNames.Map_Company, Company.class);
-        addImdg.accept(IMDGDistributedNames.Map_Security, Security.class);
+        for (String securityMap: SecurityPresentRule.SUB_SECURITY_MAP_NAMES)
+            addImdg.accept(securityMap, Security.class);
         addImdg.accept(IMDGDistributedNames.Map_DayStatusDictionary, DayStatusDictionary.class);
         addImdg.accept(IMDGDistributedNames.Map_SessionTypeDictionary, SessionTypeDictionary.class);
         return imdg;

clearing-parent/scheduler-service/src/test/java/ru/spcex/clearing/scheduler/AbstractServiceTest.java

@@ -119,10 +119,10 @@ public abstract class AbstractServiceTest {
         company.setWorkflowStatus(WorkflowStatus.Active.getKey());
         companyImdg.insert(company);
 
-        Security security = new Security();
+        Security security = new Security(); // FixedIncomeSecurity
         security.setId(testSecurityId);
         security.setWorkflowStatus(WorkflowStatus.Active.getKey());
-        Imdg<Security> securityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Security, Security.class);
+        Imdg<Security> securityImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_FixedIncomeSecurity, Security.class);
         securityImdg.insert(security);
 
         clearingCalendarImdg.insert(getClearingCalendar());

clearing-parent/scheduler-service/src/test/java/ru/spcex/clearing/scheduler/validation/IdPresentRuleTest.java

@@ -10,6 +10,7 @@ import ru.spcex.clearing.platform.messaging.domain.cud.schedule.PlannerNewReques
 import ru.spcex.clearing.scheduler.AbstractServiceTest;
 import ru.spcex.clearing.scheduler.error.ValidationError;
 import ru.spcex.clearing.scheduler.validation.rules.common.IdPresentRule;
+import ru.spcex.clearing.validation.common.rules.SecurityPresentRule;
 import ru.spcex.platform.classes.base.SpcexObjectBase;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
@@ -45,11 +46,11 @@ class IdPresentRuleTest extends AbstractServiceTest {
                 ValidationError.CompanyNotFound,
                 ValidationError.CompanyNotActive
         );
-        testIdPresentRule(
+        testSecurityIdPresentRule(
                 "securityId",
                 PlannerNewRequest::getSecurityId,
                 PlannerNewRequest::setSecurityId,
-                IMDGDistributedNames.Map_Security,
+                IMDGDistributedNames.Map_FixedIncomeSecurity,
                 Security.class,
                 PlannerNewRequest.class,
                 ValidationError.SecurityNotFound,
@@ -96,4 +97,43 @@ class IdPresentRuleTest extends AbstractServiceTest {
 
     }
 
+    private <R, D extends SpcexObjectBase> void testSecurityIdPresentRule(String fieldName,
+                                                                  Function<R, Long> getter,
+                                                                  BiConsumer<R, Long> setter,
+                                                                  String mapName,
+                                                                  Class<D> mapClass,
+                                                                  Class<R> objClass,
+                                                                  ValidationError notFoundExpectedError,
+                                                                  ValidationError notActiveExpectedError) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
+        Imdg<D> imdg = hazelcastServiceTest.getImdg(mapName, mapClass);
+        Function<R, IValidator> validatorBuilder = request -> {
+            ImdgValidationContext<R> context = new ImdgValidationContext<>();
+            context.setValidatedObject(request);
+//            context.addImdg(mapName, imdg);
+            for (String securityMap: SecurityPresentRule.SUB_SECURITY_MAP_NAMES)
+                context.addImdg(securityMap,hazelcastServiceTest.getImdg(securityMap, mapClass));
+            return new ValidatorImpl<>(context, SecurityPresentRule.instance(fieldName,
+                    getter,
+                    ValidationError.EmptyRequiredValue,
+                    notFoundExpectedError,
+                    true,
+                    company -> company.getId().equals(TEST_ID) ? null : notActiveExpectedError
+            ));
+        };
+
+        R obj = objClass.getConstructor().newInstance();
+        setter.accept(obj, TEST_ID);
+        IValidator validator = validatorBuilder.apply(obj);
+        Collection<EnumMessage> enumMessages = validator.validateAll();
+        assertEquals(1, enumMessages.size());
+        assertEquals(notFoundExpectedError, enumMessages.iterator().next().getSubject());
+
+        D map = mapClass.getConstructor().newInstance();
+        map.setId(TEST_ID);
+        imdg.insert(map);
+
+        enumMessages = validator.validateAll();
+        assertTrue(enumMessages.isEmpty());
+
+    }
 }