UpdateMapService Map_AccountSymbolsHistory bug fixed

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

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--?xml-stylesheet type="text/xsl" href="\..\corp-reports\src\data\meta\meta.server.xslt"?-->
-<meta version="3.14.105.104">
+<meta version="3.14.105.105">
 	<!-- _xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" _xsi:noNamespaceSchemaLocation="file:///E:/d/projects/meta/from/meta.xsd" -->
 	<!--Здесь словари-->
 	<enums>
@@ -2168,7 +2168,7 @@
 			<generationTime type="4" name="Дата и время создания записи" shortname="Дата и время создания" searchable="true" sortable="true" visible="true"/>
 			<generationId type="1" name="Идентификатор взаимодействия" shortname="ID взаимодействия" searchable="true" sortable="true" visible="true"/>
 			<inSDfId type="1" name="Идентификатор соответствующей записи из таблицы-источника" shortname="Входящая запись" searchable="true" sortable="true" visible="true"/>
-			<accType type="3" name="Признак счета" shortname="Признак счета" searchable="true" sortable="true" visible="true"/>
+			<accType type="2" length="3" name="Признак счета" shortname="Признак счета" searchable="true" sortable="true" visible="true"/>
 		</sDf53>
 		<sDf54 name="ДФ-54 Вывод свободных средств для инициаторов категории В с клирингового счета 30414" destination="s-dfs/s-df54" class="ru.clearing.classes.statics.data.sdf.SDf54" table="s_df_54">
 			<id type="1" name="Идентификатор записи" shortname="ID" searchable="true" sortable="true" visible="false"/>

clearing-parent/db-scripts/src/main/resources/db/DDL.sql

@@ -4433,7 +4433,7 @@ GRANT ALL PRIVILEGES ON TABLE S_DF14 TO clearing;
 
 -- sDf20 - ДФ-20 Отчет об исполнении поручения на зачисление/списание ценных бумаг
 DROP TABLE IF EXISTS S_DF20;
-CREATE TABLE S_DF20(ID bigint PRIMARY KEY, OUT_DOCUMENT varchar, IN_DOCUMENT varchar, SECURITY varchar, SECURITY_NAME varchar, SECURITY_TYPE varchar, OPEN_BALANCE varchar, DEPO_CODE_CL varchar, NAME_CL varchar, QUANTITY varchar, OPERATION_CODE varchar, DEPO_CODE_CORR varchar, OPERATION_DATE varchar, CLOSE_BALANCE varchar, TRANSACTION_NUMBER varchar(255), FILE_NAME varchar, GENERATION_TIME timestamp, GENERATION_ID bigint);
+CREATE TABLE S_DF20(ID bigint PRIMARY KEY, OUT_DOCUMENT varchar, IN_DOCUMENT varchar, SECURITY varchar, SECURITY_NAME varchar(255), SECURITY_TYPE varchar(255), OPEN_BALANCE varchar, DEPO_CODE_CL varchar, NAME_CL varchar(255), QUANTITY varchar, OPERATION_CODE varchar, DEPO_CODE_CORR varchar, OPERATION_DATE varchar, CLOSE_BALANCE varchar, TRANSACTION_NUMBER varchar(255), FILE_NAME varchar, GENERATION_TIME timestamp, GENERATION_ID bigint);
 COMMENT ON TABLE S_DF20 IS 'ДФ-20 Отчет об исполнении поручения на зачисление/списание ценных бумаг';
 
 COMMENT ON COLUMN S_DF20.ID IS 'Идентификатор записи';
@@ -4565,7 +4565,7 @@ GRANT ALL PRIVILEGES ON TABLE S_DF52 TO clearing;
 
 -- sDf53 - ДФ-53 Квитанция о получении информации о состоянии счета (блокировка/разблокировка/закрытие/открытие)
 DROP TABLE IF EXISTS S_DF53;
-CREATE TABLE S_DF53(ID bigint PRIMARY KEY, ACC_NAME varchar(30), ACCOUNT varchar(25), DEAL varchar(4), DATE varchar(8), STATUS bigint, RESULT varchar(255), FILE_NAME varchar(255), GENERATION_TIME timestamp, GENERATION_ID bigint, IN_S_DF_ID bigint, ACC_TYPE bigint);
+CREATE TABLE S_DF53(ID bigint PRIMARY KEY, ACC_NAME varchar(30), ACCOUNT varchar(25), DEAL varchar(4), DATE varchar(8), STATUS bigint, RESULT varchar(255), FILE_NAME varchar(255), GENERATION_TIME timestamp, GENERATION_ID bigint, IN_S_DF_ID bigint, ACC_TYPE varchar(3));
 COMMENT ON TABLE S_DF53 IS 'ДФ-53 Квитанция о получении информации о состоянии счета (блокировка/разблокировка/закрытие/открытие)';
 
 COMMENT ON COLUMN S_DF53.ID IS 'Идентификатор записи';

clearing-parent/db-scripts/src/main/resources/db/DDL_first.sql

@@ -2749,7 +2749,7 @@ COMMENT ON COLUMN COVERED_LIABILITIES_REGISTER.CLEARING_DATE IS '
 
 -- moneyPaymentInstructionRegister - Ðååñòð ðàñïîðÿæåíèé, íàïðàâëåííûõ ðàñ÷åòíîé îðãàíèçàöèè
 DROP TABLE IF EXISTS MONEY_PAYMENT_INSTRUCTION_REGISTER;
-CREATE TABLE MONEY_PAYMENT_INSTRUCTION_REGISTER(CREDIT_LEG_ACCOUNT varchar, CREDIT_LEG_AMOUNT numeric(72,18), CREDIT_LEG_CURRENCY_CODE varchar(4), DEBIT_LEG_ACCOUNT varchar, SENDER varchar(255), ADDRESSEE varchar(255), ID bigint PRIMARY KEY, CREATED_AT timestamp, UPDATED_AT timestamp, CLEARING_DATE date);
+CREATE TABLE MONEY_PAYMENT_INSTRUCTION_REGISTER(CREDIT_LEG_ACCOUNT varchar(50), CREDIT_LEG_AMOUNT numeric(72,18), CREDIT_LEG_CURRENCY_CODE varchar(4), DEBIT_LEG_ACCOUNT varchar(50), SENDER varchar(255), ADDRESSEE varchar(255), ID bigint PRIMARY KEY, CREATED_AT timestamp, UPDATED_AT timestamp, CLEARING_DATE date);
 COMMENT ON TABLE MONEY_PAYMENT_INSTRUCTION_REGISTER IS 'Ðååñòð ðàñïîðÿæåíèé, íàïðàâëåííûõ ðàñ÷åòíîé îðãàíèçàöèè';
 
 COMMENT ON COLUMN MONEY_PAYMENT_INSTRUCTION_REGISTER.CREDIT_LEG_ACCOUNT IS 'Ñ÷åò îòïðàâèòåëÿ';
@@ -3186,7 +3186,7 @@ COMMENT ON COLUMN S_DF02.IN_S_DF_ID IS '
 
 -- sDf03 - ÄÔ-03 Ðååñòð ïëàòåæíûõ ïîðó÷åíèé
 DROP TABLE IF EXISTS S_DF03;
-CREATE TABLE S_DF03(ID bigint PRIMARY KEY, SEG_TYPE varchar(1), DOC_TYPE varchar, DOCNM_REF varchar(16), DOCNMPREV varchar(16), C_ACC_DEB varchar(35), SBANKNAM1 varchar(35), SBANKNAM2 varchar(35), SBANKNAM3 varchar(35), SBANKNAM4 varchar(35), SBANKNAM5 varchar(35), C_ACC_CRED varchar(35), RBANKNAM1 varchar(35), RBANKNAM2 varchar(35), RBANKNAM3 varchar(35), RBANKNAM4 varchar(35), RBANKNAM5 varchar(35), PAY_DATE varchar, PAY_VAL varchar(12), SUM_DEB varchar, SPECIF_1 varchar(255), IMP_RESULT varchar(3), GENERATION_TIME timestamp, GENERATION_ID bigint, PAYMENT_INSTRUCTION_ID bigint);
+CREATE TABLE S_DF03(ID bigint PRIMARY KEY, SEG_TYPE varchar(1), DOC_TYPE varchar(4), DOCNM_REF varchar(16), DOCNMPREV varchar(16), C_ACC_DEB varchar(35), SBANKNAM1 varchar(35), SBANKNAM2 varchar(35), SBANKNAM3 varchar(35), SBANKNAM4 varchar(35), SBANKNAM5 varchar(35), C_ACC_CRED varchar(35), RBANKNAM1 varchar(35), RBANKNAM2 varchar(35), RBANKNAM3 varchar(35), RBANKNAM4 varchar(35), RBANKNAM5 varchar(35), PAY_DATE varchar(8), PAY_VAL varchar(12), SUM_DEB varchar(22), SPECIF_1 varchar(255), IMP_RESULT varchar(3), GENERATION_TIME timestamp, GENERATION_ID bigint, PAYMENT_INSTRUCTION_ID bigint);
 COMMENT ON TABLE S_DF03 IS 'ÄÔ-03 Ðååñòð ïëàòåæíûõ ïîðó÷åíèé';
 
 COMMENT ON COLUMN S_DF03.ID IS 'Èäåíòèôèêàòîð çàïèñè';
@@ -3241,7 +3241,7 @@ COMMENT ON COLUMN S_DF03.PAYMENT_INSTRUCTION_ID IS '
 
 -- sDf04 - ÄÔ-04 Ïîäòâåðæäåíèå ïðîâåäåíèÿ ðàñ÷åòîâ
 DROP TABLE IF EXISTS S_DF04;
-CREATE TABLE S_DF04(ID bigint PRIMARY KEY, SEG_TYPE varchar(1), DOC_TYPE varchar, DOCNM_REF varchar(16), DOCNMPREV varchar(16), C_ACC_DEB varchar(35), SBANKNAM1 varchar(35), SBANKNAM2 varchar(35), SBANKNAM3 varchar(35), SBANKNAM4 varchar(35), SBANKNAM5 varchar(35), C_ACC_CRED varchar(35), RBANKNAM1 varchar(35), RBANKNAM2 varchar(35), RBANKNAM3 varchar(35), RBANKNAM4 varchar(35), RBANKNAM5 varchar(35), PAY_DATE varchar, PAY_VAL varchar(12), SUM_DEB varchar, SPECIF_1 varchar(255), IMP_RESULT varchar(3), FILE_NAME varchar(255), GENERATION_TIME timestamp, GENERATION_ID bigint);
+CREATE TABLE S_DF04(ID bigint PRIMARY KEY, SEG_TYPE varchar(1), DOC_TYPE varchar(4), DOCNM_REF varchar(16), DOCNMPREV varchar(16), C_ACC_DEB varchar(35), SBANKNAM1 varchar(35), SBANKNAM2 varchar(35), SBANKNAM3 varchar(35), SBANKNAM4 varchar(35), SBANKNAM5 varchar(35), C_ACC_CRED varchar(35), RBANKNAM1 varchar(35), RBANKNAM2 varchar(35), RBANKNAM3 varchar(35), RBANKNAM4 varchar(35), RBANKNAM5 varchar(35), PAY_DATE varchar(8), PAY_VAL varchar(12), SUM_DEB varchar(22), SPECIF_1 varchar(255), IMP_RESULT varchar(3), FILE_NAME varchar(255), GENERATION_TIME timestamp, GENERATION_ID bigint);
 COMMENT ON TABLE S_DF04 IS 'ÄÔ-04 Ïîäòâåðæäåíèå ïðîâåäåíèÿ ðàñ÷åòîâ';
 
 COMMENT ON COLUMN S_DF04.ID IS 'Èäåíòèôèêàòîð çàïèñè';
@@ -3592,7 +3592,7 @@ COMMENT ON COLUMN S_DF51.GENERATION_ID IS '
 
 -- sDf52 - ÄÔ-52 Èç ÏÐÖ â ÊÑ Èíôîðìàöèÿ î ñîñòîÿíèè ñ÷åòà (áëîêèðîâêà/ðàçáëîêèðîâêà/çàêðûòèå/îòêðûòèå)
 DROP TABLE IF EXISTS S_DF52;
-CREATE TABLE S_DF52(ID bigint PRIMARY KEY, ACCOUNT varchar(25), ACC_NAME varchar(30), DEAL varchar(4), DATE varchar, STATUS bigint, FILE_NAME varchar(255), GENERATION_TIME timestamp, GENERATION_ID bigint);
+CREATE TABLE S_DF52(ID bigint PRIMARY KEY, ACCOUNT varchar(25), ACC_NAME varchar(30), DEAL varchar(4), DATE varchar(8), STATUS bigint, FILE_NAME varchar(255), GENERATION_TIME timestamp, GENERATION_ID bigint);
 COMMENT ON TABLE S_DF52 IS 'ÄÔ-52 Èç ÏÐÖ â ÊÑ Èíôîðìàöèÿ î ñîñòîÿíèè ñ÷åòà (áëîêèðîâêà/ðàçáëîêèðîâêà/çàêðûòèå/îòêðûòèå)';
 
 COMMENT ON COLUMN S_DF52.ID IS 'Èäåíòèôèêàòîð çàïèñè';
