diff --git a/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/ExcludeLiabilitiesRegisterService.java b/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/ExcludeLiabilitiesRegisterService.java index b3ed52edf..2b30ff310 100644 --- a/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/ExcludeLiabilitiesRegisterService.java +++ b/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> innPredicates = Map.of("companySymbol", CompanySymbol.INN.getKey(), - "companyId", registry.getCompanyId()); + Map> innPredicates = Map.of( + "companySymbol", CompanySymbol.INN.getKey(), + "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 " + diff --git a/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/LiabilitiesRegisterService.java b/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/LiabilitiesRegisterService.java index 3d31414af..5ccb096f9 100644 --- a/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/LiabilitiesRegisterService.java +++ b/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.RegistryDesignation; -import ru.spcex.platform.enumeration.RegistryInstrumentType; -import ru.spcex.platform.enumeration.RegistryUnit; +import ru.spcex.platform.enumeration.*; 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 registryMap; private final Imdg sessionMap; private final Imdg companySymbolsMap; - private final Imdg moneyMarketSecurityMap; + private final SecuritySelector securitySelector; private final Function, IValidator> fieldValuesValidator; private final PreClearMap 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( - Map.of( - "id", - registry.getCompanyId() - ) - ); + Session session = sessionMap.getSingleObjectByID(registry.getSessionId()); CompanySymbols companySymbols = companySymbolsMap.getFirstObjectByFieldValues( Map.of("companyId", registry.getCompanyId(), "companySymbol", CompanySymbol.INN.getKey() ) ); - MoneyMarketSecurity moneyMarketSecurity = moneyMarketSecurityMap.getFirstObjectByFieldValues( - Map.of( - "securityId", - registry.getSecurityId() - ) - ); + Security security = securitySelector.selectSecurityById(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) { - log.warn("MoneyMarketSecurity is empty!"); + if (security == null) { + 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'", diff --git a/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/MoneyBalanceRegisterService.java b/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/MoneyBalanceRegisterService.java index da1a355d5..826677d25 100644 --- a/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/MoneyBalanceRegisterService.java +++ b/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.Map; -import java.util.Optional; +import java.util.*; 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> groupingRegistry(Collection registries) { + Map, List> regGroups = registries.stream().collect(Collectors.groupingBy( + (Registry reg) -> new MutablePair(reg.getCompanyId(), reg.getAccountId()) + )); + List> 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 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 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> registerGroups = groupingRegistry(registries); preClearMap.preClearMap(); - registries.forEach((registry -> { - if (isDuplicateInMap(registry).isEmpty()) { - insertMoneyBalanceRegister(registry); - } + registerGroups.forEach((registryItems -> { +// if (isDuplicateInMap(registry).isEmpty()) { + insertMoneyBalanceRegister(registryItems); +// } } )); log.debug("successfully processed"); } - private void insertMoneyBalanceRegister(Registry registry) { + private void insertMoneyBalanceRegister(List registryGroup) { log.trace("Started generating MoneyBalanceRegister entity..."); MoneyBalanceRegister moneyBalanceRegister = new MoneyBalanceRegister(); - 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())); + Registry registryForRemainderSum = registryGroup.stream() + .filter(r -> RegistryUnit.T.equalsByKey(r.getRegistryUnit())) + .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), diff --git a/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/MoneyPaymentInstructionRegisterService.java b/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/MoneyPaymentInstructionRegisterService.java index aeaf1ee6f..73633a618 100644 --- a/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/MoneyPaymentInstructionRegisterService.java +++ b/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()); - moneyPaymentInstructionRegister.setAddressee(paymentInstruction.getAddresseeId().toString()); + if (paymentInstruction.getSenderId()!=null) + 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()); } diff --git a/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/util/FieldValuesValidator.java b/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/util/FieldValuesValidator.java index 4ae5f8a3f..e897308e2 100644 --- a/clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/util/FieldValuesValidator.java +++ b/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 delete2(Map map) { List errors = new ArrayList<>(); diff --git a/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/ExcludeLiabilitiesRegisterServiceTest.java b/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/ExcludeLiabilitiesRegisterServiceTest.java new file mode 100644 index 000000000..ec8bdeae5 --- /dev/null +++ b/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 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); + } + +} \ No newline at end of file diff --git a/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/LiabilitiesRegisterServiceTest.java b/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/LiabilitiesRegisterServiceTest.java new file mode 100644 index 000000000..b35882342 --- /dev/null +++ b/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 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); + } +} \ No newline at end of file diff --git a/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/MoneyBalanceRegisterServiceTest.java b/clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/MoneyBalanceRegisterServiceTest.java new file mode 100644 index 000000000..d6de6c4f0 --- /dev/null +++ b/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 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> 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 map1 = Mockito.mock(Imdg.class); + Mockito.when(map1.predicateBuilder()).thenReturn(new ImdgPredicateBuilderHazelcast()); + Mockito.when(imdg.getImdg(IMDGDistributedNames.Map_MoneyBalanceRegister, MoneyBalanceRegister.class)).thenReturn(map1); + Imdg 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 + } + +} \ No newline at end of file