registry-service http://jira.mfd.msk:8088/browse/CLS-280 сверка с ТЗ

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

@@ -99,18 +99,22 @@ public class ExcludeLiabilitiesRegisterService extends QueueConsumer implements
         ExcludeLiabilitiesRegister excludeLiabilitiesRegister = new ExcludeLiabilitiesRegister();
         //hz communicating
         Session sessionBySessionId = sessionMap.getSingleObjectByID(registry.getSessionId());
-        LocalDate validToDate = TimeUtil.toLocalDate(sessionBySessionId.getUpdated());
+        Map<String, ? extends Comparable<?>> innPredicates = Map.of(
-        Map<String, ? extends Comparable<?>> innPredicates = Map.of("companySymbol", CompanySymbol.INN.getKey(),
+                "companySymbol", CompanySymbol.INN.getKey(),
-                "companyId", registry.getCompanyId());
+                "companyId", registry.getCompanyId()
+        );
         ru.clearing.classes.statics.data.company.CompanySymbols companySymbol = companySymbolMap.getFirstObjectByFieldValues(innPredicates);
         Security security = securitySelector.selectSecurityById(registry.getSecurityId());
 
         excludeLiabilitiesRegister.setSessionId(registry.getSessionId());
         excludeLiabilitiesRegister.setValidFromDate(sessionBySessionId.getClearingDate());
+        LocalDate validToDate = TimeUtil.toLocalDate(sessionBySessionId.getUpdated());
         excludeLiabilitiesRegister.setValidToDate(validToDate);
         excludeLiabilitiesRegister.setCompanyId(registry.getCompanyId());
         excludeLiabilitiesRegister.setCompanyFullName(registry.getFullName());
-        excludeLiabilitiesRegister.setInn(companySymbol.getCompanySymbolValue());
+        if (companySymbol != null) {
+            excludeLiabilitiesRegister.setInn(companySymbol.getCompanySymbolValue());
+        }
         excludeLiabilitiesRegister.setRegistryCode(registry.getRegistryCode());
         excludeLiabilitiesRegister.setAccount(registry.getAccount());
         excludeLiabilitiesRegister.setRegistryStatus(registry.getRegistryStatus());
@@ -130,12 +134,12 @@ public class ExcludeLiabilitiesRegisterService extends QueueConsumer implements
         excludeLiabilitiesRegister.setSumLiabilities(registry.getBalance());
         excludeLiabilitiesRegister.setSettlementDate(registry.getSettlementDate());
         excludeLiabilitiesRegister.setCreated(Instant.now());
-        excludeLiabilitiesRegister.setUpdated(Instant.now());
+        excludeLiabilitiesRegister.setUpdated(excludeLiabilitiesRegister.getCreated());
         excludeLiabilitiesRegisterMap.insert(excludeLiabilitiesRegister);
         log.debug("inserted successfully ExcludeLiabilitiesRegister entity with id: {}", excludeLiabilitiesRegister.getId());
     }
 