@@ -3636,7 +3636,7 @@ COMMENT ON COLUMN S_DF53.IN_S_DF_ID IS '
 
 -- sDf54 - ÄÔ-54 Âûâîä ñâîáîäíûõ ñðåäñòâ äëÿ èíèöèàòîðîâ êàòåãîðèè  ñ êëèðèíãîâîãî ñ÷åòà 30414
 DROP TABLE IF EXISTS S_DF54;
-CREATE TABLE S_DF54(ID bigint PRIMARY KEY, SEG_TYPE varchar(1), DOC_TYPE varchar, DOCNM_REF varchar(16), DOCNMPREV varchar(16), SBANKCODE varchar(12), C_ACC_DEB varchar(35), SBANKNAM1 varchar(35), SBANKNAM2 varchar(35), SBANKNAM3 varchar(35), SBANKNAM4 varchar(35), SBANKNAM5 varchar(35), RBANKCODE varchar(12), C_ACC_CRED varchar(35), RBANKNAM1 varchar(35), RBANKNAM2 varchar(35), RBANKNAM3 varchar(35), RBANKNAM4 varchar(35), RBANKNAM5 varchar(35), OP_TYPE varchar(2), OP_ORDER varchar(1), PAY_DATE varchar, PAY_VAL varchar(12), SUM_DEB varchar, SCLIENTN1 varchar(35), SCLIENTN2 varchar(35), SCLIENTN3 varchar(35), SCLIENTN4 varchar(35), INN_DEB varchar(12), KPP_DEB varchar(9), ACC_DEB varchar(35), RCLIENTN1 varchar(35), RCLIENTN2 varchar(35), RCLIENTN3 varchar(35), RCLIENTN4 varchar(35), INN_CRED varchar(12), KPP_CRED varchar(9), ACC_KR_1 varchar(35), SPECIF_1 varchar(255), SEND_TYPE varchar(10), DOC_RESULT varchar(2), GENERATION_TIME timestamp, GENERATION_ID bigint);
+CREATE TABLE S_DF54(ID bigint PRIMARY KEY, SEG_TYPE varchar(1), DOC_TYPE varchar(4), DOCNM_REF varchar(16), DOCNMPREV varchar(16), SBANKCODE varchar(12), C_ACC_DEB varchar(35), SBANKNAM1 varchar(35), SBANKNAM2 varchar(35), SBANKNAM3 varchar(35), SBANKNAM4 varchar(35), SBANKNAM5 varchar(35), RBANKCODE varchar(12), C_ACC_CRED varchar(35), RBANKNAM1 varchar(35), RBANKNAM2 varchar(35), RBANKNAM3 varchar(35), RBANKNAM4 varchar(35), RBANKNAM5 varchar(35), OP_TYPE varchar(2), OP_ORDER varchar(1), PAY_DATE varchar(8), PAY_VAL varchar(12), SUM_DEB varchar(22), SCLIENTN1 varchar(35), SCLIENTN2 varchar(35), SCLIENTN3 varchar(35), SCLIENTN4 varchar(35), INN_DEB varchar(12), KPP_DEB varchar(9), ACC_DEB varchar(35), RCLIENTN1 varchar(35), RCLIENTN2 varchar(35), RCLIENTN3 varchar(35), RCLIENTN4 varchar(35), INN_CRED varchar(12), KPP_CRED varchar(9), ACC_KR_1 varchar(35), SPECIF_1 varchar(255), SEND_TYPE varchar(10), DOC_RESULT varchar(2), GENERATION_TIME timestamp, GENERATION_ID bigint);
 COMMENT ON TABLE S_DF54 IS 'ÄÔ-54 Âûâîä ñâîáîäíûõ ñðåäñòâ äëÿ èíèöèàòîðîâ êàòåãîðèè  ñ êëèðèíãîâîãî ñ÷åòà 30414';
 
 COMMENT ON COLUMN S_DF54.ID IS 'Èäåíòèôèêàòîð çàïèñè';
@@ -3727,7 +3727,7 @@ COMMENT ON COLUMN S_DF54.GENERATION_ID IS '
 
 -- sDf55 - ÄÔ-55 Êâèòàíöèÿ îá îáðàáîòêå ÄÔ-54
 DROP TABLE IF EXISTS S_DF55;
-CREATE TABLE S_DF55(ID bigint PRIMARY KEY, SEG_TYPE varchar(1), DOC_TYPE varchar, DOCNM_REF varchar(16), DOCNMPREV varchar(16), SBANKCODE varchar(12), C_ACC_DEB varchar(35), SBANKNAM1 varchar(35), SBANKNAM2 varchar(35), SBANKNAM3 varchar(35), SBANKNAM4 varchar(35), SBANKNAM5 varchar(35), RBANKCODE varchar(12), C_ACC_CRED varchar(35), RBANKNAM1 varchar(35), RBANKNAM2 varchar(35), RBANKNAM3 varchar(35), RBANKNAM4 varchar(35), RBANKNAM5 varchar(35), OP_TYPE varchar(2), OP_ORDER varchar(1), PAY_DATE varchar, PAY_VAL varchar(12), SUM_DEB varchar, SCLIENTN1 varchar(35), SCLIENTN2 varchar(35), SCLIENTN3 varchar(35), SCLIENTN4 varchar(35), INN_DEB varchar(12), KPP_DEB varchar(9), ACC_DEB varchar(35), RCLIENTN1 varchar(35), RCLIENTN2 varchar(35), RCLIENTN3 varchar(35), RCLIENTN4 varchar(35), INN_CRED varchar(12), KPP_CRED varchar(9), ACC_KR_1 varchar(35), SPECIF_1 varchar(255), SEND_TYPE varchar(10), DOC_RESULT varchar(2), FILE_NAME varchar(255), GENERATION_TIME timestamp, GENERATION_ID bigint);
+CREATE TABLE S_DF55(ID bigint PRIMARY KEY, SEG_TYPE varchar(1), DOC_TYPE varchar(4), DOCNM_REF varchar(16), DOCNMPREV varchar(16), SBANKCODE varchar(12), C_ACC_DEB varchar(35), SBANKNAM1 varchar(35), SBANKNAM2 varchar(35), SBANKNAM3 varchar(35), SBANKNAM4 varchar(35), SBANKNAM5 varchar(35), RBANKCODE varchar(12), C_ACC_CRED varchar(35), RBANKNAM1 varchar(35), RBANKNAM2 varchar(35), RBANKNAM3 varchar(35), RBANKNAM4 varchar(35), RBANKNAM5 varchar(35), OP_TYPE varchar(2), OP_ORDER varchar(1), PAY_DATE varchar(8), PAY_VAL varchar(12), SUM_DEB varchar(22), SCLIENTN1 varchar(35), SCLIENTN2 varchar(35), SCLIENTN3 varchar(35), SCLIENTN4 varchar(35), INN_DEB varchar(12), KPP_DEB varchar(9), ACC_DEB varchar(35), RCLIENTN1 varchar(35), RCLIENTN2 varchar(35), RCLIENTN3 varchar(35), RCLIENTN4 varchar(35), INN_CRED varchar(12), KPP_CRED varchar(9), ACC_KR_1 varchar(35), SPECIF_1 varchar(255), SEND_TYPE varchar(10), DOC_RESULT varchar(2), FILE_NAME varchar(255), GENERATION_TIME timestamp, GENERATION_ID bigint);
 COMMENT ON TABLE S_DF55 IS 'ÄÔ-55 Êâèòàíöèÿ îá îáðàáîòêå ÄÔ-54';
 
 COMMENT ON COLUMN S_DF55.ID IS 'Èäåíòèôèêàòîð çàïèñè';
@@ -3841,7 +3841,7 @@ COMMENT ON COLUMN S_DF56.GENERATION_ID IS '
 
 -- sDf57 - ÄÔ-57 Ñïèñîê òðàíçàêöèé î ñïèñàíèè/çà÷èñëåíèè çà ïåðèîä ïî âñåì ñ÷åòàì (ÒÁÑ è ÊÑ)
 DROP TABLE IF EXISTS S_DF57;
-CREATE TABLE S_DF57(ID bigint PRIMARY KEY, DBF_ID bigint, DEAL_DEB varchar(4), DEAL_CRED varchar, SBANKCODE varchar(12), C_ACC_DEB varchar(35), SBANKNAM1 varchar(35), SBANKNAM2 varchar(35), SBANKNAM3 varchar(35), SBANKNAM4 varchar(35), SBANKNAM5 varchar(35), RBANKCODE varchar(35), C_ACC_CRED varchar(35), RBANKNAM1 varchar(35), RBANKNAM2 varchar(35), RBANKNAM3 varchar(35), RBANKNAM4 varchar(35), RBANKNAM5 varchar(35), OP_TYPE varchar(2), PAY_DATE varchar, EXT_DATE varchar, PAY_VAL varchar(12), SUM_DEB varchar, SCLIENTN1 varchar(35), SCLIENTN2 varchar(35), SCLIENTN3 varchar(35), SCLIENTN4 varchar(35), INN_DEB varchar(12), KPP_DEB varchar(9), ACC_DEB varchar(35), RCLIENTN1 varchar(35), RCLIENTN2 varchar(35), RCLIENTN3 varchar(35), RCLIENTN4 varchar(35), INN_CRED varchar(12), KPP_CRED varchar(9), ACC_KR varchar(35), SPECIF varchar(255), FILE_NAME varchar(255), GENERATION_TIME timestamp, GENERATION_ID bigint);
+CREATE TABLE S_DF57(ID bigint PRIMARY KEY, DBF_ID bigint, DEAL_DEB varchar(4), DEAL_CRED varchar(4), SBANKCODE varchar(12), C_ACC_DEB varchar(35), SBANKNAM1 varchar(35), SBANKNAM2 varchar(35), SBANKNAM3 varchar(35), SBANKNAM4 varchar(35), SBANKNAM5 varchar(35), RBANKCODE varchar(35), C_ACC_CRED varchar(35), RBANKNAM1 varchar(35), RBANKNAM2 varchar(35), RBANKNAM3 varchar(35), RBANKNAM4 varchar(35), RBANKNAM5 varchar(35), OP_TYPE varchar(2), PAY_DATE varchar(8), EXT_DATE varchar(255), PAY_VAL varchar(12), SUM_DEB varchar(22), SCLIENTN1 varchar(35), SCLIENTN2 varchar(35), SCLIENTN3 varchar(35), SCLIENTN4 varchar(35), INN_DEB varchar(12), KPP_DEB varchar(9), ACC_DEB varchar(35), RCLIENTN1 varchar(35), RCLIENTN2 varchar(35), RCLIENTN3 varchar(35), RCLIENTN4 varchar(35), INN_CRED varchar(12), KPP_CRED varchar(9), ACC_KR varchar(35), SPECIF varchar(255), FILE_NAME varchar(255), GENERATION_TIME timestamp, GENERATION_ID bigint);
 COMMENT ON TABLE S_DF57 IS 'ÄÔ-57 Ñïèñîê òðàíçàêöèé î ñïèñàíèè/çà÷èñëåíèè çà ïåðèîä ïî âñåì ñ÷åòàì (ÒÁÑ è ÊÑ)';
 
 COMMENT ON COLUMN S_DF57.ID IS 'Èäåíòèôèêàòîð çàïèñè';

clearing-parent/db-scripts/src/main/resources/db/updateDDL_3.11.sql

@@ -345,9 +345,7 @@ COMMENT ON COLUMN EXECUTION_FOND_HISTORY.MARKET IS 'Код секции фина
 COMMENT ON COLUMN NOTIFICATION.SENDER_ID IS 'Идентификатор компании-отправителя (linked to company)';
 COMMENT ON COLUMN NOTIFICATION_HISTORY.SENDER_ID IS 'Идентификатор компании-отправителя (linked to company)';
 
-
-
-INSERT INTO DB_VERSION(ID, VERSION) values (1, '3.11') ON CONFLICT (ID) DO UPDATE SET VERSION = EXCLUDED.VERSION
-
 ALTER TABLE S_DF53 ADD COLUMN IF NOT EXISTS ACC_TYPE varchar(3);
 COMMENT ON COLUMN S_DF53.ACC_TYPE IS 'Признак счета';
+
+INSERT INTO DB_VERSION(ID, VERSION) values (1, '3.11') ON CONFLICT (ID) DO UPDATE SET VERSION = EXCLUDED.VERSION

clearing-parent/db-scripts/src/main/resources/db/updateDDL_3.15.sql

@@ -33,6 +33,37 @@ COMMENT ON COLUMN BANK_ACCOUNT.PERSONAL_ACCOUNT IS '
 COMMENT ON COLUMN BANK_ACCOUNT.BUDGET_CLASSIFICATION_CODE IS 'ÊÁÊ';
 COMMENT ON COLUMN BANK_ACCOUNT.OKTMO IS 'ÎÊÒÌÎ ïîëó÷àòåëÿ ñðåäñòâ';
 
