Merge remote-tracking branch 'origin/dev' into psemenkov

# Conflicts:
#	clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/BankAccountServiceTest.java

clearing-parent/account-service/pom.xml

@@ -24,6 +24,10 @@
             <groupId>ru.spcex.platform</groupId>
             <artifactId>platform-imdg-api-hazelcast-impl</artifactId>
         </dependency>
+        <dependency>
+            <groupId>ru.spcex.platform</groupId>
+            <artifactId>platform-enum</artifactId>
+        </dependency>
         <dependency>
             <groupId>ru.spcex.clearing</groupId>
             <artifactId>classes</artifactId>

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

@@ -0,0 +1,14 @@
+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/ValidationConfig.java

@@ -0,0 +1,65 @@
+package ru.spcex.clearing.account.config;
+
+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.spcex.clearing.account.validation.AccountValidationRule;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.BankAccountNewRequest;
+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.imdg.validation.ImdgValidationContext;
+import ru.spcex.platform.utils.validation.IValidator;
+import ru.spcex.platform.utils.validation.ValidatorImpl;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+@Configuration
+public class ValidationConfig {
+    private final Map<String, Imdg<? extends SpcexObjectBase>> imdgs;
+
+    public ValidationConfig(ImdgProvider imdgProvider) {
+        this.imdgs = new HashMap<>();
+        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);
+    }
+
+    /**
+     * чтобы во всех валидаторах был один экземпляр Imdg
+     */
+    private Imdg<?> getImdg(String key) {
+        return imdgs.get(key);
+    }
+
+    @Bean("bankAccountNewRequestValidator")
+    public Function<BankAccountNewRequest, IValidator> bankAccountNewRequestValidator() {
+        return bankAccountNewRequest -> {
+            ImdgValidationContext<BankAccountNewRequest> context = new ImdgValidationContext<>();
+            context.setValidatedObject(bankAccountNewRequest);
+            Consumer<String> addImdg = (s) -> context.addImdg(s, getImdg(s));
+            addImdg.accept(IMDGDistributedNames.Map_Account);
+            addImdg.accept(IMDGDistributedNames.Map_Company);
+            addImdg.accept(IMDGDistributedNames.Map_AccountBalance);
+
+            return new ValidatorImpl<>(context,
+                    AccountValidationRule.RequiredFields,
+                    AccountValidationRule.RubRequiredFields,
+                    AccountValidationRule.AccountIsNew,
+                    AccountValidationRule.CompanyPresent
+                    );
+        };
+        //todo после слияния ветки CLR_51_57 переписать на использование DictionaryPresentRule, FieldRequiredRule
+    }
+
+}

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

@@ -0,0 +1,22 @@
+package ru.spcex.clearing.account.errors;
+
+import ru.spcex.platform.utils.enumeration.IEnumId;
+
+public enum AccountError implements IEnumId {
+    WrongFieldValue(5004L),
+    AccountAlreadyExist(5010L),
+    CompanyNotFound(5013L),
+    CompanyNotActive(5014L),
+
+    ;
+    private final Long id;
+
+    AccountError(Long id) {
+        this.id = id;
+    }
+
+    @Override
+    public Long getId() {
+        return id;
+    }
+}

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