-    private String getSqlForRegistries() {
+    protected String getSqlForRegistries() {
         return String.format("registryDesignation = '%s' and " +
                         "registryInstrumentType  in ('%s','%s') and " +
                         "registryUnit = '%s' and " +

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

@@ -8,10 +8,12 @@ import org.springframework.beans.factory.InitializingBean;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import ru.clearing.classes.statics.data.company.CompanySymbols;
+import ru.clearing.classes.statics.data.instrument.issue.FixedIncomeSecurity;
 import ru.clearing.classes.statics.data.misc.Session;
 import ru.clearing.classes.statics.data.register.LiabilitiesRegister;
 import ru.clearing.classes.statics.data.registry.Registry;
 import ru.clearing.classes.statics.data.security.MoneyMarketSecurity;
+import ru.clearing.classes.statics.data.security.Security;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
 import ru.spcex.clearing.platform.messaging.domain.Consts;
@@ -19,16 +21,15 @@ import ru.spcex.clearing.platform.messaging.domain.cud.registry.LiabilitiesRegis
 import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest;
 import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
 import ru.spcex.clearing.registry.util.PreClearMap;
-import ru.spcex.platform.enumeration.CompanySymbol;
+import ru.spcex.platform.enumeration.*;
-import ru.spcex.platform.enumeration.RegistryDesignation;
-import ru.spcex.platform.enumeration.RegistryInstrumentType;
-import ru.spcex.platform.enumeration.RegistryUnit;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.imdg.api.predicate.specific.SecuritySelector;
 import ru.spcex.platform.utils.time.TimeUtil;
 import ru.spcex.platform.utils.validation.IValidator;
 
 import java.time.Instant;
+import java.time.LocalDate;
 import java.util.Collection;
 import java.util.Map;
 import java.util.Optional;
@@ -44,7 +45,7 @@ public class LiabilitiesRegisterService extends QueueConsumer implements Initial
     private final Imdg<Registry> registryMap;
     private final Imdg<Session> sessionMap;
     private final Imdg<CompanySymbols> companySymbolsMap;
-    private final Imdg<MoneyMarketSecurity> moneyMarketSecurityMap;
+    private final SecuritySelector<Security> securitySelector;
     private final Function<Map<String, ?>, IValidator> fieldValuesValidator;
     private final PreClearMap<LiabilitiesRegister> preClearMap;
 
@@ -58,7 +59,7 @@ public class LiabilitiesRegisterService extends QueueConsumer implements Initial
         this.registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
         this.sessionMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Session, Session.class);
         this.companySymbolsMap = imdgProvider.getImdg(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class);
-        this.moneyMarketSecurityMap = imdgProvider.getImdg(IMDGDistributedNames.Map_MoneyMarketSecurity, MoneyMarketSecurity.class);
+        this.securitySelector = new SecuritySelector<>(imdgProvider, Security.class);
         this.fieldValuesValidator = fieldValuesValidator;
         preClearMap = PreClearMap.instanceForInstantField(liabilitiesRegisterMap, "created");
     }
@@ -93,23 +94,13 @@ public class LiabilitiesRegisterService extends QueueConsumer implements Initial
     private void insertLiabilitiesRegister(Registry registry) {
         log.trace("Started generating LiabilitiesRegister entity...");
         LiabilitiesRegister liabilitiesRegister = new LiabilitiesRegister();
-        Session session = sessionMap.getFirstObjectByFieldValues(
+        Session session = sessionMap.getSingleObjectByID(registry.getSessionId());
-                Map.of(
-                        "id",
-                        registry.getCompanyId()
-                )
-        );
         CompanySymbols companySymbols = companySymbolsMap.getFirstObjectByFieldValues(
                 Map.of("companyId", registry.getCompanyId(),
                         "companySymbol", CompanySymbol.INN.getKey()
                 )
         );
-        MoneyMarketSecurity moneyMarketSecurity = moneyMarketSecurityMap.getFirstObjectByFieldValues(
+        Security security = securitySelector.selectSecurityById(registry.getSecurityId());
-                Map.of(
-                        "securityId",
-                        registry.getSecurityId()
-                )
-        );
         if (session == null) {
             log.warn("Session is empty!");
         } else {
@@ -117,16 +108,27 @@ public class LiabilitiesRegisterService extends QueueConsumer implements Initial
             liabilitiesRegister.setValidToDate(TimeUtil.toLocalDate(session.getUpdated()));
         }
         if (companySymbols == null) {
-            log.warn("CompanySymbols is empty! For companyId={}", registry.getCompanyId());
+            log.warn("CompanySymbols not found, for companyId={}", registry.getCompanyId());
         } else {
             liabilitiesRegister.setInn(companySymbols.getCompanySymbolValue());
         }
-        if (moneyMarketSecurity == null) {
+        if (security == null) {
-            log.warn("MoneyMarketSecurity is empty!");
+            log.warn("Security id={} not found for registry id={}", registry.getSecurityId(), registry.getId());
         } else {
-            liabilitiesRegister.setCurrency(moneyMarketSecurity.getNominalCurrency());
+            if (InstrumentType.RATE.equalsByKey(security.getInstrumentType())) {
+                liabilitiesRegister.setCurrency(((MoneyMarketSecurity) security).getNominalCurrency());
+            } else if (InstrumentType.BOND.equalsByKey(security.getInstrumentType())) {
+                liabilitiesRegister.setCurrency(((FixedIncomeSecurity) security).getNominalCurrency());
+            } else if (InstrumentType.EQTY.equalsByKey(security.getInstrumentType())) {
+                // не заполняется Currency
+            } else { // never
+                log.warn("Unexpected security[{}] type {}", security.getId(), security.getInstrumentType());
+            }
         }
         liabilitiesRegister.setSessionId(registry.getSessionId());
+        liabilitiesRegister.setValidFromDate(session.getClearingDate());
+        LocalDate validToDate = TimeUtil.toLocalDate(session.getUpdated());
+        liabilitiesRegister.setValidToDate(validToDate);
         liabilitiesRegister.setCompanyId(registry.getCompanyId());
         liabilitiesRegister.setCompanyFullName(registry.getFullName());
         liabilitiesRegister.setRegistryCode(registry.getRegistryCode());
@@ -135,12 +137,12 @@ public class LiabilitiesRegisterService extends QueueConsumer implements Initial
         liabilitiesRegister.setSumLiabilities(registry.getBalance());
         liabilitiesRegister.setSettlementDate(registry.getSettlementDate());
         liabilitiesRegister.setCreated(Instant.now());
-        liabilitiesRegister.setUpdated(Instant.now());
+        liabilitiesRegister.setUpdated(liabilitiesRegister.getCreated());
         liabilitiesRegisterMap.insert(liabilitiesRegister);
         log.debug("inserted successfully LiabilitiesRegister entity with id: {}", liabilitiesRegister.getId());
     }
 
-    private String getSqlForRegistries() {
+    protected String getSqlForRegistries() {
         return String.format("registryDesignation = '%s' and " +
                         "registryInstrumentType  in ('%s','%s') and " +
                         "registryUnit = '%s'",

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

@@ -1,5 +1,8 @@
 package ru.spcex.clearing.registry.service;
 
+import org.apache.commons.lang3.tuple.MutablePair;
+import org.apache.commons.lang3.tuple.MutableTriple;
+import org.apache.commons.lang3.tuple.Triple;
 import org.apache.kafka.clients.consumer.Consumer;
 import org.apache.kafka.clients.producer.Producer;
 import org.slf4j.Logger;
@@ -17,8 +20,10 @@ import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
 import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest;
 import ru.spcex.clearing.platform.messaging.service.QueueConsumer;
 import ru.spcex.clearing.registry.util.PreClearMap;
+import ru.spcex.platform.enumeration.AccountType;
 import ru.spcex.platform.enumeration.CompanySymbol;
 import ru.spcex.platform.enumeration.RegistryTradingParams;
+import ru.spcex.platform.enumeration.RegistryUnit;
 import ru.spcex.platform.imdg.api.Imdg;
 import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.imdg.api.predicate.ImdgPredicate;
@@ -27,10 +32,9 @@ import ru.spcex.platform.imdg.api.predicate.specific.RegistryCodeSqlBuilder;
 import ru.spcex.platform.utils.validation.IValidator;
 
 import java.time.Instant;
-import java.util.Collection;
+import java.util.*;
-import java.util.Map;
-import java.util.Optional;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 
 import static ru.spcex.platform.enumeration.Task.createRegistry_GBRR;
 
@@ -69,6 +73,24 @@ public class MoneyBalanceRegisterService extends QueueConsumer implements Initia
         init();
     }
 
+    protected List<List<Registry>> groupingRegistry(Collection<Registry> registries) {
+        Map<MutablePair<Long, Long>, List<Registry>> regGroups = registries.stream().collect(Collectors.groupingBy(
+                (Registry reg) -> new MutablePair(reg.getCompanyId(), reg.getAccountId())
+        ));
+        List<List<Registry>> result = new ArrayList<>(regGroups.values());
+        if (result.size() > 3) {
+            log.warn("Found too many ({}) registries in group: {}", result.size(), result);
+        }
+        return result;
+//        return regGroups.values().stream().map((List<Registry> regLst) -> {
+//            for (Registry r : regLst)
+//                if (RegistryUnit.T.equalsByKey(r.getRegistryUnit())) {
+//                    return r;// приоритетно нужен AM_T
+//                }
+//            return regLst.iterator().next();
+//        }).collect(Collectors.toList());
+    }
+
     public void moneyBalanceRegisterNew(BaseRequest<LauncherCommandRequest> userRequest) {
         log.debug("LauncherCommandRequest received from {}", createRegistry_GBRR.topic());
         ImdgPredicate sqlConditionForRegistry = getSqlForRegistries(userRequest.getRequestPayload().getCompanyId());
@@ -78,22 +100,36 @@ public class MoneyBalanceRegisterService extends QueueConsumer implements Initia
             return;
         }
         log.debug("Select {} Registry by query {}", registries.size(), sqlConditionForRegistry);
+        List<List<Registry>> registerGroups = groupingRegistry(registries);
         preClearMap.preClearMap();
-        registries.forEach((registry -> {
+        registerGroups.forEach((registryItems -> {
-            if (isDuplicateInMap(registry).isEmpty()) {
+//            if (isDuplicateInMap(registry).isEmpty()) {
-                insertMoneyBalanceRegister(registry);
+            insertMoneyBalanceRegister(registryItems);
-            }
+//            }
         }
         ));
         log.debug("successfully processed");
     }
 
-    private void insertMoneyBalanceRegister(Registry registry) {
+    private void insertMoneyBalanceRegister(List<Registry> registryGroup) {
         log.trace("Started generating MoneyBalanceRegister entity...");
         MoneyBalanceRegister moneyBalanceRegister = new MoneyBalanceRegister();
-        Registry registryForRemainderSum = registryMap.getFirstObjectByPredicate(getSqlForRemainderSum(registry.getCompanyId(), registry.getAccount()));
+        Registry registryForRemainderSum = registryGroup.stream()
-        Registry registryForBlockedSum = registryMap.getFirstObjectByPredicate(getSqlForBlockedSum(registry.getCompanyId(), registry.getAccount()));
+                .filter(r -> RegistryUnit.T.equalsByKey(r.getRegistryUnit()))
-        Registry registryForUnblockedSum = registryMap.getFirstObjectByPredicate(getSqlForUnblockedSum(registry.getCompanyId(), registry.getAccount()));
+                .findAny().orElse(null);
+        Registry registryForBlockedSum = registryGroup.stream()
+                .filter(r -> RegistryUnit.B.equalsByKey(r.getRegistryUnit()))
+                .findAny().orElse(null);
+        Registry registryForUnblockedSum = registryGroup.stream()
+                .filter(r -> RegistryUnit.F.equalsByKey(r.getRegistryUnit()))
+                .findAny().orElse(null);
+        Registry registry = registryForRemainderSum;
+        if (registry == null)
+            registry = registryGroup.iterator().next();
+        log.trace("Group of {} registries: T={}; B={}; F={}", registryGroup.size(), registryForRemainderSum, registryForBlockedSum, registryForUnblockedSum);
+//        Registry registryForRemainderSum = registryMap.getFirstObjectByPredicate(getSqlForRemainderSum(registry.getCompanyId(), registry.getAccount()));
+//        Registry registryForBlockedSum = registryMap.getFirstObjectByPredicate(getSqlForBlockedSum(registry.getCompanyId(), registry.getAccount()));
+//        Registry registryForUnblockedSum = registryMap.getFirstObjectByPredicate(getSqlForUnblockedSum(registry.getCompanyId(), registry.getAccount()));
         Company company = companyMap.getFirstObjectByFieldValues(Map.of("id", 2L));
         CompanySymbols companySymbol = companySymbolsMap.getFirstObjectByFieldValues(Map.of("companySymbol", CompanySymbol.INN.getKey(), "companyId", registry.getCompanyId()));
         String setHouseName = company != null ? company.getShortName() : null;
@@ -102,11 +138,11 @@ public class MoneyBalanceRegisterService extends QueueConsumer implements Initia
         String account = null;
         String infoAccount = null;
         if ("CLRN".equalsIgnoreCase(accountType)) {
-            Account accountValue = accountMap.getFirstObjectByFieldValues(Map.of("companyId", registry.getCompanyId(), "accountType", "INFO"));
+            Account accountValue = accountMap.getFirstObjectByFieldValues(Map.of("companyId", registry.getCompanyId(), "accountType", AccountType.Info.getKey()));
             account = registry.getAccount();
             infoAccount = accountValue != null ? accountValue.getAccount() : null;
         } else if ("INFO".equalsIgnoreCase(accountType)) {
-            Account accountValue = accountMap.getFirstObjectByFieldValues(Map.of("companyId", registry.getCompanyId(), "accountType", "CLRN"));
+            Account accountValue = accountMap.getFirstObjectByFieldValues(Map.of("companyId", registry.getCompanyId(), "accountType", AccountType.Clrn.getKey()));
             account = accountValue != null ? accountValue.getAccount() : null;
             infoAccount = registry.getAccount();
         }
@@ -121,12 +157,12 @@ public class MoneyBalanceRegisterService extends QueueConsumer implements Initia
         moneyBalanceRegister.setSessionId(registry.getSessionId());
         moneyBalanceRegister.setCompanyId(registry.getCompanyId());
         moneyBalanceRegister.setCreated(Instant.now());
-        moneyBalanceRegister.setUpdated(Instant.now());
+        moneyBalanceRegister.setUpdated(moneyBalanceRegister.getCreated());
         moneyBalanceRegisterMap.insert(moneyBalanceRegister);
         log.debug("inserted successfully MoneyBalanceRegister entity with id: {}", moneyBalanceRegister.getId());
     }
 
-    private ImdgPredicate getSqlForRegistries(Long companyId) {
+    protected ImdgPredicate getSqlForRegistries(Long companyId) {
         ImdgPredicateBuilder pb = registryMap.predicateBuilder();
         ImdgPredicate prdct;
         if (companyId == null) {
@@ -141,7 +177,7 @@ public class MoneyBalanceRegisterService extends QueueConsumer implements Initia
         return prdct;
     }
 
-    private ImdgPredicate getSqlForRemainderSum(Long companyId, String account) {
+    protected ImdgPredicate getSqlForRemainderSum(Long companyId, String account) {
         ImdgPredicateBuilder pb = registryMap.predicateBuilder();
         ImdgPredicate prdct = pb.and(
                 pb.equals("companyId", companyId),
@@ -152,7 +188,7 @@ public class MoneyBalanceRegisterService extends QueueConsumer implements Initia
         return prdct;
     }
 
-    private ImdgPredicate getSqlForBlockedSum(Long companyId, String account) {
+    protected ImdgPredicate getSqlForBlockedSum(Long companyId, String account) {
         ImdgPredicateBuilder pb = registryMap.predicateBuilder();
         ImdgPredicate prdct = pb.and(
                 pb.equals("companyId", companyId),
@@ -163,7 +199,7 @@ public class MoneyBalanceRegisterService extends QueueConsumer implements Initia
         return prdct;
     }
 
-    private ImdgPredicate getSqlForUnblockedSum(Long companyId, String account) {
+    protected ImdgPredicate getSqlForUnblockedSum(Long companyId, String account) {
         ImdgPredicateBuilder pb = registryMap.predicateBuilder();
         ImdgPredicate prdct = pb.and(
                 pb.equals("companyId", companyId),

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

@@ -85,11 +85,13 @@ public class MoneyPaymentInstructionRegisterService extends QueueConsumer implem
         moneyPaymentInstructionRegister.setCreditLegAmount(paymentInstruction.getCreditLeg_amount());
         moneyPaymentInstructionRegister.setCreditLegCurrencyCode(paymentInstruction.getCreditLeg_currencyCode());
         moneyPaymentInstructionRegister.setDebitLegAccount(paymentInstruction.getDebitLeg_account());
-        moneyPaymentInstructionRegister.setSender(paymentInstruction.getSenderId().toString());
+        if (paymentInstruction.getSenderId()!=null)
-        moneyPaymentInstructionRegister.setAddressee(paymentInstruction.getAddresseeId().toString());
+            moneyPaymentInstructionRegister.setSender(paymentInstruction.getSenderId().toString());
+        if (paymentInstruction.getAddresseeId()!=null)
+            moneyPaymentInstructionRegister.setAddressee(paymentInstruction.getAddresseeId().toString());
         moneyPaymentInstructionRegister.setClearingDate(paymentInstruction.getClearingDate());
         moneyPaymentInstructionRegister.setCreated(Instant.now());
-        moneyPaymentInstructionRegister.setUpdated(Instant.now());
+        moneyPaymentInstructionRegister.setUpdated(moneyPaymentInstructionRegister.getCreated());
         moneyPaymentInstructionRegisterMap.insert(moneyPaymentInstructionRegister);
         log.debug("inserted successfully PaymentInstruction entity with id: {}", paymentInstruction.getId());
     }

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

@@ -5,6 +5,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 
+@Deprecated
 public class FieldValuesValidator {
     public static List<String> delete2(Map<String, ?> map) {
         List<String> errors = new ArrayList<>();

clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/ExcludeLiabilitiesRegisterServiceTest.java

@@ -0,0 +1,34 @@
+package ru.spcex.clearing.registry.service;
+
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+import ru.clearing.classes.statics.data.register.ExcludeLiabilitiesRegister;
+import ru.clearing.classes.statics.data.register.MoneyBalanceRegister;
+import ru.clearing.classes.statics.data.registry.Registry;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.imdg.iml.hazelcast.adapter.predicate.ImdgPredicateBuilderHazelcast;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ExcludeLiabilitiesRegisterServiceTest {
+
+    @Test
+    void getSqlForRegistries() {
+        ExcludeLiabilitiesRegisterService svc = instance();
+        assertEquals("registryDesignation = 'O' and registryInstrumentType  in ('S','M') and registryUnit = 'T' and registryStatus in ('FAIL', 'UNCV')",
+                svc.getSqlForRegistries());
+    }
+
+
+    ExcludeLiabilitiesRegisterService instance() {
+        ImdgProvider imdg = Mockito.mock(ImdgProvider.class);
+        Imdg<ExcludeLiabilitiesRegister> map1 = Mockito.mock(Imdg.class);
+        Mockito.when(map1.predicateBuilder()).thenReturn(new ImdgPredicateBuilderHazelcast());
+        Mockito.when(imdg.getImdg(IMDGDistributedNames.Map_ExcludeLiabilitiesRegister, ExcludeLiabilitiesRegister.class)).thenReturn(map1);
+
+        return new ExcludeLiabilitiesRegisterService(null, null, imdg, null);
+    }
+
+}

clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/LiabilitiesRegisterServiceTest.java

@@ -0,0 +1,31 @@
+package ru.spcex.clearing.registry.service;
+
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+import ru.clearing.classes.statics.data.register.LiabilitiesRegister;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.imdg.iml.hazelcast.adapter.predicate.ImdgPredicateBuilderHazelcast;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class LiabilitiesRegisterServiceTest {
+
+    @Test
+    void getSqlForRegistries() {
+        LiabilitiesRegisterService svc = instance();
+        assertEquals("registryDesignation = 'L' and registryInstrumentType  in ('S','M') and registryUnit = 'T'",
+                svc.getSqlForRegistries());
+    }
+
+
+    LiabilitiesRegisterService instance() {
+        ImdgProvider imdg = Mockito.mock(ImdgProvider.class);
+        Imdg<LiabilitiesRegister> map1 = Mockito.mock(Imdg.class);
+        Mockito.when(map1.predicateBuilder()).thenReturn(new ImdgPredicateBuilderHazelcast());
+        Mockito.when(imdg.getImdg(IMDGDistributedNames.Map_LiabilitiesRegister, LiabilitiesRegister.class)).thenReturn(map1);
+
+        return new LiabilitiesRegisterService(null, null, imdg, null);
+    }
+}

clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/MoneyBalanceRegisterServiceTest.java

@@ -0,0 +1,123 @@
+package ru.spcex.clearing.registry.service;
+
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+import ru.clearing.classes.statics.data.register.MoneyBalanceRegister;
+import ru.clearing.classes.statics.data.registry.Registry;
+import ru.spcex.clearing.imdg.IMDGDistributedNames;
+import ru.spcex.platform.classes.base.SpcexObjectBase;
+import ru.spcex.platform.enumeration.RegistryUnit;
+import ru.spcex.platform.imdg.api.Imdg;
+import ru.spcex.platform.imdg.api.ImdgProvider;
+import ru.spcex.platform.imdg.iml.hazelcast.adapter.predicate.ImdgPredicateBuilderHazelcast;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class MoneyBalanceRegisterServiceTest {
+
+    @Test
+    void groupingRegistry() {
+        MoneyBalanceRegisterService svc = testInstance();
+        ArrayList<Registry> regs1 = new ArrayList<>();
+        assertEquals(0, svc.groupingRegistry(regs1).size());
+        {
+            Registry r = new Registry();
+            r.setId(1001L);
+            r.setCompanyId(10L);
+            r.setAccount("A100");
+            r.setAccountId(100L);
+            r.setRegistryUnit(RegistryUnit.T.getKey());
+            regs1.add(r);
+        }
+        {
+            Registry r = new Registry();
+            r.setId(1002L);
+            r.setCompanyId(10L);
+            r.setAccount("A100");
+            r.setAccountId(100L);
+            r.setRegistryUnit(RegistryUnit.B.getKey());
+            regs1.add(r);
+        }
+        {
+            Registry r = new Registry();
+            r.setId(1003L);
+            r.setCompanyId(10L);
+            r.setAccount("A100");
+            r.setAccountId(100L);
+            r.setRegistryUnit(RegistryUnit.F.getKey());
+            regs1.add(r);
+        }
+        {
+            Registry r = new Registry();
+            r.setId(1004L);
+            r.setCompanyId(110L);
+            r.setAccount("A103");
+            r.setAccountId(103L);
+            r.setRegistryUnit(RegistryUnit.F.getKey());
+            regs1.add(r);
+        }
+        {
+            Registry r = new Registry();
+            r.setId(1005L);
+            r.setCompanyId(10L);
+            r.setAccount("A101");
+            r.setAccountId(101L);
+            r.setRegistryUnit(RegistryUnit.F.getKey());
+            regs1.add(r);
+        }
+
+        List<List<Registry>> out = svc.groupingRegistry(regs1);
+
+        assertEquals("[[Registry{id=1004}], [Registry{id=1001}, Registry{id=1002}, Registry{id=1003}], [Registry{id=1005}]]",
+                "[" + out.stream().map(lst -> "[" + lst.stream().map(v -> v.toString()).collect(Collectors.joining(", ")) + "]")
+                        .collect(Collectors.joining(", ")) + "]");
+    }
+
+    @Test
+    void getSqlForRegistries() {
+        MoneyBalanceRegisterService svc = testInstance();
+        assertEquals("(companyId=1000 AND (registryDesignation=A AND registryInstrumentType=M))",
+                svc.getSqlForRegistries(1000L).toString());
+    }
+
+    @Test
+    void getSqlForRemainderSum() {
+        MoneyBalanceRegisterService svc = testInstance();
+        assertEquals("(companyId=1000 AND account=ACC-2 AND (registryDesignation=A AND registryInstrumentType=M AND registryUnit=T))",
+                svc.getSqlForRemainderSum(1000L, "ACC-2").toString());
+    }
+
+    @Test
+    void getSqlForBlockedSum() {
+        MoneyBalanceRegisterService svc = testInstance();
+        assertEquals("(companyId=1000 AND account=ACC-2 AND (registryDesignation=A AND registryInstrumentType=M AND registryUnit=B))",
+                svc.getSqlForBlockedSum(1000L, "ACC-2").toString());
+    }
+
+    @Test
+    void getSqlForUnblockedSum() {
+        MoneyBalanceRegisterService svc = testInstance();
+        assertEquals("(companyId=1000 AND account=ACC-2 AND (registryDesignation=A AND registryInstrumentType=M AND registryUnit=F))",
+                svc.getSqlForUnblockedSum(1000L, "ACC-2").toString());
+    }
+
+    static MoneyBalanceRegisterService testInstance() {
+        ImdgProvider imdg = Mockito.mock(ImdgProvider.class);
+        Imdg<MoneyBalanceRegister> map1 = Mockito.mock(Imdg.class);
+        Mockito.when(map1.predicateBuilder()).thenReturn(new ImdgPredicateBuilderHazelcast());
+        Mockito.when(imdg.getImdg(IMDGDistributedNames.Map_MoneyBalanceRegister, MoneyBalanceRegister.class)).thenReturn(map1);
+        Imdg<Registry> map2 = Mockito.mock(Imdg.class);
+        Mockito.when(map2.predicateBuilder()).thenReturn(new ImdgPredicateBuilderHazelcast());
+        Mockito.when(imdg.getImdg(IMDGDistributedNames.Map_Registry, Registry.class)).thenReturn(map2);
+
+        MoneyBalanceRegisterService instance = new MoneyBalanceRegisterService(null, null, imdg, null);
+        return instance;
+
+        //todo тесты с выборкой с реальным тестовым Imdg, чтобы провалидировать типы данных в SQL
+    }
+
+}