+ALTER TABLE BANK_ACCOUNT_HISTORY ADD COLUMN IF NOT EXISTS NAME varchar(255);
+ALTER TABLE BANK_ACCOUNT_HISTORY ADD COLUMN IF NOT EXISTS ADDRESS varchar(255);
+ALTER TABLE BANK_ACCOUNT_HISTORY ADD COLUMN IF NOT EXISTS BANK_ADDRESS varchar(255);
+ALTER TABLE BANK_ACCOUNT_HISTORY ADD COLUMN IF NOT EXISTS BANK_SWIFT_CODE varchar(12);
+ALTER TABLE BANK_ACCOUNT_HISTORY ADD COLUMN IF NOT EXISTS BANK_ACCOUNT varchar(35);
+ALTER TABLE BANK_ACCOUNT_HISTORY ADD COLUMN IF NOT EXISTS BANK_NAME1 varchar(255);
+ALTER TABLE BANK_ACCOUNT_HISTORY ADD COLUMN IF NOT EXISTS BANK_ADDRESS1 varchar(255);
+ALTER TABLE BANK_ACCOUNT_HISTORY ADD COLUMN IF NOT EXISTS BANK_ACCOUNT1 varchar(35);
+ALTER TABLE BANK_ACCOUNT_HISTORY ADD COLUMN IF NOT EXISTS BANK_NAME2 varchar(255);
+ALTER TABLE BANK_ACCOUNT_HISTORY ADD COLUMN IF NOT EXISTS BANK_ADDRESS2 varchar(255);
+ALTER TABLE BANK_ACCOUNT_HISTORY ADD COLUMN IF NOT EXISTS INTERMEDIARY_SWIFT_CODE2 varchar(12);
+ALTER TABLE BANK_ACCOUNT_HISTORY ADD COLUMN IF NOT EXISTS BANK_ACCOUNT2 varchar(35);
+ALTER TABLE BANK_ACCOUNT_HISTORY ADD COLUMN IF NOT EXISTS PERSONAL_ACCOUNT varchar(20);
+ALTER TABLE BANK_ACCOUNT_HISTORY ADD COLUMN IF NOT EXISTS BUDGET_CLASSIFICATION_CODE varchar(20);
+ALTER TABLE BANK_ACCOUNT_HISTORY ADD COLUMN IF NOT EXISTS OKTMO varchar(20);
+COMMENT ON COLUMN BANK_ACCOUNT_HISTORY.NAME IS 'Íàèìåíîâàíèå âëàäåëüöà ñ÷åòà';
+COMMENT ON COLUMN BANK_ACCOUNT_HISTORY.ADDRESS IS 'Àäðåñ âëàäåëüöà ñ÷åòà (ïîëó÷àòåëÿ ñðåäñòâ)';
+COMMENT ON COLUMN BANK_ACCOUNT_HISTORY.BANK_ADDRESS IS 'Ìåñòî íàõîæäåíèÿ áàíêà ïîëó÷àòåëÿ ñðåäñòâ';
+COMMENT ON COLUMN BANK_ACCOUNT_HISTORY.BANK_SWIFT_CODE IS 'SWIFT áàíêà ïîëó÷àòåëÿ ñðåäñòâ';
+COMMENT ON COLUMN BANK_ACCOUNT_HISTORY.BANK_ACCOUNT IS 'Íîìåð ñ÷åòà áàíêà ïîëó÷àòåëÿ ñðåäñòâ';
+COMMENT ON COLUMN BANK_ACCOUNT_HISTORY.BANK_NAME1 IS 'Íàèìåíîâàíèå áàíêà-ïîñðåäíèêà 1 (ïðè íàëè÷èè)';
+COMMENT ON COLUMN BANK_ACCOUNT_HISTORY.BANK_ADDRESS1 IS 'Ìåñòî íàõîæäåíèÿ áàíêà-ïîñðåäíèêà 1 (ïðè íàëè÷èè)';
+COMMENT ON COLUMN BANK_ACCOUNT_HISTORY.BANK_ACCOUNT1 IS 'Íîìåð ñ÷åòà áàíêà-ïîñðåäíèêà 1';
+COMMENT ON COLUMN BANK_ACCOUNT_HISTORY.BANK_NAME2 IS 'Íàèìåíîâàíèå áàíêà-ïîñðåäíèêà 2';
+COMMENT ON COLUMN BANK_ACCOUNT_HISTORY.BANK_ADDRESS2 IS 'Ìåñòî íàõîæäåíèÿ áàíêà-ïîñðåäíèêà 2';
+COMMENT ON COLUMN BANK_ACCOUNT_HISTORY.INTERMEDIARY_SWIFT_CODE2 IS 'SWIFT áàíêà-ïîñðåäíèêà 2';
+COMMENT ON COLUMN BANK_ACCOUNT_HISTORY.BANK_ACCOUNT2 IS 'Íîìåð ñ÷åòà áàíêà-ïîñðåäíèêà 2';
+COMMENT ON COLUMN BANK_ACCOUNT_HISTORY.PERSONAL_ACCOUNT IS 'Ëèöåâîé ñ÷åò ïîëó÷àòåëÿ';
+COMMENT ON COLUMN BANK_ACCOUNT_HISTORY.BUDGET_CLASSIFICATION_CODE IS 'ÊÁÊ';
+COMMENT ON COLUMN BANK_ACCOUNT_HISTORY.OKTMO IS 'ÎÊÒÌÎ ïîëó÷àòåëÿ ñðåäñòâ';
+
 DROP TABLE IF EXISTS RISK_PARAMETER;
 CREATE TABLE RISK_PARAMETER
 (

clearing-parent/imdg/pom.xml

@@ -118,6 +118,18 @@
             <artifactId>assertj-core</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.testcontainers</groupId>
+            <artifactId>testcontainers</artifactId>
+            <version>1.20.2</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.testcontainers</groupId>
+            <artifactId>postgresql</artifactId>
+            <version>1.20.2</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
     <build>
         <resources>

clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/businessevent/BankAccountHistoryMapStore.java

@@ -28,7 +28,7 @@ public class BankAccountHistoryMapStore extends TemplateEventMapStore<BankAccoun
     @Override
     public String[] getFields() {
         return new String[]{"ID", "EVENT_TIME", "EVENT_USER_ID", "EVENT_TYPE",
-                "BANK_ACCOUNT_ID", "ACCOUNT_ID", "BANK_IDENTIFICATION_CODE", "BANK_NAME", "CORRESPONDENT_ACCOUNT", "CORRESPONDENT_ACCOUNT_NAME", "CURRENCY", "DESTINATION", "IBAN", "INTERNATIONAL_TRANSFER_SIGN", "SWIFT_CODE", "TAXPAYER_IDENTIFICATION_NUMBER", "TAX_REGISTRATION_REASON_CODE", "ACCOUNT", "COMPANY_ID", "INTERMEDIARY_SWIFT_CODE", "NAME", "ADDRESS", "BANK_ADDRESS", "BANK_SWIFT_CODE", "BANK_ACCOUNT", "BANK_NAME1", "BANK_ADDRESS1", "BANK_ACCOUNT1", "BANK_NAME2", "BANK_ADDRESS2", "INTERMEDIARY_SWIFT_CODE2", "BANK_ACCOUNT2", "PERSONAL_ACCOUNT", "BUDGET_CLASSIFICATION_CODE", "OKTMO"
+            "BANK_ACCOUNT_ID", "ACCOUNT_ID", "BANK_IDENTIFICATION_CODE", "BANK_NAME", "CORRESPONDENT_ACCOUNT", "CORRESPONDENT_ACCOUNT_NAME", "CURRENCY", "DESTINATION", "IBAN", "INTERNATIONAL_TRANSFER_SIGN", "SWIFT_CODE", "TAXPAYER_IDENTIFICATION_NUMBER", "TAX_REGISTRATION_REASON_CODE", "ACCOUNT", "COMPANY_ID", "INTERMEDIARY_SWIFT_CODE", "NAME", "ADDRESS", "BANK_ADDRESS", "BANK_SWIFT_CODE", "BANK_ACCOUNT", "BANK_NAME1", "BANK_ADDRESS1", "BANK_ACCOUNT1", "BANK_NAME2", "BANK_ADDRESS2", "INTERMEDIARY_SWIFT_CODE2", "BANK_ACCOUNT2", "PERSONAL_ACCOUNT", "BUDGET_CLASSIFICATION_CODE", "OKTMO"
         };
     }
 
@@ -36,42 +36,42 @@ public class BankAccountHistoryMapStore extends TemplateEventMapStore<BankAccoun
     public Object[] objectToField(BankAccountHistory historyLog) {
         BankAccount object = historyLog.getObject();
         Object[] args = new Object[]{
-                historyLog.getId(),
+            historyLog.getId(),
-                TimeUtil.toDateFromInstant(historyLog.getEventTime()),
+            TimeUtil.toDateFromInstant(historyLog.getEventTime()),
-                historyLog.getUserId(),
+            historyLog.getUserId(),
-                historyLog.getEventType(),
+            historyLog.getEventType(),
 
-                object.getId(),
+            object.getId(),
-                object.getAccountId(),
+            object.getAccountId(),
-                object.getBankIdentificationCode(),
+            object.getBankIdentificationCode(),
-                object.getBankName(),
+            object.getBankName(),
-                object.getCorrespondentAccount(),
+            object.getCorrespondentAccount(),
-                object.getCorrespondentAccountName(),
+            object.getCorrespondentAccountName(),
-                object.getCurrency(),
+            object.getCurrency(),
-                object.getDestination(),
+            object.getDestination(),
-                object.getIban(),
+            object.getIban(),
-                object.getInternationalTransferSign(),
+            object.getInternationalTransferSign(),
-                object.getSwiftCode(),
+            object.getSwiftCode(),
-                object.getTaxpayerIdentificationNumber(),
+            object.getTaxpayerIdentificationNumber(),
-                object.getTaxRegistrationReasonCode(),
+            object.getTaxRegistrationReasonCode(),
-                object.getAccount(),
+            object.getAccount(),
-                object.getCompanyId(),
+            object.getCompanyId(),
-                object.getIntermediarySwiftCode(),
+            object.getIntermediarySwiftCode(),
-                object.getName(),
+            object.getName(),
-                object.getAddress(),
+            object.getAddress(),
-                object.getBankAddress(),
+            object.getBankAddress(),
-                object.getBankSwiftCode(),
+            object.getBankSwiftCode(),
-                object.getBankAccount(),
+            object.getBankAccount(),
-                object.getBankName1(),
+            object.getBankName1(),
-                object.getBankAddress1(),
+            object.getBankAddress1(),
-                object.getBankAccount1(),
+            object.getBankAccount1(),
-                object.getBankName2(),
+            object.getBankName2(),
-                object.getBankAddress2(),
+            object.getBankAddress2(),
-                object.getIntermediarySwiftCode2(),
+            object.getIntermediarySwiftCode2(),
-                object.getBankAccount2(),
+            object.getBankAccount2(),
-                object.getPersonalAccount(),
+            object.getPersonalAccount(),
-                object.getBudgetClassificationCode(),
+            object.getBudgetClassificationCode(),
-                object.getOktmo()
+            object.getOktmo()
         };
         return args;
     }

clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/businessevent/CompanyHistoryMapStore.java

@@ -81,7 +81,7 @@ public class CompanyHistoryMapStore extends BusinessEventMapStore<CompanyHistory
             }
         }
         batchInsertUpdate(insertStatement, batchArgs);
