http://jira.mfd.msk:8088/browse/CLS-765

clearing-parent/lim-exporter/src/main/java/ru/spcex/clearing/lim/exporter/services/CurrencyExporterService.java

@@ -1,31 +1,35 @@
 package ru.spcex.clearing.lim.exporter.services;
 
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.function.BiFunction;
+import java.util.function.Function;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 import ru.clearing.classes.statics.data.registry.Registry;
 import ru.spcex.clearing.lim.exporter.config.LimFormat;
 import ru.spcex.clearing.lim.exporter.config.SFTPConfig;
 import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
 import ru.spcex.platform.enumeration.RegistryStatus;
+import static ru.spcex.platform.enumeration.RegistryTradingParams.*;
 import ru.spcex.platform.enumeration.Section;
 import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
 import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
 import ru.spcex.platform.imdg.api.predicate.specific.RegistryCodeSqlBuilder;
 
-import java.math.BigDecimal;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.util.function.Function;
-
-import static ru.spcex.platform.enumeration.RegistryTradingParams.*;
-
 @Service
 public class CurrencyExporterService extends AbstractExporterService {
     private final Logger log = LoggerFactory.getLogger(getClass());
 
+    @Value("${export-lim.include-ck}")
+    private Boolean includeCK;
+
     public CurrencyExporterService(SFTPConfig.LimGateway gateway,
                                    KafkaSender kafkaSender,
                                    ImdgProvider imdgProvider) {
@@ -56,23 +60,79 @@ public class CurrencyExporterService extends AbstractExporterService {
                 pb.equals("tradingClearingRegistry", registry.getTradingClearingRegistry()),
                 pb.equals("securityId", registry.getSecurityId())
         );
+        BiFunction<Registry, LocalDate, ImdgPredicate> prdctOM_T = (registry, date) -> pb.and(
+            pb.sql(RegistryCodeSqlBuilder.getInstance(OM_T).build()),
+            pb.in("registryStatus", RegistryStatus.PROC.getKey(), RegistryStatus.MNG.getKey()),
+            pb.equals("tradingClearingRegistry", registry.getTradingClearingRegistry()),
+            pb.equals("securityId", registry.getSecurityId()),
+            pb.equals("settlementDate", date)
+        );
+        BiFunction<Registry, LocalDate, ImdgPredicate> prdctTM_T = (registry, date) -> pb.and(
+            pb.sql(RegistryCodeSqlBuilder.getInstance(TM_T).build()),
+            pb.in("registryStatus", RegistryStatus.PROC.getKey(), RegistryStatus.MNG.getKey()),
+            pb.equals("tradingClearingRegistry", registry.getTradingClearingRegistry()),
+            pb.equals("securityId", registry.getSecurityId()),
+            pb.equals("settlementDate", date)
+        );
         for (Registry registry : registriesA) {
             if (checkNotBlocked(registry)) {
-                BigDecimal sumPositive = BigDecimal.ZERO;
+                BigDecimal dmtSumElement = BigDecimal.ZERO;
+                BigDecimal omtSumElementToday = BigDecimal.ZERO;
+                BigDecimal tmtSumElementToday = BigDecimal.ZERO;
+                BigDecimal omtSumElementTomorrow = BigDecimal.ZERO;
+                BigDecimal tmtSumElementTomorrow = BigDecimal.ZERO;
                 if (registry.getTradingClearingRegistry() != null && registry.getSecurityId() != null) {
-                    ImdgPredicate query = prdctDM_T.apply(registry);
+                    ImdgPredicate queryDM_T = prdctDM_T.apply(registry);
-                    Collection<Registry> regsDMT = registryImdg.getCollectionObjectsByPredicate(query);
+                    Collection<Registry> regsDMT = registryImdg.getCollectionObjectsByPredicate(queryDM_T);
-                    log.trace("Found {} DM_T registries for registry AM_F {}", regsDMT.size(), query);
+                    log.trace("Found {} DM_T registries for registry AM_F {}", regsDMT.size(), queryDM_T);
-                    sumPositive = sumPositive.add(sum(regsDMT));
+                    dmtSumElement = dmtSumElement.add(sum(regsDMT)).negate();
+
+                    if (includeCK) {
+                        ImdgPredicate queryOM_T_today = prdctOM_T.apply(registry, LocalDate.now());
+                        Collection<Registry> regsOMT_today = registryImdg.getCollectionObjectsByPredicate(queryOM_T_today);
+                        log.trace("Found {} OM_T today registries for registry AM_F {}", regsOMT_today.size(), queryOM_T_today);
+                        omtSumElementToday = omtSumElementToday.add(sum(regsOMT_today)).negate();
+
+                        ImdgPredicate queryTM_T_today = prdctTM_T.apply(registry, LocalDate.now());
+                        Collection<Registry> regsTMT_today = registryImdg.getCollectionObjectsByPredicate(queryTM_T_today);
+                        log.trace("Found {} TM_T today registries for registry AM_F {}", regsTMT_today.size(), queryTM_T_today);
+                        tmtSumElementToday = tmtSumElementToday.add(sum(regsTMT_today));
+
+                        ImdgPredicate queryOM_T_tomorrow = prdctOM_T.apply(registry, LocalDate.now().plusDays(1));
+                        Collection<Registry> regsOMT_tomorrow = registryImdg.getCollectionObjectsByPredicate(queryOM_T_tomorrow);
+                        log.trace("Found {} OM_T tomorrow registries for registry AM_F {}", regsOMT_tomorrow.size(), queryOM_T_tomorrow);
+                        omtSumElementTomorrow = omtSumElementTomorrow.add(sum(regsOMT_tomorrow)).negate();
+
+                        ImdgPredicate queryTM_T_tomorrow = prdctTM_T.apply(registry, LocalDate.now().plusDays(1));
+                        Collection<Registry> regsTMT_tomorrow = registryImdg.getCollectionObjectsByPredicate(queryTM_T_tomorrow);
+                        log.trace("Found {} TM_T tomorrow registries for registry AM_F {}", regsTMT_tomorrow.size(), queryTM_T_tomorrow);
+                        tmtSumElementTomorrow = tmtSumElementTomorrow.add(sum(regsTMT_tomorrow));
+                    }
                 }
-                limFileRows.add(getRow(registry, sumPositive));
+                limFileRows.add(
+                    getRow(registry,
+                        0,
+                        dmtSumElement,
+                        omtSumElementToday,
+                        tmtSumElementToday)
+                );
+                limFileRows.add(
+                    getRow(registry,
+                        1,
+                        dmtSumElement,
+                        omtSumElementToday,
+                        tmtSumElementToday,
+                        omtSumElementTomorrow,
+                        tmtSumElementTomorrow)
+                );
             }
         }
         log.debug("Successfully completed the formation of rows: {} for export currency(money)", limFileRows.size());
         return limFileRows;
     }
 
-    public String getRow(Registry registryA, BigDecimal sumPositive) {
+    public String getRow(Registry registryA, int limitKind, BigDecimal ... sumElements) {
+        assert limitKind == 0 || limitKind == 1;
         StringBuilder row = new StringBuilder();
 
         row.append("MONEY:  FIRM_ID = ");
@@ -87,12 +147,16 @@ public class CurrencyExporterService extends AbstractExporterService {
         row.append(registryA.getTradingClearingRegistry());
 
         row.append("; OPEN_BALANCE = ");
-        BigDecimal balance = registryA.getBalance() != null ? registryA.getBalance().subtract(sumPositive) : BigDecimal.ZERO;
+        BigDecimal balance = registryA.getBalance() != null ? registryA.getBalance() : BigDecimal.ZERO;
+        for (BigDecimal sumElement : sumElements) {
+            if (sumElement == null) continue;
+            balance = balance.add(sumElement);
+        }
         row.append(LimFormat.toStringD2(balance));
 
         row.append("; OPEN_LIMIT = 0.00");
 
-        row.append("; LIMIT_KIND = 0;");
+        row.append("; LIMIT_KIND = %d;".formatted(limitKind));
         return row.toString();
     }
 }

clearing-parent/lim-exporter/src/main/java/ru/spcex/clearing/lim/exporter/services/MoneyExporterService.java

@@ -1,32 +1,35 @@
 package ru.spcex.clearing.lim.exporter.services;
 
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.function.BiFunction;
+import java.util.function.Function;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 import ru.clearing.classes.statics.data.registry.Registry;
 import ru.spcex.clearing.lim.exporter.config.LimFormat;
 import ru.spcex.clearing.lim.exporter.config.SFTPConfig;
 import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
 import ru.spcex.platform.enumeration.RegistryStatus;
+import static ru.spcex.platform.enumeration.RegistryTradingParams.*;
 import ru.spcex.platform.enumeration.Section;
 import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
 import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
 import ru.spcex.platform.imdg.api.predicate.specific.RegistryCodeSqlBuilder;
 
-import java.math.BigDecimal;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.util.function.Function;
-
-import static ru.spcex.platform.enumeration.RegistryTradingParams.AM_F;
-import static ru.spcex.platform.enumeration.RegistryTradingParams.DM_T;
-
 @Service
 public class MoneyExporterService extends AbstractExporterService {
     private final Logger log = LoggerFactory.getLogger(getClass());
 
+    @Value("${export-lim.include-ck}")
+    private Boolean includeCK;
+
     public MoneyExporterService(SFTPConfig.LimGateway gateway,
                                 KafkaSender kafkaSender,
                                 ImdgProvider imdgProvider) {
@@ -57,23 +60,79 @@ public class MoneyExporterService extends AbstractExporterService {
                 pb.equals("tradingClearingRegistry", registry.getTradingClearingRegistry()),
                 pb.equals("securityId", registry.getSecurityId())
         );
+        BiFunction<Registry, LocalDate, ImdgPredicate> prdctOM_T = (registry, date) -> pb.and(
+            pb.sql(RegistryCodeSqlBuilder.getInstance(OM_T).build()),
+            pb.in("registryStatus", RegistryStatus.PROC.getKey(), RegistryStatus.MNG.getKey()),
+            pb.equals("tradingClearingRegistry", registry.getTradingClearingRegistry()),
+            pb.equals("securityId", registry.getSecurityId()),
+            pb.equals("settlementDate", date)
+        );
+        BiFunction<Registry, LocalDate, ImdgPredicate> prdctTM_T = (registry, date) -> pb.and(
+            pb.sql(RegistryCodeSqlBuilder.getInstance(TM_T).build()),
+            pb.in("registryStatus", RegistryStatus.PROC.getKey(), RegistryStatus.MNG.getKey()),
+            pb.equals("tradingClearingRegistry", registry.getTradingClearingRegistry()),
+            pb.equals("securityId", registry.getSecurityId()),
+            pb.equals("settlementDate", date)
+        );
         for (Registry registry : registriesA) {
             if (checkNotBlocked(registry)) {
-                BigDecimal sumPositive = BigDecimal.ZERO;
+                BigDecimal dmtSumElement = BigDecimal.ZERO;
+                BigDecimal omtSumElementToday = BigDecimal.ZERO;
+                BigDecimal tmtSumElementToday = BigDecimal.ZERO;
+                BigDecimal omtSumElementTomorrow = BigDecimal.ZERO;
+                BigDecimal tmtSumElementTomorrow = BigDecimal.ZERO;
                 if (registry.getTradingClearingRegistry() != null && registry.getSecurityId() != null) {
-                    ImdgPredicate query = prdctDM_T.apply(registry);
+                    ImdgPredicate dmtQuery = prdctDM_T.apply(registry);
-                    Collection<Registry> regsDMT = registryImdg.getCollectionObjectsByPredicate(query);
+                    Collection<Registry> regsDMT = registryImdg.getCollectionObjectsByPredicate(dmtQuery);
-                    log.trace("Found {} DM_T registries for registry AM_F {}", regsDMT.size(), query);
+                    log.trace("Found {} DM_T registries for registry AM_F {}", regsDMT.size(), dmtQuery);
-                    sumPositive = sumPositive.add(sum(regsDMT));
+                    dmtSumElement = dmtSumElement.add(sum(regsDMT)).negate();
+
+                    if (includeCK) {
+                        ImdgPredicate queryOM_T_today = prdctOM_T.apply(registry, LocalDate.now());
+                        Collection<Registry> regsOMT_today = registryImdg.getCollectionObjectsByPredicate(queryOM_T_today);
+                        log.trace("Found {} OM_T today registries for registry AM_F {}", regsOMT_today.size(), queryOM_T_today);
+                        omtSumElementToday = omtSumElementToday.add(sum(regsOMT_today)).negate();
+
+                        ImdgPredicate queryTM_T_today = prdctTM_T.apply(registry, LocalDate.now());
+                        Collection<Registry> regsTMT_today = registryImdg.getCollectionObjectsByPredicate(queryTM_T_today);
+                        log.trace("Found {} TM_T today registries for registry AM_F {}", regsTMT_today.size(), queryTM_T_today);
+                        tmtSumElementToday = tmtSumElementToday.add(sum(regsTMT_today));
+
+                        ImdgPredicate queryOM_T_tomorrow = prdctOM_T.apply(registry, LocalDate.now().plusDays(1));
+                        Collection<Registry> regsOMT_tomorrow = registryImdg.getCollectionObjectsByPredicate(queryOM_T_tomorrow);
+                        log.trace("Found {} OM_T tomorrow registries for registry AM_F {}", regsOMT_tomorrow.size(), queryOM_T_tomorrow);
+                        omtSumElementTomorrow = omtSumElementTomorrow.add(sum(regsOMT_tomorrow)).negate();
+
+                        ImdgPredicate queryTM_T_tomorrow = prdctTM_T.apply(registry, LocalDate.now().plusDays(1));
+                        Collection<Registry> regsTMT_tomorrow = registryImdg.getCollectionObjectsByPredicate(queryTM_T_tomorrow);
+                        log.trace("Found {} TM_T tomorrow registries for registry AM_F {}", regsTMT_tomorrow.size(), queryTM_T_tomorrow);
+                        tmtSumElementTomorrow = tmtSumElementTomorrow.add(sum(regsTMT_tomorrow));
+                    }
                 }
-                limFileRows.add(getRow(registry, sumPositive));
+                limFileRows.add(
+                    getRow(registry,
+                        0,
+                        dmtSumElement,
+                        omtSumElementToday,
+                        tmtSumElementToday)
+                );
+                limFileRows.add(
+                    getRow(registry,
+                        1,
+                        dmtSumElement,
+                        omtSumElementToday,
+                        tmtSumElementToday,
+                        omtSumElementTomorrow,
+                        tmtSumElementTomorrow)
+                );
             }
         }
         log.debug("Successfully completed the formation of rows: {} for export money", limFileRows.size());
         return limFileRows;
     }
 
-    public String getRow(Registry registryA, BigDecimal sumPositive) {
+    public String getRow(Registry registryA, int limitKind, BigDecimal ... sumElements) {
+        assert limitKind == 0 || limitKind == 1;
         StringBuilder row = new StringBuilder();
 
         row.append("MONEY:  FIRM_ID = ");
@@ -88,12 +147,16 @@ public class MoneyExporterService extends AbstractExporterService {
         row.append(registryA.getTradingClearingRegistry());
 
         row.append("; OPEN_BALANCE = ");
-        BigDecimal balance = registryA.getBalance() != null ? registryA.getBalance().subtract(sumPositive) : BigDecimal.ZERO;
+        BigDecimal balance = registryA.getBalance() != null ? registryA.getBalance() : BigDecimal.ZERO;
+        for (BigDecimal sumElement : sumElements) {
+            if (sumElement == null) continue;
+            balance = balance.add(sumElement);
+        }
         row.append(LimFormat.toStringD2(balance));
 
         row.append("; OPEN_LIMIT = 0.00");
 
-        row.append("; LIMIT_KIND = 0;");
+        row.append("; LIMIT_KIND = %d;".formatted(limitKind));
         return row.toString();
     }
 }

clearing-parent/lim-exporter/src/main/resources/application.properties

@@ -26,4 +26,6 @@ export-lim-service.kafka-producer.acks=all
 export-lim-service.kafka-producer.retries=0
 export-lim-service.kafka-producer.batch-size=16384
 export-lim-service.kafka-producer.linger-ms=1
-export-lim-service.kafka-producer.buffer-memory=33554432
+export-lim-service.kafka-producer.buffer-memory=33554432
+
+export-lim.include-ck=true

clearing-parent/lim-exporter/src/test/java/ru/spcex/clearing/lim/exporter/AbstractServiceTest.java

@@ -1,5 +1,8 @@
 package ru.spcex.clearing.lim.exporter;
 
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.Objects;
 import org.apache.kafka.clients.producer.Producer;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -12,6 +15,8 @@ import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.service.sender.KafkaSender;
 import ru.spcex.clearing.test.config.ImdgTestConfig;
+import static ru.spcex.clearing.test.config.ImdgTestConfig.currentID;
+import static ru.spcex.clearing.test.config.ImdgTestConfig.waitAvailableImdgProviderAndAddAdminWithDefaultId;
 import ru.spcex.clearing.test.config.KafkaTestConfig;
 import ru.spcex.platform.enumeration.RegistryDesignation;
 import ru.spcex.platform.enumeration.RegistryStatus;
@@ -19,12 +24,6 @@ import ru.spcex.platform.enumeration.RegistryUnit;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
 
-import java.math.BigDecimal;
-import java.time.LocalDate;
-
-import static ru.spcex.clearing.test.config.ImdgTestConfig.currentID;
-import static ru.spcex.clearing.test.config.ImdgTestConfig.waitAvailableImdgProviderAndAddAdminWithDefaultId;
-
 @ExtendWith(SpringExtension.class)
 @ContextConfiguration(classes = {
         ImdgTestConfig.class,
@@ -93,6 +92,32 @@ public abstract class AbstractServiceTest {
         return registry;
     }
 
+    protected Registry getRegistry(String tradingClearingRegistry,
+                                   Long securityId,
+                                   String registryDesignation,
+                                   String registryInstrumentType,
+                                   String registryUnit,
+                                   LocalDate settlementDate,
+                                   BigDecimal balance) {
+        Registry registry = new Registry();
+        registry.setTradingCode("1A12323");
+        registry.setBalance(balance);
+        registry.setTradingClearingRegistry(tradingClearingRegistry);
+        registry.setRegistryDesignation(registryDesignation);
+        registry.setRegistryInstrumentType(registryInstrumentType);
+        registry.setRegistryUnit(registryUnit);
+        registry.setClearingCode(clearingCode(registry));
+        registry.setClearingDate(currentDate);
+        registry.setSettlementDate(currentDate);
+        registry.setSecuritySymbol("RUB");
+        registry.setSecurityId(securityId);
+        registry.setTradingClearingRegistryId(securityId);
+        registry.setCompanyId(securityId);
+        registry.setRegistryStatus(RegistryStatus.PROC.getKey());
+        registry.setSettlementDate(Objects.requireNonNullElseGet(settlementDate, LocalDate::now));
+        return registry;
+    }
+
     protected Registry getRegistryNegativeD(String tradingClearingRegistry, Long securityId, String registryInstrumentType, String registryUnit) {
         Registry registry = getRegistryD(tradingClearingRegistry, securityId, registryInstrumentType, registryUnit);
         registry.setBalance(registry.getBalance().negate());

clearing-parent/lim-exporter/src/test/java/ru/spcex/clearing/lim/exporter/services/MoneyExporterServiceTest.java

@@ -1,21 +1,21 @@
 package ru.spcex.clearing.lim.exporter.services;
 
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.Collection;
+import javax.annotation.PostConstruct;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import org.junit.jupiter.api.Test;
 import ru.clearing.classes.statics.data.registry.Registry;
 import ru.clearing.classes.statics.data.registry.TradingClearingRegistry;
 import ru.spcex.clearing.lim.exporter.AbstractServiceTest;
+import static ru.spcex.clearing.test.TestUtils.clearAllInImdg;
+import ru.spcex.platform.enumeration.RegistryDesignation;
 import ru.spcex.platform.enumeration.RegistryInstrumentType;
 import ru.spcex.platform.enumeration.RegistryUnit;
 import ru.spcex.platform.enumeration.ServiceStatus;
 
-import javax.annotation.PostConstruct;
-import java.math.BigDecimal;
-import java.util.Collection;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static ru.spcex.clearing.test.TestUtils.clearAllInImdg;
-
 class MoneyExporterServiceTest extends AbstractServiceTest {
     @PostConstruct
     public void init() {
@@ -33,14 +33,34 @@ class MoneyExporterServiceTest extends AbstractServiceTest {
         Registry registryD = getRegistryD(tcrFirst, securityIdFirst, RegistryInstrumentType.M.getKey(), RegistryUnit.T.getKey());
         registryImdg.insert(registryA);
         registryImdg.insert(registryD);
-        registryD = getRegistryNegativeD(tcrFirst, securityIdFirst, RegistryInstrumentType.M.getKey(), RegistryUnit.I.getKey());
+        Registry registryD_negate = getRegistryNegativeD(tcrFirst, securityIdFirst, RegistryInstrumentType.M.getKey(), RegistryUnit.I.getKey());
-        registryImdg.insert(registryD);
+        registryImdg.insert(registryD_negate);
         registryA = getRegistryA(tcrSecond, securityIdSecond, RegistryInstrumentType.M.getKey());
         registryD = getRegistryD(tcrSecond, securityIdSecond, RegistryInstrumentType.M.getKey(), RegistryUnit.T.getKey());
         registryImdg.insert(registryA);
         registryImdg.insert(registryD);
-        registryD = getRegistryNegativeD(tcrFirst, securityIdFirst, RegistryInstrumentType.M.getKey(), RegistryUnit.I.getKey());
+        registryD_negate = getRegistryNegativeD(tcrFirst, securityIdFirst, RegistryInstrumentType.M.getKey(), RegistryUnit.I.getKey());
-        registryImdg.insert(registryD);
+        registryImdg.insert(registryD_negate);
+
+        Registry registryO_1 = getRegistry(tcrFirst, securityIdFirst, RegistryDesignation.O.getKey(), RegistryInstrumentType.M.getKey(), RegistryUnit.T.getKey(), LocalDate.now(), BigDecimal.valueOf(5));
+        Registry registryO_2 = getRegistry(tcrFirst, securityIdFirst, RegistryDesignation.O.getKey(), RegistryInstrumentType.M.getKey(), RegistryUnit.T.getKey(), LocalDate.now().plusDays(1), BigDecimal.valueOf(10));
+        registryImdg.insert(registryO_1);
+        registryImdg.insert(registryO_2);
+
+        Registry registryT_1 = getRegistry(tcrFirst, securityIdFirst, RegistryDesignation.T.getKey(), RegistryInstrumentType.M.getKey(), RegistryUnit.T.getKey(), LocalDate.now(), BigDecimal.valueOf(5));
+        Registry registryT_2 = getRegistry(tcrFirst, securityIdFirst, RegistryDesignation.T.getKey(), RegistryInstrumentType.M.getKey(), RegistryUnit.T.getKey(), LocalDate.now().plusDays(1), BigDecimal.valueOf(10));
+        registryImdg.insert(registryT_1);
+        registryImdg.insert(registryT_2);
+
+        registryO_1 = getRegistry(tcrSecond, securityIdSecond, RegistryDesignation.O.getKey(), RegistryInstrumentType.M.getKey(), RegistryUnit.T.getKey(), LocalDate.now(), BigDecimal.valueOf(5));
+        registryO_2 = getRegistry(tcrSecond, securityIdSecond, RegistryDesignation.O.getKey(), RegistryInstrumentType.M.getKey(), RegistryUnit.T.getKey(), LocalDate.now().plusDays(1), BigDecimal.valueOf(10));
+        registryImdg.insert(registryO_1);
+        registryImdg.insert(registryO_2);
+
+        registryT_1 = getRegistry(tcrSecond, securityIdSecond, RegistryDesignation.T.getKey(), RegistryInstrumentType.M.getKey(), RegistryUnit.T.getKey(), LocalDate.now(), BigDecimal.valueOf(5));
+        registryT_2 = getRegistry(tcrSecond, securityIdSecond, RegistryDesignation.T.getKey(), RegistryInstrumentType.M.getKey(), RegistryUnit.T.getKey(), LocalDate.now().plusDays(1), BigDecimal.valueOf(10));
+        registryImdg.insert(registryT_1);
+        registryImdg.insert(registryT_2);
 
 
         MoneyExporterService moneyExporterService = new MoneyExporterService(null, kafkaSender, imdgProvider);
@@ -55,7 +75,18 @@ class MoneyExporterServiceTest extends AbstractServiceTest {
         tradingClearingRegistryImdg.insert(tradingClearingRegistry);
 
         limFileRows = moneyExporterService.getLimFileRows();
-        assertEquals(2, limFileRows.size());
+        assertEquals(4, limFileRows.size());
-        assertTrue(limFileRows.contains(moneyExporterService.getRow(registryA, new BigDecimal("5.00"))));
+        assertTrue(limFileRows.contains(moneyExporterService.getRow(registryA,
+            0,
+            registryD.getBalance().negate(),
+            registryO_1.getBalance().negate(),
+            registryT_1.getBalance())));
+        assertTrue(limFileRows.contains(moneyExporterService.getRow(registryA,
+            1,
+            registryD.getBalance().negate(),
+            registryO_1.getBalance().negate(),
+            registryT_1.getBalance(),
+            registryO_2.getBalance().negate(),
+            registryT_2.getBalance())));
     }
 }