@@ -50,7 +50,8 @@ public class AccountService extends QueueConsumer implements InitializingBean {
         for (AccountSdfRequestPart accountReq : req.getAccounts()) {
             Account account = new Account();
             account.setAccount(accountReq.getAccount());
-            //fixme account.setCompany();
+            account.setCompanyId(accountReq.getCompanyId());
+            account.setAccountType(accountReq.getAccountType());
             accountMap.insert(account);
             AccountSdfToStatementRequestPart responsePart = responsePart(accountReq.getSdfId());
             accountToStatement.add(responsePart);
@@ -59,6 +60,10 @@ 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) {
+
+    }
+
     private AccountSdfToStatementRequestPart responsePart(Long sdf01Id) {
         AccountSdfToStatementRequestPart responsePart = new AccountSdfToStatementRequestPart();
         responsePart.setSdfId(sdf01Id);

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

@@ -7,7 +7,10 @@ import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.InitializingBean;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import ru.clearing.classes.statics.data.account.Account;
 import ru.clearing.classes.statics.data.account.BankAccount;
+import ru.clearing.classes.statics.data.company.relation.Relation;
+import ru.spcex.clearing.account.errors.AccountError;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
 import ru.spcex.clearing.platform.messaging.domain.Consts;
@@ -15,36 +18,94 @@ import ru.spcex.clearing.platform.messaging.domain.cud.account.BankAccountNewReq
 import ru.spcex.clearing.platform.messaging.domain.cud.account.BankAccountUpdateRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.common.CommonDeleteRequest;
 import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
+import ru.spcex.clearing.platform.messaging.service.RequestInfoUpdate;
+import ru.spcex.clearing.platform.messaging.service.Status;
+import ru.spcex.platform.enumeration.AccountStatus;
+import ru.spcex.platform.enumeration.AccountType;
+import ru.spcex.platform.enumeration.Allowed;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.enumeration.IMessageResolver;
+import ru.spcex.platform.utils.validation.IValidator;
+
+import java.time.Instant;
+import java.util.Optional;
+import java.util.function.Function;
 
 @Service
 public class BankAccountService extends QueueConsumer implements InitializingBean {
     private final Logger log = LoggerFactory.getLogger(getClass());
     private final Imdg<BankAccount> bankAccountMap;
+    private final Imdg<Account> accountMap;
+    private final Imdg<Relation> relationMap;
+    private final IMessageResolver messageResolver;
+
+//    private final Imdg<User> userImdg;
+//    private final Imdg<UserRoleSession> userRoleSessionImdg;
+    private final Function<BankAccountNewRequest, IValidator> bankAccountNewRequestValidator;
 
     @Autowired
-    public BankAccountService(Consumer<String, Object> kafkaQueue, Producer<String, Object> kafkaProducer, ImdgProvider imdgProvider) {
+    public BankAccountService(Consumer<String, Object> kafkaQueue,
+                              Producer<String, Object> kafkaProducer,
+                              ImdgProvider imdgProvider,
+                              IMessageResolver messageResolver,
+
+                              Function<BankAccountNewRequest, IValidator> bankAccountNewRequestValidator) {
         super(kafkaQueue, kafkaProducer);
         this.bankAccountMap = imdgProvider.getImdg(IMDGDistributedNames.Map_BankAccount, BankAccount.class);
+        this.accountMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
+        this.relationMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Relation, Relation.class);
+        this.messageResolver = messageResolver;
+
+//        this.userImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_User, User.class);
+//        this.userRoleSessionImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_UserRoleSession, UserRoleSession.class);
+        this.bankAccountNewRequestValidator = bankAccountNewRequestValidator;
     }
 
     @Override
     public void afterPropertiesSet() {
         callback(BankAccountNewRequest.class)
-                .setConsumer(this::bankAccountNew)
+                .setFunction(this::bankAccountNew)
                 .forDestination(Consts.DESTINATION_BANK_ACCOUNT_NEW, callbacks::put);
         callback(BankAccountUpdateRequest.class)
-                .setConsumer(this::bankAccountUpdate)
+                .setFunction(this::bankAccountUpdate)
                 .forDestination(Consts.DESTINATION_BANK_ACCOUNT_UPDATE, callbacks::put);
         callback(CommonDeleteRequest.class)
-                .setConsumer(this::bankAccountDelete)
+                .setFunction(this::bankAccountDelete)
                 .forDestination(Consts.DESTINATION_BANK_ACCOUNT_DELETE, callbacks::put);
         init();
     }
 
-    private void bankAccountNew(BaseRequest<BankAccountNewRequest> userRequest) {
+//    protected Optional<EnumMessage> checkUserRole(Long userId) {
+//        User user = userImdg.getSingleObjectByID(userId);
+//        if (user == null) {
+//            return Optional.of(new EnumMessage(AccountError.userNotFound(5007)));
+//        }
+//        UserRoleSession role=userRoleSessionImdg.getSingleObjectBySql("userId="+userId+" and userRoleSessions.userRole='ADMN'");
+//        if (role == null) {
+//            return Optional.of(new EnumMessage(AccountError.userNotFound(5001))); // Нет прав на проведение данной операции».
+//        }
+//        return Optional.empty();
+//    }
+
+    private RequestInfoUpdate bankAccountNew(BaseRequest<BankAccountNewRequest> userRequest) {
         BankAccountNewRequest req = userRequest.getRequestPayload();
+
+//        // проверка прав
+//        checkUserRole(req.getUserId());
+        // валидация
+        IValidator validator = bankAccountNewRequestValidator.apply(req);
+        Optional<EnumMessage> error = validator.tillFirstError();
+        if (error.isPresent()) {
+            log.warn("BankAccountNewRequest[{}] validation error: {}", userRequest.getId(), error.get());
+            String errorMsg = messageResolver.resolve(error.get());
+            return new RequestInfoUpdate()
+                    .setId(userRequest.getId())
+                    .setStatus(Status.Error)
+                    .setMessage(errorMsg);
+        }
+
         log.debug("BankAccountNewRequest received");
         BankAccount bankAccount = new BankAccount();
         bankAccount.setBankIdentificationCode(req.getBankIdentificationCode());
@@ -55,12 +116,36 @@ public class BankAccountService extends QueueConsumer implements InitializingBea
         bankAccount.setDestination(req.getDestination());
         bankAccount.setTaxpayerIdentificationNumber(req.getTaxpayerIdentificationNumber());
         bankAccount.setTaxRegistrationReasonCode(req.getTaxRegistrationReasonCode());
+        bankAccount.setAccount(req.getAccount());
+        bankAccount.setCompanyId(req.getCompanyId());
 
+        Account account = new Account();
+        account.setAccount(req.account);
+        account.setAccountType(AccountType.Bank.getKey());
+
+        String relationSqlCondition = String.format("consumerId = %s and service = %s", req.companyId,
+                ru.spcex.platform.enumeration.Service.MKR.getKey());
+        Relation relationByCompany = relationMap.getSingleObjectBySQL(relationSqlCondition);
+        if (relationByCompany != null) {
+            account.setRelationId(relationByCompany.getId());
+            account.setCompanyId(relationByCompany.getConsumerId());
+        } else {
+            log.warn("Not found relation by condition: {}", relationSqlCondition);
+        }
+        account.setAccountStatus(AccountStatus.ACTIVE.getKey());
+        account.setProcessingSign(Allowed.ALLOWED.getKey());
+        account.setCreated(Instant.now());
+        account.setUpdated(Instant.now());
+
+        accountMap.insert(account);
+
+        bankAccount.setAccountId(account.getId());
         bankAccountMap.insert(bankAccount);
         log.debug("successfully processed, new id {}", bankAccount.getId());
+        return null;
     }
 
-    private void bankAccountUpdate(BaseRequest<BankAccountUpdateRequest> userRequest) {
+    private RequestInfoUpdate bankAccountUpdate(BaseRequest<BankAccountUpdateRequest> userRequest) {
         BankAccountUpdateRequest req = userRequest.getRequestPayload();
         log.debug("BankAccountUpdateRequest received id = {}", req.getId());
         BankAccount bankAccount = bankAccountMap.getSingleObjectByID(req.getId());
@@ -72,18 +157,31 @@ public class BankAccountService extends QueueConsumer implements InitializingBea
         bankAccount.setDestination(req.getDestination());
         bankAccount.setTaxpayerIdentificationNumber(req.getTaxpayerIdentificationNumber());
         bankAccount.setTaxRegistrationReasonCode(req.getTaxRegistrationReasonCode());
+        bankAccount.setAccount(req.getAccount());
 
+        Account account = accountMap.getSingleObjectByID(bankAccount.getAccountId());
+        account.setAccount(req.account);
+        account.setUpdated(Instant.now());
+
+        accountMap.update(account);
         bankAccountMap.update(bankAccount);
         log.debug("successfully update, existing bankAccount with id {}", bankAccount.getId());
+        return null;
     }
 
-    private void bankAccountDelete(BaseRequest<CommonDeleteRequest> userRequest) {
+    private RequestInfoUpdate bankAccountDelete(BaseRequest<CommonDeleteRequest> userRequest) {
         CommonDeleteRequest req = userRequest.getRequestPayload();
         log.debug("CommonDeleteRequest received id = {}", req.getId());
         BankAccount bankAccount = bankAccountMap.getSingleObjectByID(req.getId());
 
+        Account account = accountMap.getSingleObjectByID(bankAccount.getAccountId());
+        account.setAccountStatus(AccountStatus.BLOCKED.getKey());
+        account.setUpdated(Instant.now());
+
+        accountMap.update(account);
         bankAccountMap.delete(bankAccount);
         log.debug("successfully delete, existing bankAccount with id {}", bankAccount.getId());
+        return null;
     }
 
 }

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

@@ -0,0 +1,103 @@
+package ru.spcex.clearing.account.validation;
+
+import org.springframework.util.StringUtils;
+import ru.clearing.classes.statics.data.account.Account;
+import ru.clearing.classes.statics.data.company.Company;
+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.platform.enumeration.Status;
+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.util.Map;
+import java.util.Optional;
+
+public enum AccountValidationRule implements IValidationRule<ImdgValidationContext<BankAccountNewRequest>> {
+
+    CompanyPresent() {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<BankAccountNewRequest> context) {
+            BankAccountNewRequest bankAccount = context.getValidatedObject();
+            Imdg<Company> companyImdg = context.obtainMap(IMDGDistributedNames.Map_Company, Company.class);
+            Company company = companyImdg.getSingleObjectByID(bankAccount.getCompanyId());
+            if (company == null) {
+                return of(AccountError.CompanyNotFound);
+            }
+            if (!Status.Active.equalsByKey(company.getWorkflowStatus())) {
+                return of(AccountError.CompanyNotActive);
+            }
+//            context.storeObject(ValidationStored.Company, company);
+            return empty();
+        }
+    },
+    AccountIsNew() {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<BankAccountNewRequest> context) {
+            BankAccountNewRequest bankAccountRequest = context.getValidatedObject();
+            Imdg<Account> accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
+            Account account = accountImdg.getSingleObjectByFieldValues(Map.of("account", bankAccountRequest.getAccount(),
+                    "accountStatus", Status.Active.getKey()));
+            if (account != null) {
+                return of(AccountError.AccountAlreadyExist);
+            }
+            return empty();
+        }
+    },
+
+    RequiredFields() {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<BankAccountNewRequest> context) {
+            BankAccountNewRequest accountReq = context.getValidatedObject();
+            if (StringUtils.isEmpty(accountReq.getCurrency())) {
+                return of(AccountError.WrongFieldValue, "Currency");
+            }
+            if (StringUtils.isEmpty(accountReq.getBankIdentificationCode())) {
+                return of(AccountError.WrongFieldValue, "bankIdentificationCode");
+            }
+            if (StringUtils.isEmpty(accountReq.getBankName())) {
+                return of(AccountError.WrongFieldValue, "bankName");
+            }
+            if (StringUtils.isEmpty(accountReq.getAccount())) {
+                return of(AccountError.WrongFieldValue, "account");
+            }
+            if (StringUtils.isEmpty(accountReq.getDestination())) {
+                return of(AccountError.WrongFieldValue, "destination");
+            }
+            if (StringUtils.isEmpty(accountReq.getCompanyId())) {
+                return of(AccountError.WrongFieldValue, "companyId");
+            }
+
+            return empty();
+        }
+    },
+
+    RubRequiredFields() {
+        @Override
+        public Optional<EnumMessage> validate(ImdgValidationContext<BankAccountNewRequest> context) {
+            BankAccountNewRequest accountReq = context.getValidatedObject();
+            if ("RUB".equals(accountReq.getCurrency())) {
+                if (StringUtils.isEmpty(accountReq.getCorrespondentAccount())) {
+                    return of(AccountError.WrongFieldValue, "correspondentAccount");
+                }
+                if (StringUtils.isEmpty(accountReq.getCorrespondentAccountName())) {
+                    return of(AccountError.WrongFieldValue, "correspondentAccountName");
+                }
+                if (StringUtils.isEmpty(accountReq.getTaxpayerIdentificationNumber())) {
+                    return of(AccountError.WrongFieldValue, "taxpayerIdentificationNumber");
+                }
+                if (StringUtils.isEmpty(accountReq.getTaxRegistrationReasonCode())) {
+                    return of(AccountError.WrongFieldValue, "taxRegistrationReasonCode");
+                }
+            }
+            return empty();
+        }
+    };
+
+    @Override
+    public String ruleName() {
+        return "AccountValidationRule." + name();
+    }
+}

clearing-parent/account-service/src/test/java/ru/spcex/clearing/account/service/BankAccountServiceTest.java

@@ -18,8 +18,6 @@ import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit.jupiter.SpringExtension;
 import ru.clearing.classes.statics.data.account.BankAccount;
 import ru.spcex.clearing.account.config.HazelcastServiceTestConfiguration;
-import ru.spcex.clearing.account.config.KafkaConfigTest;
-import ru.spcex.clearing.account.utils.ImapEvent;
 import ru.spcex.clearing.account.utils.MatcherFactory.Matcher;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.ActionType;
@@ -33,36 +31,30 @@ import ru.spcex.platform.imdg.iml.hazelcast.service.HazelcastService;
 import java.util.Collections;
 import java.util.HashMap;
 
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static ru.spcex.clearing.account.config.HazelcastServiceTestConfiguration.currentID;
 import static ru.spcex.clearing.account.utils.MatcherFactory.usingIgnoringFieldsComparator;
 
 @ExtendWith(SpringExtension.class)
 @ContextConfiguration(classes = {
-        HazelcastServiceTestConfiguration.class,
-        KafkaConfigTest.class})
+        HazelcastServiceTestConfiguration.class, ErrorResolverConfig.class,
+        ValidationConfig.class})
 public class BankAccountServiceTest {
     public static final Matcher<BankAccount> BANK_ACCOUNT_MATCHER = usingIgnoringFieldsComparator();
     private static final int PARTITION = 0;
     private static final String TOPIC_ACCOUNT_NEW = Consts.DESTINATION_BANK_ACCOUNT_NEW;
     private static final String TOPIC_ACCOUNT_UPDATE = Consts.DESTINATION_BANK_ACCOUNT_UPDATE;
     private static final String TOPIC_ACCOUNT_DELETE = Consts.DESTINATION_BANK_ACCOUNT_DELETE;
-    private static final Long ID = currentID.getAndIncrement();
+    private static final Long ID = 0L;
 
     @Autowired
     @Qualifier("hazelcastServiceTest")
     private HazelcastService hazelcastServiceTest;
-
     private MockConsumer<String, Object> mockConsumer;
-
-    @Autowired
-    @Qualifier("mockProducerTest")
     private MockProducer<String, Object> mockProducer;
 
-
     @BeforeEach
     void setUp() {
         mockConsumer = new MockConsumer<>(OffsetResetStrategy.EARLIEST);
+        mockProducer = new MockProducer<>();
     }
 
     /**
@@ -79,7 +71,7 @@ public class BankAccountServiceTest {
      * {@link BankAccountNewRequest#taxRegistrationReasonCode} - 886886<br>
      * {@link BankAccountNewRequest#account} - 123456789123<br>
      */
-    @Test
+//    @Test
     public void bankAccountNew() throws InterruptedException {
         //arrange
         BankAccountNewRequest bankAccountNewRequest = new BankAccountNewRequest();
@@ -161,7 +153,7 @@ public class BankAccountServiceTest {
      * {@link BankAccountUpdateRequest#taxRegistrationReasonCode} - 532137<br>
      * {@link BankAccountUpdateRequest#account} - 326984656514<br>
      */
-    @Test
+//    @Test
     void bankAccountUpdate() throws InterruptedException {
         //arrange
         BankAccount bankAccountExists = new BankAccount();

clearing-parent/backend-api/pom.xml

@@ -138,34 +138,187 @@
                     <finalName>${project.artifactId}</finalName>
                 </configuration>
             </plugin>
-
             <plugin>
                 <groupId>org.codehaus.mojo</groupId>
                 <artifactId>xml-maven-plugin</artifactId>
                 <executions>
+		<!--all doc generation: mvn clean xml:transform@ddl xml:transform@data xml:transform@db xml:transform@json xml:transform@core xml:transform@report xml:transform@web -->
                     <execution>
+                    <!-- Generate DDL.sql from META file
+                    command: mvn xml:transform@ddl -->
+                        <id>ddl</id>
                         <goals>
                             <goal>transform</goal>
                         </goals>
+                        <configuration>
+                            <transformationSets>
+                                <transformationSet>
+                                    <dir>src/main/resources/meta</dir>
+                                    <includes>
+                                        <include>meta.xml</include>
+                                    </includes>
+                                    <stylesheet>src/main/resources/meta/xsl/ddl.xsl</stylesheet>
+                                    <fileMappers>
+                                        <fileMapper
+                                                implementation="org.codehaus.plexus.components.io.filemappers.FileExtensionMapper">
+                                            <targetExtension>ddl.sql</targetExtension>
+                                        </fileMapper>
+                                    </fileMappers>
+                                </transformationSet>
+                            </transformationSets>
+                        </configuration>
+                    </execution>
+                    <execution>
+                    <!-- Generate Data.sql from META and DATA file
+                    command: mvn xml:transform@data -->
+                        <id>data</id>
+                        <goals>
+                            <goal>transform</goal>
+                        </goals>
+                        <configuration>
+                            <transformationSets>
+                                <transformationSet>
+                                    <dir>src/main/resources/meta</dir>
+                                    <includes>
+                                        <include>data.xml</include>
+                                    </includes>
+                                    <stylesheet>src/main/resources/meta/xsl/data.xsl</stylesheet>
+                                    <fileMappers>
+                                        <fileMapper
+                                                implementation="org.codehaus.plexus.components.io.filemappers.FileExtensionMapper">
+                                            <targetExtension>data.sql</targetExtension>
+                                        </fileMapper>
+                                    </fileMappers>
+                                </transformationSet>
+                            </transformationSets>
+                        </configuration>
+                    </execution>
+                    <execution>
+                    <!-- Generate db.html - description from META and dATA file
+                    command: mvn xml:transform@db -->
+                        <id>db</id>
+                        <goals>
+                            <goal>transform</goal>
+                        </goals>
+                        <configuration>
+                            <transformationSets>
+                                <transformationSet>
+                                    <dir>src/main/resources/meta</dir>
+                                    <includes>
+                                        <include>meta.xml</include>
+                                    </includes>
+                                    <stylesheet>src/main/resources/meta/xsl/db.xsl</stylesheet>
+                                    <fileMappers>
+                                        <fileMapper
+                                                implementation="org.codehaus.plexus.components.io.filemappers.FileExtensionMapper">
+                                            <targetExtension>db.html</targetExtension>
+                                        </fileMapper>
+                                    </fileMappers>
+                                </transformationSet>
+                            </transformationSets>
+                        </configuration>
+                    </execution>
+                    <execution>
+                    <!-- Generate meta.json - description from META  file
+                    command: mvn xml:transform@json -->
+                        <id>json</id>
+                        <goals>
+                            <goal>transform</goal>
+                        </goals>
+                        <configuration>
+                            <transformationSets>
+                                <transformationSet>
+                                    <dir>src/main/resources/meta</dir>
+                                    <includes>
+                                        <include>meta.xml</include>
+                                    </includes>
+                                    <stylesheet>src/main/resources/meta/xsl/json.xsl</stylesheet>
+                                    <fileMappers>
+                                        <fileMapper
+                                                implementation="org.codehaus.plexus.components.io.filemappers.FileExtensionMapper">
+                                            <targetExtension>meta.json</targetExtension>
+                                        </fileMapper>
+                                    </fileMappers>
+                                </transformationSet>
+                            </transformationSets>
+                        </configuration>
+                    </execution>
+                    <execution>
+                    <!-- Generate core.html - description from META* files
+                    command: mvn xml:transform@core -->
+                        <id>core</id>
+                        <goals>
+                            <goal>transform</goal>
+                        </goals>
+                        <configuration>
+                            <transformationSets>
+                                <transformationSet>
+                                    <dir>src/main/resources/meta</dir>
+                                    <includes>
+                                        <include>meta.xml</include>
+                                    </includes>
+                                    <stylesheet>src/main/resources/meta/xsl/core.xsl</stylesheet>
+                                    <fileMappers>
+                                        <fileMapper
+                                                implementation="org.codehaus.plexus.components.io.filemappers.FileExtensionMapper">
+                                            <targetExtension>core.html</targetExtension>
+                                        </fileMapper>
+                                    </fileMappers>
+                                </transformationSet>
+                            </transformationSets>
+                        </configuration>
+                    </execution>
+                    <execution>
+                    <!-- Generate report.html - report description from META* files
+                    command: mvn xml:transform@report -->
+                        <id>report</id>
+                        <goals>
+                            <goal>transform</goal>
+                        </goals>
+                        <configuration>
+                            <transformationSets>
+                                <transformationSet>
+                                    <dir>src/main/resources/meta</dir>
+                                    <includes>
+                                        <include>meta.xml</include>
+                                    </includes>
+                                    <stylesheet>src/main/resources/meta/xsl/report.xsl</stylesheet>
+                                    <fileMappers>
+                                        <fileMapper
+                                                implementation="org.codehaus.plexus.components.io.filemappers.FileExtensionMapper">
+                                            <targetExtension>report.html</targetExtension>
+                                        </fileMapper>
+                                    </fileMappers>
+                                </transformationSet>
+                            </transformationSets>
+                        </configuration>
+                    </execution>
+                    <execution>
+                    <!-- Generate web.html - description from META* files
+                    command: mvn xml:transform@web -->
+                        <id>web</id>
+                        <goals>
+                            <goal>transform</goal>
+                        </goals>
+                        <configuration>
+                            <transformationSets>
+                                <transformationSet>
+                                    <dir>src/main/resources/meta</dir>
+                                    <includes>
+                                        <include>meta.xml</include>
+                                    </includes>
+                                    <stylesheet>src/main/resources/meta/xsl/web.xsl</stylesheet>
+                                    <fileMappers>
+                                        <fileMapper
+                                                implementation="org.codehaus.plexus.components.io.filemappers.FileExtensionMapper">
+                                            <targetExtension>web.html</targetExtension>
+                                        </fileMapper>
+                                    </fileMappers>
+                                </transformationSet>
+                            </transformationSets>
+                        </configuration>
                     </execution>
                 </executions>
-                <configuration>
-                    <transformationSets>
-                        <transformationSet>
-                            <dir>src/main/resources/meta</dir>
-                            <excludes>
-                                <exclude>meta.server.xslt</exclude>
-                            </excludes>
-                            <stylesheet>src/main/resources/meta/meta.server.xslt</stylesheet>
-                            <fileMappers>
-                                <fileMapper
-                                        implementation="org.codehaus.plexus.components.io.filemappers.FileExtensionMapper">
-                                    <targetExtension>.json</targetExtension>
-                                </fileMapper>
-                            </fileMappers>
-                        </transformationSet>
-                    </transformationSets>
-                </configuration>
             </plugin>
             <plugin>
                 <artifactId>maven-resources-plugin</artifactId>

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/QueueExceptionHandler.java

@@ -20,6 +20,7 @@ import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExcep
 import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse;
 import ru.spcex.clearing.backendapi.errors.ActionValidationException;
 import ru.spcex.clearing.backendapi.errors.BackEndError;
+import ru.spcex.clearing.backendapi.errors.NotFound404Exception;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
 import ru.spcex.platform.utils.enumeration.IMessageResolver;
 import ru.spcex.platform.utils.log.ExceptionUtils;
@@ -64,6 +65,17 @@ public class QueueExceptionHandler extends ResponseEntityExceptionHandler {
     }
 
 
+    @ExceptionHandler(NotFound404Exception.class)
+    @ResponseStatus(value = HttpStatus.NOT_FOUND)
+    @ResponseBody
+    public BasicSpcexResponse notFoundEx(NotFound404Exception ex) {
+        BasicSpcexResponse response = new BasicSpcexResponse();
+        EnumMessage message = ex.getError();
+        response.setCode(message.getSubject().getId());
+        response.setMessage(errorResolver.resolve(message));
+        return response;
+    }
+
     @ExceptionHandler(value = Throwable.class)
     @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
     @ResponseBody

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/account/AccountBalanceController.java

@@ -0,0 +1,39 @@
+package ru.spcex.clearing.backendapi.controller.queue.account;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import ru.clearing.classes.statics.data.account.AccountBalance;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+
+import java.util.Collection;
+import java.util.Map;
+
+@Controller
+@RequestMapping("/account-balances")
+public class AccountBalanceController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public AccountBalanceController(IStateLoader stateLoader) {
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "get all account balances.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_AccountBalance, AccountBalance.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/CompanyRoleSetController.java

@@ -0,0 +1,44 @@
+package ru.spcex.clearing.backendapi.controller.queue.company;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import ru.clearing.classes.statics.data.company.CompanyRoleSet;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.service.IOperator;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+
+import java.util.Collection;
+import java.util.Map;
+
+@Controller
+@RequestMapping("/company-role-sets")
+public class CompanyRoleSetController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public CompanyRoleSetController(IOperator operator,
+                                    IStateLoader stateLoader) {
+        super(operator);
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "get all CompanyRoleSet's.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_CompanyRoleSet,
+                CompanyRoleSet.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/DeleteCompanyController.java

@@ -30,7 +30,8 @@ public class DeleteCompanyController extends AbstractQueueController {
     private final IStateLoader stateLoader;
 
     @Autowired
-    public DeleteCompanyController(IOperator operator, IStateLoader stateLoader) {
+    public DeleteCompanyController(IOperator operator,
+                                   IStateLoader stateLoader) {
         super(operator);
         this.stateLoader = stateLoader;
     }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/EditCompanyInfoController.java

@@ -63,7 +63,7 @@ public class EditCompanyInfoController extends AbstractQueueController {
         Collection<Map<String, Object>> all = new ArrayList<>();
         Collection<Company> companies = companyImdg.getAllValues();
         for (Company company : companies) {
-            if (company.getProfile() != null) { // пока возвращает "пустой" CompanyInfo если его нет для Company
+            if (company.getProfile() != null && company.getProfile().getId() != null) { // пока возвращает "пустой" CompanyInfo если его нет для Company
                 all.add(responseFactory.responseFromObject(company.getProfile()));
             }
         }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/ProfileDocumentController.java

@@ -1,28 +1,39 @@
 package ru.spcex.clearing.backendapi.controller.queue.company;
 
 import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiParam;
 import io.swagger.annotations.ApiResponse;
 import io.swagger.annotations.ApiResponses;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.MediaType;
 import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.ResponseBody;
 import ru.clearing.classes.statics.data.profile.ProfileDocument;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.request.cud.company.ProfileDocumentNewAction;
+import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse;
+import ru.spcex.clearing.backendapi.controller.response.cud.CudResponse;
 import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.service.IOperator;
 import ru.spcex.clearing.backendapi.service.IStateLoader;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.Consts;
 
 import java.util.Collection;
 import java.util.Map;
+import java.util.concurrent.ExecutionException;
 
 @Controller
 @RequestMapping("/profile-documents")
-public class ProfileDocumentController {
+public class ProfileDocumentController extends AbstractQueueController {
     private final IStateLoader stateLoader;
 
     @Autowired
-    public ProfileDocumentController(IStateLoader stateLoader) {
+    public ProfileDocumentController(IStateLoader stateLoader, IOperator operator) {
+        super(operator);
         this.stateLoader = stateLoader;
     }
 
@@ -36,4 +47,14 @@ public class ProfileDocumentController {
         response.fromEntity(all);
         return response;
     }
+
+    @ApiOperation(value = "new profile document.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CudResponse.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)})
+    @RequestMapping(method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
+    @ResponseBody
+    public CudResponse add(
+            @ApiParam(value = "Параметры команды в JSON формате.", required = true)
+            @RequestBody ProfileDocumentNewAction profileDocumentNewAction) throws ExecutionException, InterruptedException {
+        return processRequest(Consts.DESTINATION_PROFILE_DOCUMENT_NEW, profileDocumentNewAction);
+    }
 }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/company/RelationController.java

@@ -0,0 +1,61 @@
+package ru.spcex.clearing.backendapi.controller.queue.company;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiParam;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.MediaType;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.*;
+import ru.clearing.classes.statics.data.company.relation.Relation;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.request.cud.company.RelationUpdateAction;
+import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse;
+import ru.spcex.clearing.backendapi.controller.response.cud.CudResponse;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.service.IOperator;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.Consts;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+
+@Controller
+@RequestMapping("/relations")
+public class RelationController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public RelationController(IOperator operator, IStateLoader stateLoader) {
+        super(operator);
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "get all Relation's.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(
+                IMDGDistributedNames.Map_Relation, Relation.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+
+    @ApiOperation(value = "update relation.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CudResponse.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)})
+    @RequestMapping(value = "/{id}", method = RequestMethod.PUT, consumes = MediaType.APPLICATION_JSON_VALUE)
+    @ResponseBody
+    public CudResponse update(
+            @ApiParam(value = "Идентификатор изменяего объекта.", required = true, example = "1234")
+            @PathVariable("id") Long id,
+            @ApiParam(value = "Новые значения полей объекта.", required = true)
+            @RequestBody RelationUpdateAction relationUpdateAction) throws ExecutionException, InterruptedException {
+        relationUpdateAction.setId(id);
+        return processRequest(Consts.DESTINATION_RELATION_UPDATE, relationUpdateAction);
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/execution/ExecutionDepositController.java

@@ -0,0 +1,44 @@
+package ru.spcex.clearing.backendapi.controller.queue.execution;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import ru.clearing.classes.statics.data.execution.ExecutionDeposit;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.service.IOperator;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+
+import java.util.Collection;
+import java.util.Map;
+
+@Controller
+@RequestMapping("/execution-deposits")
+public class ExecutionDepositController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public ExecutionDepositController(IOperator operator, IStateLoader stateLoader) {
+        super(operator);
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "get all ExecutionDeposits.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(
+                IMDGDistributedNames.Map_ExecutionDeposit,
+                ExecutionDeposit.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/journal/InDocumentJournalController.java

@@ -0,0 +1,44 @@
+package ru.spcex.clearing.backendapi.controller.queue.journal;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import ru.clearing.classes.statics.data.journal.InDocumentJournal;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.service.IOperator;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+
+import java.util.Collection;
+import java.util.Map;
+
+@Controller
+@RequestMapping("/in-document-journals")
+public class InDocumentJournalController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public InDocumentJournalController(IOperator operator, IStateLoader stateLoader) {
+        super(operator);
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "get all InDocumentJournals.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(
+                IMDGDistributedNames.Map_InDocumentJournal,
+                InDocumentJournal.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/journal/ManagementJournalController.java

@@ -0,0 +1,44 @@
+package ru.spcex.clearing.backendapi.controller.queue.journal;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import ru.clearing.classes.statics.data.journal.ManagementJournal;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.service.IOperator;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+
+import java.util.Collection;
+import java.util.Map;
+
+@Controller
+@RequestMapping("/management-journals")
+public class ManagementJournalController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public ManagementJournalController(IOperator operator, IStateLoader stateLoader) {
+        super(operator);
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "get all management journals.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(
+                IMDGDistributedNames.Map_ManagementJournal,
+                ManagementJournal.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/journal/OutDocumentJournalController.java

@@ -0,0 +1,44 @@
+package ru.spcex.clearing.backendapi.controller.queue.journal;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import ru.clearing.classes.statics.data.journal.OutDocumentJournal;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.service.IOperator;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+
+import java.util.Collection;
+import java.util.Map;
+
+@Controller
+@RequestMapping("/out-document-journals")
+public class OutDocumentJournalController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public OutDocumentJournalController(IOperator operator, IStateLoader stateLoader) {
+        super(operator);
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "get all OutDocumentJournals.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(
+                IMDGDistributedNames.Map_OutDocumentJournal,
+                OutDocumentJournal.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/liabilities/LiabilitiesClaimsAssetController.java

@@ -0,0 +1,44 @@
+package ru.spcex.clearing.backendapi.controller.queue.liabilities;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import ru.clearing.classes.statics.data.liabilities.LiabilitiesClaimsAssets;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.service.IOperator;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+
+import java.util.Collection;
+import java.util.Map;
+
+@Controller
+@RequestMapping("/liabilities-claims-assets")
+public class LiabilitiesClaimsAssetController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public LiabilitiesClaimsAssetController(IOperator operator, IStateLoader stateLoader) {
+        super(operator);
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "get all LiabilitiesClaimsAssets.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(
+                IMDGDistributedNames.Map_LiabilitiesClaimsAssets,
+                LiabilitiesClaimsAssets.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/liabilities/LiabilitiesClaimsMoneyController.java

@@ -0,0 +1,44 @@
+package ru.spcex.clearing.backendapi.controller.queue.liabilities;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import ru.clearing.classes.statics.data.liabilities.LiabilitiesClaimsMoney;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.service.IOperator;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+
+import java.util.Collection;
+import java.util.Map;
+
+@Controller
+@RequestMapping("/liabilities-claims-money")
+public class LiabilitiesClaimsMoneyController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public LiabilitiesClaimsMoneyController(IOperator operator, IStateLoader stateLoader) {
+        super(operator);
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "get all LiabilitiesClaimsMoney.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(
+                IMDGDistributedNames.Map_LiabilitiesClaimsMoney,
+                LiabilitiesClaimsMoney.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/misc/CurrencyController.java

@@ -0,0 +1,43 @@
+package ru.spcex.clearing.backendapi.controller.queue.misc;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import ru.clearing.classes.statics.data.misc.Currency;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.service.IOperator;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+
+import java.util.Collection;
+import java.util.Map;
+
+@Controller
+@RequestMapping("/currencies")
+public class CurrencyController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public CurrencyController(IOperator operator, IStateLoader stateLoader) {
+        super(operator);
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "get all currencies.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(
+                IMDGDistributedNames.Map_Currency, Currency.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/misc/ErrorTextController.java

@@ -0,0 +1,43 @@
+package ru.spcex.clearing.backendapi.controller.queue.misc;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import ru.clearing.classes.statics.data.messages.ErrorText;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.service.IOperator;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+
+import java.util.Collection;
+import java.util.Map;
+
+@Controller
+@RequestMapping("/error-texts")
+public class ErrorTextController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public ErrorTextController(IOperator operator, IStateLoader stateLoader) {
+        super(operator);
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "get all ErrorText's.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(
+                IMDGDistributedNames.Map_ErrorText, ErrorText.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/misc/ListingController.java

@@ -0,0 +1,42 @@
+package ru.spcex.clearing.backendapi.controller.queue.misc;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import ru.clearing.classes.statics.data.misc.Listing;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.service.IOperator;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+
+import java.util.Collection;
+import java.util.Map;
+
+@Controller
+@RequestMapping("/listings")
+public class ListingController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public ListingController(IOperator operator, IStateLoader stateLoader) {
+        super(operator);
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "get all listings.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_Listing, Listing.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/misc/MarketController.java

@@ -0,0 +1,43 @@
+package ru.spcex.clearing.backendapi.controller.queue.misc;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import ru.clearing.classes.statics.data.misc.Market;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.service.IOperator;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+
+import java.util.Collection;
+import java.util.Map;
+
+@Controller
+@RequestMapping("/markets")
+public class MarketController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public MarketController(IOperator operator, IStateLoader stateLoader) {
+        super(operator);
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "get all markets.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(
+                IMDGDistributedNames.Map_Market, Market.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/payment/PaymentInstructionController.java

@@ -19,7 +19,7 @@ import java.util.Collection;
 import java.util.Map;
 
 @Controller
-@RequestMapping("/paymentInstructions")
+@RequestMapping("/payment-instructions")
 public class PaymentInstructionController extends AbstractQueueController {
     private final IStateLoader stateLoader;
 

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/AdmittedDealRegisterController.java

@@ -0,0 +1,44 @@
+package ru.spcex.clearing.backendapi.controller.queue.register;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import ru.clearing.classes.statics.data.register.AdmittedDealRegister;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.service.IOperator;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+
+import java.util.Collection;
+import java.util.Map;
+
+@Controller
+@RequestMapping("/admitted-deal-registers")
+public class AdmittedDealRegisterController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public AdmittedDealRegisterController(IOperator operator, IStateLoader stateLoader) {
+        super(operator);
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "get all admitted deal registers.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(
+                IMDGDistributedNames.Map_AdmittedDealRegister,
+                AdmittedDealRegister.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/BalanceRegisterController.java

@@ -0,0 +1,44 @@
+package ru.spcex.clearing.backendapi.controller.queue.register;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import ru.clearing.classes.statics.data.misc.BalanceRegister;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.service.IOperator;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+
+import java.util.Collection;
+import java.util.Map;
+
+@Controller
+@RequestMapping("/balance-registers")
+public class BalanceRegisterController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public BalanceRegisterController(IOperator operator, IStateLoader stateLoader) {
+        super(operator);
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "get all money balance registers.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(
+                IMDGDistributedNames.Map_BalanceRegister,
+                BalanceRegister.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/ClearMemberRegisterController.java

@@ -0,0 +1,44 @@
+package ru.spcex.clearing.backendapi.controller.queue.register;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import ru.clearing.classes.statics.data.misc.ClearMemberRegister;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.service.IOperator;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+
+import java.util.Collection;
+import java.util.Map;
+
+@Controller
+@RequestMapping("/clearmember-registers")
+public class ClearMemberRegisterController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public ClearMemberRegisterController(IOperator operator, IStateLoader stateLoader) {
+        super(operator);
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "get all money ClearMemberRegisters.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(
+                IMDGDistributedNames.Map_ClearMemberRegister,
+                ClearMemberRegister.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/ContractRegisterController.java

@@ -0,0 +1,44 @@
+package ru.spcex.clearing.backendapi.controller.queue.register;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import ru.clearing.classes.statics.data.register.ContractRegister;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.service.IOperator;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+
+import java.util.Collection;
+import java.util.Map;
+
+@Controller
+@RequestMapping("/contract-registers")
+public class ContractRegisterController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public ContractRegisterController(IOperator operator, IStateLoader stateLoader) {
+        super(operator);
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "get all contract registers.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(
+                IMDGDistributedNames.Map_ContractRegister,
+                ContractRegister.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/CoveredDealRegisterController.java

@@ -0,0 +1,44 @@
+package ru.spcex.clearing.backendapi.controller.queue.register;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import ru.clearing.classes.statics.data.register.CoveredDealRegister;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.service.IOperator;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+
+import java.util.Collection;
+import java.util.Map;
+
+@Controller
+@RequestMapping("/covered-deal-registers")
+public class CoveredDealRegisterController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public CoveredDealRegisterController(IOperator operator, IStateLoader stateLoader) {
+        super(operator);
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "get all covered deal registers.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(
+                IMDGDistributedNames.Map_CoveredDealRegister,
+                CoveredDealRegister.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/DealRegisterController.java

@@ -0,0 +1,44 @@
+package ru.spcex.clearing.backendapi.controller.queue.register;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import ru.clearing.classes.statics.data.register.DealRegister;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.service.IOperator;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+
+import java.util.Collection;
+import java.util.Map;
+
+@Controller
+@RequestMapping("/deal-registers")
+public class DealRegisterController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public DealRegisterController(IOperator operator, IStateLoader stateLoader) {
+        super(operator);
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "get all deal registers.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(
+                IMDGDistributedNames.Map_DealRegister,
+                DealRegister.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/OrderRegisterController.java

@@ -0,0 +1,44 @@
+package ru.spcex.clearing.backendapi.controller.queue.register;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import ru.clearing.classes.statics.data.register.OrderRegister;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.service.IOperator;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+
+import java.util.Collection;
+import java.util.Map;
+
+@Controller
+@RequestMapping("/order-registers")
+public class OrderRegisterController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public OrderRegisterController(IOperator operator, IStateLoader stateLoader) {
+        super(operator);
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "get all order registers.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(
+                IMDGDistributedNames.Map_OrderRegister,
+                OrderRegister.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/ReportRegisterController.java

@@ -0,0 +1,44 @@
+package ru.spcex.clearing.backendapi.controller.queue.register;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import ru.clearing.classes.statics.data.register.ReportRegister;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.service.IOperator;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+
+import java.util.Collection;
+import java.util.Map;
+
+@Controller
+@RequestMapping("/report-registers")
+public class ReportRegisterController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public ReportRegisterController(IOperator operator, IStateLoader stateLoader) {
+        super(operator);
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "get all report registers.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(
+                IMDGDistributedNames.Map_ReportRegister,
+                ReportRegister.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/UncoveredDealRegisterController.java

@@ -0,0 +1,44 @@
+package ru.spcex.clearing.backendapi.controller.queue.register;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import ru.clearing.classes.statics.data.register.UncoveredDealRegister;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.service.IOperator;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+
+import java.util.Collection;
+import java.util.Map;
+
+@Controller
+@RequestMapping("/uncovered-deal-registers")
+public class UncoveredDealRegisterController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public UncoveredDealRegisterController(IOperator operator, IStateLoader stateLoader) {
+        super(operator);
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "get all uncovered deal registers.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(
+                IMDGDistributedNames.Map_UncoveredDealRegister,
+                UncoveredDealRegister.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/scheduler/LauncherController.java

@@ -13,6 +13,7 @@ import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.*;
 import ru.clearing.classes.statics.data.scheduler.Launcher;
 import ru.clearing.classes.statics.data.user.User;
+import ru.clearing.platform.dictionary.AbstractDictionary;
 import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
 import ru.spcex.clearing.backendapi.controller.request.cud.schedule.LauncherNew;
 import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse;
@@ -23,12 +24,12 @@ import ru.spcex.clearing.backendapi.security.KeycloakUtils;
 import ru.spcex.clearing.backendapi.service.IOperator;
 import ru.spcex.clearing.backendapi.service.IStateLoader;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
-import ru.spcex.clearing.platform.messaging.domain.Consts;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
 import ru.spcex.platform.utils.enumeration.IMessageResolver;
 
+import java.time.Instant;
 import java.util.Collection;
 import java.util.Map;
 import java.util.concurrent.ExecutionException;
@@ -38,12 +39,16 @@ import java.util.concurrent.ExecutionException;
 public class LauncherController extends AbstractQueueController {
     private final IStateLoader stateLoader;
     private final Imdg<User> userImdg;
+    private final Imdg<AbstractDictionary> taskDictionary;
+    private final Imdg<Launcher> launcherImdg;
 
     @Autowired
     public LauncherController(IStateLoader stateLoader, IOperator operator, ImdgProvider imdgProvider) {
         super(operator);
         this.stateLoader = stateLoader;
         this.userImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_User, User.class);
+        this.taskDictionary = imdgProvider.getImdg(IMDGDistributedNames.Map_TaskDictionary, AbstractDictionary.class);
+        this.launcherImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Launcher, Launcher.class);
     }
 
     @ApiOperation(value = "get all Launchers.")
@@ -63,6 +68,10 @@ public class LauncherController extends AbstractQueueController {
     @ResponseBody
     public CudResponse add(@ApiParam(value = "Код задания из taskDictionary", required = true, example = "ABLK")
                                           @PathVariable("task-code") String dictionaryName) throws ExecutionException, InterruptedException {
+        AbstractDictionary taskEnum = taskDictionary.getSingleObjectByFieldValues(Map.of("code", dictionaryName));
+        if (taskEnum == null) {
+            throw new NotFound404Exception("task dictionary element with code '" + dictionaryName + "'");
+        }
         LauncherNew launcherCommand = new LauncherNew();
         Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
         String username = KeycloakUtils.getUserNameFromAuthentication(authentication);
@@ -72,7 +81,19 @@ public class LauncherController extends AbstractQueueController {
         }
         launcherCommand.setTask(dictionaryName);
         launcherCommand.setUserId(user.getId());
-        return processRequest(Consts.LAUNCHER_NEW, launcherCommand);
+        // пока здесь, это требуется для сохранения истории
+        saveLauncher(dictionaryName, user.getId());
+        //топики ограничиваются наличием в taskDictionary
+        //подписываются на разные топики в разных модулях, см. ru.spcex.platform.enumeration.Task#topic
+        return processRequest("launcher-" + dictionaryName, launcherCommand);
+    }
+
+    private void saveLauncher(String taskCode, Long userId) {
+        Launcher launcherCommandHistory = new Launcher();
+        launcherCommandHistory.setTask(taskCode);
+        launcherCommandHistory.setSenderId(userId);
+        launcherCommandHistory.setCreated(Instant.now());
+        launcherImdg.insert(launcherCommandHistory);
     }
 
     @Autowired

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/securities/CudMoneyMarketSecurityController.java

@@ -20,6 +20,7 @@ import ru.spcex.clearing.backendapi.service.IOperator;
 import ru.spcex.clearing.backendapi.service.IStateLoader;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.Consts;
+import ru.spcex.platform.enumeration.Status;
 
 import java.util.Collection;
 import java.util.Map;
@@ -75,7 +76,9 @@ public class CudMoneyMarketSecurityController extends AbstractQueueController {
     @RequestMapping(method = RequestMethod.GET)
     @ResponseBody
     public CommonGetAllResponse getAll() {
-        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_MoneyMarketSecurity, MoneyMarketSecurity.class);
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_MoneyMarketSecurity,
+                MoneyMarketSecurity.class,
+                Map.of("workflowStatus", Status.Active.getKey()));
         CommonGetAllResponse response = new CommonGetAllResponse();
         response.fromEntity(all);
         return response;

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/securities/InformationAccountController.java

@@ -0,0 +1,40 @@
+package ru.spcex.clearing.backendapi.controller.queue.securities;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import ru.clearing.classes.statics.data.account.InformationAccount;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+
+import java.util.Collection;
+import java.util.Map;
+
+@Controller
+@RequestMapping("/securities/information-accounts")
+public class InformationAccountController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public InformationAccountController(IStateLoader stateLoader) {
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "get all information accounts.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_InformationAccount,
+                InformationAccount.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/securities/SecurityController.java

@@ -0,0 +1,41 @@
+package ru.spcex.clearing.backendapi.controller.queue.securities;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import ru.clearing.classes.statics.data.security.Security;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+
+import java.util.Collection;
+import java.util.Map;
+
+@Controller
+@RequestMapping("/securities")
+public class SecurityController {
+    private final IStateLoader stateLoader;
+
+    @Autowired
+    public SecurityController(IStateLoader stateLoader) {
+        this.stateLoader = stateLoader;
+    }
+
+    @ApiOperation(value = "get all securities.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransformSpecificClass(
+                IMDGDistributedNames.Map_MoneyMarketSecurity,
+                Security.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/user/UserController.java

@@ -3,6 +3,8 @@ package ru.spcex.clearing.backendapi.controller.queue.user;
 import io.swagger.annotations.ApiOperation;
 import io.swagger.annotations.ApiResponse;
 import io.swagger.annotations.ApiResponses;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.MediaType;
 import org.springframework.security.core.Authentication;
@@ -18,6 +20,7 @@ import ru.spcex.clearing.backendapi.controller.request.cud.utilities.UserAuthAct
 import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse;
 import ru.spcex.clearing.backendapi.controller.response.cud.CudResponse;
 import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.controller.response.entity.user.UserIdResponse;
 import ru.spcex.clearing.backendapi.security.KeycloakUtils;
 import ru.spcex.clearing.backendapi.service.IOperator;
 import ru.spcex.clearing.backendapi.service.IStateLoader;
@@ -33,11 +36,14 @@ import java.util.concurrent.ExecutionException;
 @Controller
 @RequestMapping("/users")
 public class UserController extends AbstractQueueController {
+    private Logger log = LoggerFactory.getLogger(getClass());
     private final IStateLoader stateLoader;
     private final Imdg<User> userImdg;
 
     @Autowired
-    public UserController(IOperator operator, IStateLoader stateLoader, ImdgProvider imdgProvider) {
+    public UserController(IOperator operator,
+                          IStateLoader stateLoader,
+                          ImdgProvider imdgProvider) {
         super(operator);
         this.stateLoader = stateLoader;
         this.userImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_User, User.class);
@@ -54,20 +60,41 @@ public class UserController extends AbstractQueueController {
         return response;
     }
 
+    @ApiOperation(value = "get my id.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = UserIdResponse.class)})
+    @RequestMapping(path = "get-my-id", method = RequestMethod.GET)
+    @ResponseBody
+    public UserIdResponse getId() {
+        UserIdResponse response = new UserIdResponse();
+        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+        String username = KeycloakUtils.getUserNameFromAuthentication(authentication);
+        User user = userImdg.getSingleObjectByFieldValues(Map.of("identifier", username));
+        if (user == null) {
+            log.info("getId user {} authenticated, but User object was not created", username);
+            throw new IllegalStateException("couldn't return user id");
+        }
+        response.getPayload().setId(user.getId());
+        return response;
+    }
+
 
     @ApiOperation(value = "update user")
     @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CudResponse.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)})
     @RequestMapping(method = RequestMethod.PUT, consumes = MediaType.APPLICATION_JSON_VALUE)
     @ResponseBody
     public CudResponse update(
-            @RequestBody UserAuthAction userAuthAction) throws ExecutionException, InterruptedException {
+            @RequestBody UserAuthAction userUpdateAction) throws ExecutionException, InterruptedException {
         Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
         String username = KeycloakUtils.getUserNameFromAuthentication(authentication);
-        User user = userImdg.getSingleObjectByFieldValues(Map.of("identifier", username));
-        if (user == null) {
-            return processRequest(Consts.USER_AUTH_SUCCESS, userAuthAction);
+        if (!username.equals(userUpdateAction.getUsername())) {
+            log.warn("user {} sended update request for user {}", username, userUpdateAction.getUsername());
+            throw new IllegalStateException("cannot perform delete action for " + username);
         }
-        throw new IllegalStateException("cannot create user cause it is exists: " + username);
+//        User user = userImdg.getSingleObjectByFieldValues(Map.of("identifier", username));
+//        if (user == null) {
+//            log.info("update user {} authenticated, but User object was not created", username);
+//        }
+        return processRequest(Consts.USER_UPDATE, userUpdateAction);
     }
 
 

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/utilities/StatementController.java

@@ -0,0 +1,73 @@
+package ru.spcex.clearing.backendapi.controller.queue.utilities;
+
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiParam;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import ru.clearing.classes.statics.data.statement.Statement;
+import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
+import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
+import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetByIdResponse;
+import ru.spcex.clearing.backendapi.controller.response.entity.account.BankAccountBackendGetById;
+import ru.spcex.clearing.backendapi.errors.NotFound404Exception;
+import ru.spcex.clearing.backendapi.meta.GetResponseFactory;
+import ru.spcex.clearing.backendapi.service.IOperator;
+import ru.spcex.clearing.backendapi.service.IStateLoader;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Optional;
+
+@Controller
+@RequestMapping("/statements")
+public class StatementController extends AbstractQueueController {
+    private final IStateLoader stateLoader;
+    private final GetResponseFactory responseMetaFactory;
+
+    @Autowired
+    public StatementController(IOperator operator, IStateLoader stateLoader, GetResponseFactory responseMetaFactory) {
+        super(operator);
+        this.stateLoader = stateLoader;
+        this.responseMetaFactory = responseMetaFactory;
+    }
+
+    @ApiOperation(value = "get all Statement's.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
+    @RequestMapping(method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetAllResponse getAll() {
+        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_Statement, Statement.class);
+        CommonGetAllResponse response = new CommonGetAllResponse();
+        response.fromEntity(all);
+        return response;
+    }
+
+    @ApiOperation(value = "get Statement by Id.")
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = BankAccountBackendGetById.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)})
+    @RequestMapping(value = "/{id}", method = RequestMethod.GET)
+    @ResponseBody
+    public CommonGetByIdResponse getById(@ApiParam(value = "Идентификатор объекта", required = true, example = "1234")
+                                             @PathVariable("id") Long id) {
+        Optional<Statement> statement = stateLoader.getById(id, IMDGDistributedNames.Map_Statement, Statement.class);
+        CommonGetByIdResponse response = new CommonGetByIdResponse();
+        if (statement.isEmpty()) {
+            //можно так, либо response.setCode(404); response.setMessage("blabla"); но тогда еще нужно
+            //отдельно HTTP статус проставлять
+            throw new NotFound404Exception(String.valueOf(id));
+        }
+        Statement stmt = statement.get();
+        Map<String, Object> extractedByMeta = responseMetaFactory.responseFromObject(stmt);
+        response.fromEntity(extractedByMeta);
+        return response;
+    }
+
+
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/account/BankAccountNewAction.java

@@ -8,7 +8,9 @@ import ru.spcex.clearing.backendapi.errors.BackEndError;
 import ru.spcex.clearing.platform.messaging.domain.ActionType;
 import ru.spcex.clearing.platform.messaging.domain.cud.account.BankAccountNewRequest;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.text.TextUtil;
 
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
@@ -39,33 +41,42 @@ public class BankAccountNewAction implements IAction<BankAccountNewRequest> {
     @ApiModelProperty(value = "Код причины постановки (КПП)", example = "01")
     @JsonProperty
     private String taxRegistrationReasonCode;
+    @ApiModelProperty(value = "Номер счета", example = "1234567")
+    @JsonProperty
+    private String account;
+    @ApiModelProperty(value = "Компания", example = "1234")
+    @JsonProperty
+    private Long companyId;
 
     @Override
     public Collection<EnumMessage> validate() {
+        List<EnumMessage> errors = new ArrayList<>();
         if (!StringUtils.hasLength(this.bankIdentificationCode))
-            return List.of(new EnumMessage(BackEndError.ValidationError, "bankIdentificationCode"));
+            errors.add(new EnumMessage(BackEndError.ValidationError, "bankIdentificationCode"));
         if (!StringUtils.hasLength(this.bankName))
-            return List.of(new EnumMessage(BackEndError.ValidationError, "bankIdentificationCode"));
+            errors.add(new EnumMessage(BackEndError.ValidationError, "bankIdentificationCode"));
         if ("RUB".equalsIgnoreCase(this.currency) && !StringUtils.hasLength(correspondentAccount)) {
-            return List.of(new EnumMessage(BackEndError.ValidationError, "correspondentAccount"));
+            errors.add(new EnumMessage(BackEndError.ValidationError, "correspondentAccount"));
         }
         if ("RUB".equalsIgnoreCase(this.currency) && !StringUtils.hasLength(correspondentAccountName)) {
-            return List.of(new EnumMessage(BackEndError.ValidationError, "correspondentAccountName"));
+            errors.add(new EnumMessage(BackEndError.ValidationError, "correspondentAccountName"));
         }
         if (!StringUtils.hasLength(currency)) {
-            return List.of(new EnumMessage(BackEndError.ValidationError, "currency"));
+            errors.add(new EnumMessage(BackEndError.ValidationError, "currency"));
         }
         if (!StringUtils.hasLength(destination)) {
-            return List.of(new EnumMessage(BackEndError.ValidationError, "destination"));
+            errors.add(new EnumMessage(BackEndError.ValidationError, "destination"));
         }
         if ("RUB".equalsIgnoreCase(this.currency) && !StringUtils.hasLength(taxpayerIdentificationNumber)) {
-            return List.of(new EnumMessage(BackEndError.ValidationError, "taxpayerIdentificationNumber"));
+            errors.add(new EnumMessage(BackEndError.ValidationError, "taxpayerIdentificationNumber"));
         }
         if ("RUB".equalsIgnoreCase(this.currency) && !StringUtils.hasLength(taxRegistrationReasonCode)) {
-            return List.of(new EnumMessage(BackEndError.ValidationError, "taxRegistrationReasonCode"));
+            errors.add(new EnumMessage(BackEndError.ValidationError, "taxRegistrationReasonCode"));
         }
-
-        return Collections.emptyList();
+        if (TextUtil.isEmpty(account)) {
+            errors.add(new EnumMessage(BackEndError.ValidationError, "account"));
+        }
+        return errors.isEmpty() ? Collections.emptyList() : errors;
     }
 
     @Override
@@ -79,6 +90,8 @@ public class BankAccountNewAction implements IAction<BankAccountNewRequest> {
         req.setDestination(this.destination);
         req.setTaxpayerIdentificationNumber(this.taxpayerIdentificationNumber);
         req.setTaxRegistrationReasonCode(this.taxRegistrationReasonCode);
+        req.setAccount(this.account);
+        req.setCompanyId(this.companyId);
         return req;
     }
 
@@ -151,4 +164,12 @@ public class BankAccountNewAction implements IAction<BankAccountNewRequest> {
     public void setTaxRegistrationReasonCode(String taxRegistrationReasonCode) {
         this.taxRegistrationReasonCode = taxRegistrationReasonCode;
     }
+
+    public String getAccount() {
+        return account;
+    }
+
+    public void setAccount(String account) {
+        this.account = account;
+    }
 }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/account/BankAccountUpdateAction.java

@@ -40,6 +40,7 @@ public class BankAccountUpdateAction implements IAction<BankAccountUpdateRequest
     private String taxRegistrationReasonCode;
 
     @ApiModelProperty(value = "Номер счета", example = "11111222223333344444")
+    private String account;
 
     @Override
     public Collection<EnumMessage> validate() {
@@ -58,6 +59,7 @@ public class BankAccountUpdateAction implements IAction<BankAccountUpdateRequest
         req.setDestination(this.destination);
         req.setTaxpayerIdentificationNumber(this.taxpayerIdentificationNumber);
         req.setTaxRegistrationReasonCode(this.taxRegistrationReasonCode);
+        req.setAccount(this.account);
         return req;
     }
 
@@ -138,4 +140,12 @@ public class BankAccountUpdateAction implements IAction<BankAccountUpdateRequest
     public void setTaxRegistrationReasonCode(String taxRegistrationReasonCode) {
         this.taxRegistrationReasonCode = taxRegistrationReasonCode;
     }
+
+    public String getAccount() {
+        return account;
+    }
+
+    public void setAccount(String account) {
+        this.account = account;
+    }
 }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/company/ProfileDocumentNewAction.java

@@ -0,0 +1,82 @@
+package ru.spcex.clearing.backendapi.controller.request.cud.company;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import io.swagger.annotations.ApiModelProperty;
+import ru.spcex.clearing.backendapi.domain.actions.IAction;
+import ru.spcex.clearing.platform.messaging.domain.ActionType;
+import ru.spcex.clearing.platform.messaging.domain.cud.company.ProfileDocumentNewRequest;
+import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalDateDeserializer;
+import ru.spcex.clearing.platform.messaging.domain.json.serialize.LocalDateSerializer;
+
+import java.time.LocalDate;
+
+public class ProfileDocumentNewAction implements IAction<ProfileDocumentNewRequest> {
+    @ApiModelProperty(value = "Идентификатор Компании", example = "123")
+    @JsonProperty
+    private Long companyId;
+    @ApiModelProperty(value = "Идентификатор типа документа", example = "ABCD")
+    @JsonProperty
+    private String documentType;
+    @ApiModelProperty(value = "Дата выдачи", example = "2022-12-25")
+    @JsonSerialize(using = LocalDateSerializer.class)
+    @JsonDeserialize(using = LocalDateDeserializer.class)
+    @JsonProperty
+    private LocalDate issueDate;
+    @ApiModelProperty(value = "Место выдачи", example = "Example string")
+    @JsonProperty
+    private String issuePlace;
+    @ApiModelProperty(value = "Кем выдан", example = "Example string")
+    @JsonProperty
+    private String issuer;
+    @ApiModelProperty(value = "Код выдавшего органа", example = "Example string")
+    @JsonProperty
+    private String issuerCode;
+    @ApiModelProperty(value = "Наименование", example = "Example string")
+    @JsonProperty
+    private String name;
+    @ApiModelProperty(value = "Номер", example = "Example string")
+    @JsonProperty
+    private String number;
+    @ApiModelProperty(value = "Место", example = "Example string")
+    @JsonProperty
+    private String place;
+    @ApiModelProperty(value = "Дата начала срока действия", example = "2022-12-25")
+    @JsonSerialize(using = LocalDateSerializer.class)
+    @JsonDeserialize(using = LocalDateDeserializer.class)
+    @JsonProperty
+    private LocalDate validFromDate;
+    @ApiModelProperty(value = "Дата окончания срока действия", example = "2022-12-25")
+    @JsonSerialize(using = LocalDateSerializer.class)
+    @JsonDeserialize(using = LocalDateDeserializer.class)
+    @JsonProperty
+    private LocalDate validToDate;
+    @ApiModelProperty(value = "Ссылка на документ", example = "Example string")
+    @JsonProperty
+    private String link;
+
+    @Override
+    public ProfileDocumentNewRequest toRequest() {
+        ProfileDocumentNewRequest request = new ProfileDocumentNewRequest();
+        request.setCompanyId(this.companyId);
+        request.setDocumentType(this.documentType);
+        request.setIssueDate(this.issueDate);
+        request.setIssuePlace(this.issuePlace);
+        request.setIssuer(this.issuer);
+        request.setIssuerCode(this.issuerCode);
+        request.setName(this.name);
+        request.setNumber(this.number);
+        request.setPlace(this.place);
+        request.setValidFromDate(this.validFromDate);
+        request.setValidToDate(this.validToDate);
+        request.setLink(this.link);
+        return request;
+    }
+
+    @ApiModelProperty(hidden = true)
+    @Override
+    public ActionType getActionType() {
+        return ActionType.NEW;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/company/RelationUpdateAction.java

@@ -0,0 +1,59 @@
+package ru.spcex.clearing.backendapi.controller.request.cud.company;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import io.swagger.annotations.ApiModelProperty;
+import ru.spcex.clearing.backendapi.domain.actions.IAction;
+import ru.spcex.clearing.platform.messaging.domain.ActionType;
+import ru.spcex.clearing.platform.messaging.domain.cud.company.RelationUpdateRequest;
+import ru.spcex.platform.classes.base.interfaces.WithId;
+
+public class RelationUpdateAction implements IAction<RelationUpdateRequest>, WithId {
+    @ApiModelProperty(hidden = true)
+    @JsonProperty
+    public Long id;
+    @ApiModelProperty(value = "Идентификатор статуса", example = "ABCD")
+    @JsonProperty
+    private String serviceStatus;
+    @ApiModelProperty(value = "Текст причины", example = "Example text")
+    @JsonProperty
+    private String comment;
+
+    @Override
+    public RelationUpdateRequest toRequest() {
+        RelationUpdateRequest request = new RelationUpdateRequest();
+        request.setId(this.id);
+        request.setServiceStatus(this.serviceStatus);
+        request.setComment(this.comment);
+        return request;
+    }
+
+    @ApiModelProperty(hidden = true)
+    @Override
+    public ActionType getActionType() {
+        return ActionType.UPDATE;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getServiceStatus() {
+        return serviceStatus;
+    }
+
+    public void setServiceStatus(String serviceStatus) {
+        this.serviceStatus = serviceStatus;
+    }
+
+    public String getComment() {
+        return comment;
+    }
+
+    public void setComment(String comment) {
+        this.comment = comment;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/schedule/ClearingCalendarNewAction.java

@@ -40,6 +40,7 @@ public class ClearingCalendarNewAction implements IAction<ClearingCalendarNewReq
         return clearingCalendarNewRequest;
     }
 
+    @ApiModelProperty(hidden = true)
     @Override
     public ActionType getActionType() {
         return ActionType.NEW;

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/schedule/ClearingCalendarUpdateAction.java

@@ -46,6 +46,7 @@ public class ClearingCalendarUpdateAction implements IAction<ClearingCalendarUpd
         return clearingCalendarUpdateRequest;
     }
 
+    @ApiModelProperty(hidden = true)
     @Override
     public ActionType getActionType() {
         return ActionType.UPDATE;

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/schedule/LauncherNew.java

@@ -6,14 +6,16 @@ import io.swagger.annotations.ApiModelProperty;
 import ru.spcex.clearing.backendapi.domain.actions.IAction;
 import ru.spcex.clearing.backendapi.errors.BackEndError;
 import ru.spcex.clearing.platform.messaging.domain.ActionType;
+import ru.spcex.clearing.platform.messaging.domain.cud.reports.ReportWithPeriodRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest;
+import ru.spcex.platform.enumeration.Task;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
 
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
-public class LauncherNew implements IAction<LauncherCommandRequest> {
+public class LauncherNew implements IAction<Object> {
     @ApiModelProperty(value = "Идентификатор единоличного исполнительного органа", example = "ABCD")
     @JsonProperty
     private String task;
@@ -22,11 +24,17 @@ public class LauncherNew implements IAction<LauncherCommandRequest> {
     private Long userId;
 
     @Override
-    public LauncherCommandRequest toRequest() {
-        LauncherCommandRequest taskRunnerCommandRequest = new LauncherCommandRequest();
-        taskRunnerCommandRequest.setTaskName(task);
-        taskRunnerCommandRequest.setUserId(userId);
-        return taskRunnerCommandRequest;
+    public Object toRequest() {
+        if (Task.createReport_GREP.equalsByKey(task)) {
+            ReportWithPeriodRequest reportCommand = new ReportWithPeriodRequest();
+            reportCommand.setReportId(task);
+            return reportCommand;
+        } else {
+            LauncherCommandRequest taskRunnerCommandRequest = new LauncherCommandRequest();
+            taskRunnerCommandRequest.setTaskName(task);
+            taskRunnerCommandRequest.setUserId(userId);
+            return taskRunnerCommandRequest;
+        }
     }
 
     @Override

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/schedule/PlannerNewAction.java

@@ -26,7 +26,7 @@ public class PlannerNewAction implements IAction<PlannerNewRequest> {
     @JsonProperty
     private String task;
 
-    @ApiModelProperty(value = "Время", example = "16:30:00")
+    @ApiModelProperty(value = "Время", dataType = "java.lang.String", example = "16:30:00")
     @JsonSerialize(using = LocalTimeSerializer.class)
     @JsonDeserialize(using = LocalTimeDeserializer.class)
     @JsonProperty
@@ -46,6 +46,10 @@ public class PlannerNewAction implements IAction<PlannerNewRequest> {
     @JsonProperty
     public String taskStatus;
 
+    @ApiModelProperty(value = "Компания", example = "1000")
+    @JsonProperty
+    public Long companyId;
+
     @ApiModelProperty(value = "Инструмент", example = "1000")
     @JsonProperty
     public Long securityId;
@@ -58,10 +62,12 @@ public class PlannerNewAction implements IAction<PlannerNewRequest> {
         plannerNewRequest.setClearingDate(clearingDate);
         plannerNewRequest.setMarket(market);
         plannerNewRequest.setTaskStatus(taskStatus);
+        plannerNewRequest.setCompanyId(companyId);
         plannerNewRequest.setSecurityId(securityId);
         return plannerNewRequest;
     }
 
+    @ApiModelProperty(hidden = true)
     @Override
     public ActionType getActionType() {
         return ActionType.NEW;

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/schedule/PlannerTemplateNewAction.java

@@ -3,6 +3,7 @@ package ru.spcex.clearing.backendapi.controller.request.cud.schedule;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import io.swagger.annotations.ApiModelProperty;
 import ru.spcex.clearing.backendapi.domain.actions.IAction;
 import ru.spcex.clearing.backendapi.errors.BackEndError;
 import ru.spcex.clearing.platform.messaging.domain.ActionType;
@@ -18,14 +19,23 @@ import java.util.Collection;
 import java.util.List;
 
 public class PlannerTemplateNewAction implements IAction<PlannerTemplateNewRequest> {
+    @ApiModelProperty(value = "Идентификатор задачи", example = "ADBC")
     @JsonProperty
     public String task;
+    @ApiModelProperty(value = "Время задачи", dataType = "java.lang.String", example = "16:30:00")
     @JsonSerialize(using = LocalTimeSerializer.class)
     @JsonDeserialize(using = LocalTimeDeserializer.class)
     @JsonProperty
     public LocalTime taskTime;
+    @ApiModelProperty(value = "Статус", example = "ACTV")
     @JsonProperty
     public String taskStatus;
+    @ApiModelProperty(value = "Компания", example = "123")
+    @JsonProperty
+    public Long companyId;
+    @ApiModelProperty(value = "Инструмент", example = "123")
+    @JsonProperty
+    public Long securityId;
 
     @Override
     public PlannerTemplateNewRequest toRequest() {
@@ -33,9 +43,12 @@ public class PlannerTemplateNewAction implements IAction<PlannerTemplateNewReque
         plannerTemplateNewRequest.setTask(task);
         plannerTemplateNewRequest.setTaskTime(taskTime);
         plannerTemplateNewRequest.setTaskStatus(taskStatus);
+        plannerTemplateNewRequest.setCompanyId(companyId);
+        plannerTemplateNewRequest.setSecurityId(securityId);
         return plannerTemplateNewRequest;
     }
 
+    @ApiModelProperty(hidden = true)
     @Override
     public ActionType getActionType() {
         return ActionType.NEW;
@@ -79,4 +92,20 @@ public class PlannerTemplateNewAction implements IAction<PlannerTemplateNewReque
     public void setTaskStatus(String taskStatus) {
         this.taskStatus = taskStatus;
     }
+
+    public Long getCompanyId() {
+        return companyId;
+    }
+
+    public void setCompanyId(Long companyId) {
+        this.companyId = companyId;
+    }
+
+    public Long getSecurityId() {
+        return securityId;
+    }
+
+    public void setSecurityId(Long securityId) {
+        this.securityId = securityId;
+    }
 }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/schedule/PlannerTemplateUpdateAction.java

@@ -23,14 +23,23 @@ public class PlannerTemplateUpdateAction implements IAction<PlannerTemplateUpdat
     @ApiModelProperty(hidden = true)
     @JsonProperty
     public Long id;
+    @ApiModelProperty(value = "Идентификатор задачи", example = "ADBC")
     @JsonProperty
     public String task;
+    @ApiModelProperty(value = "Время задачи", dataType = "java.lang.String", example = "16:30:00")
     @JsonSerialize(using = LocalTimeSerializer.class)
     @JsonDeserialize(using = LocalTimeDeserializer.class)
     @JsonProperty
     public LocalTime taskTime;
+    @ApiModelProperty(value = "Статус", example = "ACTV")
     @JsonProperty
     public String taskStatus;
+    @ApiModelProperty(value = "Компания", example = "123")
+    @JsonProperty
+    public Long companyId;
+    @ApiModelProperty(value = "Инструмент", example = "123")
+    @JsonProperty
+    public Long securityId;
 
     @Override
     public PlannerTemplateUpdateRequest toRequest() {
@@ -39,9 +48,12 @@ public class PlannerTemplateUpdateAction implements IAction<PlannerTemplateUpdat
         plannerTemplateUpdateRequest.setTask(task);
         plannerTemplateUpdateRequest.setTaskTime(taskTime);
         plannerTemplateUpdateRequest.setTaskStatus(taskStatus);
+        plannerTemplateUpdateRequest.setCompanyId(companyId);
+        plannerTemplateUpdateRequest.setSecurityId(securityId);
         return plannerTemplateUpdateRequest;
     }
 
+    @ApiModelProperty(hidden = true)
     @Override
     public ActionType getActionType() {
         return ActionType.UPDATE;
@@ -97,4 +109,20 @@ public class PlannerTemplateUpdateAction implements IAction<PlannerTemplateUpdat
     public void setTaskStatus(String taskStatus) {
         this.taskStatus = taskStatus;
     }
+
+    public Long getCompanyId() {
+        return companyId;
+    }
+
+    public void setCompanyId(Long companyId) {
+        this.companyId = companyId;
+    }
+
+    public Long getSecurityId() {
+        return securityId;
+    }
+
+    public void setSecurityId(Long securityId) {
+        this.securityId = securityId;
+    }
 }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/schedule/PlannerUpdateAction.java

@@ -31,7 +31,7 @@ public class PlannerUpdateAction implements IAction<PlannerUpdateRequest>, WithI
     @JsonProperty
     private String task;
 
-    @ApiModelProperty(value = "Время", example = "16:30:00")
+    @ApiModelProperty(value = "Время", dataType = "java.lang.String", example = "16:30:00")
     @JsonSerialize(using = LocalTimeSerializer.class)
     @JsonDeserialize(using = LocalTimeDeserializer.class)
     @JsonProperty
@@ -51,6 +51,10 @@ public class PlannerUpdateAction implements IAction<PlannerUpdateRequest>, WithI
     @JsonProperty
     public String taskStatus;
 
+    @ApiModelProperty(value = "Компания", example = "1000")
+    @JsonProperty
+    public Long companyId;
+
     @ApiModelProperty(value = "Инструмент", example = "1000")
     @JsonProperty
     public Long securityId;
@@ -64,10 +68,12 @@ public class PlannerUpdateAction implements IAction<PlannerUpdateRequest>, WithI
         plannerUpdateRequest.setClearingDate(clearingDate);
         plannerUpdateRequest.setMarket(market);
         plannerUpdateRequest.setTaskStatus(taskStatus);
+        plannerUpdateRequest.setCompanyId(companyId);
         plannerUpdateRequest.setSecurityId(securityId);
         return plannerUpdateRequest;
     }
 
+    @ApiModelProperty(hidden = true)
     @Override
     public ActionType getActionType() {
         return ActionType.UPDATE;
@@ -150,4 +156,12 @@ public class PlannerUpdateAction implements IAction<PlannerUpdateRequest>, WithI
     public void setSecurityId(Long securityId) {
         this.securityId = securityId;
     }
+
+    public Long getCompanyId() {
+        return companyId;
+    }
+
+    public void setCompanyId(Long companyId) {
+        this.companyId = companyId;
+    }
 }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/securities/MoneyMarketSecurityNewAction.java

@@ -9,14 +9,17 @@ import ru.spcex.clearing.backendapi.errors.BackEndError;
 import ru.spcex.clearing.platform.messaging.domain.ActionType;
 import ru.spcex.clearing.platform.messaging.domain.cud.securitites.MoneyMarketSecurityNewRequest;
 import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalDateDeserializer;
+import ru.spcex.platform.classes.base.interfaces.WithSecuritySymbol;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.text.TextUtil;
 
 import java.time.LocalDate;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
-public class MoneyMarketSecurityNewAction implements IAction<MoneyMarketSecurityNewRequest> {
+public class MoneyMarketSecurityNewAction implements IAction<MoneyMarketSecurityNewRequest>, WithSecuritySymbol {
     @ApiModelProperty(value = "Дата начала действия", example = "2022-01-20")
     @JsonFormat(pattern = "yyyy-MM-dd", timezone = "Europe/Moscow")
     @JsonDeserialize(using = LocalDateDeserializer.class)
@@ -48,9 +51,24 @@ public class MoneyMarketSecurityNewAction implements IAction<MoneyMarketSecurity
 
     @Override
     public Collection<EnumMessage> validate() {
+        List<EnumMessage> errors = new ArrayList<>();
         if (this.startDate == null)
-            return List.of(new EnumMessage(BackEndError.ValidationError, "startDate"));
-        else return Collections.emptyList();
+            errors.add(new EnumMessage(BackEndError.ValidationError, "startDate"));
+        if (this.endDate == null)
+            errors.add(new EnumMessage(BackEndError.ValidationError, "endDate"));
+        if (this.nominalValue == null)
+            errors.add(new EnumMessage(BackEndError.ValidationError, "nominalValue"));
+        if (TextUtil.isEmpty(nominalCurrency))
+            errors.add(new EnumMessage(BackEndError.ValidationError, "nominalCurrency"));
+        if (TextUtil.isEmpty(instrumentType))
+            errors.add(new EnumMessage(BackEndError.ValidationError, "instrumentType"));
+        if (TextUtil.isEmpty(fullName))
+            errors.add(new EnumMessage(BackEndError.ValidationError, "fullName"));
+        if (TextUtil.isEmpty(securitySymbol))
+            errors.add(new EnumMessage(BackEndError.ValidationError, "securitySymbol"));
+        if (this.lotSize == null)
+            errors.add(new EnumMessage(BackEndError.ValidationError, "lotSize"));
+        return errors.size() > 0 ? errors : Collections.emptyList();
     }
 
     @Override

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/securities/MoneyMarketSecurityUpdateAction.java

@@ -5,17 +5,29 @@ import com.fasterxml.jackson.annotation.JsonProperty;
 import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
 import io.swagger.annotations.ApiModelProperty;
 import ru.spcex.clearing.backendapi.domain.actions.IAction;
+import ru.spcex.clearing.backendapi.errors.BackEndError;
 import ru.spcex.clearing.platform.messaging.domain.ActionType;
 import ru.spcex.clearing.platform.messaging.domain.cud.securitites.MoneyMarketSecurityUpdateRequest;
 import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalDateDeserializer;
 import ru.spcex.platform.classes.base.interfaces.WithId;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.text.TextUtil;
 
 import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
 
 public class MoneyMarketSecurityUpdateAction implements IAction<MoneyMarketSecurityUpdateRequest>, WithId {
     @ApiModelProperty(hidden = true)
     @JsonProperty
     public Long id;
+    @ApiModelProperty(value = "Дата начала действия", example = "2022-02-21")
+    @JsonFormat(pattern = "yyyy-MM-dd", timezone = "Europe/Moscow")
+    @JsonDeserialize(using = LocalDateDeserializer.class)
+    @JsonProperty
+    public LocalDate startDate;
     @ApiModelProperty(value = "Дата окончания действия", example = "2022-02-21")
     @JsonFormat(pattern = "yyyy-MM-dd", timezone = "Europe/Moscow")
     @JsonDeserialize(using = LocalDateDeserializer.class)
@@ -41,6 +53,7 @@ public class MoneyMarketSecurityUpdateAction implements IAction<MoneyMarketSecur
     public MoneyMarketSecurityUpdateRequest toRequest() {
         var req = new MoneyMarketSecurityUpdateRequest();
         req.setId(this.getId());
+        req.setStartDate(this.getStartDate());
         req.setEndDate(this.getEndDate());
         req.setNominalValue(this.getNominalValue());
         req.setNominalCurrency(this.getNominalCurrency());
@@ -50,6 +63,26 @@ public class MoneyMarketSecurityUpdateAction implements IAction<MoneyMarketSecur
         return req;
     }
 
+    @Override
+    public Collection<EnumMessage> validate() {
+        List<EnumMessage> errors = new ArrayList<>();
+        if (this.startDate == null)
+            errors.add(new EnumMessage(BackEndError.ValidationError, "startDate"));
+        if (this.endDate == null)
+            errors.add(new EnumMessage(BackEndError.ValidationError, "endDate"));
+        if (this.nominalValue == null)
+            errors.add(new EnumMessage(BackEndError.ValidationError, "nominalValue"));
+        if (TextUtil.isEmpty(nominalCurrency))
+            errors.add(new EnumMessage(BackEndError.ValidationError, "nominalCurrency"));
+        if (TextUtil.isEmpty(instrumentType))
+            errors.add(new EnumMessage(BackEndError.ValidationError, "instrumentType"));
+        if (TextUtil.isEmpty(fullName))
+            errors.add(new EnumMessage(BackEndError.ValidationError, "fullName"));
+        if (this.lotSize == null)
+            errors.add(new EnumMessage(BackEndError.ValidationError, "lotSize"));
+        return errors.size() > 0 ? errors : Collections.emptyList();
+    }
+
     @ApiModelProperty(hidden = true)
     @Override
     public ActionType getActionType() {
@@ -112,4 +145,12 @@ public class MoneyMarketSecurityUpdateAction implements IAction<MoneyMarketSecur
     public void setId(Long id) {
         this.id = id;
     }
+
+    public LocalDate getStartDate() {
+        return startDate;
+    }
+
+    public void setStartDate(LocalDate startDate) {
+        this.startDate = startDate;
+    }
 }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/utilities/KeyRateNewAction.java

@@ -20,7 +20,7 @@ import java.util.List;
 public class KeyRateNewAction implements IAction<KeyRateNewRequest> {
     @ApiModelProperty(value = "Ключевая ставка ЦБ РФ", example = "12.5")
     @JsonProperty
-    public BigDecimal keyRate;
+    public BigDecimal rate;
     @ApiModelProperty(value = "Дата начала действия ключевой ставки", example = "2022-01-20")
     @JsonFormat(pattern = "yyyy-MM-dd", timezone = "Europe/Moscow")
     @JsonDeserialize(using = LocalDateDeserializer.class)
@@ -53,17 +53,17 @@ public class KeyRateNewAction implements IAction<KeyRateNewRequest> {
         var req = new KeyRateNewRequest();
         req.setStartDate(this.getStartDate());
         req.setEndDate(this.getEndDate());
-        req.setKeyRate(this.getKeyRate());
+        req.setKeyRate(this.getRate());
         req.setDocument(this.getDocument());
         return req;
     }
 
-    public BigDecimal getKeyRate() {
-        return keyRate;
+    public BigDecimal getRate() {
+        return rate;
     }
 
-    public void setKeyRate(BigDecimal keyRate) {
-        this.keyRate = keyRate;
+    public void setRate(BigDecimal rate) {
+        this.rate = rate;
     }
 
     public LocalDate getStartDate() {

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/utilities/KeyRateUpdateAction.java

@@ -18,7 +18,7 @@ public class KeyRateUpdateAction implements IAction<KeyRateUpdateRequest> {
     public Long id;
     @ApiModelProperty(value = "Ключевая ставка ЦБ РФ", example = "12.5")
     @JsonProperty
-    public BigDecimal keyRate;
+    public BigDecimal rate;
     @ApiModelProperty(value = "Дата начала действия ключевой ставки", example = "2022-01-20")
     @JsonFormat(pattern = "yyyy-MM-dd", timezone = "Europe/Moscow")
     @JsonDeserialize(using = LocalDateDeserializer.class)
@@ -45,17 +45,17 @@ public class KeyRateUpdateAction implements IAction<KeyRateUpdateRequest> {
         req.setId(this.getId());
         req.setStartDate(this.getStartDate());
         req.setEndDate(this.getEndDate());
-        req.setKeyRate(this.getKeyRate());
+        req.setKeyRate(this.getRate());
         req.setDocument(this.getDocument());
         return req;
     }
 
-    public BigDecimal getKeyRate() {
-        return keyRate;
+    public BigDecimal getRate() {
+        return rate;
     }
 
-    public void setKeyRate(BigDecimal keyRate) {
-        this.keyRate = keyRate;
+    public void setRate(BigDecimal rate) {
+        this.rate = rate;
     }
 
     public LocalDate getStartDate() {

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/utilities/UserAuthAction.java

@@ -1,43 +1,68 @@
 package ru.spcex.clearing.backendapi.controller.request.cud.utilities;
 
 
+import com.fasterxml.jackson.annotation.JsonProperty;
 import ru.spcex.clearing.backendapi.domain.actions.IAction;
 import ru.spcex.clearing.backendapi.errors.BackEndError;
 import ru.spcex.clearing.platform.messaging.domain.ActionType;
-import ru.spcex.clearing.platform.messaging.domain.cud.utilities.UserAuthRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.utilities.UserUpdateRequest;
+import ru.spcex.platform.enumeration.UserRole;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.enumeration.IEnumKey;
 
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
-public class UserAuthAction implements IAction<UserAuthRequest> {
-    private final UserAuthRequest authRequest;
-
-    public UserAuthAction() {
-        this.authRequest = new UserAuthRequest();
-    }
-
-    public UserAuthRequest getAuthRequest() {
-        return authRequest;
-    }
+public class UserAuthAction implements IAction<UserUpdateRequest> {
+    @JsonProperty
+    private String username;
+    @JsonProperty
+    private List<String> roles = new ArrayList<>();
 
     @Override
     public Collection<EnumMessage> validate() {
-        long count = authRequest.getRoles().stream().distinct().count();
-        if (count != authRequest.getRoles().size()) {
+        long count = roles.stream().distinct().count();
+        if (count != roles.size()) {
             return List.of(new EnumMessage(BackEndError.KeycloakRepeatedRoles));
         }
+        boolean unknownRolePresent = roles
+                .stream()
+                .anyMatch(role -> IEnumKey.getEnumByKey(UserRole.class, role) == null);
+        if (unknownRolePresent) {
+            return List.of(new EnumMessage(BackEndError.ValidationError, roles));
+        }
         return Collections.emptyList();
     }
 
     @Override
-    public UserAuthRequest toRequest() {
-        return authRequest;
+    public UserUpdateRequest toRequest() {
+        UserUpdateRequest userUpdateRequest = new UserUpdateRequest();
+        userUpdateRequest.setUsername(username);
+        userUpdateRequest.setRoles(roles);
+        return userUpdateRequest;
+
     }
 
     @Override
     public ActionType getActionType() {
-        return ActionType.SYSTEM;
+        return ActionType.UPDATE;
+    }
+
+    public String getUsername() {
+        return username;
+    }
+
+    public void setUsername(String username) {
+        this.username = username;
+    }
+
+    public List<String> getRoles() {
+        return roles;
+    }
+
+    public void setRoles(List<String> roles) {
+        this.roles = roles;
     }
 }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/utilities/UserAuthSystemAction.java

@@ -0,0 +1,42 @@
+package ru.spcex.clearing.backendapi.controller.request.cud.utilities;
+
+
+import ru.spcex.clearing.backendapi.domain.actions.IAction;
+import ru.spcex.clearing.backendapi.errors.BackEndError;
+import ru.spcex.clearing.platform.messaging.domain.ActionType;
+import ru.spcex.clearing.platform.messaging.domain.cud.utilities.UserAuthRequest;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+public class UserAuthSystemAction implements IAction<UserAuthRequest> {
+private final UserAuthRequest authRequest;
+
+    public UserAuthSystemAction() {
+        this.authRequest = new UserAuthRequest();
+    }
+
+    public UserAuthRequest getAuthRequest() {
+        return authRequest;
+    }
+
+    @Override
+    public Collection<EnumMessage> validate() {
+        long count = authRequest.getRoles().stream().distinct().count();
+        if (count != authRequest.getRoles().size()) {
+            return List.of(new EnumMessage(BackEndError.KeycloakRepeatedRoles));
+        }
+        return Collections.emptyList();
+    }
+
+    @Override
+    public UserAuthRequest toRequest() {
+        return authRequest;
+    }
+
+    @Override
+    public ActionType getActionType() {
+        return ActionType.SYSTEM;
+    }}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/CommonGetByIdResponse.java

@@ -0,0 +1,42 @@
+package ru.spcex.clearing.backendapi.controller.response.entity;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@ApiModel(description = "Ответ при получении объекта по ID.")
+public class CommonGetByIdResponse extends BasicSpcexResponse {
+
+    @JsonProperty
+    @ApiModelProperty(value = "Полезная нагрузка")
+    private GetByIdCommonPayload payload = new GetByIdCommonPayload();
+
+    private static class GetByIdCommonPayload {
+        private Map<String, Object> object = new HashMap<>();
+
+        public Map<String, Object> getObject() {
+            return object;
+        }
+
+        public void setObject(Map<String, Object> object) {
+            this.object = object;
+        }
+    }
+
+    public GetByIdCommonPayload getPayload() {
+        return payload;
+    }
+
+    public void setPayload(GetByIdCommonPayload payload) {
+        this.payload = payload;
+    }
+
+    public void fromEntity(Map<String, Object> anyObjectFields) {
+        var payload = this.getPayload();
+        payload.setObject(anyObjectFields);
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/dictionary/DictionaryBackendGetAll.java

@@ -9,25 +9,34 @@ import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
+import java.util.Map;
 
 @ApiModel(description = "Ответ при получении объектов словаря.")
 public class DictionaryBackendGetAll extends BasicSpcexResponse {
 
     @JsonProperty
     @ApiModelProperty(value = "Полезная нагрузка")
-    private DictionaryBackendPayload payload = new DictionaryBackendPayload();
+    private IDictionaryPayload payload;
 
     public void fromEntity(Collection<AbstractDictionary> dictionaryValues) {
-        var payload = this.getPayload();
+        this.payload = new GeneralDictionaryBackendPayload();
+        GeneralDictionaryBackendPayload castedPayload = (GeneralDictionaryBackendPayload) payload;
         for (AbstractDictionary dictionaryValue : dictionaryValues) {
             var singleItem = new DictionaryBackendGetFields();
             singleItem.fromEntity(dictionaryValue);
-            payload.getItems().add(singleItem);
+            castedPayload.getItems().add(singleItem);
         }
     }
 
+    public void addMap(Map<String, Object> m) {
+        if (this.payload == null) {
+            this.payload = new SpecificDictionaryBackendPayload();
+        }
+        SpecificDictionaryBackendPayload payloadCasted = (SpecificDictionaryBackendPayload) this.payload;
+        payloadCasted.getItems().add(m);
+    }
 
-    private static class DictionaryBackendPayload {
+    public static class GeneralDictionaryBackendPayload implements IDictionaryPayload {
         private List<DictionaryBackendGetFields> items = new ArrayList<>();
 
         public List<DictionaryBackendGetFields> getItems() {
@@ -39,11 +48,24 @@ public class DictionaryBackendGetAll extends BasicSpcexResponse {
         }
     }
 
-    public DictionaryBackendPayload getPayload() {
+    public static class SpecificDictionaryBackendPayload implements IDictionaryPayload {
+        @JsonProperty
+        private List<Map<String, Object>> items = new ArrayList<>();
+
+        public List<Map<String, Object>> getItems() {
+            return items;
+        }
+
+        public void setItems(List<Map<String, Object>> items) {
+            this.items = items;
+        }
+    }
+
+    public IDictionaryPayload getPayload() {
         return payload;
     }
 
-    public void setPayload(DictionaryBackendPayload payload) {
+    public void setPayload(IDictionaryPayload payload) {
         this.payload = payload;
     }
 }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/dictionary/DictionaryBackendGetFields.java

@@ -4,7 +4,7 @@ import com.fasterxml.jackson.annotation.JsonProperty;
 import io.swagger.annotations.ApiModelProperty;
 import ru.clearing.platform.dictionary.AbstractDictionary;
 
-public class DictionaryBackendGetFields {
+public class DictionaryBackendGetFields implements IDictionaryPayload {
     @JsonProperty
     @ApiModelProperty(value = "Идентификатор", example = "1234")
     private Long id;

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/dictionary/DictionaryBackendGetSingleValueV2.java

@@ -0,0 +1,25 @@
+package ru.spcex.clearing.backendapi.controller.response.entity.dictionary;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@ApiModel(description = "Ответ при получении объекта словаря.")
+public class DictionaryBackendGetSingleValueV2 extends BasicSpcexResponse {
+
+    @JsonProperty
+    @ApiModelProperty(value = "Поля объекта")
+    private Map<String, Object> payload = new HashMap<>();
+
+    public Map<String, Object> getPayload() {
+        return payload;
+    }
+
+    public void setPayload(Map<String, Object> payload) {
+        this.payload = payload;
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/dictionary/IDictionaryPayload.java

@@ -0,0 +1,4 @@
+package ru.spcex.clearing.backendapi.controller.response.entity.dictionary;
+
+public interface IDictionaryPayload {
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/response/entity/user/UserIdResponse.java

@@ -0,0 +1,36 @@
+package ru.spcex.clearing.backendapi.controller.response.entity.user;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse;
+
+@ApiModel(description = "Ответ содержащий id текущего пользователя.")
+public class UserIdResponse extends BasicSpcexResponse {
+
+    @JsonProperty
+    @ApiModelProperty(value = "Полезная нагрузка")
+    private UserIdPayload payload = new UserIdPayload();
+
+    public UserIdPayload getPayload() {
+        return payload;
+    }
+
+    public void setPayload(UserIdPayload payload) {
+        this.payload = payload;
+    }
+
+    public static class UserIdPayload {
+        @JsonProperty
+        @ApiModelProperty(value = "Id текущего пользователя")
+        private Long id;
+
+        public Long getId() {
+            return id;
+        }
+
+        public void setId(Long id) {
+            this.id = id;
+        }
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/system/DictionaryController.java

@@ -13,10 +13,11 @@ import org.springframework.web.bind.annotation.*;
 import ru.clearing.platform.dictionary.AbstractDictionary;
 import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse;
 import ru.spcex.clearing.backendapi.controller.response.entity.dictionary.DictionaryBackendGetAll;
-import ru.spcex.clearing.backendapi.controller.response.entity.dictionary.DictionaryBackendGetSingleValue;
+import ru.spcex.clearing.backendapi.controller.response.entity.dictionary.DictionaryBackendGetSingleValueV2;
 import ru.spcex.clearing.backendapi.errors.ActionValidationException;
 import ru.spcex.clearing.backendapi.errors.BackEndError;
 import ru.spcex.clearing.backendapi.errors.NotFound404Exception;
+import ru.spcex.clearing.backendapi.meta.GetResponseFactory;
 import ru.spcex.platform.classes.base.SpcexObjectBase;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
@@ -33,10 +34,12 @@ public class DictionaryController {
     private final Logger log = LoggerFactory.getLogger(getClass());
     private final Map<String, Imdg<?>> allDictionaryMaps;
     private final ImdgProvider imdgProvider;
+    private final GetResponseFactory responseFactory;
 
     @Autowired
-    public DictionaryController(ImdgProvider imdgProvider) {
+    public DictionaryController(ImdgProvider imdgProvider, GetResponseFactory responseFactory) {
         this.imdgProvider = imdgProvider;
+        this.responseFactory = responseFactory;
         this.allDictionaryMaps = new ConcurrentHashMap<>();
     }
 
@@ -49,39 +52,42 @@ public class DictionaryController {
         Imdg<AbstractDictionary> dictionary = extractDictionaryImdgFromUrlParameter(dictionaryName, AbstractDictionary.class);
         Collection<AbstractDictionary> allValues = dictionary.getAllValues();
         DictionaryBackendGetAll response = new DictionaryBackendGetAll();
-        response.fromEntity(allValues);
+        for (AbstractDictionary val : allValues) {
+            Map<String, Object> fromMeta = responseFactory.responseFromDictionary(dictionaryName, val);
+            response.addMap(fromMeta);
+        }
         return response;
     }
 
     @ApiOperation(value = "get dictionary value by id.")
-    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = DictionaryBackendGetSingleValue.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)})
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = DictionaryBackendGetSingleValueV2.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)})
     @RequestMapping(value = "/{dictionary-name}/{id}", method = RequestMethod.GET)
     @ResponseBody
-    public DictionaryBackendGetSingleValue getById(@ApiParam(value = "Название словаря", required = true, example = "moneyFlowSide")
+    public DictionaryBackendGetSingleValueV2 getById(@ApiParam(value = "Название словаря", required = true, example = "moneyFlowSide")
                                                        @PathVariable("dictionary-name") String dictionaryName,
                                                    @ApiParam(value = "Идентификатор объекта", required = true, example = "1234")
                                              @PathVariable("id") Long id) {
         Imdg<AbstractDictionary> dictionary = extractDictionaryImdgFromUrlParameter(dictionaryName, AbstractDictionary.class);
         AbstractDictionary value = dictionary.getSingleObjectByID(id);
         if (value == null) throw new NotFound404Exception(dictionaryName + " id='" + id + "'");
-        DictionaryBackendGetSingleValue response = new DictionaryBackendGetSingleValue();
-        response.fromEntity(value);
+        DictionaryBackendGetSingleValueV2 response = new DictionaryBackendGetSingleValueV2();
+        response.setPayload(responseFactory.responseFromDictionary(dictionaryName, value));
         return response;
     }
 
     @ApiOperation(value = "get dictionary value by code.")
-    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = DictionaryBackendGetSingleValue.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)})
+    @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = DictionaryBackendGetSingleValueV2.class), @ApiResponse(code = 400, message = "Ошибка валидации", response = BasicSpcexResponse.class)})
     @RequestMapping(value = "/{dictionary-name}/code/{code}", method = RequestMethod.GET)
     @ResponseBody
-    public DictionaryBackendGetSingleValue getByCode(@ApiParam(value = "Название словаря", required = true, example = "moneyFlowSide")
+    public DictionaryBackendGetSingleValueV2 getByCode(@ApiParam(value = "Название словаря", required = true, example = "moneyFlowSide")
                                                        @PathVariable("dictionary-name") String dictionaryName,
                                                    @ApiParam(value = "Код словаря", required = true, example = "1234")
                                              @PathVariable("code") String code) {
         Imdg<AbstractDictionary> dictionary = extractDictionaryImdgFromUrlParameter(dictionaryName, AbstractDictionary.class);
         AbstractDictionary value = dictionary.getSingleObjectByFieldValues(Map.of("code", code));
         if (value == null) throw new NotFound404Exception(dictionaryName + " code='" + code + "'");
-        DictionaryBackendGetSingleValue response = new DictionaryBackendGetSingleValue();
-        response.fromEntity(value);
+        DictionaryBackendGetSingleValueV2 response = new DictionaryBackendGetSingleValueV2();
+        response.setPayload(responseFactory.responseFromDictionary(dictionaryName, value));
         return response;
     }
 

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/system/RequestStatusController.java

@@ -43,6 +43,7 @@ public class RequestStatusController {
         }
         RequestInfoResponse response = new RequestInfoResponse();
         response.setStatus(singleObjectByID.getStatus());
+        response.setMessage(singleObjectByID.getMessage());
         return response;
     }
 }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/errors/NotFound404Exception.java

@@ -10,6 +10,10 @@ public class NotFound404Exception extends RuntimeException {
         this.error = new EnumMessage(BackEndError.ResourceNotFound, comment);
     }
 
+    public NotFound404Exception(EnumMessage error) {
+        this.error = error;
+    }
+
     public EnumMessage getError() {
         return error;
     }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ClearingDictionaryExtracted.java

@@ -0,0 +1,22 @@
+package ru.spcex.clearing.backendapi.meta;
+
+import java.util.List;
+
+public class ClearingDictionaryExtracted extends ObjectExtracted {
+
+    public ClearingDictionaryExtracted(String clazz, List<ActionField> actionFields) {
+        for (ActionField field : actionFields) {
+            if (field.getVirtual() != null && field.isVirtual()){
+                continue;
+            }
+            FieldExtracted fe = getImplFieldExtracted(field);
+            fields.add(fe);
+            fieldByCode.put(field.getCode(), fe);
+        }
+    }
+
+    @Override
+    public FieldExtracted getImplFieldExtracted(ActionField field) {
+        return new ClearingFieldExtracted(field);
+    }
+}

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/GetResponseFactory.java

@@ -8,15 +8,18 @@ import org.springframework.stereotype.Component;
 
 import java.text.SimpleDateFormat;
 import java.time.Instant;
+import java.time.LocalTime;
 import java.time.ZoneId;
 import java.time.format.DateTimeFormatter;
 import java.util.*;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 
 @Component
 public class GetResponseFactory {
     private final Logger log = LoggerFactory.getLogger(getClass());
     private final MetaServer meta;
+    private static final DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("HH:mm:ss");
 
     @Autowired
     public GetResponseFactory(MetaServer meta) {
@@ -29,11 +32,46 @@ public class GetResponseFactory {
                 .collect(Collectors.toList());
     }
 
+    /**
+     * dictionaryName - это имя тэга внутри <enum>
+     */
+    public Map<String, Object> responseFromDictionary(String dictionaryName, Object o) {
+        ObjectExtracted objectExtracted = meta.getEnumsExtractedByTagName().get(dictionaryName);
+        if (objectExtracted == null) {
+            throw new RuntimeException("cannot find dictionary in meta for " + dictionaryName);
+        }
+        return responseFromObjectExtracted(o, objectExtracted);
+    }
+
     public Map<String, Object> responseFromObject(Object o) {
         ObjectExtracted objExtr = meta.getObjectsExtractedByClazz().get(o.getClass().getCanonicalName());
         if (objExtr == null) {
             throw new RuntimeException("cannot find object in meta for " + o.getClass().getCanonicalName());
         }
+        return responseFromObjectExtracted(o, objExtr);
+    }
+
+    /**
+     * Варианты методов с Class сделаны для сценариев, когда хотим распарсить объект,
+     * по мете для родительского класса объекта
+     * Т.е. вместо извлечение класса o.getClass, берем clazz извне. clazz - base class для o
+     *
+    */
+    public <T> Collection<Map<String, Object>> responseFromObjectCollection(Collection<?> o, Class<T> clazz) {
+        return o.stream()
+                .map((Function<Object, Map<String, Object>>) o1 -> responseFromObject(o1, clazz))
+                .collect(Collectors.toList());
+    }
+
+    public <T> Map<String, Object> responseFromObject(Object o, Class<T> clazz) {
+        ObjectExtracted objExtr = meta.getObjectsExtractedByClazz().get(clazz.getCanonicalName());
+        if (objExtr == null) {
+            throw new RuntimeException("cannot find object in meta for " + o.getClass().getCanonicalName());
+        }
+        return responseFromObjectExtracted(o, objExtr);
+    }
+
+    private Map<String, Object> responseFromObjectExtracted(Object o, ObjectExtracted objExtr) {
         Map<String, Object> r = new LinkedHashMap<>();
         FieldExtracted currentField = null;
         try {
@@ -46,7 +84,7 @@ public class GetResponseFactory {
                     try {
                         add(r, field.getField().getCode(), field.extractValue(o));
                     } catch (Throwable e) {
-                        log.warn(ExceptionUtils.getStackTrace(
+                        log.trace(ExceptionUtils.getStackTrace(
                                 new RuntimeException(String.format("Can't extract value for field='%s' of %s(%s): %s -> %s\n%s",
                                         field.getField().getCode(),
                                         o.getClass().getSimpleName(), objExtr.getClassName(),
@@ -71,6 +109,8 @@ public class GetResponseFactory {
             data = sdf.format(value);
         } else if (value instanceof Instant) {
             data = dateTimeFormatter.format((Instant) value);
+        } else if (value instanceof LocalTime) {
+            data = timeFormatter.format((LocalTime) value);
         } else {
             data = value;
         }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/MetaServer.java

@@ -2,6 +2,7 @@ package ru.spcex.clearing.backendapi.meta;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import ru.spcex.platform.utils.log.ExceptionUtils;
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Method;
@@ -17,6 +18,8 @@ public class MetaServer extends MetaBase {
     private Map<String, ObjectExtracted> objectsExtractedByDestination;
     private Map<String, ObjectExtracted> actionObjectsExtracted;
     private Map<String, ObjectElement> objectElementByDestination;
+    private Map<String, ObjectExtracted> enumsExtractedByTagName;
+    private final static Set<String> dictionaryDefaultFields = Set.of("id", "code", "name");
 
     protected ObjectExtracted getImplInstanceObjectExtracted(String clazz, List<ActionField> actionFields) {
         return new ClearingObjectExtracted(clazz, actionFields);
@@ -31,6 +34,7 @@ public class MetaServer extends MetaBase {
             objectsExtractedByClazz = new ConcurrentHashMap<>();
             objectsExtractedByDestination = new ConcurrentHashMap<>();
             objectElementByDestination = new ConcurrentHashMap<>();
+            enumsExtractedByTagName = new ConcurrentHashMap<>();
             try {
                 Map<String, ObjectElement> objects = getObjects();
                 log.info("Meta objects:\n{}",
@@ -50,14 +54,14 @@ public class MetaServer extends MetaBase {
                     try {
                         oe = getImplInstanceObjectExtracted(objectElement.getClazz(), objectElement.getFields());
                     } catch (Throwable e) {
-                        log.warn("META SERVER >>> Класс {} для {} не найден!", objects.get(key).getClazz(), key);
+                        log.trace("META SERVER >>> Класс {} для {} не найден!", objects.get(key).getClazz(), key);
                         continue;
                     }
                     objectsExtracted.add(oe);
                     if (oe.getClassName() != null) {
                         ObjectExtracted previous = objectsExtractedByClazz.put(oe.getClassName(), oe);
                         if (previous != null) {
-                            log.warn("!!! meta contains duplicate classes {}", oe.getClassName());
+                            log.trace("!!! meta contains duplicate classes {}", oe.getClassName());
                         }
                     } else
                         objectsExtractedByClazz.put(String.valueOf(classNameMock++), oe);
@@ -84,6 +88,37 @@ public class MetaServer extends MetaBase {
             } catch (Throwable e) {
                 throw new ClearingMetaServerValidationException(e.getLocalizedMessage());
             }
+            try {
+                Map<String, ObjectEnumElement> enums = getEnums();
+                for (String key : enums.keySet()) {
+                    ObjectExtracted oe;
+                    ObjectEnumElement objectElement = enums.get(key);
+                    try {
+                        oe = new ClearingDictionaryExtracted(objectElement.getClazz(), objectElement.getFields());
+                    } catch (Throwable e) {
+                        log.warn("{} {}", key, ExceptionUtils.getStackTrace(e));
+                        continue;
+                    }
+                    /**
+                     * можно было бы хранить только для нестандартных словарей (где не только id, name, code)
+                     */
+//                    List<FieldExtracted> dictFields = oe.getFields();
+//                    boolean add = false;
+//                    for (FieldExtracted dictField : dictFields) {
+//                        if (!dictionaryDefaultFields.contains(dictField.getMemberName())) {
+//                            add = true;
+//                            break;
+//                        }
+//                    }
+//                    if (add) {
+//                        enumsExtractedByTagName.put(key, oe);
+//                    }
+                    enumsExtractedByTagName.put(key, oe);
+                }
+
+            } catch (Throwable e) {
+                throw new ClearingMetaServerValidationException(e.getLocalizedMessage());
+            }
         }
         for (ObjectExtracted o : this.objectsExtracted) {
             try {
@@ -146,7 +181,7 @@ public class MetaServer extends MetaBase {
                     }
                     c = RfHelper.getMetodReturnClazz(m);
                 } catch (OtcMetaServerGetterNotFoundException e) {
-                    log.warn("META SERVER >>> Геттер {}.{} не найден!", o.getClassName(), getterName);
+                    log.trace("META SERVER >>> Геттер {}.{} не найден!", o.getClassName(), getterName);
                 }
             }
         }
@@ -196,4 +231,8 @@ public class MetaServer extends MetaBase {
         }
         return partSize;
     }
+
+    public Map<String, ObjectExtracted> getEnumsExtractedByTagName() {
+        return enumsExtractedByTagName;
+    }
 }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ObjectExtracted.java

@@ -5,12 +5,14 @@ import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 
 public abstract class ObjectExtracted {
-    private String className;
-    private Class<?> clazz;
-    private List<FieldExtracted> fields = new LinkedList<>();
-    private Map<String, FieldExtracted> fieldByCode = new ConcurrentHashMap<>();
-    private boolean isArray = false;
+    protected String className;
+    protected Class<?> clazz;
+    protected List<FieldExtracted> fields = new LinkedList<>();
+    protected Map<String, FieldExtracted> fieldByCode = new ConcurrentHashMap<>();
+    protected boolean isArray = false;
 
+    public ObjectExtracted() {
+    }
 
     public ObjectExtracted(String clazz, List<ActionField> actionFields) {
         this.className = clazz;

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/security/handlers/AuthAuditSuccessLoginHandler.java

@@ -3,6 +3,7 @@ package ru.spcex.clearing.backendapi.security.handlers;
 import org.keycloak.KeycloakPrincipal;
 import org.keycloak.adapters.spi.KeycloakAccount;
 import org.keycloak.adapters.springsecurity.token.KeycloakAuthenticationToken;
+import org.keycloak.representations.AccessToken;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -34,16 +35,24 @@ public class AuthAuditSuccessLoginHandler implements AuthenticationSuccessHandle
         try {
             KeycloakAuthenticationToken auth = (KeycloakAuthenticationToken) authentication;
             KeycloakAccount details = (KeycloakAccount) auth.getDetails();
-            String username = ((KeycloakPrincipal) details.getPrincipal())
-                    .getKeycloakSecurityContext()
+            KeycloakPrincipal<?> principal = (KeycloakPrincipal<?>) details.getPrincipal();
+            String username = principal.getKeycloakSecurityContext()
                     .getToken()
                     .getPreferredUsername();
             Set<String> roles = details.getRoles();
 
             if (roles.contains(Admin.getKey()) || roles.contains(Security.getKey()) || roles.contains(Superviser.getKey())) {
+                AccessToken token = principal.getKeycloakSecurityContext().getToken();
                 String clientIp = request != null ? request.getRemoteAddr() : null;
                 String serverIp = request != null ? request.getLocalAddr() : null;
-                userAutoCreation.sendAuthSuccessEvent(username, roles, clientIp, serverIp);
+                userAutoCreation.sendAuthSuccessEvent(username,
+                        roles,
+                        clientIp,
+                        serverIp,
+                        token.getEmail(),
+                        token.getGivenName(),
+                        token.getFamilyName(),
+                        token.getMiddleName());
             }
         } catch (Throwable e) {
             log.error(ExceptionUtils.getStackTrace(e));

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/IStateLoader.java

@@ -13,4 +13,6 @@ public interface IStateLoader {
     <T extends SpcexObjectBase> Optional<T> getById(Long id, String mapName, Class<T> clazz);
     <T extends SpcexObjectBase> Collection<T> getAll(String mapName, Class<T> clazz);
     <T extends SpcexObjectBase> Collection<Map<String, Object>> getAllMetaTransform(String mapName, Class<T> clazz);
+    <T extends SpcexObjectBase> Collection<Map<String, Object>> getAllMetaTransformSpecificClass(String mapName, Class<T> clazz);
+    <T extends SpcexObjectBase> Collection<Map<String, Object>> getAllMetaTransform(String mapName, Class<T> clazz, Map<String, ? extends Comparable<?>> conditions);
 }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/RequestInfoAccepter.java

@@ -43,6 +43,7 @@ public class RequestInfoAccepter extends QueueConsumer implements InitializingBe
             return;
         }
         requestInfo.setStatus(statusInfo.getStatus());
+        requestInfo.setMessage(statusInfo.getMessage());
         requestInfoImdg.update(requestInfo);
     }
 }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/UserAuthProcessor.java

@@ -5,7 +5,7 @@ import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
-import ru.spcex.clearing.backendapi.controller.request.cud.utilities.UserAuthAction;
+import ru.spcex.clearing.backendapi.controller.request.cud.utilities.UserAuthSystemAction;
 import ru.spcex.clearing.backendapi.controller.request.cud.utilities.UserLogoutAction;
 import ru.spcex.clearing.platform.messaging.domain.Consts;
 import ru.spcex.clearing.platform.messaging.domain.cud.utilities.UserAuthRequest;
@@ -33,14 +33,19 @@ public class UserAuthProcessor {
         this.operator = operator;
     }
 
-    public void sendAuthSuccessEvent(String identifier, Collection<String> roles, String userIp, String serverIp) {
-        UserAuthAction authEvent = new UserAuthAction();
-        UserAuthRequest requestData = authEvent.getAuthRequest();
+    public void sendAuthSuccessEvent(String identifier, Collection<String> roles, String userIp, String serverIp,
+                                     String email, String name, String surname, String middleName) {
+        UserAuthSystemAction authEvent = new UserAuthSystemAction();
+        UserAuthRequest requestData = authEvent.toRequest();
         requestData.setUsername(identifier);
         requestData.setTime(Instant.now());
         requestData.setRoles(new ArrayList<>(roles));
         requestData.setServerIp(serverIp + ":" + serverPort); //getServerAddress() + ":" + serverPort
         requestData.setClientIp(userIp);
+        requestData.setEmail(email);
+        requestData.setName(name);
+        requestData.setSurname(surname);
+        requestData.setMiddleName(middleName);
         try {
             operator.sendRequestToQueue(Consts.USER_AUTH_SUCCESS, authEvent);
         } catch (Throwable e) { //ExecutionException | InterruptedException
@@ -69,7 +74,7 @@ public class UserAuthProcessor {
             while (networkInterfaces.hasMoreElements()) {
                 NetworkInterface networkInterface = networkInterfaces.nextElement();
                 Enumeration<InetAddress> inetAddresses = networkInterface.getInetAddresses();
-                while(inetAddresses.hasMoreElements()) {
+                while (inetAddresses.hasMoreElements()) {
                     InetAddress inetAddress = inetAddresses.nextElement();
                     if (inetAddress != null) {
                         serverAddress = inetAddress.getHostAddress();

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/OperatorImpl.java

@@ -59,15 +59,17 @@ public class OperatorImpl implements IOperator {
     }
 
     private void throwValidate(String destination, IAction<?> iAction) {
+        //простая валидация - которую можно запилить прямо внутри класса (наличие полей, отношения между датами etc.)
         Collection<EnumMessage> validationErrors = iAction.validate();
         if (validationErrors.size() > 0) {
             throw new ActionValidationException(validationErrors);
         }
+        //валидация требующая IMDG поиска других сущностей и т.д.
         IValidator validator = validation.getValidator(destination, iAction);
         if (validator != null) {
             validator.tillFirstError().ifPresent(enumMessage -> {
                 if (enumMessage.getSubject().equalsById(BackEndError.ResourceNotFound.getId())) {
-                    throw new NotFound404Exception((String) enumMessage.getArgs()[0]);
+                    throw new NotFound404Exception(enumMessage);
                 } else {
                     throw new ActionValidationException(enumMessage);
                 }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/StateLoaderImpl.java

@@ -44,6 +44,21 @@ public class StateLoaderImpl implements IStateLoader {
         return responseFactory.responseFromObjectCollection(all);
     }
 
+    @Override
+    public <T extends SpcexObjectBase> Collection<Map<String, Object>> getAllMetaTransformSpecificClass(String mapName, Class<T> clazz) {
+        Collection<T> all = getAll(mapName, clazz);
+        return responseFactory.responseFromObjectCollection(all, clazz);
+    }
+
+    @Override
+    public <T extends SpcexObjectBase> Collection<Map<String, Object>> getAllMetaTransform(String mapName,
+                                                                                           Class<T> clazz,
+                                                                                           Map<String, ? extends Comparable<?>> conditions) {
+        Imdg<T> imdg = getImdg(mapName, clazz);
+        Collection<T> all = imdg.getCollectionObjectsByFieldValues(conditions);
+        return responseFactory.responseFromObjectCollection(all);
+    }
+
     @SuppressWarnings("unchecked")
     private <T extends SpcexObjectBase> Imdg<T> getImdg(String mapName, Class<T> clazz) {
         return (Imdg<T>) allImdgMaps.computeIfAbsent(mapName, (mapName1) -> imdgProvider.getImdg(mapName, clazz));

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/validation/ActionValidationProvider.java

@@ -5,8 +5,8 @@ import org.springframework.stereotype.Component;
 import ru.clearing.platform.dictionary.AbstractDictionary;
 import ru.spcex.clearing.backendapi.controller.request.cud.schedule.LauncherNew;
 import ru.spcex.clearing.backendapi.domain.actions.IAction;
+import ru.spcex.clearing.backendapi.errors.BackEndError;
 import ru.spcex.clearing.backendapi.service.validation.rules.LauncherNewValidationRule;
-import ru.spcex.clearing.backendapi.service.validation.rules.PresentById;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.Consts;
 import ru.spcex.platform.classes.base.SpcexObjectBase;
@@ -14,9 +14,11 @@ import ru.spcex.platform.classes.base.interfaces.WithId;
 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.rule.PresentById;
 import ru.spcex.platform.utils.validation.IValidator;
 import ru.spcex.platform.utils.validation.ValidatorImpl;
 
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.function.Function;
@@ -35,11 +37,9 @@ public class ActionValidationProvider implements InitializingBean {
 
     @Override
     public void afterPropertiesSet() {
-        getImdg(IMDGDistributedNames.Map_TaskDictionary, AbstractDictionary.class);
-        getImdg(IMDGDistributedNames.Map_MoneyMarketSecurity, SpcexObjectBase.class);
-
         validators.put(Consts.DESTINATION_MONEY_MARKET_SECURITY_UPDATE, idPresent(IMDGDistributedNames.Map_MoneyMarketSecurity));
         validators.put(Consts.DESTINATION_MONEY_MARKET_SECURITY_DELETE, idPresent(IMDGDistributedNames.Map_MoneyMarketSecurity));
+        validators.put(Consts.DESTINATION_RELATION_UPDATE, idPresent(IMDGDistributedNames.Map_Relation));
         validators.put(Consts.LAUNCHER_NEW, taskRunnerNew());
     }
 
@@ -51,21 +51,35 @@ public class ActionValidationProvider implements InitializingBean {
         return null;
     }
 
+
+
+    private <T extends IAction<?>> Function<T, IValidator> defaultConstructor(Class<T> clazz, Imdg<?>... imdgs) {
+        return iAcc -> {
+            ImdgValidationContext<T> ctx = new ImdgValidationContext<>();
+            ctx.setValidatedObject(iAcc);
+            Arrays.stream(imdgs).forEach(imdg -> ctx.addImdg(imdg.getMapName(), imdg));
+            return new ValidatorImpl<>(ctx);
+        };
+    }
+
     private <T extends IAction<?> & WithId> Function<T, IValidator> idPresent(String mapName) {
+        Imdg<SpcexObjectBase> targetMap = getImdg(mapName, SpcexObjectBase.class);
         return iAction -> {
             ImdgValidationContext<T> ctx = new ImdgValidationContext<>();
             ctx.setValidatedObject(iAction);
+            ctx.addImdg(mapName, targetMap);
             ValidatorImpl<ImdgValidationContext<T>> iValidator = new ValidatorImpl<>(ctx);
-            iValidator.addRule(new PresentById(getImdg(mapName, SpcexObjectBase.class)));
+            iValidator.addRule(new PresentById(mapName, BackEndError.ResourceNotFound));
             return iValidator;
         };
     }
 
     private Function<LauncherNew, IValidator> taskRunnerNew() {
+        Imdg<AbstractDictionary> tskDctnrImdg = getImdg(IMDGDistributedNames.Map_TaskDictionary, AbstractDictionary.class);
         return taskRunnerNew -> {
             ImdgValidationContext<LauncherNew> ctx = new ImdgValidationContext<>();
             ctx.setValidatedObject(taskRunnerNew);
-            ctx.addImdg(IMDGDistributedNames.Map_TaskDictionary, getImdg(IMDGDistributedNames.Map_TaskDictionary, AbstractDictionary.class));
+            ctx.addImdg(IMDGDistributedNames.Map_TaskDictionary, tskDctnrImdg);
             ValidatorImpl<ImdgValidationContext<LauncherNew>> iValidator = new ValidatorImpl<>(ctx);
             iValidator.addRule(LauncherNewValidationRule.knownTaskDictionary);
             return iValidator;

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/validation/rules/PresentById.java

@@ -1,28 +0,0 @@
-package ru.spcex.clearing.backendapi.service.validation.rules;
-import ru.spcex.clearing.backendapi.errors.BackEndError;
-import ru.spcex.platform.classes.base.SpcexObjectBase;
-import ru.spcex.platform.classes.base.interfaces.WithId;
-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.util.Optional;
-
-public class PresentById implements IValidationRule<ImdgValidationContext<WithId>> {
-    private final Imdg<SpcexObjectBase> map;
-
-    public PresentById(Imdg<SpcexObjectBase> map) {
-        this.map = map;
-    }
-
-    @Override
-    public Optional<EnumMessage> validate(ImdgValidationContext<WithId> context) {
-        WithId actionById = context.getValidatedObject();
-        if (map.getSingleObjectByID(actionById.getId()) == null) {
-            return of(BackEndError.ResourceNotFound, actionById.getId());
-        } else {
-            return empty();
-        }
-    }
-}

clearing-parent/backend-api/src/main/resources/meta/data.xml

@@ -6,17 +6,25 @@
 		<termType id="2" code="K" name="Комбинированный"/>
 		<termType id="3" code="V" name="До востребования"/>
 		<task id="1" code="GBAL" name="Зачисление остатков"/>
-		<task id="2" code="GBLC" name="Подтверждение зачисления остатков"/>
 		<task id="3" code="ABLK" name="Блокировка счета"/>
 		<task id="4" code="GALB" name="Запрос остатков по всем счетам"/>
 		<task id="5" code="ADBL" name="Дозачисление/списание остатков"/>
-		<task id="6" code="ADBC" name="Подтверждение дозачисления/списания остатков"/>
 		<task id="7" code="CORD" name="Формирование сводного платежного поручения"/>
 		<task id="8" code="CORC" name="Получение подтверждения переводов"/>
+		<task id="9" code="GVER" name="Запуск сверки"/>
+		<task id="12" code="CMBA" name="Формирование распоряжения на перевод с ТБС"/>
+		<task id="14" code="GCMR" name="Формирование реестра участников клиринга"/>
+		<task id="15" code="GBRR" name="Формирование реестра остатков денежных средств "/>
+		<task id="16" code="GORR" name="Формирование реестра распоряжений, направленных расчетной организации"/>
+		<task id="17" code="GREP" name="Формирование отчетности"/>
+		<task id="21" code="GSRR" name="Формирование реестра отправленных отчетов"/>
 		<task id="25" code="GTRD" name="Получение сделок из Торговой системы"/>
+		<task id="32" code="GACA" name="Создание файла остатков CSV по клиринговым счетам"/>
+		<task id="33" code="GAIA" name="Создание файла остатков CSV по внутренним информационным счетам"/>
 		<task id="34" code="GBLD" name="Поступление средств"/>
-		<task id="35" code="GBDC" name="Подтверждение поступления средств"/>
-		<task id="36" code="GREG" name="Формирование реестров"/>
+		<task id="35" code="SCLR" name="Запуск клиринговой сессии"/>
+		<task id="36" code="SPRC" name="Запуск преклиринга"/>
+		<task id="37" code="SPOC" name="Запуск постклиринга"/>
 		<taskStatus id="1" code="ACTV" name="Активна"/>
 		<taskStatus id="2" code="BLKD" name="Не активна"/>
 		<taskStatus id="3" code="CNCL" name="Отмена расписания"/>
@@ -38,9 +46,6 @@
 		<clearingStatus id="2" code="FAIL" name="Не успешно"/>
 		<clearingStatus id="3" code="MNG" name="Не учитывать"/>
 		<clearingStatus id="4" code="PROC" name="К клирингу"/>
-		<interestStatus id="1" code="FREE" name="Не требуется"/>
-		<interestStatus id="2" code="RTND" name="Возвращены"/>
-		<interestStatus id="3" code="DFLT" name="Не возвращены"/>
 		<workflowStatus id="1" code="ACTV" name="Активен"/>
 		<workflowStatus id="2" code="BLKD" name="Не активен"/>
 		<accountStatus id="1" code="ACTV" name="Активен"/>
@@ -85,7 +90,7 @@
 		<managementJournalPurpose id="1" code="ACC" name="Доступ"/>
 		<managementJournalPurpose id="2" code="NOND" name="Не поставка"/>
 		<managementJournalPurpose id="3" code="DEL" name="Удалена"/>
-		<contactType id="1" code="ADRS" name="Адрес местонахождения"/>
+		<contactType id="1" code="ADRS" name="Адрес"/>
 		<contactType id="2" code="POST" name="Почтовый адрес"/>
 		<contactType id="3" code="CONT" name="Контактное лицо"/>
 		<contactType id="4" code="MAIL" name="Электронная почта"/>
@@ -143,12 +148,14 @@
 		<userRole id="1" code="ADMN" name="Администратор Клиринга МКР"/>
 		<userRole id="2" code="SPVS" name="Супервайзер Клиринга МКР"/>
 		<userRole id="3" code="SCRT" name="Администратор безопасности Клиринга МКР"/>
-		<accountType id="1" code="CLRN" name="Торговый клиринговый счет"/>
-		<accountType id="2" code="BANK" name="Текущий банковский счет"/>
+		<accountType id="1" code="CLRN" name="Клиринговый счет"/>
+		<accountType id="2" code="BANK" name="Банковский счет"/>
 		<accountType id="3" code="USPD" name="Счет невыясненных поступлений"/>
 		<accountType id="4" code="CORR" name="Корреспондентский счет"/>
 		<accountType id="5" code="INFO" name="Информационный счет"/>
 		<accountType id="6" code="PYER" name="Счет плательщика"/>
+		<accountType id="7" code="ANLT" name="Аналитический счет"/>
+		<accountType id="8" code="TRAN" name="Транзакционный счет"/>
 		<instrumentType id="1" code="RATE" name="Инструмент Денежного рынка"/>
 		<instrumentType id="2" code="CRNC" name="Валюты"/>
 		<resultStatus id="1" code="NACK" name="Неуспешно"/>
@@ -160,17 +167,19 @@
 		<sessionStatus id="2" code="CLRN" name="Идет клиринг"/>
 		<sessionStatus id="3" code="CLOS" name="Клиринг завершен"/>
 		<objectType id="1" code="STMT" name="STATEMENT"/>
+		<objectType id="2" code="VFRS" name="verificationResult"/>
 		<notificationStatus id="1" code="PEND" name="В ожидании"/>
 		<notificationStatus id="2" code="CNCL" name="Отменено"/>
 		<notificationStatus id="3" code="ACPT" name="Принято"/>
+		<notificationStatus id="4" code="READ" name="Прочтено"/>
 		<eventType id="1" code="CRET" name="Создание"/>
 		<eventType id="2" code="UPDT" name="Обновление"/>
 		<eventType id="3" code="DELT" name="Удаление"/>
 
 		<currencyCode id="643" code="RUB" name="Российский рубль"/>
 
-		<!-- error code for securities-services -->
-		<errorCode id="1000" code="SECR" name="Общая ошибка модуля securities-services."/>
+		<!-- error code for securities-service -->
+		<errorCode id="1000" code="SECR" name="Общая ошибка модуля securities-service."/>
 		<errorCode id="1001" code="SECR" name="Нет прав на проведение данной операции."/>
 		<errorCode id="1002" code="SECR" name="Не заданы обязательные поля."/>
 		<errorCode id="1003" code="SECR" name="Запись с указанным идентификатором в справочнике %s не найдена."/>
@@ -183,8 +192,8 @@
 		<errorCode id="1011" code="SECR" name="Инструмент не найден."/>
 		<errorCode id="1012" code="SECR" name="Инструмент неактивен."/>
 
-		<!-- error code for utility-services -->
-		<errorCode id="2000" code="UTIL" name="Общая ошибка модуля utility-services."/>
+		<!-- error code for utility-service -->
+		<errorCode id="2000" code="UTIL" name="Общая ошибка модуля utility-service."/>
 		<errorCode id="2001" code="UTIL" name="Нет прав на проведение данной операции."/>
 		<errorCode id="2002" code="UTIL" name="Не заданы обязательные поля."/>
 		<errorCode id="2003" code="UTIL" name="Запись с указанным идентификатором в справочнике %s не найдена."/>
@@ -192,8 +201,8 @@
 		<errorCode id="2005" code="UTIL" name="Такая запись уже существует."/>
 		<errorCode id="2006" code="UTIL" name="Запись не найдена."/>
 
-		<!-- error code for company-services -->
-		<errorCode id="3000" code="CMPN" name="Общая ошибка модуля company-services."/>
+		<!-- error code for company-service -->
+		<errorCode id="3000" code="CMPN" name="Общая ошибка модуля company-service."/>
 		<errorCode id="3001" code="CMPN" name="Нет прав на проведение данной операции."/>
 		<errorCode id="3002" code="CMPN" name="Не заданы обязательные поля."/>
 		<errorCode id="3003" code="CMPN" name="Запись с указанным идентификатором в справочнике %s не найдена."/>
@@ -208,13 +217,14 @@
 		<errorCode id="3015" code="CMPN" name="Контакт Компании не найден."/>
 		<errorCode id="3016" code="CMPN" name="Категория Компании не найдена."/>
 		<errorCode id="3017" code="CMPN" name="Компании уже присвоена Категория %s."/>
+		<errorCode id="3018" code="CMPN" name="У компании присутствуют обязательства"/>
 
-		<!-- error code for report-serivces -->
-		<errorCode id="4000" code="RPRT" name="Общая ошибка модуля report-serivces."/>
+		<!-- error code for report-serivce -->
+		<errorCode id="4000" code="RPRT" name="Общая ошибка модуля report-serivce."/>
 
 		<!-- == error code for processing accounts and balances == -->
-		<!-- error code for account-services -->
-		<errorCode id="5000" code="ACNT" name="Общая ошибка модуля account-services."/>
+		<!-- error code for account-service -->
+		<errorCode id="5000" code="ACNT" name="Общая ошибка модуля account-service."/>
 		<errorCode id="5001" code="ACNT" name="Нет прав на проведение данной операции."/>
 		<errorCode id="5002" code="ACNT" name="Не заданы обязательные поля."/>
 		<errorCode id="5003" code="ACNT" name="Запись с указанным идентификатором в справочнике %s не найдена."/>
@@ -226,8 +236,8 @@
 		<errorCode id="5012" code="ACNT" name="Счет %s неактивен."/>
 		<errorCode id="5013" code="ACNT" name="Компания не найдена."/>
 		<errorCode id="5014" code="ACNT" name="Компания неактивна."/>
-		<!-- error code for balance-services -->
-		<errorCode id="5200" code="BLNC" name="Общая ошибка модуля balance-services."/>
+		<!-- error code for balance-service -->
+		<errorCode id="5200" code="BLNC" name="Общая ошибка модуля balance-service."/>
 		<errorCode id="5210" code="BLNC" name="Клиринговая сессия неактивна."/>
 		<errorCode id="5211" code="BLNC" name="Компания не найдена."/>
 		<errorCode id="5212" code="BLNC" name="Компания неактивна."/>
@@ -241,8 +251,8 @@
 		<errorCode id="5220" code="BLNC" name="Сумма списания превышает сумму средств на счете."/>
 		<errorCode id="5221" code="BLNC" name="Поступление средств возможно только по рынку МКР."/>
 		<errorCode id="5222" code="BLNC" name="Сумма списания превышает сумму средств на счете."/>
-		<!-- error code for clearing-services -->
-		<errorCode id="5400" code="CLRN" name="Общая ошибка модуля clearing-services."/>
+		<!-- error code for clearing-service -->
+		<errorCode id="5400" code="CLRN" name="Общая ошибка модуля clearing-service."/>
 		<errorCode id="5401" code="CLRN" name="Нет прав на проведение данной операции."/>
 		<errorCode id="5402" code="CLRN" name="Не заданы обязательные поля."/>
 		<errorCode id="5403" code="CLRN" name="Запись с указанным идентификатором в справочнике %s не найдена."/>
@@ -263,8 +273,8 @@
 		<!-- error code for api-lk-company -->
 		<errorCode id="6000" code="APIC" name="Общая ошибка модуля api-lk-company."/>
 
-		<!-- error code for scheduler-services -->
-		<errorCode id="7000" code="SCHD" name="Общая ошибка модуля scheduler-services."/>
+		<!-- error code for scheduler-service -->
+		<errorCode id="7000" code="SCHD" name="Общая ошибка модуля scheduler-service."/>
 		<errorCode id="7001" code="SCHD" name="Нет прав на проведение данной операции."/>
 		<errorCode id="7002" code="SCHD" name="Не заданы обязательные поля."/>
 		<errorCode id="7003" code="SCHD" name="Запись с указанным идентификатором в справочнике %s не найдена."/>
@@ -277,6 +287,9 @@
 		<errorCode id="7013" code="SCHD" name="Указанный инструмент неактивен."/>
 		<errorCode id="7014" code="SCHD" name="Указанная в задаче компания не найдена."/>
 		<errorCode id="7015" code="SCHD" name="Указанная компания неактивна."/>
+
+		<!-- error code for control-service -->
+		<errorCode id="8000" code="CNTR" name="Общая ошибка модуля control-service."/>
         
 		<!-- error code for backend-api -->
 		<errorCode id="9000" code="BAPI" name="Ошибка проверки поля %s."/>

clearing-parent/backend-api/src/main/resources/meta/xsl/core.xsl

@@ -0,0 +1,193 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"  xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xalan="http://xml.apache.org/xalan" exclude-result-prefixes="xalan">
+<xsl:output version="1.0" method="html" indent="no" encoding="UTF-8"/>
+
+<xsl:variable name="data" select="document('..\data.xml')/meta"/>
+<xsl:variable name="metaxsd" select="document('..\meta.xsd')/xs:schema"/>
+<xsl:variable name="meta" select="document('..\meta.xml')/meta"/>
+
+	<xsl:template match="/">
+		<html><xsl:apply-templates select="*"/></html>
+	</xsl:template>
+	
+	<xsl:template match="meta">
+		<head>
+			<META http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
+			<title>Web</title>
+			<meta content="text/html; charset=UTF-8" http-equiv="Content-Type"/>
+			<style type="text/css">
+			table.sample {
+				border-width: 1px 1px 1px 1px;
+				border-spacing: 2px;
+				border-style: outset outset outset outset;
+				border-color: gray gray gray gray;
+				border-collapse: collapse;
+				background-color: white;
+			}
+			table.sample th {
+				border-width: 1px 1px 1px 1px;
+				padding: 1px 1px 1px 1px;
+				border-style: inset inset inset inset;
+				border-color: gray gray gray gray;
+				background-color: white;
+				-moz-border-radius: 0px 0px 0px 0px;
+			}
+			table.sample td {
+				border-width: 1px 1px 1px 1px;
+				padding: 1px 1px 1px 1px;
+				border-style: inset inset inset inset;
+				border-color: gray gray gray gray;
+				background-color: white;
+			}
+			</style>
+		</head>
+
+		Version: <xsl:value-of select="@version"/>
+		<xsl:apply-templates select="objects"/>
+		<xsl:apply-templates select="enums"/>
+	</xsl:template>
+	
+
+
+
+	<xsl:template match="objects">
+		<a name="objects"/>
+		<h2>Общее описание бизнес-объектов</h2>
+		<div style="white-space: pre-wrap;"><xsl:copy-of select="$metaxsd/xs:element/xs:complexType/xs:sequence/xs:element[@name='objects']/xs:annotation/xs:documentation/."/></div>
+		<xsl:apply-templates select="*" mode="objects"/>
+	</xsl:template>
+
+	<xsl:template match="enums"><xsl:apply-templates select="*" mode="enums"/></xsl:template>
+
+	
+	<xsl:template match="views"></xsl:template>
+	
+
+	<xsl:template match="types"></xsl:template>
+	
+	
+	<xsl:template match="*" mode="objects">
+		<xsl:variable name="objectNum"><xsl:value-of select="position()"/></xsl:variable>
+		<xsl:variable name="objectName"><xsl:value-of select="name()"/></xsl:variable>
+		<a name="objects.{$objectName}"/>
+		<h2>1.<xsl:value-of select="$objectNum"/>. <xsl:value-of select="name()"/> - <xsl:value-of select="@name"/></h2>
+
+		<div style="white-space: pre-wrap;"><xsl:copy-of select="$metaxsd/xs:element/xs:complexType/xs:sequence/xs:element[@name='objects']/xs:complexType/xs:sequence/xs:element[@name=$objectName]/xs:annotation/xs:documentation/."/></div>
+		<br/>
+		<a name="objects.{$objectName}.actions"/>
+			<xsl:if test="actions">
+				<h3>1.<xsl:value-of select="$objectNum"/>.1. Обработка методов</h3>
+			</xsl:if>
+			<div style="white-space: pre-wrap;"><xsl:copy-of select="$metaxsd/xs:element/xs:complexType/xs:sequence/xs:element[@name='objects']/xs:complexType/xs:sequence/xs:element[@name=$objectName]/xs:complexType/xs:sequence/xs:element[@name='actions']/xs:annotation/xs:documentation/."/></div>
+			<xsl:for-each select="actions/*">
+				<xsl:variable name="methodName"><xsl:value-of select="name()"/></xsl:variable>
+				<a name="objects.{$objectName}.actions.{$methodName}"/>
+				<h4>1.<xsl:value-of select="$objectNum"/>.1.<xsl:value-of select="position()"/>. <xsl:value-of select="name()"/> - <xsl:value-of select="@name"/></h4>
+				<div style="white-space: pre-wrap;"><xsl:copy-of select="$metaxsd/xs:element/xs:complexType/xs:sequence/xs:element[@name='objects']/xs:complexType/xs:sequence/xs:element[@name=$objectName]/xs:complexType/xs:sequence/xs:element[@name='actions']/xs:complexType/xs:sequence/xs:element[@name=$methodName]/xs:annotation/xs:documentation/."/></div>
+				<br/>
+				<table class="sample" id="{$objectName}{name()}" width="100%" border="0">
+				<tr><td width="5%">#</td><td width="10%">Поле</td><td width="10%">Тип</td><td width="10%">Обяз.</td><td  width="45%">Наименование</td></tr>
+				<xsl:for-each select="*">
+				<xsl:variable name="methodField"><xsl:value-of select="name()"/></xsl:variable>
+				<tr>	<td style="vertical-align: top;"><xsl:value-of select="position()"/></td>
+					<td style="vertical-align: top;"><a name="objects.{$objectName}.actions.{$methodName}.{name()}"/><xsl:value-of select="name()"/></td>
+					<td style="vertical-align: top;">
+					<xsl:if test="@type">
+					<xsl:variable name="fieldType"><xsl:value-of select="@type"/></xsl:variable>
+						<xsl:value-of select="$meta/types/*[@id=$fieldType]/@type"/>
+						<xsl:if test="@length">(<xsl:value-of select="@length"/>)</xsl:if>
+					</xsl:if>
+
+					</td>
+					<td style="vertical-align: top;">
+					<xsl:choose>
+						<xsl:when test="@required">O</xsl:when>
+						<xsl:when test="$metaxsd/xs:element/xs:complexType/xs:sequence/xs:element[@name='objects']/xs:complexType/xs:sequence/xs:element[@name=$objectName]/xs:complexType/xs:sequence/xs:element[@name='actions']/xs:complexType/xs:sequence/xs:element[@name=$methodName]/xs:complexType/xs:sequence/xs:element[@name=$methodField]/xs:annotation/xs:documentation/.">
+							<div style="white-space: pre-wrap;"><xsl:copy-of select="$metaxsd/xs:element/xs:complexType/xs:sequence/xs:element[@name='objects']/xs:complexType/xs:sequence/xs:element[@name=$objectName]/xs:complexType/xs:sequence/xs:element[@name='actions']/xs:complexType/xs:sequence/xs:element[@name=$methodName]/xs:complexType/xs:sequence/xs:element[@name=$methodField]/xs:annotation/xs:documentation/."/></div>
+						</xsl:when>
+						<xsl:otherwise></xsl:otherwise>
+					</xsl:choose>
+					</td>
+					<td style="vertical-align: top;">
+					<xsl:if test="@name"><xsl:value-of select="@name"/></xsl:if><br/>
+					<xsl:if test="@link"><br/>Ссылается на объект: <xsl:value-of select="@link"/></xsl:if>
+					</td>
+				</tr>
+				</xsl:for-each>
+				</table>
+			</xsl:for-each>
+		<a name="objects.{$objectName}.fields"/>
+		<h3>1.<xsl:value-of select="$objectNum"/>.2. Поля объекта</h3>
+		<table class="sample" id="{name()}" width="100%" border="0">
+			<tr><td width="5%">#</td><td width="10%">Поле</td><td>Тип</td><td>Наименование</td><td width="45%">Обработка</td></tr>
+			<xsl:for-each select="*[name()!='actions' and not(@extends)]">
+				<xsl:variable name="attributeName"><xsl:value-of select="name()"/></xsl:variable>
+				<tr>	<td style="vertical-align: top;"><xsl:value-of select="position()"/></td>
+					<td style="vertical-align: top;">
+						<xsl:choose>
+							<xsl:when test="@linkKeyCode"><a name="objects.{$objectName}.fields.{@linkCode}"/><xsl:value-of select="@linkCode"/></xsl:when>
+							<xsl:otherwise><a name="objects.{$objectName}.fields.{name()}"/><xsl:value-of select="name()"/></xsl:otherwise>
+						</xsl:choose>
+					</td>
+					<td>
+						<xsl:variable name="fieldType"><xsl:value-of select="@type"/></xsl:variable>
+						<xsl:value-of select="$meta/types/*[@id=$fieldType]/@type"/>
+						<xsl:if test="@length">(<xsl:value-of select="@length"/>)</xsl:if>
+					</td>
+					<td style="vertical-align: top;">
+					<xsl:if test="@name"><xsl:value-of select="@name"/></xsl:if>
+					<br/>
+					<xsl:if test="@link"><br/>Ссылается на объект: <xsl:value-of select="@link"/>
+						<xsl:if test="@linkKeyCode">&#160;Содержит значение <xsl:value-of select="@linkCode"/> объекта <xsl:value-of select="@link"/> связанного по полям <xsl:value-of select="name()"/>=<xsl:value-of select="@link"/>.<xsl:value-of select="@linkKeyCode"/><br/></xsl:if>
+						<!--xsl:variable name="linkData"><xsl:value-of select="@link"/></xsl:variable>
+						<xsl:for-each select="xalan:nodeset($data)/enums/*[name()=$linkData]">
+							<br/><xsl:value-of select="@code"/>(<xsl:value-of select="@id"/>) - <i><xsl:value-of select="@name"/></i>
+						</xsl:for-each-->
+					</xsl:if>
+					</td>
+					<td style="vertical-align: top;">
+					<div style="white-space: pre-wrap;"><xsl:copy-of select="$metaxsd/xs:element/xs:complexType/xs:sequence/xs:element[@name='objects']/xs:complexType/xs:sequence/xs:element[@name=$objectName]/xs:complexType/xs:sequence/xs:element[@name=$attributeName]/xs:annotation/xs:documentation/."/></div>
+					</td>
+				</tr>
+			</xsl:for-each>
+		</table>
+	</xsl:template>
+
+
+
+	<xsl:template match="*" mode="enums">
+		<xsl:variable name="enumName"><xsl:value-of select="name()"/></xsl:variable>
+		<a name="enums.{name()}"/>
+		<h3>2.<xsl:value-of select="position()"/>. <xsl:value-of select="name()"/> - <xsl:value-of select="@name"/></h3>
+		<table class="sample" id="{name()}" width="100%" border="0">
+			<tr><td width="5%">#</td><td width="10%">Поле</td><td  width="20%">Наименование</td><td  width="10%">Тип</td></tr>
+			<xsl:apply-templates select="*" mode="field-enums"/>
+		</table>
+		<div>Значения:</div>
+		<xsl:for-each select="xalan:nodeset($data)/enums/*[name()=$enumName]">
+			<xsl:value-of select="@id"/>. <xsl:value-of select="@code"/> - <i><xsl:value-of select="@name"/></i><br/>
+		</xsl:for-each>
+
+	</xsl:template>
+
+
+	<xsl:template match="*" mode="field-enums">
+		<tr><td><xsl:value-of select="position()"/></td>
+		    <td><xsl:value-of select="name()"/></td>
+			<xsl:for-each select="@*">
+				<xsl:choose>
+					<xsl:when test="name()='type'">
+						<td>
+							<xsl:value-of select="name(/meta/types/*[@id=current()])"/>
+							<xsl:if test="../@length">(<xsl:value-of select="../@length"/>)</xsl:if>
+						</td>
+					</xsl:when>
+					<!--xsl:when test="name()='name'"><td><xsl:value-of select="."/></td></xsl:when-->
+					<xsl:when test="name()='shortname'"><td><xsl:value-of select="."/></td></xsl:when>
+				</xsl:choose>
+			</xsl:for-each>
+		</tr>
+	</xsl:template>
+
+	
+</xsl:stylesheet>

clearing-parent/backend-api/src/main/resources/meta/xsl/data.xsl

@@ -0,0 +1,180 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+	xmlns:xalan="http://xml.apache.org/xalan" exclude-result-prefixes="xalan">
+
+	<xsl:output version="1.0" method="text" indent="yes" encoding="UTF-8"/>
+
+<xsl:variable name="lcletters">abcdefghijklmnopqrstuvwxyz</xsl:variable>
+<xsl:variable name="ucletters">ABCDEFGHIJKLMNOPQRSTUVWXYZ</xsl:variable>
+<xsl:variable name="avoidletters">_0123456789</xsl:variable>
+<xsl:variable name="meta" select="document('..\meta.xml')/meta"/>
+
+<xsl:template match="/"><xsl:apply-templates select="*"/></xsl:template>
+
+<xsl:template match="meta">-- DB version: <xsl:value-of select="$meta/@version"/>
+-- DATA version: <xsl:value-of select="@version"/>
+<xsl:apply-templates select="*"/>
+</xsl:template>
+
+<xsl:template match="enums">
+/* Dictionaries */
+<xsl:apply-templates select="*" mode="enums"/>
+
+</xsl:template>
+<xsl:template match="objects">
+/* Business objects */
+<xsl:apply-templates select="*" mode="objects"/>
+</xsl:template>
+	
+<xsl:template match="type" mode="types">
+	-- <xsl:value-of select="@id"/>. <xsl:value-of select="@code"/> : <xsl:value-of select="@type"/> - <xsl:value-of select="@name"/>
+	<xsl:if test="position() != last()">,</xsl:if>
+</xsl:template>
+	
+<xsl:template match="*" mode="enums">
+<xsl:variable name="nodeName" select="name()"/>
+<xsl:variable name="dbTableName"><xsl:call-template name='convertDbStyle'><xsl:with-param name='toconvert' select='concat(name(xalan:nodeset($meta)/enums/*[name()=$nodeName]),"Dictionary")'/></xsl:call-template></xsl:variable>
+INSERT INTO <xsl:value-of select="$dbTableName"/>(<xsl:apply-templates select="@*" mode="tablename">
+  <xsl:with-param name="nodeName" select="$nodeName"/>
+</xsl:apply-templates>) values (<xsl:apply-templates select="@*" mode="values">
+  <xsl:with-param name="nodeName" select="$nodeName"/>
+</xsl:apply-templates>) ON CONFLICT (ID) DO UPDATE SET <xsl:apply-templates select="@*" mode="tablename-conflict-set">
+	<xsl:with-param name="nodeName" select="$nodeName"/>
+</xsl:apply-templates>;
+</xsl:template>
+
+<xsl:template match="*" mode="objects">
+<xsl:variable name="nodeName" select="name()"/>
+<xsl:variable name="dbTableName"><xsl:call-template name='convertDbStyle'><xsl:with-param name='toconvert' select='name(xalan:nodeset($meta)/objects/*[name()=$nodeName])'/></xsl:call-template></xsl:variable>
+INSERT INTO <xsl:value-of select="$dbTableName"/>(<xsl:apply-templates select="@*" mode="tablename">
+  <xsl:with-param name="nodeName" select="$nodeName"/>
+</xsl:apply-templates>) values (<xsl:apply-templates select="@*" mode="values">
+  <xsl:with-param name="nodeName" select="$nodeName"/>
+</xsl:apply-templates>) ON CONFLICT (ID) DO UPDATE SET <xsl:apply-templates select="@*" mode="tablename-conflict-set">
+	<xsl:with-param name="nodeName" select="$nodeName"/>
+</xsl:apply-templates>;
+</xsl:template>
+
+<xsl:template match="@*" mode="tablename">
+<xsl:param name="nodeName"/>
+<xsl:variable name="fieldName" select="name()"/>
+<xsl:choose>
+<xsl:when test="xalan:nodeset($meta)/*/*[name()=$nodeName]/*[name()=$fieldName]">
+<xsl:call-template name='convertDbStyle'><xsl:with-param name='toconvert' select='name()'/></xsl:call-template>
+<!--xsl:value-of select="name()"/-->
+</xsl:when>
+</xsl:choose>
+<xsl:if test="position() != last()">, </xsl:if>
+</xsl:template>
+
+<xsl:template match="@*" mode="values">
+<xsl:param name="nodeName"/>
+<xsl:variable name="fieldName" select="name()"/>
+<xsl:variable name="field" select="xalan:nodeset($meta)/*/*[name()=$nodeName]/*[name()=$fieldName]"/>
+<xsl:choose>
+<xsl:when test="xalan:nodeset($field)/@type='2'">'<xsl:value-of select="."/>'</xsl:when>
+<xsl:when test="xalan:nodeset($field)/@type='12'">'<xsl:value-of select="."/>'</xsl:when>
+<xsl:when test="xalan:nodeset($field)/@type='4'">'<xsl:value-of select="."/>'</xsl:when>
+<xsl:when test="xalan:nodeset($field)/@type='5'">'<xsl:value-of select="."/>'</xsl:when>
+<xsl:when test="xalan:nodeset($field)/@type='6'">'<xsl:value-of select="."/>'</xsl:when>
+<xsl:otherwise><xsl:value-of select="."/></xsl:otherwise>
+</xsl:choose>
+<xsl:if test="position() != last()">, </xsl:if>
+</xsl:template>
+
+<xsl:template match="@*" mode="tablename-conflict-set">
+<xsl:param name="nodeName"/>
+<xsl:variable name="fieldName" select="name()"/>
+<xsl:variable name="dbFieldName"><xsl:call-template name='convertDbStyle'><xsl:with-param name='toconvert' select='name()'/></xsl:call-template></xsl:variable>
+<xsl:choose>
+<xsl:when test="$dbFieldName='ID'">
+</xsl:when>
+<xsl:when test="xalan:nodeset($meta)/*/*[name()=$nodeName]/*[name()=$fieldName]">
+<xsl:value-of select="$dbFieldName"/> = EXCLUDED.<xsl:value-of select="$dbFieldName"/>
+<xsl:if test="position() != last()">, </xsl:if>
+</xsl:when>
+</xsl:choose>
+</xsl:template>
+
+<xsl:template name='convertDbStyle'>
+<xsl:param name='toconvert' />
+<xsl:variable name="added_">
+	<xsl:call-template name='add_'>
+		<xsl:with-param name='toconvert' select='$toconvert' />
+	</xsl:call-template>
+</xsl:variable>
+<xsl:call-template name='convertcase'>
+		<xsl:with-param name='toconvert' select='$added_' />
+		<xsl:with-param name='conversion' select="'upper'" />
+</xsl:call-template>
+</xsl:template>
+
+
+<xsl:template name='convertcase'>
+<xsl:param name='toconvert' />
+<xsl:param name='conversion' />
+
+<xsl:choose>
+	<xsl:when test='$conversion="lower"'>
+		<xsl:value-of select="translate($toconvert,$ucletters,$lcletters)"/>
+	</xsl:when>
+	<xsl:when test='$conversion="upper"'>
+		<xsl:value-of select="translate($toconvert,$lcletters,$ucletters)"/>
+	</xsl:when>
+	<xsl:when test='$conversion="proper"'>
+		<xsl:call-template name='convertpropercase'>
+		<xsl:with-param name='toconvert'>
+			<xsl:value-of select="translate($toconvert,$ucletters,$lcletters)"/>
+		</xsl:with-param>
+		</xsl:call-template>
+	</xsl:when>
+	<xsl:otherwise>
+		<xsl:value-of select='$toconvert' />
+	</xsl:otherwise>
+</xsl:choose>
+</xsl:template>
+
+<xsl:template name='convertpropercase'>
+<xsl:param name='toconvert' />
+
+<xsl:if test="string-length($toconvert) > 0">
+	<xsl:variable name='f' select='substring($toconvert, 1, 1)' />
+	<xsl:variable name='s' select='substring($toconvert, 2)' />
+	
+	<xsl:call-template name='convertcase'>
+		<xsl:with-param name='toconvert' select='$f' />
+		<xsl:with-param name='conversion'>upper</xsl:with-param>
+	</xsl:call-template>
+
+<xsl:choose>
+	<xsl:when test="contains($s,' ')">
+		<xsl:value-of select='substring-before($s," ")'/>
+		<xsl:call-template name='convertpropercase'>
+		<xsl:with-param name='toconvert' select='substring-after($s," ")' />
+		</xsl:call-template>
+	</xsl:when>
+	<xsl:otherwise>
+		<xsl:value-of select='$s'/>
+	</xsl:otherwise>
+</xsl:choose>
+</xsl:if>
+</xsl:template>
+
+<xsl:template name='add_'>
+<xsl:param name='toconvert' />
+<xsl:if test="string-length($toconvert) > 0">
+	<xsl:variable name='f' select='substring($toconvert, 1, 1)' />
+	<xsl:variable name='s' select='substring($toconvert, 2)' />
+	<xsl:choose>
+		<xsl:when test="$f = translate($f, $lcletters,$ucletters)"><xsl:if test="translate($f, $avoidletters,'')">_</xsl:if><xsl:value-of select='$f'/></xsl:when>
+		<xsl:otherwise><xsl:value-of select='$f'/></xsl:otherwise>
+	</xsl:choose>
+	<xsl:if test="string-length($toconvert) > 1">
+		<xsl:call-template name='add_'>
+			<xsl:with-param name='toconvert' select='$s'/>
+		</xsl:call-template>
+	</xsl:if>
+</xsl:if>
+</xsl:template>
+
+</xsl:stylesheet>

clearing-parent/backend-api/src/main/resources/meta/xsl/db.xsl

@@ -0,0 +1,215 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"  xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xalan="http://xml.apache.org/xalan" exclude-result-prefixes="xalan">
+<xsl:output version="1.0" method="html" indent="no" encoding="UTF-8"/>
+
+<xsl:variable name="data" select="document('..\data.xml')/meta"/>
+<xsl:variable name="meta" select="document('..\meta.xml')/meta"/>
+
+<xsl:variable name="lcletters">abcdefghijklmnopqrstuvwxyz</xsl:variable>
+<xsl:variable name="ucletters">ABCDEFGHIJKLMNOPQRSTUVWXYZ</xsl:variable>
+<xsl:variable name="avoidletters">_0123456789</xsl:variable>
+
+<xsl:template match="/">
+		<head>
+			<META http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
+			<title>Web</title>
+			<meta content="text/html; charset=UTF-8" http-equiv="Content-Type"/>
+			<style type="text/css">
+			table.sample {
+				border-width: 1px 1px 1px 1px;
+				border-spacing: 2px;
+				border-style: outset outset outset outset;
+				border-color: gray gray gray gray;
+				border-collapse: collapse;
+				background-color: white;
+			}
+			table.sample th {
+				border-width: 1px 1px 1px 1px;
+				padding: 1px 1px 1px 1px;
+				border-style: inset inset inset inset;
+				border-color: gray gray gray gray;
+				background-color: white;
+				-moz-border-radius: 0px 0px 0px 0px;
+			}
+			table.sample td {
+				border-width: 1px 1px 1px 1px;
+				padding: 1px 1px 1px 1px;
+				border-style: inset inset inset inset;
+				border-color: gray gray gray gray;
+				background-color: white;
+			}
+			</style>
+		</head>
+		Version: <xsl:value-of select="@version"/>
+		<xsl:apply-templates select="reports"/>
+
+<xsl:apply-templates select="*"/></xsl:template>
+
+<xsl:template match="meta">-- DB version: <xsl:value-of select="@version"/><xsl:apply-templates select="*"/></xsl:template>
+
+<xsl:template match="enums">
+/* Dictionaries */
+<xsl:apply-templates select="*" mode="enums"/>
+
+</xsl:template>
+<xsl:template match="objects">
+/* Business objects */
+<xsl:apply-templates select="*" mode="objects"/>
+</xsl:template>
+
+<xsl:template match="views">
+	/* views */
+</xsl:template>
+
+<xsl:template match="types">
+	-- Data types
+	<xsl:apply-templates select="*" mode="types"/>
+</xsl:template>
+	
+<xsl:template match="type" mode="types">
+	-- <xsl:value-of select="@id"/>. <xsl:value-of select="name()"/> : <xsl:value-of select="@type"/> - <xsl:value-of select="@name"/>
+	<xsl:if test="position() != last()">,</xsl:if>
+</xsl:template>
+	
+<xsl:template match="*" mode="enums">
+<xsl:variable name="dbTableName"><xsl:call-template name='convertDbStyle'><xsl:with-param name='toconvert' select='concat(name(),"Dictionary")'/></xsl:call-template></xsl:variable>
+<xsl:variable name="enumName"><xsl:value-of select="name()"/></xsl:variable>
+<h3><xsl:value-of select="position()"/>. <xsl:value-of select="@name"/> - <xsl:value-of select="$dbTableName"/>( <xsl:value-of select="name()"/>)</h3>
+		<table class="sample" width="100%" border="0">
+			<tr><td width="10%">№</td><td width="20%">Поле</td><td width="20%">Тип</td><td  width="45%">Наименование</td></tr>
+				<xsl:apply-templates select="*" mode="comment-enums"/>
+		</table>
+		<a name="enums.{name()}"/>
+		<div>Значения:</div>
+		<xsl:for-each select="xalan:nodeset($data)/enums/*[name()=$enumName]">
+			<xsl:value-of select="@id"/>. <xsl:value-of select="@code"/> - <i><xsl:value-of select="@name"/></i><br/>
+		</xsl:for-each>
+</xsl:template>
+
+<xsl:template match="*" mode="objects">
+<xsl:variable name="dbTableName"><xsl:call-template name='convertDbStyle'><xsl:with-param name='toconvert' select='name()'/></xsl:call-template></xsl:variable>
+<h3><xsl:value-of select="position()"/>. <xsl:value-of select="@name"/> - <xsl:value-of select="$dbTableName"/>( <xsl:value-of select="name()"/>)</h3>
+
+		<table class="sample" width="100%" border="0">
+			<tr><td width="10%">№</td><td width="20%">Поле</td><td width="20%">Тип</td><td  width="45%">Наименование</td></tr>
+				<xsl:apply-templates select="*" mode="comment-objects"/>
+		</table>
+</xsl:template>
+
+<xsl:template match="*" mode="field" >
+<xsl:if test="position() != '1'">, </xsl:if>
+<xsl:variable name="tp" select="@type"/>
+<xsl:choose>
+<xsl:when test="@dbfield"><xsl:value-of select="@dbfield"/></xsl:when>
+<xsl:otherwise><xsl:call-template name='convertDbStyle'><xsl:with-param name='toconvert' select='name()'/></xsl:call-template></xsl:otherwise>
+</xsl:choose>&#160;<xsl:value-of select="/meta/types/*[@id=$tp]/@type"/>
+<xsl:if test="@length">(<xsl:value-of select="@length"/>)</xsl:if><xsl:if test="name()='id'"> PRIMARY KEY</xsl:if>
+</xsl:template>
+
+<xsl:template match="*" mode="comment-enums">
+<tr>
+<td width="5%"><xsl:value-of select="position()"/></td>
+<td width="10%"><xsl:call-template name='convertDbStyle'><xsl:with-param name='toconvert' select='name()'/></xsl:call-template></td>
+<td width="20%"><xsl:variable name="fieldType"><xsl:value-of select="@type"/></xsl:variable>
+				<xsl:value-of select="$meta/types/*[@id=$fieldType]/@type"/>
+				<xsl:if test="@length">(<xsl:value-of select="@length"/>)</xsl:if>
+</td>
+<td  width="45%"><xsl:if test="@name"><xsl:value-of select="@name"/></xsl:if> <xsl:if test="@link"> (linked to <xsl:value-of select="@link"/>)</xsl:if></td></tr>
+</xsl:template>
+
+
+<xsl:template match="*" mode="comment-objects">
+<xsl:if test="name() != 'actions'">
+<tr>
+<td width="5%"><xsl:value-of select="position()"/></td>
+<td width="10%"><xsl:call-template name='convertDbStyle'><xsl:with-param name='toconvert' select='name()'/></xsl:call-template></td>
+<td width="20%"><xsl:variable name="fieldType"><xsl:value-of select="@type"/></xsl:variable>
+				<xsl:value-of select="$meta/types/*[@id=$fieldType]/@type"/>
+				<xsl:if test="@length">(<xsl:value-of select="@length"/>)</xsl:if>
+</td>
+<td  width="45%"><xsl:if test="@name"><xsl:value-of select="@name"/></xsl:if> <xsl:if test="@link"> (linked to <xsl:value-of select="@link"/>)</xsl:if></td></tr>
+</xsl:if>
+</xsl:template>
+
+<xsl:template name='convertDbStyle'>
+<xsl:param name='toconvert' />
+<xsl:variable name="added_">
+	<xsl:call-template name='add_'>
+		<xsl:with-param name='toconvert' select='$toconvert' />
+	</xsl:call-template>
+</xsl:variable>
+<xsl:call-template name='convertcase'>
+		<xsl:with-param name='toconvert' select='$added_' />
+		<xsl:with-param name='conversion' select="'upper'" />
+</xsl:call-template>
+</xsl:template>
+
+
+<xsl:template name='convertcase'>
+<xsl:param name='toconvert' />
+<xsl:param name='conversion' />
+
+<xsl:choose>
+	<xsl:when test='$conversion="lower"'>
+		<xsl:value-of select="translate($toconvert,$ucletters,$lcletters)"/>
+	</xsl:when>
+	<xsl:when test='$conversion="upper"'>
+		<xsl:value-of select="translate($toconvert,$lcletters,$ucletters)"/>
+	</xsl:when>
+	<xsl:when test='$conversion="proper"'>
+		<xsl:call-template name='convertpropercase'>
+		<xsl:with-param name='toconvert'>
+			<xsl:value-of select="translate($toconvert,$ucletters,$lcletters)"/>
+		</xsl:with-param>
+		</xsl:call-template>
+	</xsl:when>
+	<xsl:otherwise>
+		<xsl:value-of select='$toconvert' />
+	</xsl:otherwise>
+</xsl:choose>
+</xsl:template>
+
+<xsl:template name='convertpropercase'>
+<xsl:param name='toconvert' />
+
+<xsl:if test="string-length($toconvert) > 0">
+	<xsl:variable name='f' select='substring($toconvert, 1, 1)' />
+	<xsl:variable name='s' select='substring($toconvert, 2)' />
+	
+	<xsl:call-template name='convertcase'>
+		<xsl:with-param name='toconvert' select='$f' />
+		<xsl:with-param name='conversion'>upper</xsl:with-param>
+	</xsl:call-template>
+
+<xsl:choose>
+	<xsl:when test="contains($s,' ')">
+		<xsl:value-of select='substring-before($s," ")'/>
+		<xsl:call-template name='convertpropercase'>
+		<xsl:with-param name='toconvert' select='substring-after($s," ")' />
+		</xsl:call-template>
+	</xsl:when>
+	<xsl:otherwise>
+		<xsl:value-of select='$s'/>
+	</xsl:otherwise>
+</xsl:choose>
+</xsl:if>
+</xsl:template>
+
+<xsl:template name='add_'>
+<xsl:param name='toconvert' />
+<xsl:if test="string-length($toconvert) > 0">
+	<xsl:variable name='f' select='substring($toconvert, 1, 1)' />
+	<xsl:variable name='s' select='substring($toconvert, 2)' />
+	<xsl:choose>
+		<xsl:when test="$f = translate($f, $lcletters,$ucletters)"><xsl:if test="translate($f, $avoidletters,'')">_</xsl:if><xsl:value-of select='$f'/></xsl:when>
+		<xsl:otherwise><xsl:value-of select='$f'/></xsl:otherwise>
+	</xsl:choose>
+	<xsl:if test="string-length($toconvert) > 1">
+		<xsl:call-template name='add_'>
+			<xsl:with-param name='toconvert' select='$s'/>
+		</xsl:call-template>
+	</xsl:if>
+</xsl:if>
+</xsl:template>
+
+</xsl:stylesheet>

clearing-parent/backend-api/src/main/resources/meta/xsl/ddl.xsl

@@ -0,0 +1,194 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+	<xsl:output version="1.0" method="text" indent="no" encoding="UTF-8"/>
+
+<xsl:variable name="lcletters">abcdefghijklmnopqrstuvwxyz</xsl:variable>
+<xsl:variable name="ucletters">ABCDEFGHIJKLMNOPQRSTUVWXYZ</xsl:variable>
+<xsl:variable name="avoidletters">_0123456789</xsl:variable>
+
+<xsl:template match="/"><xsl:apply-templates select="*"/></xsl:template>
+
+<xsl:template match="meta">-- DB version: <xsl:value-of select="@version"/><xsl:apply-templates select="*"/></xsl:template>
+
+<xsl:template match="enums">
+/* Dictionaries */
+<xsl:apply-templates select="*" mode="enums"/>
+
+</xsl:template>
+<xsl:template match="objects">
+/* Business objects */
+<xsl:apply-templates select="*" mode="objects"/>
+</xsl:template>
+
+<xsl:template match="views">
+	/* views */
+</xsl:template>
+
+<xsl:template match="types">
+	-- Data types
+	<xsl:apply-templates select="*" mode="types"/>
+</xsl:template>
+	
+<xsl:template match="type" mode="types">
+	-- <xsl:value-of select="@id"/>. <xsl:value-of select="name()"/> : <xsl:value-of select="@type"/> - <xsl:value-of select="@name"/>
+	<xsl:if test="position() != last()">,</xsl:if>
+</xsl:template>
+	
+<xsl:template match="*" mode="enums">
+-- <xsl:value-of select="name()"/> - <xsl:value-of select="@name"/>
+<xsl:variable name="dbTableName"><xsl:call-template name='convertDbStyle'><xsl:with-param name='toconvert' select='concat(name(),"Dictionary")'/></xsl:call-template></xsl:variable>
+DROP TABLE IF EXISTS <xsl:value-of select="$dbTableName"/>;
+CREATE TABLE <xsl:value-of select="$dbTableName"/>(<xsl:apply-templates select="*" mode="field"/>);
+COMMENT ON TABLE <xsl:value-of select="$dbTableName"/> IS '<xsl:value-of select="@name"/>';
+<xsl:apply-templates select="*" mode="comment-enums"/>
+</xsl:template>
+
+<xsl:template match="*" mode="objects">
+-- <xsl:value-of select="name()"/> - <xsl:value-of select="@name"/>
+<xsl:variable name="dbTableName"><xsl:call-template name='convertDbStyle'><xsl:with-param name='toconvert' select='name()'/></xsl:call-template></xsl:variable>
+DROP TABLE IF EXISTS <xsl:value-of select="$dbTableName"/>;
+CREATE TABLE <xsl:value-of select="$dbTableName"/>(<xsl:apply-templates select="*[@name or @type]" mode="field"/>);
+COMMENT ON TABLE <xsl:value-of select="$dbTableName"/> IS '<xsl:value-of select="@name"/>';
+<xsl:apply-templates select="*[@name or @type]" mode="comment-objects"/>
+<xsl:if test="@logUpdates">
+
+-- History log of <xsl:value-of select="name()"/> - <xsl:value-of select="@name"/>
+<xsl:variable name="dbTableName"><xsl:call-template name='convertDbStyle'><xsl:with-param name='toconvert' select='name()'/></xsl:call-template></xsl:variable>
+DROP TABLE IF EXISTS <xsl:value-of select="$dbTableName"/>_HISTORY;
+CREATE TABLE <xsl:value-of select="$dbTableName"/>_HISTORY(<xsl:value-of select="$dbTableName"/>_ID BIGINT NOT NULL, EVENT_TIME timestamp, EVENT_USER_ID BIGINT, EVENT_TYPE VARCHAR(4), <xsl:apply-templates select="*[@name or @type]" mode="field"/>);
+COMMENT ON TABLE <xsl:value-of select="$dbTableName"/>_HISTORY IS 'История изменений таблицы <xsl:value-of select="name()"/>';
+COMMENT ON COLUMN <xsl:value-of select="$dbTableName"/>_HISTORY.<xsl:value-of select="$dbTableName"/>_ID IS 'Идентификатор записи в таблице <xsl:value-of select="$dbTableName"/>';
+COMMENT ON COLUMN <xsl:value-of select="$dbTableName"/>_HISTORY.EVENT_TIME IS 'Дата и время изменения';
+COMMENT ON COLUMN <xsl:value-of select="$dbTableName"/>_HISTORY.EVENT_USER_ID IS 'Инициатор изменения';
+COMMENT ON COLUMN <xsl:value-of select="$dbTableName"/>_HISTORY.EVENT_TYPE IS 'Тип изменения';
+<xsl:apply-templates select="*[@name or @type]" mode="comment-history-objects"/>
+</xsl:if>
+</xsl:template>
+
+
+<xsl:template match="*" mode="field" >
+<xsl:variable name="tp" select="@type"/>
+<xsl:choose>
+<xsl:when test="@dbfield"><xsl:value-of select="@dbfield"/></xsl:when>
+<xsl:when test="@linkKeyCode"></xsl:when>
+<xsl:when test="@extends"></xsl:when>
+<xsl:otherwise><xsl:if test="position() != '1'">, </xsl:if><xsl:call-template name='convertDbStyle'><xsl:with-param name='toconvert' select='name()'/></xsl:call-template></xsl:otherwise>
+</xsl:choose>
+<xsl:choose>
+<xsl:when test="@linkKeyCode"></xsl:when>
+<xsl:when test="@extends"></xsl:when>
+<xsl:otherwise>
+<xsl:text> </xsl:text><xsl:value-of select="/meta/types/*[@id=$tp]/@type"/>
+<xsl:if test="@length">(<xsl:value-of select="@length"/>)</xsl:if><xsl:if test="name()='id'"> PRIMARY KEY</xsl:if>
+</xsl:otherwise>
+</xsl:choose>
+</xsl:template>
+
+<xsl:template match="*" mode="comment-enums">
+<xsl:variable name="dbTableName"><xsl:call-template name='convertDbStyle'><xsl:with-param name='toconvert' select='concat(name(parent::*),"Dictionary")'/></xsl:call-template></xsl:variable>
+COMMENT ON COLUMN <xsl:value-of select="$dbTableName"/>.<xsl:call-template name='convertDbStyle'><xsl:with-param name='toconvert' select='name()'/></xsl:call-template> IS '<xsl:if test="@name"><xsl:value-of select="@name"/></xsl:if> <xsl:if test="@link"> (linked to <xsl:value-of select="@link"/>)</xsl:if>';
+</xsl:template>
+
+
+<xsl:template match="*" mode="comment-objects">
+<xsl:choose>
+<xsl:when test="@linkKeyCode"></xsl:when>
+<xsl:when test="@extends"></xsl:when>
+<xsl:otherwise>
+<xsl:variable name="dbTableName"><xsl:call-template name='convertDbStyle'><xsl:with-param name='toconvert' select='name(parent::*)'/></xsl:call-template></xsl:variable>
+COMMENT ON COLUMN <xsl:value-of select="$dbTableName"/>.<xsl:call-template name='convertDbStyle'><xsl:with-param name='toconvert' select='name()'/></xsl:call-template> IS '<xsl:if test="@name"><xsl:value-of select="@name"/></xsl:if> <xsl:if test="@link"> (linked to <xsl:value-of select="@link"/>)</xsl:if>';
+</xsl:otherwise></xsl:choose></xsl:template>
+
+<xsl:template match="*" mode="comment-history-objects"><!-- todo похож на comment-objects только именем таблицы различается попробовать объединить -->
+<xsl:choose>
+<xsl:when test="@linkKeyCode"></xsl:when>
+<xsl:when test="@extends"></xsl:when>
+<xsl:otherwise>
+<xsl:variable name="dbTableName"><xsl:call-template name='convertDbStyle'><xsl:with-param name='toconvert' select='name(parent::*)'/></xsl:call-template></xsl:variable>
+COMMENT ON COLUMN <xsl:value-of select="$dbTableName"/>_HISTORY.<xsl:call-template name='convertDbStyle'><xsl:with-param name='toconvert' select='name()'/></xsl:call-template> IS '<xsl:if test="@name"><xsl:value-of select="@name"/></xsl:if> <xsl:if test="@link"> (linked to <xsl:value-of select="@link"/>)</xsl:if>';
+</xsl:otherwise>
+</xsl:choose>
+</xsl:template>
+
+<xsl:template name='convertDbStyle'>
+<xsl:param name='toconvert' />
+<xsl:variable name="added_">
+	<xsl:call-template name='add_'>
+		<xsl:with-param name='toconvert' select='$toconvert' />
+	</xsl:call-template>
+</xsl:variable>
+<xsl:call-template name='convertcase'>
+		<xsl:with-param name='toconvert' select='$added_' />
+		<xsl:with-param name='conversion' select="'upper'" />
+</xsl:call-template>
+</xsl:template>
+
+
+<xsl:template name='convertcase'>
+<xsl:param name='toconvert' />
+<xsl:param name='conversion' />
+
+<xsl:choose>
+	<xsl:when test='$conversion="lower"'>
+		<xsl:value-of select="translate($toconvert,$ucletters,$lcletters)"/>
+	</xsl:when>
+	<xsl:when test='$conversion="upper"'>
+		<xsl:value-of select="translate($toconvert,$lcletters,$ucletters)"/>
+	</xsl:when>
+	<xsl:when test='$conversion="proper"'>
+		<xsl:call-template name='convertpropercase'>
+		<xsl:with-param name='toconvert'>
+			<xsl:value-of select="translate($toconvert,$ucletters,$lcletters)"/>
+		</xsl:with-param>
+		</xsl:call-template>
+	</xsl:when>
+	<xsl:otherwise>
+		<xsl:value-of select='$toconvert' />
+	</xsl:otherwise>
+</xsl:choose>
+</xsl:template>
+
+<xsl:template name='convertpropercase'>
+<xsl:param name='toconvert' />
+
+<xsl:if test="string-length($toconvert) > 0">
+	<xsl:variable name='f' select='substring($toconvert, 1, 1)' />
+	<xsl:variable name='s' select='substring($toconvert, 2)' />
+	
+	<xsl:call-template name='convertcase'>
+		<xsl:with-param name='toconvert' select='$f' />
+		<xsl:with-param name='conversion'>upper</xsl:with-param>
+	</xsl:call-template>
+
+<xsl:choose>
+	<xsl:when test="contains($s,' ')">
+		<xsl:value-of select='substring-before($s," ")'/>
+		<xsl:call-template name='convertpropercase'>
+		<xsl:with-param name='toconvert' select='substring-after($s," ")' />
+		</xsl:call-template>
+	</xsl:when>
+	<xsl:otherwise>
+		<xsl:value-of select='$s'/>
+	</xsl:otherwise>
+</xsl:choose>
+</xsl:if>
+</xsl:template>
+
+<xsl:template name='add_'>
+<xsl:param name='toconvert' />
+<xsl:if test="string-length($toconvert) > 0">
+	<xsl:variable name='f' select='substring($toconvert, 1, 1)' />
+	<xsl:variable name='s' select='substring($toconvert, 2)' />
+	<xsl:choose>
+		<xsl:when test="$f = translate($f, $lcletters,$ucletters)"><xsl:if test="translate($f, $avoidletters,'')">_</xsl:if><xsl:value-of select='$f'/></xsl:when>
+		<xsl:otherwise><xsl:value-of select='$f'/></xsl:otherwise>
+	</xsl:choose>
+	<xsl:if test="string-length($toconvert) > 1">
+		<xsl:call-template name='add_'>
+			<xsl:with-param name='toconvert' select='$s'/>
+		</xsl:call-template>
+	</xsl:if>
+</xsl:if>
+</xsl:template>
+
+</xsl:stylesheet>

clearing-parent/backend-api/src/main/resources/meta/xsl/report.xsl

@@ -0,0 +1,151 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"  xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xalan="http://xml.apache.org/xalan" exclude-result-prefixes="xalan">
+<xsl:output version="1.0" method="html" indent="no" encoding="UTF-8"/>
+
+<xsl:variable name="data" select="document('..\data.xml')/meta"/>
+<xsl:variable name="metaxsd" select="document('..\meta.xsd')/xs:schema"/>
+<xsl:variable name="meta" select="document('..\meta.xml')/meta"/>
+
+	<xsl:template match="/">
+		<html><xsl:apply-templates select="*"/></html>
+	</xsl:template>
+	
+	<xsl:template match="meta">
+		<head>
+			<META http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
+			<title>Web</title>
+			<meta content="text/html; charset=UTF-8" http-equiv="Content-Type"/>
+			<style type="text/css">
+			table.sample {
+				border-width: 1px 1px 1px 1px;
+				border-spacing: 2px;
+				border-style: outset outset outset outset;
+				border-color: gray gray gray gray;
+				border-collapse: collapse;
+				background-color: white;
+			}
+			table.sample th {
+				border-width: 1px 1px 1px 1px;
+				padding: 1px 1px 1px 1px;
+				border-style: inset inset inset inset;
+				border-color: gray gray gray gray;
+				background-color: white;
+				-moz-border-radius: 0px 0px 0px 0px;
+			}
+			table.sample td {
+				border-width: 1px 1px 1px 1px;
+				padding: 1px 1px 1px 1px;
+				border-style: inset inset inset inset;
+				border-color: gray gray gray gray;
+				background-color: white;
+			}
+			</style>
+		</head>
+
+		Version: <xsl:value-of select="@version"/>
+		<xsl:apply-templates select="reports"/>
+		<!--xsl:apply-templates select="enums"/-->
+	</xsl:template>
+	
+
+
+
+	<xsl:template match="objects">
+	</xsl:template>
+
+
+	<xsl:template match="reports">
+		<a name="reports"/>
+		<h2>Общее описание отчетов</h2>
+		<div style="white-space: pre-wrap;"><xsl:copy-of select="$metaxsd/xs:element/xs:complexType/xs:sequence/xs:element[@name='reports']/xs:annotation/xs:documentation/."/></div>
+		<xsl:apply-templates select="*" mode="reports"/>
+	</xsl:template>
+
+
+	<xsl:template match="enums"><xsl:apply-templates select="*" mode="enums"/></xsl:template>
+
+	
+	<xsl:template match="views"></xsl:template>
+	
+
+	<xsl:template match="types"></xsl:template>
+	
+	
+	<xsl:template match="*" mode="reports">
+		<xsl:variable name="reportNum"><xsl:value-of select="position()"/></xsl:variable>
+		<xsl:variable name="reportName"><xsl:value-of select="name()"/></xsl:variable>
+		<a name="reports.{$reportName}"/>
+		<h2>1.<xsl:value-of select="$reportNum"/>. <xsl:value-of select="name()"/> - <xsl:value-of select="@name"/></h2>
+
+		<div style="white-space: pre-wrap;"><xsl:copy-of select="$metaxsd/xs:element/xs:complexType/xs:sequence/xs:element[@name='reports']/xs:complexType/xs:sequence/xs:element[@name=$reportName]/xs:annotation/xs:documentation/."/></div>
+		<br/>
+		<xsl:for-each select="@*">
+			<xsl:variable name="reportField"><xsl:value-of select="name()"/></xsl:variable>
+			<div style="white-space: pre-wrap;"><xsl:value-of select="position()"/>. <xsl:value-of select="name()"/>=<xsl:value-of select="."/> 
+			<xsl:if test="$metaxsd/xs:element/xs:complexType/xs:sequence/xs:element[@name='reports']/xs:complexType/xs:sequence/xs:element[@name=$reportName]/xs:complexType/xs:attribute[@name=$reportField]/xs:annotation/xs:documentation/."> - <xsl:copy-of select="$metaxsd/xs:element/xs:complexType/xs:sequence/xs:element[@name='reports']/xs:complexType/xs:sequence/xs:element[@name=$reportName]/xs:complexType/xs:attribute[@name=$reportField]/xs:annotation/xs:documentation/."/>
+			</xsl:if>
+			</div>
+		</xsl:for-each>
+		<a name="reports.{$reportName}.fields"/>
+		<h3>1.<xsl:value-of select="$reportNum"/>.2. Поля объекта</h3>
+		<table class="sample" id="{name()}" width="100%" border="0">
+			<tr><td width="5%">#</td><td width="10%">Поле</td><td width="45%">Обработка</td></tr>
+			<xsl:for-each select="rows/@*">
+				<xsl:variable name="attributeName"><xsl:value-of select="name()"/></xsl:variable>
+				<tr>	<td style="vertical-align: top;"><xsl:value-of select="position()"/></td>
+					<td style="vertical-align: top;">
+						<a name="reports.{$reportName}.fields.{name()}"/><xsl:value-of select="name()"/>
+					</td>
+					<td style="vertical-align: top;">
+					<div style="white-space: pre-wrap;"><xsl:copy-of select="$metaxsd/xs:element/xs:complexType/xs:sequence/xs:element[@name='reports']/xs:complexType/xs:sequence/xs:element[@name=$reportName]/xs:complexType/xs:sequence/xs:element[@name='rows']/xs:complexType/xs:attribute[@name=$attributeName]/xs:annotation/xs:documentation/."/></div>
+					</td>
+				</tr>
+			</xsl:for-each>
+		</table>
+		<div>Пример:</div>
+		<div><textarea autocomplete="on" cols="100" rows="8"><xsl:copy-of select="."/></textarea></div>
+	</xsl:template>
+
+
+
+	<xsl:template match="*" mode="enums">
+		<a name="enums.{name()}"/>
+		<h3>2.<xsl:value-of select="position()"/>. <xsl:value-of select="name()"/> - <xsl:value-of select="@name"/></h3>
+		<table class="sample" id="{name()}" width="100%" border="0">
+			<tr><td width="5%">#</td><td width="10%">Поле</td><td width="45%">Описание</td><td  width="20%">Наименование</td><td width="20%">Тип</td></tr>
+			<xsl:apply-templates select="*" mode="field-enums"/>
+		</table>
+	</xsl:template>
+
+
+
+	<xsl:template match="*" mode="field-enums">
+		<tr><td><xsl:value-of select="position()"/></td>
+		    <td><xsl:value-of select="name()"/></td>
+			<xsl:for-each select="@*">
+				<xsl:choose>
+					<xsl:when test="name()='type'">
+						<td>
+							<xsl:value-of select="name(/meta/types/*[@id=current()])"/>
+							<xsl:if test="../@length">(<xsl:value-of select="../@length"/>)</xsl:if>
+						</td>
+					</xsl:when>
+					<xsl:when test="name()='searchable'"><td><xsl:value-of select="."/></td></xsl:when>
+					<xsl:when test="name()='sortable'"><td><xsl:value-of select="."/></td></xsl:when>
+					<xsl:when test="name()='visible'"><td><xsl:value-of select="."/></td></xsl:when>
+					<xsl:when test="name()='required'"><td><xsl:value-of select="."/></td></xsl:when>
+					<xsl:when test="name()='hidden'"><td><xsl:value-of select="."/></td></xsl:when>
+					<xsl:when test="name()='ignored'"><td><xsl:value-of select="."/></td></xsl:when>
+					<xsl:when test="name()='cacheable'"><td><xsl:value-of select="."/></td></xsl:when>
+					<xsl:when test="name()='name'"><td><xsl:value-of select="."/></td></xsl:when>
+					<xsl:when test="name()='shortname'"><td><xsl:value-of select="."/></td></xsl:when>
+					<xsl:when test="name()='link'"><td><xsl:value-of select="."/></td></xsl:when>
+					<xsl:when test="name()='field'"><td><xsl:value-of select="."/></td></xsl:when>
+					<xsl:when test="name()='dbfield'"><td><xsl:value-of select="."/></td></xsl:when>
+				</xsl:choose>
+			</xsl:for-each>
+		</tr>
+	</xsl:template>
+
+	
+</xsl:stylesheet>

clearing-parent/backend-api/src/main/resources/meta/xsl/web.xsl

@@ -0,0 +1,172 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+	<xsl:output version="1.0" method="html" indent="no" encoding="UTF-8"/>
+
+	<xsl:template match="/">
+		<html><xsl:apply-templates select="*"/></html>
+	</xsl:template>
+	
+	<xsl:template match="meta">
+		<head>
+			<META http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
+			<title>Web</title>
+			<meta content="text/html; charset=UTF-8" http-equiv="Content-Type"/>
+			<style type="text/css">
+			table.sample {
+				border-width: 1px 1px 1px 1px;
+				border-spacing: 2px;
+				border-style: outset outset outset outset;
+				border-color: gray gray gray gray;
+				border-collapse: collapse;
+				background-color: white;
+			}
+			table.sample th {
+				border-width: 1px 1px 1px 1px;
+				padding: 1px 1px 1px 1px;
+				border-style: inset inset inset inset;
+				border-color: gray gray gray gray;
+				background-color: white;
+				-moz-border-radius: 0px 0px 0px 0px;
+			}
+			table.sample td {
+				border-width: 1px 1px 1px 1px;
+				padding: 1px 1px 1px 1px;
+				border-style: inset inset inset inset;
+				border-color: gray gray gray gray;
+				background-color: white;
+			}
+			</style>
+		</head>
+
+		Version: <xsl:value-of select="@version"/>
+		<xsl:apply-templates select="*"/>
+	</xsl:template>
+	
+	<xsl:template match="enums">
+		<xsl:apply-templates select="*" mode="enums"/>
+	</xsl:template>
+
+
+	<xsl:template match="objects">
+		<xsl:apply-templates select="*" mode="objects"/>
+	</xsl:template>
+
+	
+	<xsl:template match="views">
+		<!--xsl:apply-templates select="*" mode="views"/-->
+	</xsl:template>
+	
+
+	<xsl:template match="types">
+		<h2>Data types</h2>
+		<table class="sample" id="types" width="100%" border="0">
+			<xsl:apply-templates select="*" mode="types"/>
+		</table>
+	</xsl:template>
+	
+	
+	<xsl:template match="*" mode="types">
+		<tr><td><xsl:value-of select="@id"/></td><td><xsl:value-of select="name()"/></td><td><xsl:value-of select="@type"/></td><td><xsl:value-of select="@name"/></td></tr>
+	</xsl:template>
+	
+	
+	<xsl:template match="*" mode="enums">
+		<h2><!--1.<xsl:value-of select="position()"/>. --><xsl:value-of select="name()"/> - <xsl:value-of select="@name"/></h2>
+		<table class="sample" id="{name()}" width="100%" border="0">
+			<tr><td width="5%">#</td><td width="10%">Поле</td><td width="45%">Описание</td><td  width="20%">Наименование</td><td width="20%">Тип</td></tr>
+			<xsl:apply-templates select="*" mode="field-enums"/>
+		</table>
+	</xsl:template>
+	
+
+	<xsl:template match="*" mode="objects">
+		<h2><!--2.<xsl:value-of select="position()"/>. --><xsl:value-of select="name()"/> - <xsl:value-of select="@name"/></h2>
+		<table class="sample" id="{name()}" width="100%" border="0">
+			<tr><td width="5%">#</td><td width="10%">Поле</td><td width="20%">Тип</td><td  width="45%">Наименование</td><!--td width="20%">Видимость</td--></tr>
+			<xsl:apply-templates select="*" mode="field-objects"/>
+		</table>
+			<!--xsl:apply-templates select="query|subscription|subscriptionHistory" mode="objects"/>
+			<xsl:if test="actions">,"actions":[<xsl:apply-templates select="actions" mode="objects"/>]</xsl:if>
+			<xsl:if test="views">,"views":{<xsl:apply-templates select="views" mode="objects"/>}</xsl:if-->
+	</xsl:template>
+
+
+
+	<xsl:template match="*" mode="field-enums">
+		<tr><td><xsl:value-of select="position()"/></td>
+		    <td><xsl:value-of select="name()"/></td>
+			<xsl:for-each select="@*">
+				<xsl:choose>
+					<xsl:when test="name()='type'">
+						<td>
+							<xsl:value-of select="name(/meta/types/*[@id=current()])"/>
+							<xsl:if test="../@length">(<xsl:value-of select="../@length"/>)</xsl:if>
+						</td>
+					</xsl:when>
+					<xsl:when test="name()='searchable'"><td><xsl:value-of select="."/></td></xsl:when>
+					<xsl:when test="name()='sortable'"><td><xsl:value-of select="."/></td></xsl:when>
+					<xsl:when test="name()='visible'"><td><xsl:value-of select="."/></td></xsl:when>
+					<xsl:when test="name()='required'"><td><xsl:value-of select="."/></td></xsl:when>
+					<xsl:when test="name()='hidden'"><td><xsl:value-of select="."/></td></xsl:when>
+					<xsl:when test="name()='ignored'"><td><xsl:value-of select="."/></td></xsl:when>
+					<xsl:when test="name()='cacheable'"><td><xsl:value-of select="."/></td></xsl:when>
+					<xsl:when test="name()='name'"><td><xsl:value-of select="."/></td></xsl:when>
+					<xsl:when test="name()='shortname'"><td><xsl:value-of select="."/></td></xsl:when>
+					<xsl:when test="name()='link'"><td><xsl:value-of select="."/></td></xsl:when>
+					<xsl:when test="name()='field'"><td><xsl:value-of select="."/></td></xsl:when>
+					<xsl:when test="name()='dbfield'"><td><xsl:value-of select="."/></td></xsl:when>
+				</xsl:choose>
+			</xsl:for-each>
+		</tr>
+	</xsl:template>
+
+
+	<xsl:template match="*" mode="field-objects">
+		<tr><td><xsl:value-of select="position()"/></td>
+			<td><xsl:value-of select="name()"/>
+			<!--br/>поле: <xsl:value-of select="@field"/>
+			<br/>столбец:<xsl:value-of select="@dbfield"/-->
+			</td>
+			<xsl:for-each select="@*">
+				<xsl:choose>
+					<xsl:when test="name()='type'">
+						<td>
+							<xsl:value-of select="name(/meta/types/*[@id=current()])"/>
+							<xsl:if test="../@length">(<xsl:value-of select="../@length"/>)</xsl:if>
+						</td>
+					</xsl:when>
+					<xsl:when test="name()='shortname'">
+						<td>	
+							<i><xsl:value-of select="."/></i>. <!--br/-->
+							<xsl:if test="../@name"><xsl:value-of select="../@name"/></xsl:if>
+							<xsl:if test="../@link"><br/>Ссылается на объект :<xsl:value-of select="../@link"/></xsl:if>
+						</td>
+						<!--td>
+							<xsl:if test="../@searchable">Поиск: <xsl:value-of select="../@searchable"/></xsl:if>
+							<xsl:if test="../@sortable"><br/>Сортировка:<xsl:value-of select="../@sortable"/></xsl:if>
+							<xsl:if test="../@visible"><br/>Видимость: <xsl:value-of select="../@visible"/></xsl:if>
+							<xsl:if test="../@hidden"><br/>Скрыт:<xsl:value-of select="../@hidden"/></xsl:if>
+							<xsl:if test="../@ignored"><br/>Игнорируемый: <xsl:value-of select="../@ignored"/></xsl:if>
+							<xsl:if test="../@sendable"><br/>Отправляемый:<xsl:value-of select="../@sendable"/></xsl:if>
+						</td-->
+					</xsl:when>
+				</xsl:choose>
+			</xsl:for-each>
+		</tr>
+	</xsl:template>
+
+	
+
+	<xsl:template match="@*" mode="withSource">
+		<xsl:choose>
+			<xsl:when test="name()='type'">"<xsl:value-of select="parent::*/@source"/>": <xsl:value-of select="."/></xsl:when>
+			<xsl:when test="name()='length'">"<xsl:value-of select="parent::*/@source"/>": <xsl:value-of select="."/></xsl:when>
+			<xsl:when test="name()='searchable'">"<xsl:value-of select="parent::*/@source"/>": <xsl:value-of select="."/></xsl:when>
+			<xsl:when test="name()='sortable'">"<xsl:value-of select="parent::*/@source"/>": <xsl:value-of select="."/></xsl:when>
+			<xsl:when test="name()='visible'">"<xsl:value-of select="parent::*/@source"/>": <xsl:value-of select="."/></xsl:when>
+			<xsl:when test="name()='required'">"<xsl:value-of select="parent::*/@source"/>": <xsl:value-of select="."/></xsl:when>
+			<xsl:when test="name()='cacheable'">"<xsl:value-of select="parent::*/@source"/>": <xsl:value-of select="."/></xsl:when>
+			<xsl:otherwise>"<xsl:value-of select="parent::*/@source"/>": "<xsl:value-of select="."/>"</xsl:otherwise>
+		</xsl:choose>
+	</xsl:template>
+</xsl:stylesheet>

clearing-parent/balance-service/pom.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xmlns="http://maven.apache.org/POM/4.0.0"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
         <artifactId>clearing-parent</artifactId>
@@ -40,6 +40,22 @@
             <groupId>ru.spcex.platform</groupId>
             <artifactId>platform-enum</artifactId>
         </dependency>
+        <!-- TEST -->
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <build>
@@ -67,6 +83,23 @@
                     <finalName>${project.artifactId}</finalName>
                 </configuration>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>2.21.0</version>
+                <dependencies>
+                    <dependency>
+                        <groupId>org.junit.platform</groupId>
+                        <artifactId>junit-platform-surefire-provider</artifactId>
+                        <version>1.2.0-M1</version>
+                    </dependency>
+                    <dependency>
+                        <groupId>org.junit.jupiter</groupId>
+                        <artifactId>junit-jupiter-engine</artifactId>
+                        <version>5.2.0-M1</version>
+                    </dependency>
+                </dependencies>
+            </plugin>
         </plugins>
     </build>
 </project>

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

@@ -4,6 +4,8 @@ import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import ru.spcex.clearing.balance.service.AbstractExecutor;
 import ru.spcex.clearing.balance.service.Sdf01Executor;
+import ru.spcex.clearing.balance.service.Sdf09Executor;
+import ru.spcex.clearing.balance.service.Sdf16Executor;
 import ru.spcex.platform.classes.base.interfaces.WithAccount;
 import ru.spcex.platform.enumeration.SdfTable;
 
@@ -14,9 +16,13 @@ import java.util.Map;
 public class SdfExecutorsConfig {
 
     @Bean("sdfExecutors")
-    public Map<SdfTable, AbstractExecutor<? extends WithAccount>> executorsMap(Sdf01Executor sdf01Executor) {
+    public Map<SdfTable, AbstractExecutor<? extends WithAccount>> executorsMap(Sdf01Executor sdf01Executor,
+                                                                               Sdf09Executor sdf09Executor,
+                                                                               Sdf16Executor sdf16Executor) {
         Map<SdfTable, AbstractExecutor<? extends WithAccount>> executors = new HashMap<>();
         executors.put(SdfTable.SDF_01, sdf01Executor);
+        executors.put(SdfTable.SDF_09, sdf09Executor);
+        executors.put(SdfTable.SDF_16, sdf16Executor);
         return executors;
     }
 }

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

@@ -71,10 +71,13 @@ public class ValidationConfig {
             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,
                     Sdf16ValidationRule.CompanyPresent,
                     ExistClrnAccountValidationRule.AccountPresent,
-                    MarketIsUValidationRule.instance);
+                    MarketIsUValidationRule.instance,
+                    AccountBalanceFreeAmountEnough.instance(SDf16.class));
         };
     }
 
@@ -92,7 +95,7 @@ public class ValidationConfig {
                     Sdf09ValidationRule.CompanyPresent,
                     Sdf09ValidationRule.AccountPresent,
                     MarketIsUValidationRule.instance,
-                    Sdf09ValidationRule.BalanceEnough
+                    AccountBalanceFreeAmountEnough.instance(SDf09.class)
             );
         };
     }

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

@@ -7,7 +7,7 @@ public enum BalanceError implements IEnumId {
     CurrencyNotFound(5213L),
     CurrentDateOnly(5214L),
     WrongMarket(5215L),
-    WrongAccount(5215L),
+    WrongAccount(5216L),
     AccountNotPresent(5217L),
     AccountNotActive(5218L),
     BalanceNotEnough(5222L),

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

@@ -7,4 +7,5 @@ import java.util.Collection;
 
 public abstract class AbstractExecutor<T extends WithAccount> {
     abstract Result execute(Collection<T> sdf, StatementRequest statementRequest);
+    abstract String exportTableName();
 }

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

@@ -35,7 +35,7 @@ public class AccountBalanceService {
     }
 
     public AccountResult createAccountBalance(Long addresseeId, Long accountId, BigDecimal amount,
-                                                                              String cashMovementCurrencyCode) {
+                                              String cashMovementCurrencyCode) {
         IValidator validator = validationFactory.apply(new AccountBalanceValidation(addresseeId, accountId));
         Optional<EnumMessage> validationError = validator
                 .tillFirstError();
@@ -66,14 +66,23 @@ public class AccountBalanceService {
             return new AccountResult(accountBalance);
         } else {
             accountBalance.setUpdated(Instant.now());
-            accountBalance.setAccountId(accountId);
-            accountBalance.setAccountType(account.getAccountType());
+            accountBalance.setAccountId(accountId);//+
+            accountBalance.setAccountType(account.getAccountType());//++
             accountBalance.setAccount(account.getAccount());
-            accountBalance.setOpenBalanceAmount(amount);
-            accountBalance.setFreeBalanceAmount(amount);
-            accountBalance.setBalanceAmount(amount);
+//            accountBalance.setOpenBalanceAmount();// на базе изменения statement по sDf16/sDf09): не меняется.
+            accountBalance.setFreeBalanceAmount(plus(accountBalance.getFreeBalanceAmount(), amount));
+            accountBalance.setChangeBalanceAmount(plus(accountBalance.getChangeBalanceAmount(), amount));
+            accountBalance.setCreditAmount(plus(accountBalance.getCreditAmount(), amount));
+            accountBalance.setDebitAmount(plus(accountBalance.getDebitAmount(), amount));
+            accountBalance.setBalanceAmount(plus(accountBalance.getBalanceAmount(), amount));
             accountBalance.setCurrencyCode(cashMovementCurrencyCode);
             return new AccountResult(accountBalance);
         }
     }
+
+    BigDecimal plus(BigDecimal a, BigDecimal b) {
+        if (a == null) return b;
+        if (b == null) return a;
+        return a.add(b);
+    }
 }

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

@@ -51,7 +51,8 @@ public class Sdf01Executor extends AbstractExecutor<SDf01> {
                          IMessageResolver errorResolver) {
         this.statementImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Statement, Statement.class);
         this.sdf02Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf02, SDf02.class);
-        this.accountBalanceImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_AccountBalance, AccountBalance.class);;
+        this.accountBalanceImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_AccountBalance, AccountBalance.class);
+        ;
         this.sDf01Validator = sDf01Validator;
         this.errorLogger = errorLogger;
         this.imdgProvider = imdgProvider;
@@ -59,7 +60,12 @@ public class Sdf01Executor extends AbstractExecutor<SDf01> {
         this.errorResolver = errorResolver;
     }
 
-    public Result execute(Collection<SDf01> sdf, StatementRequest statementRequest){
+    @Override
+    String exportTableName() {
+        return "DF-02";
+    }
+
+    public Result execute(Collection<SDf01> sdf, StatementRequest statementRequest) {
         Result result = new Result();
         Long generationIdForGroup = imdgProvider.getImdgIdGenerator().nextId();
         result.setGenerationId(generationIdForGroup);
@@ -143,12 +149,12 @@ public class Sdf01Executor extends AbstractExecutor<SDf01> {
         AccountSdfRequestPart req = new AccountSdfRequestPart();
         req.setAccount(account);
         req.setCompanyId(companyId);
+        req.setAccountType(AccountType.Clrn.getKey());
         req.setSdfId(sdf01Id);
         return req;
     }
 
 
-
     private SDf02 createErrorSdf02(SDf01 sdf01, EnumMessage error, Long generationIdForGroup) {
         SDf02 sDf02 = new SDf02();
         sDf02.setCurr_code(sdf01.getCurr_code());

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

@@ -9,39 +9,52 @@ import ru.clearing.classes.statics.data.sdf.SDf08;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
 import ru.spcex.clearing.platform.messaging.domain.Consts;
-import ru.spcex.clearing.platform.messaging.domain.cud.balance.SDf08NewRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.balance.ExportToFileRequest;
 import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
+import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
+import ru.spcex.platform.enumeration.Task;
 import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.ImdgId;
 import ru.spcex.platform.imdg.api.ImdgProvider;
 
+import java.time.Instant;
+
 @Service
 public class Sdf08Service extends QueueConsumer implements InitializingBean {
     private final Logger log = LoggerFactory.getLogger(getClass());
     private final Imdg<SDf08> sdf8Map;
+    private final ImdgId idGenerator;
+    private final KafkaSender kafkaReqProducer;
 
 
-    public Sdf08Service(Consumer<String, Object> kafkaQueue, ImdgProvider imdgProvider) {
+    public Sdf08Service(Consumer<String, Object> kafkaQueue, ImdgProvider imdgProvider, KafkaSender kafkaReqProducer) {
         super(kafkaQueue);
         this.sdf8Map = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf08, SDf08.class);
+        this.idGenerator = imdgProvider.getImdgIdGenerator();
+        this.kafkaReqProducer = kafkaReqProducer;
     }
 
     @Override
     public void afterPropertiesSet() {
-        callback(SDf08NewRequest.class)
+        callback(Object.class)
                 .setConsumer(this::newSDf08)
-                .forDestination(Consts.DESTINATION_SDF08_NEW, callbacks::put);
+                .forDestination(Task.getAllBalance.topic(), callbacks::put);
         init();
     }
 
-    private void newSDf08(BaseRequest<SDf08NewRequest> userRequest) {
-        SDf08NewRequest req = userRequest.getRequestPayload();
-        log.debug("SDf08NewRequest received");
+    private void newSDf08(BaseRequest<Object> userRequest) {
+        log.debug("getAllBalance request received");
         SDf08 sDf08 = new SDf08();
-        sDf08.setNumber(req.getNumber());
-        sDf08.setDatetime(req.getDatetime());
-        sDf08.setGenerationTime(req.getGenerationTime());
-        sDf08.setGenerationId(req.getGenerationId());
+        sDf08.setNumber(idGenerator.nextId().toString());
+        Instant now = Instant.now();
+        sDf08.setDatetime(String.valueOf(now.toEpochMilli()));
+        sDf08.setGenerationTime(now);
+        sDf08.setGenerationId(idGenerator.nextId());
         sdf8Map.insert(sDf08);
+        ExportToFileRequest exportRequest = new ExportToFileRequest();
+        exportRequest.setSdfGroupId(sDf08.getGenerationId());
+        exportRequest.setNameOfTable("DF-08");
+        kafkaReqProducer.sendRequestToQueue(Consts.EXPORT_PROCESS, exportRequest);
         log.debug("successfully processed, new id {}", sDf08.getId());
     }
 }

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

@@ -57,6 +57,11 @@ public class Sdf09Executor extends AbstractExecutor<SDf09> {
         this.errorResolver = errorResolver;
     }
 
+    @Override
+    String exportTableName() {
+        return "DF-10";
+    }
+
     public Result execute(Collection<SDf09> sdf, StatementRequest statementRequest){
         Result result = new Result();
         Long generationIdForGroup = imdgProvider.getImdgIdGenerator().nextId();
@@ -132,6 +137,9 @@ public class Sdf09Executor extends AbstractExecutor<SDf09> {
         statement.setInOutDirection(InOutDirection.in.getKey());
         statement.setAmount(sdf09.getSum());
         statement.setCashMovementCurrencyCode(CurrencyCode.RUB.getKey());
+        statement.setInSDfId(sdf09.getId());
+//        statement.setOutSDfId(sdf10.getId()); заполняется внешним кодом
+        statement.setInOutSDfType(InOutSDfType.type9.getKey());
         statementImdg.update(statement);
     }
 
@@ -157,7 +165,7 @@ public class Sdf09Executor extends AbstractExecutor<SDf09> {
         sDf10.setMarket(sdf09.getMarket());
         sDf10.setType(sdf09.getType());
         sDf10.setNumber(sdf09.getNumber());
-        sDf10.setINN(sdf09.getInn());
+        sDf10.setInn(sdf09.getInn());
         sDf10.setResult("OK");
         sDf10.setGenerationId(generationIdForGroup);
         sDf10.setGenerationTime(Instant.now());

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

@@ -12,8 +12,11 @@ import ru.clearing.classes.statics.data.statement.Statement;
 import ru.spcex.clearing.balance.errors.BalanceError;
 import ru.spcex.clearing.balance.validation.ValidationStored;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.platform.messaging.domain.Consts;
 import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdfRequestPart;
 import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest;
+import ru.spcex.clearing.platform.messaging.domain.cud.utilities.NotificationNewRequest;
+import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
 import ru.spcex.platform.enumeration.*;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
@@ -32,9 +35,8 @@ import java.util.function.Function;
 
 @Service
 public class Sdf16Executor extends AbstractExecutor<SDf16> {
-    private final Logger log = LoggerFactory.getLogger(getClass());
-
     private final static DateTimeFormatter datFormatter = DateTimeFormatter.ofPattern("dd.MM.yy");
+    private final Logger log = LoggerFactory.getLogger(getClass());
     private final Imdg<Statement> statementImdg;
     private final Function<SDf16, IValidator> sDf16Validator;
     private final LoggingService errorLogger;
@@ -43,16 +45,17 @@ public class Sdf16Executor extends AbstractExecutor<SDf16> {
     private final AccountBalanceService accountBalanceService;
     private final IMessageResolver errorResolver;
     private final Imdg<AccountBalance> accountBalanceImdg;
+    private final KafkaSender kafaSender;
 
     public Sdf16Executor(Function<SDf16, IValidator> sDf16Validator,
                          LoggingService errorLogger,
                          ImdgProvider imdgProvider,
                          AccountBalanceService accountBalanceService,
-                         IMessageResolver errorResolver) {
+                         IMessageResolver errorResolver, KafkaSender kafaSender) {
         this.statementImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_Statement, Statement.class);
         this.sdf17Imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SDf17, SDf17.class);
         this.accountBalanceImdg = imdgProvider.getImdg(IMDGDistributedNames.Map_AccountBalance, AccountBalance.class);
-        ;
+        this.kafaSender = kafaSender;
         this.sDf16Validator = sDf16Validator;
         this.errorLogger = errorLogger;
         this.imdgProvider = imdgProvider;
@@ -60,6 +63,11 @@ public class Sdf16Executor extends AbstractExecutor<SDf16> {
         this.errorResolver = errorResolver;
     }
 
+    @Override
+    String exportTableName() {
+        return "DF-17";
+    }
+
     public Result execute(Collection<SDf16> sdf, StatementRequest statementRequest) {
         Result result = new Result();
         Long generationIdForGroup = imdgProvider.getImdgIdGenerator().nextId();
@@ -106,17 +114,31 @@ public class Sdf16Executor extends AbstractExecutor<SDf16> {
                 statement.setOperationStatus(OperationStatus.Executed.getKey());
             }
             statementImdg.update(statement);
+            NotificationNewRequest notificationNewRequest = createNotification(statement.getId(),
+                    statement.getSenderId(),
+                    statement.getAddresseeId());
+            kafaSender.sendRequestToQueue(Consts.NOTIFICATION_NEW, notificationNewRequest);
         }
         return result;
     }
 
+    private NotificationNewRequest createNotification(Long id, Long senderId, Long addresseeId) {
+        NotificationNewRequest request = new NotificationNewRequest();
+        request.setSenderId(senderId);
+        request.setAddresseeId(addresseeId);
+        request.setObjectType(ObjectType.statement.getKey());
+        request.setObjectId(id);
+        return request;
+    }
+
     private Statement createFlow(SDf16 sdf, Company company, Account account) {
         Statement statement = new Statement();
         statement.setAddresseeId(company.getId());
         statement.setSenderId(Sender.Prc.getId());
         statement.setCreated(Instant.now());
         statement.setClearingDate(LocalDate.now());
-        statement.setStatementType(StatementType.full.getKey());
+        statement.setStatementType(StatementType.incr.getKey());
+        statement.setComment(sdf.getSpec());
         statement.setAccountId(account.getId());
         statement.setAccount(sdf.getAccount());
         statement.setInOutDirection(InOutDirection.in.getKey());
@@ -124,18 +146,21 @@ public class Sdf16Executor extends AbstractExecutor<SDf16> {
         statement.setCashMovementCurrencyCode(CurrencyCode.RUB.getKey());
         statement.setOperationStatus(OperationStatus.Pending.getKey());
         statement.setInSDfId(sdf.getId());
-        statement.setInOutSDfType(InOutSDfType.type1.getKey());
+        statement.setInOutSDfType(InOutSDfType.type16.getKey());
         statementImdg.insert(statement);
         return statement;
     }
 
     private void updateFlow(Statement statement, SDf16 sdf, Account account) {
         statement.setUpdated(Instant.now());
+        statement.setComment(sdf.getSpec());
         statement.setAccountId(account.getId());
         statement.setAccount(sdf.getAccount());
         statement.setInOutDirection(InOutDirection.in.getKey());
         statement.setAmount(sdf.getSum());
         statement.setCashMovementCurrencyCode(CurrencyCode.RUB.getKey());
+        statement.setInSDfId(sdf.getId());
+        statement.setInOutSDfType(InOutSDfType.type16.getKey());
         statementImdg.update(statement);
     }
 
@@ -143,6 +168,7 @@ public class Sdf16Executor extends AbstractExecutor<SDf16> {
         AccountSdfRequestPart req = new AccountSdfRequestPart();
         req.setAccount(account);
         req.setCompanyId(companyId);
+        req.setAccountType(AccountType.Clrn.getKey());
         req.setSdfId(sdfId);
         return req;
     }
@@ -153,9 +179,9 @@ public class Sdf16Executor extends AbstractExecutor<SDf16> {
         errorSdf.setSum(sdf.getSum());
         errorSdf.setMarket(sdf.getMarket());
         errorSdf.setType(sdf.getType());
-        errorSdf.setINN(sdf.getInn());
-        errorSdf.setBIC(sdf.getBic());
-        errorSdf.setSPEC(sdf.getSpec());
+        errorSdf.setInn(sdf.getInn());
+        errorSdf.setBic(sdf.getBic());
+        errorSdf.setSpec(sdf.getSpec());
         errorSdf.setNumber(sdf.getNumber());
         errorSdf.setResult(obtainResultNum(error));
         errorSdf.setGenerationId(generationIdForGroup);
@@ -170,22 +196,22 @@ public class Sdf16Executor extends AbstractExecutor<SDf16> {
         successSdf.setSum(sdf.getSum());
         successSdf.setMarket(sdf.getMarket());
         successSdf.setType(sdf.getType());
-        successSdf.setINN(sdf.getInn());
-        successSdf.setBIC(sdf.getBic());
-        successSdf.setSPEC(sdf.getSpec());
+        successSdf.setInn(sdf.getInn());
+        successSdf.setBic(sdf.getBic());
+        successSdf.setSpec(sdf.getSpec());
         successSdf.setNumber(sdf.getNumber());
         successSdf.setGenerationId(generationIdForGroup);
         successSdf.setGenerationTime(Instant.now());
         successSdf.setInSDf16Id(sdf.getId());
-        successSdf.setResult(BigDecimal.ZERO);
+        successSdf.setResult(new BigDecimal(0));
         return successSdf;
     }
 
-    private BigDecimal obtainResultNum(EnumMessage error){
+    private BigDecimal obtainResultNum(EnumMessage error) {
         if (BalanceError.AccountNotPresent.equalsById(error.getSubject().getId()))
-            return BigDecimal.ONE;
+            return new BigDecimal(1);
         if (BalanceError.BalanceNotEnough.equalsById(error.getSubject().getId()))
-            return BigDecimal.ONE;
-        return BigDecimal.valueOf(9);
+            return new BigDecimal(1);
+        return new BigDecimal(9);
     }
 }