-        batchInsertUpdate(insertCompanyInfoStatement, batchCompanyInfoArgs);
+        batchInsertUpdate(insertCompanyInfoStatement, batchCompanyInfoArgs, "COMPANY_INFO_HISTORY", this.getFieldsForCompanyInfo());
     }
 
     /**

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

@@ -92,7 +92,7 @@ public class CompanyMapStore extends BusinessObjectMapStore<Company> {
             }
         }
         batchInsertUpdate(insertStatement, batchArgs);
-        batchInsertUpdate(insertCompanyInfoStatement, batchCompanyInfoArgs);
+        batchInsertUpdate(insertCompanyInfoStatement, batchCompanyInfoArgs, "COMPANY_INFO", this.getFieldsForCompanyInfo());
     }
 
 

clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/services/UpdateMapService.java

@@ -214,7 +214,7 @@ public class UpdateMapService extends AbstractUpdateMapService {
             AccountSymbolsHistory accountSymbolsHistory = new AccountSymbolsHistory();
             createBusinessEvent(accountSymbolsHistory, eventType);
             accountSymbolsHistory.setObject((AccountSymbols) value);
-            hazelcastServerInstance.getMap(IMDGDistributedNames.Map_TradingClearingRegistryHistory).put(accountSymbolsHistory.getId(), accountSymbolsHistory);
+            hazelcastServerInstance.getMap(IMDGDistributedNames.Map_AccountSymbolsHistory).put(accountSymbolsHistory.getId(), accountSymbolsHistory);
         } else if (value instanceof CurrencyPairSecurity) {
             CurrencyPairSecurityHistory currencyPairSecurityHistory = new CurrencyPairSecurityHistory();
             createBusinessEvent(currencyPairSecurityHistory, eventType);

clearing-parent/imdg/src/test/java/ru/spcex/clearing/imdg/AllMapStoreTest.java

@@ -1,11 +1,36 @@
 package ru.spcex.clearing.imdg;
 
+import static ru.spcex.clearing.imdg.structure.RunnableMapNamesForTesting.checkerBusinessMapStores;
+import static ru.spcex.clearing.imdg.structure.RunnableMapNamesForTesting.checkerDictionaryMapStores;
+import static ru.spcex.clearing.imdg.utils.DbDataUtils.generatingRandomString;
+
 import com.hazelcast.config.MapStoreConfig;
 import com.hazelcast.core.Hazelcast;
 import com.hazelcast.core.HazelcastInstance;
 import com.hazelcast.core.IMap;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import javax.annotation.PostConstruct;
 import org.apache.commons.lang3.exception.ExceptionUtils;
-import org.junit.jupiter.api.*;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Assumptions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -17,6 +42,7 @@ import org.springframework.jdbc.core.SqlTypeValue;
 import org.springframework.jdbc.core.StatementCreatorUtils;
 import org.springframework.lang.NonNull;
 import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.TestPropertySource;
 import org.springframework.test.context.junit.jupiter.SpringExtension;
 import ru.clearing.classes.statics.data.company.Company;
 import ru.clearing.classes.statics.data.company.CompanyHistory;
@@ -24,7 +50,12 @@ import ru.clearing.classes.statics.data.profile.CompanyInfo;
 import ru.clearing.platform.dictionary.AbstractDictionary;
 import ru.clearing.platform.dictionary.CompanySymbolDictionary;
 import ru.clearing.platform.dictionary.CurrencyPairDictionary;
-import ru.spcex.clearing.imdg.base.*;
+import ru.spcex.clearing.imdg.base.BusinessEventMapStore;
+import ru.spcex.clearing.imdg.base.BusinessObjectMapStore;
+import ru.spcex.clearing.imdg.base.DictionaryMapStore;
+import ru.spcex.clearing.imdg.base.DictionaryTMapStore;
+import ru.spcex.clearing.imdg.base.TemplateEventMapStore;
+import ru.spcex.clearing.imdg.base.TemplateMapStore;
 import ru.spcex.clearing.imdg.config.DbTestConnectionConfig;
 import ru.spcex.clearing.imdg.config.TestConfiguration;
 import ru.spcex.clearing.imdg.structure.CheckerBusinessMapStore;
@@ -35,24 +66,11 @@ import ru.spcex.clearing.imdg.utils.SpcexObjectBaseRowMapper;
 import ru.spcex.platform.classes.base.SpcexObjectBase;
 import ru.spcex.platform.utils.text.TextUtil;
 
-import javax.annotation.PostConstruct;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.sql.*;
-import java.util.*;
-import java.util.stream.Collectors;
-
-import static ru.spcex.clearing.imdg.structure.RunnableMapNamesForTesting.checkerBusinessMapStores;
-import static ru.spcex.clearing.imdg.structure.RunnableMapNamesForTesting.checkerDictionaryMapStores;
-import static ru.spcex.clearing.imdg.utils.DbDataUtils.generatingRandomString;
-
 @ContextConfiguration(classes = {
         TestConfiguration.class,
         DbTestConnectionConfig.class})
 @ExtendWith(SpringExtension.class)
-//@TestPropertySource(properties = "spring.config.location=D:/repo/mfd/clearing/clearing-parent/imdg/src/main/resources") @TestPropertySource(locations = "/AllMapStoreTest.properties")
+@TestPropertySource(locations="classpath:application.properties")
 public class AllMapStoreTest {
     private static final Long ID = 1000000L;
     private final Logger log = LoggerFactory.getLogger(this.getClass());
@@ -78,45 +96,54 @@ public class AllMapStoreTest {
     @PostConstruct
     public void initTestObjects() {
         try {
-            for (CheckerBusinessMapStore<SpcexObjectBase> objectForCheck : checkerBusinessMapStores) {
+            for (Map.Entry<String, CheckerBusinessMapStore> objectForCheck : checkerBusinessMapStores.entrySet()) {
-                SpcexObjectBase object = objectForCheck.getClazz().getDeclaredConstructor().newInstance();
+                log.info("Checking business -> {}", objectForCheck.getKey());
+                SpcexObjectBase object = (SpcexObjectBase) objectForCheck.getValue().getClazz().getDeclaredConstructor().newInstance();
                 DbDataUtils.fillObjectDefaultValues(object, object.getClass());
-                if (objectForCheck.getClazz().equals(CompanyHistory.class)) {
+                if (objectForCheck.getValue().getClazz().equals(CompanyHistory.class)) {
                     CompanyHistory companyHistory = (CompanyHistory) object;
                     CompanyInfo companyInfo = companyHistory.getObject().getProfile();
                     companyInfo.setCompanyId(companyHistory.getObject().getId());
                     companyInfo.setId(1000000L);
-                    objectForCheck.setPredictableObj(companyHistory);
+                    objectForCheck.getValue().setPredictableObj(companyHistory);
-                } else if (objectForCheck.getClazz().equals(Company.class)) {
+                } else if (objectForCheck.getValue().getClazz().equals(Company.class)) {
                     Company company = (Company) object;
                     CompanyInfo companyInfo = company.getProfile();
                     companyInfo.setCompanyId(1000000L);
                     companyInfo.setId(1000000L);
-                    objectForCheck.setPredictableObj(company);
+                    objectForCheck.getValue().setPredictableObj(company);
-                } else if (objectForCheck.getMapName().startsWith("Map_SDf")) {
+                } else if (objectForCheck.getValue().getMapName().toUpperCase().startsWith("MAP_SDF")) {
-                    trySettingString(object, objectForCheck.getClazz(), "setMarket", 1);
+                    trySettingString(object, objectForCheck.getValue().getClazz(), "setMarket", 1);
-                    trySettingString(object, objectForCheck.getClazz(), "setFile_type", 1);
+                    trySettingString(object, objectForCheck.getValue().getClazz(), "setFile_type", 1);
-                    trySettingString(object, objectForCheck.getClazz(), "setSeg_type", 1);
+                    trySettingString(object, objectForCheck.getValue().getClazz(), "setSeg_type", 1);
-                    trySettingString(object, objectForCheck.getClazz(), "setPriority", 1);
+                    trySettingString(object, objectForCheck.getValue().getClazz(), "setPriority", 1);
-                    trySettingString(object, objectForCheck.getClazz(), "setPr", 1);
+                    trySettingString(object, objectForCheck.getValue().getClazz(), "setPr", 1);
-                    trySettingString(object, objectForCheck.getClazz(), "setType", 1);
+                    trySettingString(object, objectForCheck.getValue().getClazz(), "setType", 1);
-                    trySettingString(object, objectForCheck.getClazz(), "setOp_order", 1);
+                    trySettingString(object, objectForCheck.getValue().getClazz(), "setOp_order", 1);
-                    trySettingString(object, objectForCheck.getClazz(), "setSp_code", 2);
+                    trySettingString(object, objectForCheck.getValue().getClazz(), "setSp_code", 2);
-                    trySettingString(object, objectForCheck.getClazz(), "setDoc_result", 2);
+                    trySettingString(object, objectForCheck.getValue().getClazz(), "setDoc_result", 2);
-                    trySettingString(object, objectForCheck.getClazz(), "setAcc_type", 2);
+                    trySettingString(object, objectForCheck.getValue().getClazz(), "setDoc_num", 3);
-                    trySettingString(object, objectForCheck.getClazz(), "setOp_type", 2);
+                    if (objectForCheck.getValue().getMapName().equalsIgnoreCase("Map_sDf52")) {
-                    trySettingString(object, objectForCheck.getClazz(), "setDoc_result", 2);
+                        trySettingString(object, objectForCheck.getValue().getClazz(), "setAcc_type", 3);
-                    trySettingString(object, objectForCheck.getClazz(), "setResult", 3);
+                    } else if (objectForCheck.getValue().getMapName().equalsIgnoreCase("Map_sDf53")) {
-                    trySettingString(object, objectForCheck.getClazz(), "setImp_result", 3);
+                        trySettingString(object, objectForCheck.getValue().getClazz(), "setAccType", 3);
-                    objectForCheck.setPredictableObj(object);
+                    } else {
+                        trySettingString(object, objectForCheck.getValue().getClazz(), "setAcc_type", 2);
+                    }
+                    trySettingString(object, objectForCheck.getValue().getClazz(), "setOp_type", 2);
+                    trySettingString(object, objectForCheck.getValue().getClazz(), "setDoc_result", 2);
+                    trySettingString(object, objectForCheck.getValue().getClazz(), "setResult", 3);
+                    trySettingString(object, objectForCheck.getValue().getClazz(), "setImp_result", 3);
+                    objectForCheck.getValue().setPredictableObj(object);
                 } else {
-                    objectForCheck.setPredictableObj(object);
+                    objectForCheck.getValue().setPredictableObj(object);
                 }
             }
-            for (CheckerDictionaryMapStore<AbstractDictionary> objectForCheck : checkerDictionaryMapStores) {
+            for (Map.Entry<String, CheckerDictionaryMapStore> objectForCheck : checkerDictionaryMapStores.entrySet()) {
-                AbstractDictionary object = objectForCheck.getClazz().getDeclaredConstructor().newInstance();
+                log.info("Checking dictionary -> {}", objectForCheck.getKey());
+                AbstractDictionary object = (AbstractDictionary) objectForCheck.getValue().getClazz().getDeclaredConstructor().newInstance();
                 DbDataUtils.fillObjectDefaultValues(object, object.getClass());
-                objectForCheck.setPredictableObj(object);
+                objectForCheck.getValue().setPredictableObj(object);
             }
         } catch (InstantiationException | IllegalAccessException e) {
             log.error(e.getMessage());
@@ -179,7 +206,7 @@ public class AllMapStoreTest {
         testConfig.shutDownHazelcast();
         testConfig.reinitHazlecastInstance();
 
-        for (CheckerBusinessMapStore objectForCheck : checkerBusinessMapStores) {
+        for (CheckerBusinessMapStore objectForCheck : checkerBusinessMapStores.values()) {
             String mapName = objectForCheck.getMapName();
             SpcexObjectBase actual;
             if (getMapStore(mapName) instanceof TemplateEventMapStore) {
@@ -201,12 +228,13 @@ public class AllMapStoreTest {
             }
             if (actual == null) {
                 log.error("No actual object for check {}", objectForCheck.getMapName());
-//                continue; or throw new IllegalArgumentException("Empty actual of "+objectForCheck.getMapName());
+                continue;
             }
             objectForCheck.getMATCHER().assertMatch(actual, objectForCheck.getPredictableObj());
         }
-        for (CheckerDictionaryMapStore objectForCheck : checkerDictionaryMapStores) {
+        for (CheckerDictionaryMapStore objectForCheck : checkerDictionaryMapStores.values()) {
             String mapName = objectForCheck.getMapName();
+            log.info("Checking map {}", mapName);
             AbstractDictionary actual;
             IMap<Long, AbstractDictionary> map = testConfig.getHazelcastInstance().getMap(mapName);
             actual = map.get(ID);
@@ -220,7 +248,7 @@ public class AllMapStoreTest {
         Assumptions.assumeTrue(false, "todo удалить если будет не нужна, пока не работает из-за \"deleteIsSupported() return false\" в SimpleObjectMapStore.");
         saveBusinessObjectAndBusinessEventToMaps();
 
-        for (CheckerBusinessMapStore objectForCheck : checkerBusinessMapStores) {
+        for (CheckerBusinessMapStore objectForCheck : checkerBusinessMapStores.values()) {
             IMap<Long, SpcexObjectBase> map = testConfig.getHazelcastInstance().getMap(objectForCheck.getMapName());
             map.remove(ID);
             String sql = String.format("SELECT * FROM %s WHERE id = %d", getTableNameFromMapStore(objectForCheck.getMapName()), ID);
@@ -255,7 +283,7 @@ public class AllMapStoreTest {
     }
 
     private void saveBusinessObjectAndBusinessEventToMaps() {
-        for (CheckerBusinessMapStore objectForCheck : checkerBusinessMapStores) {
+        for (CheckerBusinessMapStore objectForCheck : checkerBusinessMapStores.values()) {
             String mapName = objectForCheck.getMapName();
             SpcexObjectBase spcexObjectBase = objectForCheck.getPredictableObj();
             spcexObjectBase.setId(ID);
@@ -266,7 +294,7 @@ public class AllMapStoreTest {
     }
 
     private void saveDictionaryObjectToMaps() {
-        for (CheckerDictionaryMapStore objectForCheck : checkerDictionaryMapStores) {
+        for (CheckerDictionaryMapStore objectForCheck : checkerDictionaryMapStores.values()) {
             String mapName = objectForCheck.getMapName();
             AbstractDictionary dictionaryObj = objectForCheck.getPredictableObj();
             dictionaryObj.setId(ID);

clearing-parent/imdg/src/test/java/ru/spcex/clearing/imdg/DbUpdateCompareTest.java

@@ -0,0 +1,155 @@
+package ru.spcex.clearing.imdg;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.mchange.v2.c3p0.ComboPooledDataSource;
+import java.beans.PropertyVetoException;
+import java.io.File;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Stream;
+import javax.sql.DataSource;
+import org.junit.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.core.io.FileSystemResource;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.datasource.init.ResourceDatabasePopulator;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+import org.testcontainers.containers.PostgreSQLContainer;
+import ru.spcex.clearing.imdg.config.ImdgSettings;
+
+@ExtendWith(SpringExtension.class)
+@ContextConfiguration(classes = {
+    ImdgSettings.class
+})
+public class DbUpdateCompareTest {
+    private final Logger log = LoggerFactory.getLogger(this.getClass());
+    private static final File DB_SCRIPTS_LOCATION = new File("D:\\Projects\\MFD\\clearing\\clearing-parent\\db-scripts\\src\\main\\resources\\db\\");
+
+    @Test
+    public void compareCompleteDDLWithUpdatedDDL() {
+        // Creating docker containers
+        try (PostgreSQLContainer<?> dbWithCompleteDDL = new PostgreSQLContainer<>(PostgreSQLContainer.IMAGE);
+             PostgreSQLContainer<?> dbWithUpdatedDDL = new PostgreSQLContainer<>(PostgreSQLContainer.IMAGE)) {
+            // Starting docker containers
+            dbWithCompleteDDL.start();
+            dbWithUpdatedDDL.start();
+
+            // Acquiring JdbcTemplate through data source
+            JdbcTemplate dbWithCompleteDDLJdbc = new JdbcTemplate(getDataSource(dbWithCompleteDDL));
+            JdbcTemplate dbWithUpdatedDDLJdbc = new JdbcTemplate(getDataSource(dbWithUpdatedDDL));
+
+            // Creating clearing role
+            dbWithCompleteDDLJdbc.execute("CREATE ROLE clearing");
+            dbWithUpdatedDDLJdbc.execute("CREATE ROLE clearing");
+
+            // Executing DDL.sql (self-sufficient sql script containing all current updates)
+            new ResourceDatabasePopulator(new FileSystemResource(DB_SCRIPTS_LOCATION.toPath().resolve("DDL.sql").toString()))
+                .execute(Objects.requireNonNull(dbWithCompleteDDLJdbc.getDataSource()));
+
+            // Executing DDL_first.sql (template sql script for creating base tables)
+            new ResourceDatabasePopulator(new FileSystemResource(DB_SCRIPTS_LOCATION.toPath().resolve("DDL_first.sql").toString()))
+                .execute(Objects.requireNonNull(dbWithUpdatedDDLJdbc.getDataSource()));
+            // Executing all updateDDL_*.sql script in order
+            getUpdateScripts().forEach(us -> new ResourceDatabasePopulator(new FileSystemResource(us.getPath()))
+                .execute(Objects.requireNonNull(dbWithUpdatedDDLJdbc.getDataSource())));
+
+            // Get all table names
+            String getAllTablesSql = "SELECT table_name FROM information_schema.tables WHERE table_schema='public';";
+            List<String> dbWithCompleteDDLTables = dbWithCompleteDDLJdbc.queryForList(getAllTablesSql)
+                .stream()
+                .map(t -> t.get("table_name").toString())
+                .sorted()
+                .toList();
+            List<String> dbWithUpdatedDDLTables = dbWithUpdatedDDLJdbc.queryForList(getAllTablesSql)
+                .stream()
+                .map(t -> t.get("table_name").toString())
+                .sorted()
+                .toList();
+
+            assertThat(dbWithCompleteDDLTables.size()).isEqualTo(dbWithUpdatedDDLTables.size());
+            assertThat(dbWithCompleteDDLTables).usingRecursiveComparison().isEqualTo(dbWithUpdatedDDLTables);
+
+            // Comparing column names, data types, char max length, nullability, default values and comments
+            dbWithCompleteDDLTables.forEach(t -> {
+                String sql = """
+                    SELECT cols.column_name,
+                           (SELECT pg_catalog.col_description(c.oid, cols.ordinal_position::int)
+                            FROM pg_catalog.pg_class c
+                            WHERE c.oid = (SELECT ('"' || cols.table_name || '"')::regclass::oid)
+                              AND c.relname = cols.table_name) AS column_comment,
+                           cols.data_type,
+                           cols.character_maximum_length,
+                           cols.is_nullable
+                    FROM information_schema.columns cols
+                    WHERE cols.table_name = '""" + t + "';";
+
+                List<Map<String, Object>> firstTableResult = dbWithCompleteDDLJdbc.queryForList(sql)
+                    .stream()
+                    .sorted((Comparator.comparing(o -> ((String) o.get("column_name")))))
+                    .toList();
+                List<Map<String, Object>> secondTableResult = dbWithUpdatedDDLJdbc.queryForList(sql)
+                    .stream()
+                    .sorted((Comparator.comparing(o -> ((String) o.get("column_name")))))
+                    .toList();
+
+                assertThat(firstTableResult.size()).as("Checking columns quantity on table %s", t).isEqualTo(secondTableResult.size());
+
+                for (int i = 0; i < firstTableResult.size(); i++) {
+                    Map<String, Object> first = firstTableResult.get(i);
+                    Map<String, Object> second = secondTableResult.get(i);
+
+                    assertThat(first.get("column_name")).as("Checking column's name on table %s", t).isEqualTo(second.get("column_name"));
+//                    assertThat(first.get("column_comment")).as("Checking column's comment on table %s", t).isEqualTo(second.get("column_comment"));
+                    assertThat(first.get("data_type")).as("Checking column's %s data type on table %s", first.get("column_name"), t).isEqualTo(second.get("data_type"));
+                    assertThat(first.get("character_maximum_length")).as("Checking column's %s character maximum length on table %s", first.get("column_name"), t).isEqualTo(second.get("character_maximum_length"));
+                    assertThat(first.get("is_nullable")).as("Checking column's %s nullability on table %s", first.get("column_name"), t).isEqualTo(second.get("is_nullable"));
+                }
+            });
+        }
+    }
+
+    private List<File> getUpdateScripts() {
+        return Stream.of(Objects.requireNonNull(DB_SCRIPTS_LOCATION.listFiles(File::isFile)))
+            .filter(f -> f.getName().startsWith("updateDDL"))
+            .sorted((o1, o2) -> versionCompare(o1.getName(), o2.getName()))
+            .toList();
+    }
+
+    private int versionCompare(String o1, String o2) {
+        List<Integer> o1Version = Arrays.stream(o1.substring(0, o1.lastIndexOf(".")).split("_")[1].split("\\.")).map(Integer::parseInt).toList();
+        List<Integer> o2Version = Arrays.stream(o2.substring(0, o2.lastIndexOf(".")).split("_")[1].split("\\.")).map(Integer::parseInt).toList();
+
+        for (int i = 0; i < Math.min(o1Version.size(), o2Version.size()); i++) {
+            if (!o1Version.get(i).equals(o2Version.get(i))) {
+                return o1Version.get(i).compareTo(o2Version.get(i));
+            }
+        }
+
+        return Integer.compare(o1Version.size(), o2Version.size());
+    }
+
+    private DataSource getDataSource(PostgreSQLContainer<?> container) {
+        ComboPooledDataSource cpds = new ComboPooledDataSource();
+        try {
+            cpds.setDriverClass(container.getDriverClassName());
+            cpds.setJdbcUrl(container.getJdbcUrl());
+            cpds.setUser(container.getUsername());
+            cpds.setPassword(container.getPassword());
+
+            cpds.setMaxPoolSize(100);
+            cpds.setMinPoolSize(50);
+            cpds.setAcquireIncrement(5);
+        } catch (PropertyVetoException e) {
+            throw new RuntimeException(e);
+        }
+
+        return cpds;
+    }
+}

clearing-parent/imdg/src/test/java/ru/spcex/clearing/imdg/config/DbTestConnectionConfig.java

@@ -1,24 +1,28 @@
 package ru.spcex.clearing.imdg.config;
 
 import com.mchange.v2.c3p0.ComboPooledDataSource;
+import java.sql.Connection;
+import javax.sql.DataSource;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.core.io.ClassPathResource;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.jdbc.datasource.init.DatabasePopulator;
-import org.springframework.jdbc.datasource.init.DatabasePopulatorUtils;
 import org.springframework.jdbc.datasource.init.ResourceDatabasePopulator;
 import ru.spcex.clearing.imdg.error.ModuleInitializeException;
 
-import javax.sql.DataSource;
-import java.sql.Connection;
-
 @SuppressWarnings("UnnecessaryLocalVariable")
 @Configuration
 public class DbTestConnectionConfig {
     private final Logger log = LoggerFactory.getLogger(this.getClass());
+    private final ImdgSettings settings;
+
+    public DbTestConnectionConfig(@Qualifier("imdgSettingsTest") ImdgSettings settings) {
+        this.settings = settings;
+    }
 
     private DatabasePopulator createDatabasePopulator() {
         ResourceDatabasePopulator databasePopulator = new ResourceDatabasePopulator();
@@ -30,10 +34,10 @@ public class DbTestConnectionConfig {
     @Bean
     public DataSource dataSource() {
         DataSource result;
-        String login = "clearing";
+        String login = settings.getDatabase().getLogin();
-        String password = "Aa111111";
+        String password = settings.getDatabase().getPassword();
         String logTimeoutPart = "";
-        String dbPath = "jdbc:postgresql://10.200.200.133:5432/postgres?currentSchema=clearing_tester";
+        String dbPath = settings.getDatabase().getUrl();
         int timeoutSec = 30;
 
         ComboPooledDataSource cpds = new ComboPooledDataSource();

clearing-parent/imdg/src/test/java/ru/spcex/clearing/imdg/config/ImdgSettings.java

@@ -0,0 +1,31 @@
+package ru.spcex.clearing.imdg.config;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+import org.springframework.test.context.TestPropertySource;
+import ru.spcex.clearing.imdg.config.element.DatabaseSettings;
+import ru.spcex.clearing.imdg.config.element.HazelcastServerSettings;
+
+@Component("imdgSettingsTest")
+@TestPropertySource(locations="classpath:application.properties")
+@ConfigurationProperties("imdg")
+public class ImdgSettings {
+    private HazelcastServerSettings hazelcast;
+    private DatabaseSettings database;
+
+    public HazelcastServerSettings getHazelcast() {
+        return hazelcast;
+    }
+
+    public void setHazelcast(HazelcastServerSettings hazelcast) {
+        this.hazelcast = hazelcast;
+    }
+
+    public DatabaseSettings getDatabase() {
+        return database;
+    }
+
+    public void setDatabase(DatabaseSettings database) {
+        this.database = database;
+    }
+}

clearing-parent/imdg/src/test/java/ru/spcex/clearing/imdg/structure/CheckerDictionaryMapStore.java

@@ -10,7 +10,7 @@ import static ru.spcex.clearing.imdg.utils.MatcherFactory.usingIgnoringFieldsCom
 
 public class CheckerDictionaryMapStore<T> {
 
-    public final Matcher<T> MATCHER = usingIgnoringFieldsComparator();
+    public final Matcher<T> MATCHER;
     private final String mapName;
     private final Class<T> clazz;
 
@@ -19,6 +19,13 @@ public class CheckerDictionaryMapStore<T> {
     public CheckerDictionaryMapStore(String mapName, Class<T> clazz) {
         this.mapName = mapName;
         this.clazz = clazz;
+        this.MATCHER = usingIgnoringFieldsComparator();
+    }
+
+    public CheckerDictionaryMapStore(String mapName, Class<T> clazz, Matcher<T> matcher) {
+        this.mapName = mapName;
+        this.clazz = clazz;
+        this.MATCHER = matcher;
     }
 
     public String getMapName() {

clearing-parent/imdg/src/test/java/ru/spcex/clearing/imdg/structure/RunnableMapNamesForTesting.java

@@ -1,430 +1,379 @@
 package ru.spcex.clearing.imdg.structure;
 
-import ru.clearing.classes.statics.data.account.*;
-import ru.clearing.classes.statics.data.clearing.VerificationResult;
-import ru.clearing.classes.statics.data.company.*;
-import ru.clearing.classes.statics.data.company.relation.Relation;
-import ru.clearing.classes.statics.data.company.relation.RelationHistory;
-import ru.clearing.classes.statics.data.execution.*;
-import ru.clearing.classes.statics.data.instrument.issue.*;
-import ru.clearing.classes.statics.data.journal.InDocumentJournal;
-import ru.clearing.classes.statics.data.journal.ManagementJournal;
-import ru.clearing.classes.statics.data.journal.OutDocumentJournal;
-import ru.clearing.classes.statics.data.messages.ErrorText;
-import ru.clearing.classes.statics.data.misc.*;
-import ru.clearing.classes.statics.data.payment.Operation;
-import ru.clearing.classes.statics.data.payment.PaymentInstruction;
-import ru.clearing.classes.statics.data.profile.Contact;
-import ru.clearing.classes.statics.data.profile.ProfileDocument;
-import ru.clearing.classes.statics.data.profile.ProfileDocumentHistory;
-import ru.clearing.classes.statics.data.register.*;
-import ru.clearing.classes.statics.data.registry.TradingClearingRegistryList;
-import ru.clearing.classes.statics.data.registry.TradingClearingRegistryListHistory;
-import ru.clearing.classes.statics.data.scheduler.*;
-import ru.clearing.classes.statics.data.sdf.*;
-import ru.clearing.classes.statics.data.security.CurrencyPairSecurity;
-import ru.clearing.classes.statics.data.security.CurrencyPairSecurityHistory;
-import ru.clearing.classes.statics.data.security.MoneyMarketSecurity;
-import ru.clearing.classes.statics.data.security.MoneyMarketSecurityHistory;
-import ru.clearing.classes.statics.data.statement.Statement;
-import ru.clearing.classes.statics.data.user.*;
-import ru.clearing.platform.dictionary.*;
-import ru.spcex.clearing.imdg.IMDGDistributedNames;
-import ru.spcex.clearing.imdg.structure.CheckerBusinessMapStore.SettingOperation;
-
-import java.math.BigDecimal;
-import java.time.Instant;
-import java.util.LinkedList;
-import java.util.List;
-
 import static ru.spcex.clearing.imdg.utils.DbDataUtils.generatingRandomBigDecimal;
 import static ru.spcex.clearing.imdg.utils.DbDataUtils.generatingRandomInstant;
 import static ru.spcex.clearing.imdg.utils.MatcherFactory.usingIgnoringFieldsComparator;
 
-public class RunnableMapNamesForTesting {
+import com.hazelcast.core.HazelcastInstance;
-    public static List<CheckerBusinessMapStore> checkerBusinessMapStores;
+import java.lang.reflect.ParameterizedType;
-    public static List<CheckerDictionaryMapStore> checkerDictionaryMapStores;
+import java.math.BigDecimal;
+import java.time.Instant;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import ru.clearing.classes.statics.data.clearing.VerificationResult;
+import ru.clearing.classes.statics.data.company.Company;
+import ru.clearing.classes.statics.data.company.CompanyHistory;
+import ru.clearing.classes.statics.data.execution.ExecutionCurrency;
+import ru.clearing.classes.statics.data.execution.ExecutionCurrencyHistory;
+import ru.clearing.classes.statics.data.execution.ExecutionDeposit;
+import ru.clearing.classes.statics.data.execution.ExecutionDepositHistory;
+import ru.clearing.classes.statics.data.execution.ExecutionFond;
+import ru.clearing.classes.statics.data.execution.ExecutionFondHistory;
+import ru.clearing.classes.statics.data.instrument.issue.CouponPeriod;
+import ru.clearing.classes.statics.data.instrument.issue.CouponPeriodHistory;
+import ru.clearing.classes.statics.data.instrument.issue.EquitySecurity;
+import ru.clearing.classes.statics.data.instrument.issue.EquitySecurityHistory;
+import ru.clearing.classes.statics.data.instrument.issue.FixedIncomeCashFlow;
+import ru.clearing.classes.statics.data.instrument.issue.FixedIncomeCashFlowHistory;
+import ru.clearing.classes.statics.data.instrument.issue.FixedIncomeSecurity;
+import ru.clearing.classes.statics.data.instrument.issue.FixedIncomeSecurityHistory;
+import ru.clearing.classes.statics.data.journal.InDocumentJournal;
+import ru.clearing.classes.statics.data.journal.OutDocumentJournal;
+import ru.clearing.classes.statics.data.misc.Listing;
+import ru.clearing.classes.statics.data.misc.ListingHistory;
+import ru.clearing.classes.statics.data.misc.STrades;
+import ru.clearing.classes.statics.data.register.AdmittedLiabilitiesRegister;
+import ru.clearing.classes.statics.data.register.ContractRegister;
+import ru.clearing.classes.statics.data.register.CoveredLiabilitiesRegister;
+import ru.clearing.classes.statics.data.register.DepoBalanceRegister;
+import ru.clearing.classes.statics.data.register.DepoPaymentInstructionRegister;
+import ru.clearing.classes.statics.data.register.ExcludeLiabilitiesRegister;
+import ru.clearing.classes.statics.data.register.ExecutionRegister;
+import ru.clearing.classes.statics.data.register.LiabilitiesRegister;
+import ru.clearing.classes.statics.data.register.MoneyBalanceRegister;
+import ru.clearing.classes.statics.data.register.MoneyPaymentInstructionRegister;
+import ru.clearing.classes.statics.data.register.ReportRegister;
+import ru.clearing.classes.statics.data.sdf.SDf54;
+import ru.clearing.classes.statics.data.sdf.SDf55;
+import ru.clearing.classes.statics.data.sdf.SDf57;
+import ru.clearing.classes.statics.data.security.CurrencyPairSecurity;
+import ru.clearing.classes.statics.data.security.CurrencyPairSecurityHistory;
+import ru.clearing.classes.statics.data.security.MoneyMarketSecurity;
+import ru.clearing.classes.statics.data.security.MoneyMarketSecurityHistory;
+import ru.clearing.classes.statics.data.security.TradedMoneyMarketSecurity;
+import ru.clearing.classes.statics.data.statement.Statement;
+import ru.clearing.platform.dictionary.CurrencyPairDictionary;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.clearing.imdg.config.TestConfiguration;
+import ru.spcex.clearing.imdg.structure.CheckerBusinessMapStore.SettingOperation;
 
-    static {
+@Component
-        init();
+public class RunnableMapNamesForTesting implements InitializingBean {
+    // Deprecated and default map stores that are not in the scope of tests
+    private static final List<String> MAP_STORES_TO_IGNORE = List.of(
+        "Map_DbVersion",
+        "default",
+        "Map_AccountBalance",
+        "Map_Security",
+        "Map_SecurityHistory",
+        "Map_SDf17",
+        "Map_SDf16",
+        "Map_SDf18",
+        "Map_ClearingStatusDictionary",
+        "Map_KeyRate",
+        "Map_LiabilitiesClaimsAssets",
+        "Map_LiabilitiesClaimsMoney"
+    );
+
+    @Autowired
+    TestConfiguration testConfig;
+
+    public static Map<String, CheckerBusinessMapStore> checkerBusinessMapStores = new HashMap<>();
+    public static Map<String, CheckerDictionaryMapStore> checkerDictionaryMapStores = new HashMap<>();
+
+    @Override
+    public void afterPropertiesSet() {
+        HazelcastInstance hazelcastInstance = testConfig.getHazelcastInstance();
+        setExceptions();
+        hazelcastInstance.getConfig().getMapConfigs().forEach((key, value) -> {
+            if (!MAP_STORES_TO_IGNORE.contains(key)) {
+                if (value.getMapStoreConfig().getImplementation().getClass().getSuperclass().getSimpleName().equals("DictionaryTMapStore")) {
+                    if (((ParameterizedType) value.getMapStoreConfig().getImplementation().getClass().getGenericSuperclass()).getActualTypeArguments()[0].getClass().getSimpleName().equals("Class")) {
+                        checkerDictionaryMapStores.putIfAbsent(key, new CheckerDictionaryMapStore<>(key, (Class<?>) ((ParameterizedType) value.getMapStoreConfig()
+                            .getImplementation()
+                            .getClass()
+                            .getGenericSuperclass())
+                            .getActualTypeArguments()[0]));
+                    } else {
+                        checkerDictionaryMapStores.putIfAbsent(key, new CheckerDictionaryMapStore<>(key, ((ParameterizedType) value.getMapStoreConfig()
+                            .getImplementation()
+                            .getClass()
+                            .getGenericSuperclass())
+                            .getActualTypeArguments()[0]
+                            .getClass()));
+                    }
+                } else {
+                    if (((ParameterizedType) value.getMapStoreConfig().getImplementation().getClass().getGenericSuperclass()).getActualTypeArguments()[0].getClass().getSimpleName().equals("Class")) {
+                        checkerBusinessMapStores.putIfAbsent(key, new CheckerBusinessMapStore<>(key, (Class<?>) ((ParameterizedType) value.getMapStoreConfig()
+                            .getImplementation()
+                            .getClass()
+                            .getGenericSuperclass())
+                            .getActualTypeArguments()[0]));
+                    } else {
+                        checkerBusinessMapStores.putIfAbsent(key, new CheckerBusinessMapStore<>(key, ((ParameterizedType) value.getMapStoreConfig()
+                            .getImplementation()
+                            .getClass()
+                            .getGenericSuperclass())
+                            .getActualTypeArguments()[0]
+                            .getClass()));
+                    }
+                }
+            }
+        });
     }
 
-    private static void init() {
+    private static void setExceptions() {
-        checkerBusinessMapStores = new LinkedList<>();
+        checkerDictionaryMapStores.put(IMDGDistributedNames.Map_CurrencyPairDictionary, new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_CurrencyPairDictionary, CurrencyPairDictionary.class,
-        checkerDictionaryMapStores = new LinkedList<>();
+            usingIgnoringFieldsComparator("name")));
-
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_CompanyHistory, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_CompanyHistory, CompanyHistory.class,
-        //business event
+            usingIgnoringFieldsComparator("object.profile.clearingCode",
-//        businessObjectAndBusinessEventForCheckMapStores.add(new BusinessObjectAndBusinessEventForCheckMapStore<>(IMDGDistributedNames.Map_AccountBalanceHistory, AccountBalanceHistory.class));
+                "object.profile.fullName",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_AccountHistory, AccountHistory.class));
+                "object.profile.registrationCode",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_BankAccountHistory, BankAccountHistory.class));
+                "object.profile.shortName",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_CompanyHistory, CompanyHistory.class,
+                "object.profile.tradingCode")));
-                usingIgnoringFieldsComparator("object.profile.clearingCode", "object.profile.fullName", "object.profile.registrationCode", "object.profile.shortName", "object.profile.tradingCode")));
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_ExecutionDepositHistory, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ExecutionDepositHistory, ExecutionDepositHistory.class,
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ExecutionDepositHistory, ExecutionDepositHistory.class,
+            usingIgnoringFieldsComparator("object.firstLegAmount",
-                usingIgnoringFieldsComparator(
+                "object.interestAmount",
-                        "object.firstLegAmount",
+                "object.lots",
-                        "object.interestAmount",
+                "object.quantity",
-                        "object.lots",
+                "object.secondLegAmount")));
-                        "object.quantity",
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_ExecutionFondHistory, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ExecutionFondHistory, ExecutionFondHistory.class,
-                        "object.secondLegAmount")
+            usingIgnoringFieldsComparator("object.interestAmount",
-                /*new SettingOperation("object.firstLegAmount", new Object[]{new BigDecimal("850.640000000000000000")}),
+                "object.lots",
-                new SettingOperation("object.interestAmount", new Object[]{new BigDecimal("851.640000000000000000")}),
+                "object.quantity",
-                new SettingOperation("object.lots", new Object[]{new BigDecimal("852.640000000000000000")}),
+                "object.settlementAmount")));
-                new SettingOperation("object.quantity", new Object[]{new BigDecimal("853.640000000000000000")}),
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_ListingHistory, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ListingHistory, ListingHistory.class,
-                new SettingOperation("object.secondLegAmount", new Object[]{new BigDecimal("854.640000000000000000")})*/
+            usingIgnoringFieldsComparator("object.lotSize",
-        ));
+                "object.minStep",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ExecutionFondHistory, ExecutionFondHistory.class,
+                "object.precision")));
-                usingIgnoringFieldsComparator(
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_MoneyMarketSecurityHistory, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_MoneyMarketSecurityHistory, MoneyMarketSecurityHistory.class,
-                        "object.interestAmount",
+            usingIgnoringFieldsComparator("object.created",
-                        "object.lots",
+                "object.updated",
-                        "object.quantity",
+                "object.fullName",
-                        "object.settlementAmount")
+                "object.fullNameEng",
-                /*new SettingOperation("object.interestAmount", new Object[]{new BigDecimal("850.640000000000000000")}),
+                "object.instrumentType",
-                new SettingOperation("object.lots", new Object[]{new BigDecimal("851.640000000000000000")}),
+                "object.isin",
-                new SettingOperation("object.quantity", new Object[]{new BigDecimal("852.640000000000000000")}),
+                "object.issuerId",
-                new SettingOperation("object.settlementAmount", new Object[]{new BigDecimal("853.640000000000000000")})*/));
+                "object.lotSize",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_InformationAccountHistory, InformationAccountHistory.class));
+                "object.securitySymbol",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_RelationHistory, RelationHistory.class));
+                "object.shortName",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SessionHistory, SessionHistory.class));
+                "object.shortNameEng",
-//        businessObjectAndBusinessEventForCheckMapStores.add(new BusinessObjectAndBusinessEventForCheckMapStore<>(IMDGDistributedNames.Map_SecurityHistory, SecurityHistory.class)); // parent table
+                "object.uuid",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_UserConnectHistory, UserConnectHistory.class));
+                "object.workflowStatus")));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_UserHistory, UserHistory.class));
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_EquitySecurityHistory, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_EquitySecurityHistory, EquitySecurityHistory.class,
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_CurrencyHistory, CurrencyHistory.class));
+            usingIgnoringFieldsComparator("object.created",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ListingHistory, ListingHistory.class,
+                "object.updated",
-                usingIgnoringFieldsComparator(
+                "object.fullName",
-                        "object.lotSize",
+                "object.fullNameEng",
-                        "object.minStep","object.precision")
+                "object.instrumentType",
-                /*new SettingOperation("object.lotSize", new Object[]{new BigDecimal("850.640000000000000000")}),*/));
+                "object.isin",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_MarketHistory, MarketHistory.class));
+                "object.issuerId",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_NotificationHistory, NotificationHistory.class));
+                "object.lotSize",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_CompanySymbolsHistory, CompanySymbolsHistory.class));
+                "object.securitySymbol",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ProfileDocumentHistory, ProfileDocumentHistory.class));
+                "object.shortName",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ClearingMemberCategoryHistory, ClearingMemberCategoryHistory.class));
+                "object.shortNameEng",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_MoneyMarketSecurityHistory, MoneyMarketSecurityHistory.class,
+                "object.uuid",
-                usingIgnoringFieldsComparator( // todo поправить тест для ASecurityHistoryMapStore
+                "object.workflowStatus")));
-                        "object.created", "object.updated",
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_FixedIncomeSecurityHistory, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_FixedIncomeSecurityHistory, FixedIncomeSecurityHistory.class,
-                        "object.fullName", "object.fullNameEng",
+            usingIgnoringFieldsComparator("object.created",
-                        "object.instrumentType",
+                "object.updated",
-                        "object.isin", "object.issuerId",
+                "object.fullName",
-                        "object.lotSize",
+                "object.fullNameEng",
-                        "object.securitySymbol",
+                "object.instrumentType",
-                        "object.shortName", "object.shortNameEng",
+                "object.isin",
-                        "object.uuid", "object.workflowStatus"
+                "object.issuerId",
-                )));
+                "object.lotSize",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_EquitySecurityHistory, EquitySecurityHistory.class,
+                "object.securitySymbol",
-                usingIgnoringFieldsComparator( // todo поправить тест для ASecurityHistoryMapStore
+                "object.shortName",
-                        "object.created", "object.updated",
+                "object.shortNameEng",
-                        "object.fullName", "object.fullNameEng",
+                "object.uuid",
-                        "object.instrumentType",
+                "object.workflowStatus")));
-                        "object.isin", "object.issuerId",
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_FixedIncomeCashFlowHistory, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_FixedIncomeCashFlowHistory, FixedIncomeCashFlowHistory.class,
-                        "object.lotSize",
+            usingIgnoringFieldsComparator("object.accruedCoupon")));
-                        "object.securitySymbol",
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_CouponPeriodHistory, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_CouponPeriodHistory, CouponPeriodHistory.class,
-                        "object.shortName", "object.shortNameEng",
+            usingIgnoringFieldsComparator("object.couponRate")));
-                        "object.uuid", "object.workflowStatus"
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_CurrencyPairSecurityHistory, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_CurrencyPairSecurityHistory, CurrencyPairSecurityHistory.class,
-                )));
+            usingIgnoringFieldsComparator("object.baseUnitSize",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_FixedIncomeSecurityHistory, FixedIncomeSecurityHistory.class,
+                "object.fullName",
-                usingIgnoringFieldsComparator( // todo поправить тест для ASecurityHistoryMapStore
+                "object.fullNameEng",
-                        "object.created", "object.updated",
+                "object.instrumentType",
-                        "object.fullName", "object.fullNameEng",
+                "object.isin",
-                        "object.instrumentType",
+                "object.issuerId",
-                        "object.isin", "object.issuerId",
+                "object.securitySymbol",
-                        "object.lotSize",
+                "object.shortName",
-                        "object.securitySymbol",
+                "object.shortNameEng",
-                        "object.shortName", "object.shortNameEng",
+                "object.uuid",
-                        "object.uuid", "object.workflowStatus"
+                "object.workflowStatus")));
-                )));
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_ExecutionCurrencyHistory, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ExecutionCurrencyHistory, ExecutionCurrencyHistory.class,
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_FixedIncomeCashFlowHistory, FixedIncomeCashFlowHistory.class,
+            usingIgnoringFieldsComparator("object.duration",
-                usingIgnoringFieldsComparator("object.accruedCoupon")
+                "object.interestAmount",
-               /* new SettingOperation("getObject.setAccruedCoupon", new Object[]{new BigDecimal("870.680000000000000000")})*/));
+                "object.lots",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_CouponPeriodHistory, CouponPeriodHistory.class,
+                "object.quantity",
-                usingIgnoringFieldsComparator("object.couponRate")
+                "object.settlementAmount",
-                /* new SettingOperation("getObject.setCouponRate", new Object[]{new BigDecimal("870.680000000000000000")})*/));
+                "object.settlementCurrency")));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_CurrencyPairSecurityHistory, CurrencyPairSecurityHistory.class
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_Company, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_Company, Company.class,
-//                ,new SettingOperation("object.baseUnitSize", new Object[]{new BigDecimal("53.820000000000000000")})
+            usingIgnoringFieldsComparator("profile.clearingCode",
-                ,usingIgnoringFieldsComparator(
+                "profile.fullName",
-                        "object.baseUnitSize",
+                "profile.registrationCode",
-                        "object.fullName", "object.fullNameEng",
+                "profile.shortName",
-                        "object.instrumentType",
+                "profile.tradingCode")));
-                        "object.isin", "object.issuerId",
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_ExecutionFond, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ExecutionFond, ExecutionFond.class,
-                        "object.securitySymbol",
+            new SettingOperation("setInterestAmount", new Object[]{new BigDecimal("850.64")}),
-                        "object.shortName", "object.shortNameEng",
+            new SettingOperation("setLots", new Object[]{new BigDecimal("851.64")}),
-                        "object.uuid", "object.workflowStatus"
+            new SettingOperation("setQuantity", new Object[]{new BigDecimal("852.64")}),
-                )
+            new SettingOperation("setSettlementAmount", new Object[]{new BigDecimal("853.64")})));
-        ));
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_Listing, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_Listing, Listing.class,
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ExecutionCurrencyHistory, ExecutionCurrencyHistory.class));
+            new SettingOperation("setLotSize", new Class[]{BigDecimal.class}, new Object[]{new BigDecimal("21.11")}),
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SettlementHousePropertiesHistory, SettlementHousePropertiesHistory.class));
+            new SettingOperation("setMinStep", new Object[]{new BigDecimal("13.32")}),
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_TradingClearingRegistryListHistory, TradingClearingRegistryListHistory.class));
+            new SettingOperation("setPrecision", new Object[]{new BigDecimal("53.12")})));
-
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_Statement, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_Statement, Statement.class,
-        //business object
+            new SettingOperation("setAmount", new Class[]{BigDecimal.class}, new Object[]{new BigDecimal("23.22")})));
-//        businessObjectAndBusinessEventForCheckMapStores.add(new BusinessObjectAndBusinessEventForCheckMapStore<>(IMDGDistributedNames.Map_AccountBalance, AccountBalance.class));
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_EquitySecurity, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_EquitySecurity, EquitySecurity.class,
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_Account, Account.class));
+            usingIgnoringFieldsComparator("created",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ClearingCalendar, ClearingCalendar.class));
+                "updated",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_Company, Company.class,
+                "fullName",
-                usingIgnoringFieldsComparator("profile.clearingCode", "profile.fullName", "profile.registrationCode", "profile.shortName", "profile.tradingCode")));
+                "fullNameEng",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ErrorText, ErrorText.class));
+                "instrumentType",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ExecutionFond, ExecutionFond.class,
+                "isin",
-                new SettingOperation("setInterestAmount", new Object[]{new BigDecimal("850.64")}),
+                "issuerId",
-                new SettingOperation("setLots", new Object[]{new BigDecimal("851.64")}),
+                "lotSize",
-                new SettingOperation("setQuantity", new Object[]{new BigDecimal("852.64")}),
+                "securitySymbol",
-                new SettingOperation("setSettlementAmount", new Object[]{new BigDecimal("853.64")})));
+                "shortName",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_Launcher, Launcher.class));
+                "shortNameEng",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_Listing, Listing.class,
+                "uuid",
-                new SettingOperation("setLotSize", new Class[]{BigDecimal.class}, new Object[]{new BigDecimal("21.11")}),
+                "workflowStatus")));
-                new SettingOperation("setMinStep", new Object[]{new BigDecimal("13.32")}),
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_FixedIncomeSecurity, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_FixedIncomeSecurity, FixedIncomeSecurity.class,
-                new SettingOperation("setPrecision", new Object[]{new BigDecimal("53.12")})
+            usingIgnoringFieldsComparator("created",
-        ));
+                "updated",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ManagementJournal, ManagementJournal.class));
+                "fullName",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_Market, Market.class));
+                "fullNameEng",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_Planner, Planner.class));
+                "instrumentType",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_PlannerTemplate, PlannerTemplate.class));
+                "isin", "issuerId",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_Relation, Relation.class));
+                "lotSize",
-//        businessObjectAndBusinessEventForCheckMapStores.add(new BusinessObjectAndBusinessEventForCheckMapStore<>(IMDGDistributedNames.Map_Security, Security.class)); // класс наследуется
+                "securitySymbol",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_Statement, Statement.class,
+                "shortName",
-                new SettingOperation("setAmount", new Class[]{BigDecimal.class}, new Object[]{new BigDecimal("23.22")})));
+                "shortNameEng",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_UserConnect, UserConnect.class));
+                "uuid",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_User, User.class));
+                "workflowStatus")));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_EquitySecurity, EquitySecurity.class
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_CurrencyPairSecurity, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_CurrencyPairSecurity, CurrencyPairSecurity.class,
-                , usingIgnoringFieldsComparator( // todo поправить тест для ASecurityMapStore - проблема в заполнении securityId
+            usingIgnoringFieldsComparator(
-                        "created", "updated",
+                "created",
-                        "fullName", "fullNameEng",
+                "updated",
-                        "instrumentType",
+                "fullName",
-                        "isin", "issuerId",
+                "fullNameEng",
-                        "lotSize",
+                "instrumentType",
-                        "securitySymbol",
+                "isin",
-                        "shortName", "shortNameEng",
+                "issuerId",
-                        "uuid", "workflowStatus"
+                "lotSize",
-                )
+                "securitySymbol",
-        ));
+                "shortName",
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_FixedIncomeSecurity, FixedIncomeSecurity.class,
+                "shortNameEng",
-                usingIgnoringFieldsComparator( // todo поправить тест для ASecurityMapStore
+                "uuid",
-                        "created", "updated",
+                "workflowStatus",
-                        "fullName", "fullNameEng",
+                "baseUnitSize")));
-                        "instrumentType",
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_ContractRegister, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ContractRegister, ContractRegister.class,
-                        "isin", "issuerId",
+            new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-                        "lotSize",
+            new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)})));
-                        "securitySymbol",
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_AdmittedLiabilitiesRegister, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_AdmittedLiabilitiesRegister, AdmittedLiabilitiesRegister.class,
-                        "shortName", "shortNameEng",
+            new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-                        "uuid", "workflowStatus"
+            new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)})));
-                )));
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_CoveredLiabilitiesRegister, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_CoveredLiabilitiesRegister, CoveredLiabilitiesRegister.class,
-
+            new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-        //dictionary
+            new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)})));
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_AccountTypeDictionary, AccountTypeDictionary.class));
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_DepoBalanceRegister, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_DepoBalanceRegister, DepoBalanceRegister.class,
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_AllowedDictionary, AllowedDictionary.class));
+            new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_ClearingCategoryDictionary, ClearingCategoryDictionary.class));
+            new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_CompanyRoleDictionary, CompanyRoleDictionary.class));
+            new SettingOperation("setQuantity", new Object[]{BigDecimal.valueOf(73.32)})));
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_CompanySymbolDictionary, CompanySymbolDictionary.class));
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_DepoPaymentInstructionRegister, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_DepoPaymentInstructionRegister, DepoPaymentInstructionRegister.class,
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_ConnectionStateDictionary, ConnectionStateDictionary.class));
+            new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_ContactTypeDictionary, ContactTypeDictionary.class));
+            new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_CorporationSoleTypeDictionary, CorporationSoleTypeDictionary.class));
+            new SettingOperation("setQuantity", new Object[]{BigDecimal.valueOf(73.32)})));
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_CountryCodeDictionary, CountryCodeDictionary.class));
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_ExcludeLiabilitiesRegister, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ExcludeLiabilitiesRegister, ExcludeLiabilitiesRegister.class,
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_CourierTypeDictionary, CourierTypeDictionary.class));
+            new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_CurrencyCodeDictionary, CurrencyCodeDictionary.class));
+            new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)})));
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_CurrencyPairDictionary, CurrencyPairDictionary.class));
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_ExecutionRegister, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ExecutionRegister, ExecutionRegister.class,
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_CurrencySettlementTypeDictionary, CurrencySettlementTypeDictionary.class));
+            new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_DayStatusDictionary, DayStatusDictionary.class));
+            new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_DocumentTypeDictionary, DocumentTypeDictionary.class));
+            new SettingOperation("setQuantity", new Object[]{BigDecimal.valueOf(73.32)}),
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_GatewayResultStatusDictionary, GatewayResultStatusDictionary.class));
+            new SettingOperation("setAmount", new Object[]{BigDecimal.valueOf(45.32)})));
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_ErrorCodeDictionary, ErrorCodeDictionary.class));
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_LiabilitiesRegister, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_LiabilitiesRegister, LiabilitiesRegister.class,
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_EventTypeDictionary, EventTypeDictionary.class));
+            new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_InOutDirectionDictionary, InOutDirectionDictionary.class));
+            new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)})));
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_InOutSDfTypeDictionary, InOutSDfTypeDictionary.class));
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_MoneyBalanceRegister, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_MoneyBalanceRegister, MoneyBalanceRegister.class,
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_InstrumentTypeDictionary, InstrumentTypeDictionary.class));
+            new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_LegalKindDictionary, LegalKindDictionary.class));
+            new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)})));
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_ManagementJournalPurposeDictionary, ManagementJournalPurposeDictionary.class));
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_MoneyPaymentInstructionRegister, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_MoneyPaymentInstructionRegister, MoneyPaymentInstructionRegister.class,
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_ManagementJournalStatusDictionary, ManagementJournalStatusDictionary.class));
+            new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_ManagementJournalTypeDictionary, ManagementJournalTypeDictionary.class));
+            new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)})));
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_MarketTypeDictionary, MarketTypeDictionary.class));
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_ExecutionDeposit, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ExecutionDeposit, ExecutionDeposit.class,
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_MajorSignDictionary, MajorSignDictionary.class));
+            new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_MoneyFlowSideDictionary, MoneyFlowSideDictionary.class));
+            new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_MarketCodeDictionary, MarketCodeDictionary.class));
+            new SettingOperation("setFirstLegAmount", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)}),
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_NotificationStatusDictionary, NotificationStatusDictionary.class));
+            new SettingOperation("setSecondLegAmount", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)}),
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_OperationStatusDictionary, OperationStatusDictionary.class));
+            new SettingOperation("setInterestAmount", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)}),
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_OperationTypeDictionary, OperationTypeDictionary.class));
+            new SettingOperation("setLots", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)}),
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_OrganizationTypeDictionary, OrganizationTypeDictionary.class));
+            new SettingOperation("setQuantity", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)})));
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_ObjectTypeDictionary, ObjectTypeDictionary.class));
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_ExecutionCurrency, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ExecutionCurrency, ExecutionCurrency.class,
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_ParentDictionary, ParentDictionary.class));
+            usingIgnoringFieldsComparator("duration",
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_ResultStatusDictionary, ResultStatusDictionary.class));
+                "interestAmount",
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_PriorityDictionary, PriorityDictionary.class));
+                "lots",
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_SessionStatusDictionary, SessionStatusDictionary.class));
+                "quantity",
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_SessionTypeDictionary, SessionTypeDictionary.class));
+                "settlementAmount",
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_ServiceDictionary, ServiceDictionary.class));
+                "settlementCurrency")));
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_ServiceProductDictionary, ServiceProductDictionary.class));
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_InDocumentJournal, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_InDocumentJournal, InDocumentJournal.class,
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_ServiceStatusDictionary, ServiceStatusDictionary.class));
+            new SettingOperation("setAmount", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)})));
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_StatementTypeDictionary, StatementTypeDictionary.class));
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_MoneyMarketSecurity, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_MoneyMarketSecurity, MoneyMarketSecurity.class,
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_SideDictionary, SideDictionary.class));
+            usingIgnoringFieldsComparator("created",
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_TaskDictionary, TaskDictionary.class));
+                "updated",
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_TaskStatusDictionary, TaskStatusDictionary.class));
+                "fullName",
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_TermTypeDictionary, TermTypeDictionary.class));
+                "fullNameEng",
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_TransactionStatusDictionary, TransactionStatusDictionary.class));
+                "instrumentType",
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_UserRoleDictionary, UserRoleDictionary.class));
+                "isin",
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_WorkflowStatusDictionary, WorkflowStatusDictionary.class));
+                "issuerId",
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_SectionDictionary, SectionDictionary.class));
+                "lotSize",
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_ShareTypeDictionary, ShareTypeDictionary.class));
+                "securitySymbol",
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_BondTypeDictionary, BondTypeDictionary.class));
+                "shortName",
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_TradingClearingRegistryTypeDictionary, TradingClearingRegistryTypeDictionary.class));
+                "shortNameEng",
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_TradingClearingRegistryLevelDictionary, TradingClearingRegistryLevelDictionary.class));
+                "uuid",
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_TradingClearingRegistryPurposeDictionary, TradingClearingRegistryPurposeDictionary.class));
+                "workflowStatus",
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_RegistryDesignationDictionary, RegistryDesignationDictionary.class));
+                "nominalValue")));
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_RegistryInstrumentTypeDictionary, RegistryInstrumentTypeDictionary.class));
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_OutDocumentJournal, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_OutDocumentJournal, OutDocumentJournal.class,
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_RegistryCapacityDictionary, RegistryCapacityDictionary.class));
+            new SettingOperation("setAmount", new Class[]{BigDecimal.class}, new Object[]{new BigDecimal("28.28")})));
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_RegistryUnitDictionary, RegistryUnitDictionary.class));
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_ReportRegister, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ReportRegister, ReportRegister.class,
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_RegistryCodeDictionary, RegistryCodeDictionary.class));
+            new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_RegistryStatusDictionary, RegistryStatusDictionary.class));
+            new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)})));
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_BalanceDimensionDictionary, BalanceDimensionDictionary.class));
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_STrades, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_STrades, STrades.class,
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_DepoAccountTypeDictionary, DepoAccountTypeDictionary.class));
+            new SettingOperation("setQty", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)}),
-        checkerDictionaryMapStores.add(new CheckerDictionaryMapStore<>(IMDGDistributedNames.Map_ClearingAccountTypeDictionary, ClearingAccountTypeDictionary.class));
+            new SettingOperation("setValue", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)}),
-
+            new SettingOperation("setExchangeCommission", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(18)}),
-        //object
+            new SettingOperation("setQty", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(18)}),
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_BankAccount, BankAccount.class));
+            new SettingOperation("setValue", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(18)})));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ClearingMemberCategory, ClearingMemberCategory.class));
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_VerificationResult, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_VerificationResult, VerificationResult.class,
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_CompanyRoleSet, CompanyRoleSet.class));
+            new SettingOperation("setDiffSum", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)}),
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class));
+            new SettingOperation("setInSum", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)}),
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_Contact, Contact.class));
+            new SettingOperation("setOutExtSum", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)}),
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_CurrencyPairSecurity, CurrencyPairSecurity.class,
+            new SettingOperation("setOutIntSum", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)})));
-                usingIgnoringFieldsComparator( // todo поправить тест для ASecurityHistoryMapStore
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_FixedIncomeCashFlow, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_FixedIncomeCashFlow, FixedIncomeCashFlow.class,
-                        "created", "updated",
+            new SettingOperation("setAccruedCoupon", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)})));
-                        "fullName", "fullNameEng",
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_CouponPeriod, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_CouponPeriod, CouponPeriod.class,
-                        "instrumentType",
+            new SettingOperation("setCouponRate", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)})));
-                        "isin", "issuerId",
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_SDf54, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf54, SDf54.class,
-                        "lotSize",
+            new SettingOperation("setSeg_type", new Object[]{"S"}),
-                        "securitySymbol",
+            new SettingOperation("setDoc_result", new Object[]{"DR"}),
-                        "shortName", "shortNameEng",
+            new SettingOperation("setOp_type", new Object[]{"OT"}),
-                        "uuid", "workflowStatus",
+            new SettingOperation("setOp_order", new Object[]{"A"})));
-
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_SDf55, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf55, SDf55.class,
-                        "baseUnitSize" // только по точности не совпадает поле, но читается  23.52
+            new SettingOperation("setSeg_type", new Object[]{"S"}),
-                )));
+            new SettingOperation("setDoc_result", new Object[]{"DR"}),
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ContractRegister, ContractRegister.class,
+            new SettingOperation("setOp_type", new Object[]{"OT"}),
-                new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
+            new SettingOperation("setOp_order", new Object[]{"A"})));
-                new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)})));
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_SDf57, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf57, SDf57.class,
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_AdmittedLiabilitiesRegister, AdmittedLiabilitiesRegister.class,
+            new SettingOperation("setOp_type", new Object[]{"OT"})));
-                new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
+        checkerBusinessMapStores.put(IMDGDistributedNames.Map_TradedMoneyMarketSecurity, new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_TradedMoneyMarketSecurity, TradedMoneyMarketSecurity.class,
-                new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)})));
+            usingIgnoringFieldsComparator("shortName")));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_CoveredLiabilitiesRegister, CoveredLiabilitiesRegister.class,
-                new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-                new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)})));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_DepoBalanceRegister, DepoBalanceRegister.class,
-                new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-                new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-                new SettingOperation("setQuantity", new Object[]{BigDecimal.valueOf(73.32)})));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_DepoPaymentInstructionRegister, DepoPaymentInstructionRegister.class,
-                new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-                new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-                new SettingOperation("setQuantity", new Object[]{BigDecimal.valueOf(73.32)})));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ExcludeLiabilitiesRegister, ExcludeLiabilitiesRegister.class,
-                new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-                new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)})));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ExecutionRegister, ExecutionRegister.class,
-                new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-                new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-                new SettingOperation("setQuantity", new Object[]{BigDecimal.valueOf(73.32)}),
-                new SettingOperation("setAmount", new Object[]{BigDecimal.valueOf(45.32)})));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_LiabilitiesRegister, LiabilitiesRegister.class,
-                new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-                new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)})));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_MoneyBalanceRegister, MoneyBalanceRegister.class,
-                new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-                new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)})));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_MoneyPaymentInstructionRegister, MoneyPaymentInstructionRegister.class,
-                new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-                new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)})));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_GatewayResult, GatewayResult.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_Currency, Currency.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ExecutionDeposit, ExecutionDeposit.class,
-                new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-                new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-                new SettingOperation("setFirstLegAmount", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)}),
-                new SettingOperation("setSecondLegAmount", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)}),
-                new SettingOperation("setInterestAmount", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)}),
-                new SettingOperation("setLots", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)}),
-                new SettingOperation("setQuantity", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)})));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ExecutionCurrency, ExecutionCurrency.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_InDocumentJournal, InDocumentJournal.class,
-                new SettingOperation("setAmount", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)})));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_InformationAccount, InformationAccount.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_MoneyMarketSecurity, MoneyMarketSecurity.class,
-                usingIgnoringFieldsComparator( // todo поправить тест для ASecurityHistoryMapStore
-                        "created", "updated",
-                        "fullName", "fullNameEng",
-                        "instrumentType",
-                        "isin", "issuerId",
-                        "lotSize",
-                        "securitySymbol",
-                        "shortName", "shortNameEng",
-                        "uuid", "workflowStatus",
-
-                        "nominalValue" // только по точности не совпадает поле, но читается
-                )//,
-                //new SettingOperation("setNominalValue", new Class[]{BigDecimal.class}, new Object[]{new BigDecimal("25.25")})
-        ));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_MarketDataLiquidation, MarketDataLiquidation.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_Notification, Notification.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_OutDocumentJournal, OutDocumentJournal.class,
-                new SettingOperation("setAmount", new Class[]{BigDecimal.class}, new Object[]{new BigDecimal("28.28")})));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_Operation, Operation.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_PaymentInstruction, PaymentInstruction.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_PlannerAllToday, PlannerAllToday.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ProfileDocument, ProfileDocument.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_PairSdf, PairSdf.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_ReportRegister, ReportRegister.class,
-                new SettingOperation("setCreated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)}),
-                new SettingOperation("setUpdated", new Class[]{Instant.class}, new Object[]{generatingRandomInstant(true)})));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf01, SDf01.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf02, SDf02.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf03, SDf03.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf04, SDf04.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf05, SDf05.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf06, SDf06.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf07, SDf07.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf08, SDf08.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf09, SDf09.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf10, SDf10.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf11, SDf11.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf12, SDf12.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf13, SDf13.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf14, SDf14.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf20, SDf20.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf21, SDf21.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SettlementHouseProperties, SettlementHouseProperties.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_Session, Session.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_STrades, STrades.class,
-                new SettingOperation("setQty", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)}),
-                new SettingOperation("setValue", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)}),
-                new SettingOperation("setExchangeCommission", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(18)}),
-                new SettingOperation("setQty", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(18)}),
-                new SettingOperation("setValue", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(18)})
-        ));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_TradingClearingRegistryList, TradingClearingRegistryList.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_UserRoleSession, UserRoleSession.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_UserSettings, UserSettings.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_VerificationResult, VerificationResult.class,
-                new SettingOperation("setDiffSum", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)}),
-                new SettingOperation("setInSum", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)}),
-                new SettingOperation("setOutExtSum", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)}),
-                new SettingOperation("setOutIntSum", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)})));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_FixedIncomeCashFlow, FixedIncomeCashFlow.class,
-                new SettingOperation("setAccruedCoupon", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)})
-        ));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_CouponPeriod, CouponPeriod.class,
-                new SettingOperation("setCouponRate", new Class[]{BigDecimal.class}, new Object[]{generatingRandomBigDecimal(2)})
-        ));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf51, SDf51.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf52, SDf52.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf53, SDf53.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf54, SDf54.class,
-                new SettingOperation("setSeg_type", new Object[]{"S"}),
-                new SettingOperation("setDoc_result", new Object[]{"DR"}),
-                new SettingOperation("setOp_type", new Object[]{"OT"}),
-                new SettingOperation("setOp_order", new Object[]{"A"})
-        ));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf55, SDf55.class,
-                new SettingOperation("setSeg_type", new Object[]{"S"}),
-                new SettingOperation("setDoc_result", new Object[]{"DR"}),
-                new SettingOperation("setOp_type", new Object[]{"OT"}),
-                new SettingOperation("setOp_order", new Object[]{"A"})
-        ));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf56, SDf56.class));
-        checkerBusinessMapStores.add(new CheckerBusinessMapStore<>(IMDGDistributedNames.Map_SDf57, SDf57.class,
-                new SettingOperation("setOp_type", new Object[]{"OT"})
-        ));
-
     }
 }