treshenkov/clearing
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

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

Browse source
This commit is contained in:
akulikov 2023-12-07 13:19:11 +03:00
parent 2656d6a78c
commit 313ff28cbd
5 changed files with 130 additions and 238 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

85
clearing-parent/registry-service/src/main/java/ru/spcex/clearing/registry/service/DepoBalanceRegisterService.java
View file

@ -9,6 +9,7 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import ru.clearing.classes.statics.data.register.DepoBalanceRegister;
import ru.clearing.classes.statics.data.registry.Registry;
import ru.clearing.classes.statics.data.registry.RegistryHistory;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.BaseRequest;
import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest;
@ -21,34 +22,29 @@ 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 ru.spcex.platform.utils.validation.IValidator;
import ru.spcex.platform.utils.enumeration.IEnumKey;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.Collection;
import java.util.Map;
import java.util.Optional;
import java.util.function.Function;
import static ru.spcex.platform.enumeration.Task.createRegistry_GRRT;
@Service
public class DepoBalanceRegisterService extends QueueConsumer implements InitializingBean, ICheckDuplicate<Registry, DepoBalanceRegister> {
public class DepoBalanceRegisterService extends QueueConsumer implements InitializingBean {
private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<DepoBalanceRegister> depoBalanceRegisterMap;
private final Imdg<Registry> registryMap;
private final Function<Map<String, ?>, IValidator> fieldValuesValidator;
private final Imdg<RegistryHistory> registryHistoryMap;
private final PreClearMap<DepoBalanceRegister> preClearMap;
@Autowired
public DepoBalanceRegisterService(Consumer<String, Object> kafkaQueue,
Producer<String, Object> kafkaProducer,
ImdgProvider imdgProvider,
Function<Map<String, ?>, IValidator> fieldValuesValidator) {
ImdgProvider imdgProvider) {
super(kafkaQueue, kafkaProducer);
this.depoBalanceRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_DepoBalanceRegister, DepoBalanceRegister.class);
this.registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
this.fieldValuesValidator = fieldValuesValidator;
this.registryHistoryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_RegistryHistory, RegistryHistory.class);
preClearMap = PreClearMap.instanceForInstantField(depoBalanceRegisterMap, "created");
}
@ -62,35 +58,29 @@ public class DepoBalanceRegisterService extends QueueConsumer implements Initial
public void depoBalanceRegisterNew(BaseRequest<LauncherCommandRequest> userRequest) {
log.debug("LauncherCommandRequest received from {}", createRegistry_GRRT.topic());
ImdgPredicate prdctForRegistries = getPredicateForRegistries(userRequest.getRequestPayload().getCompanyId());
Collection<Registry> registries = registryMap.getCollectionObjectsByPredicate(prdctForRegistries);
log.trace("Started searching depoBalanceRegister in register by '{}'", prdctForRegistries);
if (registries.isEmpty()) {
log.debug("No registry with such conditions '{}'", prdctForRegistries);
ImdgPredicate predicate = getPredicateForRegistries(userRequest.getRequestPayload().getCompanyId());
Collection<RegistryHistory> registryHistories = registryHistoryMap.getCollectionObjectsByPredicate(predicate);
log.trace("Started searching depoBalanceRegister in register by '{}'", predicate);
if (registryHistories.isEmpty()) {
log.debug("No registry with such conditions '{}'", predicate);
return;
}
log.debug("Select {} Registry by query {}", registries.size(), prdctForRegistries);
log.debug("Select {} Registry history by query {}", registryHistories.size(), predicate);
preClearMap.preClearMap();
registries.forEach((registry -> {
if (isDuplicateInMap(registry).isEmpty()) {
insertDepoBalanceRegister(registry);
}
}
));
registryHistories.forEach(this::insertDepoBalanceRegister);
log.debug("Successfully processed");
}
private void insertDepoBalanceRegister(Registry registry) {
private void insertDepoBalanceRegister(RegistryHistory registryHistory) {
log.trace("Started generating DepoBalanceRegister entity...");
Registry registry = registryHistory.getObject();
DepoBalanceRegister depoBalanceRegister = new DepoBalanceRegister();
depoBalanceRegister.setUpdated(Instant.now());
depoBalanceRegister.setCreated(depoBalanceRegister.getUpdated());
depoBalanceRegister.setCompanyId(registry.getCompanyId());
depoBalanceRegister.setSessionId(registry.getSessionId());
if (AccountType.Depo.equalsByKey(registry.getAccountType())) {
AccountType accountType = IEnumKey.getEnumByKey(AccountType.class, registry.getAccountType());
if (AccountType.Depo == accountType) {
depoBalanceRegister.setDepoCode(registry.getAccount());
} else if (registry.getAccountType() != null) {
log.warn("Unexpected registry[{}].accountType={}", registry.getId(), registry.getAccountType());
}
depoBalanceRegister.setQuantity(registry.getBalance());
depoBalanceRegister.setSecuritySymbol(registry.getSecuritySymbol());
@ -99,26 +89,29 @@ public class DepoBalanceRegisterService extends QueueConsumer implements Initial
}
private ImdgPredicate getPredicateForRegistries(Long companyId) {
ImdgPredicateBuilder pb = registryMap.predicateBuilder();
ImdgPredicateBuilder pb = registryHistoryMap.predicateBuilder();
RegistryCodeSqlBuilder codeSql = RegistryCodeSqlBuilder.getInstance(RegistryTradingParams.AS_T);
if (companyId == null) // default use case
return pb.sql(codeSql.build());
else
return pb.and(
pb.equals("companyId", companyId),
pb.sql(codeSql.build())
ImdgPredicate registryPredicate;
if (companyId == null) {
registryPredicate = pb.sql(codeSql.build("object."));
} else {
registryPredicate = pb.and(
pb.equals("object.companyId", companyId),
pb.sql(codeSql.build("object."))
);
}
ImdgPredicate finalPredicate = pb.and(
registryPredicate,
pb.equals("object.diffBalance", 0),
pb.notNull("object.tradingClearingRegistry"),
pb.and(
pb.greatEqual("eventTime", Instant.now().truncatedTo(ChronoUnit.DAYS)),
pb.less("eventTime", Instant.now().plus(1, ChronoUnit.DAYS))
)
);
log.trace("sql predicate for registry_history {}", finalPredicate);
return finalPredicate;
}
@Override
public Optional<DepoBalanceRegister> isDuplicateInMap(Registry entity) {
return Optional.empty();
// Map<String, ? extends Comparable<?>> fieldValues = Map.of("companyId", entity.getCompanyId(), "sessionId", entity.getSessionId());
// Optional<EnumMessage> message = fieldValuesValidator.apply(fieldValues).tillFirstError();
// if (message.isPresent()) {
// log.warn("Illegal value in map for request to imdg: {}", message.get());
// throw new IllegalArgumentException(MessageFormat.format("Illegal value in request to imdg: {0}", message.get()));
// }
// return Optional.ofNullable(depoBalanceRegisterMap.getFirstObjectByFieldValues(fieldValues));
}
}

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

@ -1,8 +1,5 @@
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;
@ -10,58 +7,48 @@ import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import ru.clearing.classes.statics.data.account.Account;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.company.CompanySymbols;
import ru.clearing.classes.statics.data.register.MoneyBalanceRegister;
import ru.clearing.classes.statics.data.registry.Registry;
import ru.clearing.classes.statics.data.registry.RegistryHistory;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
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;
import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder;
import ru.spcex.platform.imdg.api.predicate.specific.RegistryCodeSqlBuilder;
import ru.spcex.platform.utils.validation.IValidator;
import ru.spcex.platform.utils.enumeration.IEnumKey;
import java.time.Instant;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.time.temporal.ChronoUnit;
import java.util.Collection;
import java.util.Map;
import static ru.spcex.platform.enumeration.Task.createRegistry_GBRR;
@Service
public class MoneyBalanceRegisterService extends QueueConsumer implements InitializingBean, ICheckDuplicate<Registry, MoneyBalanceRegister> {
public class MoneyBalanceRegisterService extends QueueConsumer implements InitializingBean {
private final Logger log = LoggerFactory.getLogger(getClass());
private final Imdg<MoneyBalanceRegister> moneyBalanceRegisterMap;
private final Imdg<Registry> registryMap;
private final Imdg<CompanySymbols> companySymbolsMap;
private final Imdg<RegistryHistory> registryHistoryMap;
private final Imdg<Company> companyMap;
private final Imdg<Account> accountMap;
private final Function<Map<String, ?>, IValidator> fieldValuesValidator;
private final PreClearMap<MoneyBalanceRegister> preClearMap;
@Autowired
public MoneyBalanceRegisterService(Consumer<String, Object> kafkaQueue,
Producer<String, Object> kafkaProducer,
ImdgProvider imdgProvider,
Function<Map<String, ?>, IValidator> fieldValuesValidator) {
ImdgProvider imdgProvider) {
super(kafkaQueue, kafkaProducer);
this.moneyBalanceRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_MoneyBalanceRegister, MoneyBalanceRegister.class);
this.registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
this.companySymbolsMap = imdgProvider.getImdg(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class);
this.registryHistoryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_RegistryHistory, RegistryHistory.class);
this.companyMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
this.accountMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
this.fieldValuesValidator = fieldValuesValidator;
preClearMap = PreClearMap.instanceForInstantField(moneyBalanceRegisterMap, "created");
}
@ -73,154 +60,67 @@ 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());
Collection<Registry> registries = registryMap.getCollectionObjectsByPredicate(sqlConditionForRegistry);
if (registries.isEmpty()) {
log.debug("No registry with such conditions {}", sqlConditionForRegistry);
ImdgPredicate predicate = getSqlForRegistryHistory(userRequest.getRequestPayload().getCompanyId());
Collection<RegistryHistory> registryHistories = registryHistoryMap.getCollectionObjectsByPredicate(predicate);
if (registryHistories.isEmpty()) {
log.debug("No registry history with such conditions {}", predicate);
return;
}
log.debug("Select {} Registry by query {}", registries.size(), sqlConditionForRegistry);
List<List<Registry>> registerGroups = groupingRegistry(registries);
log.debug("Select {} Registry history by query {}", registryHistories.size(), predicate);
preClearMap.preClearMap();
registerGroups.forEach((registryItems -> {
// if (isDuplicateInMap(registry).isEmpty()) {
insertMoneyBalanceRegister(registryItems);
// }
}
));
registryHistories.forEach((this::insertMoneyBalanceRegister));
log.debug("successfully processed");
}
private void insertMoneyBalanceRegister(List<Registry> registryGroup) {
private void insertMoneyBalanceRegister(RegistryHistory registryHistory) {
log.trace("Started generating MoneyBalanceRegister entity...");
Registry registry = registryHistory.getObject();
MoneyBalanceRegister moneyBalanceRegister = new MoneyBalanceRegister();
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;
String inn = companySymbol != null ? companySymbol.getCompanySymbolValue() : null;
String accountType = registry.getAccountType();
AccountType accountType = IEnumKey.getEnumByKey(AccountType.class, registry.getAccountType());
String account = null;
String infoAccount = null;
if ("CLRN".equalsIgnoreCase(accountType)) {
Account accountValue = accountMap.getFirstObjectByFieldValues(Map.of("companyId", registry.getCompanyId(), "accountType", AccountType.Info.getKey()));
if (accountType == AccountType.Clrn || accountType == AccountType.Info) {
account = registry.getAccount();
infoAccount = accountValue != null ? accountValue.getAccount() : null;
} else if ("INFO".equalsIgnoreCase(accountType)) {
Account accountValue = accountMap.getFirstObjectByFieldValues(Map.of("companyId", registry.getCompanyId(), "accountType", AccountType.Clrn.getKey()));
account = accountValue != null ? accountValue.getAccount() : null;
infoAccount = registry.getAccount();
}
moneyBalanceRegister.setSetHouseName(setHouseName);
moneyBalanceRegister.setCompanyFullName(registry.getFullName());
moneyBalanceRegister.setAccount(account);
moneyBalanceRegister.setInfoAccount(infoAccount);
moneyBalanceRegister.setRemainderSum(registryForRemainderSum != null ? registryForRemainderSum.getBalance() : null);
moneyBalanceRegister.setBlockedSum(registryForBlockedSum != null ? registryForBlockedSum.getBalance() : null);
moneyBalanceRegister.setUnblockedSum(registryForUnblockedSum != null ? registryForUnblockedSum.getBalance() : null);
moneyBalanceRegister.setInn(inn);
moneyBalanceRegister.setSessionId(registry.getSessionId());
moneyBalanceRegister.setCompanyId(registry.getCompanyId());
moneyBalanceRegister.setCreated(Instant.now());
moneyBalanceRegister.setCompanyId(registry.getCompanyId());
moneyBalanceRegister.setAccount(account);
moneyBalanceRegister.setRemainderSum(registry.getBalance());
moneyBalanceRegister.setUpdated(moneyBalanceRegister.getCreated());
moneyBalanceRegisterMap.insert(moneyBalanceRegister);
log.debug("inserted successfully MoneyBalanceRegister entity with id: {}", moneyBalanceRegister.getId());
}
protected ImdgPredicate getSqlForRegistries(Long companyId) {
ImdgPredicateBuilder pb = registryMap.predicateBuilder();
ImdgPredicate prdct;
protected ImdgPredicate getSqlForRegistryHistory(Long companyId) {
ImdgPredicateBuilder pb = registryHistoryMap.predicateBuilder();
RegistryCodeSqlBuilder codeSql = RegistryCodeSqlBuilder.getInstance(RegistryTradingParams.AM_T);
ImdgPredicate registryPredicate;
if (companyId == null) {
prdct = pb.sql(RegistryCodeSqlBuilder.getInstance(RegistryTradingParams.AM__).build());
registryPredicate = pb.sql(codeSql.build("object."));
} else {
prdct = pb.and(
pb.equals("companyId", companyId),
pb.sql(RegistryCodeSqlBuilder.getInstance(RegistryTradingParams.AM__).build())
registryPredicate = pb.and(
pb.equals("object.companyId", companyId),
pb.sql(codeSql.build("object."))
);
}
log.trace("sql predicate for registries {}", prdct);
return prdct;
}
protected ImdgPredicate getSqlForRemainderSum(Long companyId, String account) {
ImdgPredicateBuilder pb = registryMap.predicateBuilder();
ImdgPredicate prdct = pb.and(
pb.equals("companyId", companyId),
pb.equals("account", account),
pb.sql(RegistryCodeSqlBuilder.getInstance(RegistryTradingParams.AM_T).build())
ImdgPredicate finalPredicate = pb.and(
registryPredicate,
pb.equals("object.diffBalance", 0),
pb.notNull("object.tradingClearingRegistry"),
pb.and(
pb.greatEqual("eventTime", Instant.now().truncatedTo(ChronoUnit.DAYS)),
pb.less("eventTime", Instant.now().plus(1, ChronoUnit.DAYS))
)
);
log.trace("sql predicate for registries remainder sum {}", prdct);
return prdct;
log.trace("sql predicate for registry_history {}", finalPredicate);
return finalPredicate;
}
protected ImdgPredicate getSqlForBlockedSum(Long companyId, String account) {
ImdgPredicateBuilder pb = registryMap.predicateBuilder();
ImdgPredicate prdct = pb.and(
pb.equals("companyId", companyId),
pb.equals("account", account),
pb.sql(RegistryCodeSqlBuilder.getInstance(RegistryTradingParams.AM_B).build())
);
log.trace("sql predicate for registries blocked sum {}", prdct);
return prdct;
}
protected ImdgPredicate getSqlForUnblockedSum(Long companyId, String account) {
ImdgPredicateBuilder pb = registryMap.predicateBuilder();
ImdgPredicate prdct = pb.and(
pb.equals("companyId", companyId),
pb.equals("account", account),
pb.sql(RegistryCodeSqlBuilder.getInstance(RegistryTradingParams.AM_F).build())
);
log.trace("sql predicate for registries unblocked sum {}", prdct);
return prdct;
}
@Override
public Optional<MoneyBalanceRegister> isDuplicateInMap(Registry entity) {
return Optional.empty();
// Map<String, Long> fieldValues = new HashMap<>();
// fieldValues.put("companyId", entity.getCompanyId());
// fieldValues.put("sessionId", entity.getSessionId());
// Optional<EnumMessage> message = fieldValuesValidator.apply(fieldValues).tillFirstError();
// if (message.isPresent()) {
// log.warn("Illegal value in map for request to imdg: {}", message.get());
// throw new IllegalArgumentException(MessageFormat.format("Illegal value in request to imdg: {0}", message.get()));
// }
// return Optional.ofNullable(moneyBalanceRegisterMap.getFirstObjectByFieldValues(fieldValues));
}
}

19
clearing-parent/registry-service/src/test/java/ru/spcex/clearing/registry/service/DepoBalanceRegisterServiceTest.java
View file

@ -13,6 +13,7 @@ import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import ru.clearing.classes.statics.data.register.DepoBalanceRegister;
import ru.clearing.classes.statics.data.registry.Registry;
import ru.clearing.classes.statics.data.registry.RegistryHistory;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest;
import ru.spcex.clearing.registry.config.ValidationConfig;
@ -25,6 +26,7 @@ import ru.spcex.platform.imdg.api.ImdgProvider;
import javax.annotation.PostConstruct;
import java.math.BigDecimal;
import java.time.Instant;
import java.util.Collection;
import static org.junit.jupiter.api.Assertions.assertEquals;
@ -48,7 +50,7 @@ class DepoBalanceRegisterServiceTest {
private static final String SECURITY_SYMBOL= "SECURITY_SYMBOL";
private Imdg<DepoBalanceRegister> depoBalanceRegisterMap;
private Imdg<Registry> registryMap;
private Imdg<RegistryHistory> registryHistoryMap;
@Autowired
private DepoBalanceRegisterService depoBalanceRegisterService;
@ -66,27 +68,29 @@ class DepoBalanceRegisterServiceTest {
ImdgTestConfig.waitAvailableImdgProviderAndAddAdminWithDefaultId();
//initializing of imdg
registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
registryHistoryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_RegistryHistory, RegistryHistory.class);
depoBalanceRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_DepoBalanceRegister, DepoBalanceRegister.class);
// initialing objects for imdg repos
Long securityId = 1L;
Registry registry = new Registry();
registry.setRegistryDesignation(RegistryDesignation.A.getKey());
registry.setRegistryInstrumentType(RegistryInstrumentType.S.getKey());
registry.setRegistryUnit(RegistryUnit.T.getKey());
registry.setRegistryStatus(RegistryStatus.OK.getKey());
registry.setSessionId(sessionId);
registry.setDiffBalance(BigDecimal.ZERO);
registry.setTradingClearingRegistry("not null value");
registry.setCompanyId(companyId);
registry.setAccountType(AccountType.Depo.getKey());
registry.setAccount(account);
registry.setBalance(balance);
registry.setSecuritySymbol(SECURITY_SYMBOL);
registryMap.insert(registry);
RegistryHistory registryHistory = new RegistryHistory();
registryHistory.setObject(registry);
registryHistory.setEventTime(Instant.now());
registryHistoryMap.insert(registryHistory);
}
@Test
@Order(1)
void executionRegisterNewForClearingDate() {
void executionRegisterNewForEventTime() {
//making launcherCommand
LauncherCommandRequest launcherCommandRequest = new LauncherCommandRequest();
@ -104,7 +108,6 @@ class DepoBalanceRegisterServiceTest {
//take all values is procceed imdg
Collection<DepoBalanceRegister> allValues = depoBalanceRegisterMap.getAllValues();
DepoBalanceRegister depoBalanceRegister = allValues.iterator().next();
assertEquals(sessionId, depoBalanceRegister.getSessionId());
assertEquals(companyId, depoBalanceRegister.getCompanyId());
assertEquals(account, depoBalanceRegister.getDepoCode());
assertEquals(balance, depoBalanceRegister.getQuantity());

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

@ -11,11 +11,10 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import ru.clearing.classes.statics.data.account.Account;
import ru.clearing.classes.statics.data.company.Company;
import ru.clearing.classes.statics.data.company.CompanySymbols;
import ru.clearing.classes.statics.data.register.MoneyBalanceRegister;
import ru.clearing.classes.statics.data.registry.Registry;
import ru.clearing.classes.statics.data.registry.RegistryHistory;
import ru.spcex.clearing.imdg.IMDGDistributedNames;
import ru.spcex.clearing.platform.messaging.domain.cud.schedule.LauncherCommandRequest;
import ru.spcex.clearing.registry.config.ValidationConfig;
@ -28,6 +27,7 @@ import ru.spcex.platform.imdg.api.ImdgProvider;
import javax.annotation.PostConstruct;
import java.math.BigDecimal;
import java.time.Instant;
import java.time.LocalDate;
import java.util.Collection;
@ -62,10 +62,8 @@ class MoneyBalanceRegisterServiceTest {
@Autowired
private MoneyBalanceRegisterService moneyBalanceRegisterService;
private Imdg<MoneyBalanceRegister> moneyBalanceRegisterMap;
private Imdg<Registry> registryMap;
private Imdg<CompanySymbols> companySymbolsMap;
private Imdg<RegistryHistory> registryHistoryMap;
private Imdg<Company> companyMap;
private Imdg<Account> accountMap;
@Autowired
@Qualifier("hazelcastServiceTest")
private ImdgProvider imdgProvider;
@ -79,16 +77,16 @@ class MoneyBalanceRegisterServiceTest {
ImdgTestConfig.waitAvailableImdgProviderAndAddAdminWithDefaultId();
moneyBalanceRegisterMap = imdgProvider.getImdg(IMDGDistributedNames.Map_MoneyBalanceRegister, MoneyBalanceRegister.class);
registryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Registry, Registry.class);
companySymbolsMap = imdgProvider.getImdg(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class);
companyMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Company, Company.class);
accountMap = imdgProvider.getImdg(IMDGDistributedNames.Map_Account, Account.class);
registryHistoryMap = imdgProvider.getImdg(IMDGDistributedNames.Map_RegistryHistory, RegistryHistory.class);
}
@Test
@Order(1)
void executionRegisterNewForClearingDate() {
Registry registry = new Registry();
registry.setTradingClearingRegistry("not null value");
registry.setDiffBalance(BigDecimal.ZERO);
registry.setRegistryUnit(RegistryUnit.T.getKey());
registry.setRegistryInstrumentType(REGISTRY_INSTRUMENT_TYPE);
registry.setRegistryDesignation(REGISTRY_DESIGNATION);
@ -102,29 +100,16 @@ class MoneyBalanceRegisterServiceTest {
registry.setBalance(REGISTRY_BALANCE);
registry.setSettlementDate(REGISTRY_SETTLEMENT_DATE);
registry.setSecurityId(REGISTRY_SECURITY_ID);
registryMap.insert(registry);
registry.setId(null);
registry.setRegistryUnit(RegistryUnit.B.getKey());
registryMap.insert(registry);
registry.setId(null);
registry.setRegistryUnit(RegistryUnit.F.getKey());
registryMap.insert(registry);
RegistryHistory registryHistory = new RegistryHistory();
registryHistory.setObject(registry);
registryHistory.setEventTime(Instant.now());
registryHistoryMap.insert(registryHistory);
Company company = new Company();
company.setId(2L);
company.setShortName(COMPANY_SHORTNAME);
companyMap.insert(company);
CompanySymbols companySymbols = new CompanySymbols();
companySymbols.setCompanyId(REGISTRY_COMPANY_ID);
companySymbols.setCompanySymbol(COMPANY_SYMBOL_INN);
companySymbols.setCompanySymbolValue(COMPANY_SYMBOL_VALUE);
companySymbolsMap.insert(companySymbols);
Account account = new Account();
account.setCompanyId(REGISTRY_COMPANY_ID);
account.setAccountType(AccountType.Info.getKey());
account.setAccount(ACCOUNT_ACCOUNT);
accountMap.insert(account);
//making launcherCommand
LauncherCommandRequest launcherCommandRequest = new LauncherCommandRequest();
launcherCommandRequest.setCompanyId(REGISTRY_COMPANY_ID);
@ -142,13 +127,8 @@ class MoneyBalanceRegisterServiceTest {
Collection<MoneyBalanceRegister> allValues = moneyBalanceRegisterMap.getAllValues();
MoneyBalanceRegister moneyBalanceRegister = allValues.iterator().next();
assertEquals(REGISTRY_COMPANY_ID, moneyBalanceRegister.getCompanyId());
assertEquals(REGISTRY_FULL_NAME, moneyBalanceRegister.getCompanyFullName());
assertEquals(REGISTRY_BALANCE, moneyBalanceRegister.getRemainderSum());
assertEquals(REGISTRY_BALANCE, moneyBalanceRegister.getBlockedSum());
assertEquals(REGISTRY_BALANCE, moneyBalanceRegister.getUnblockedSum());
assertEquals(REGISTRY_ACCOUNT, moneyBalanceRegister.getAccount());
assertEquals(ACCOUNT_ACCOUNT, moneyBalanceRegister.getInfoAccount());
assertEquals(COMPANY_SHORTNAME, moneyBalanceRegister.getSetHouseName());
assertEquals(COMPANY_SYMBOL_VALUE, moneyBalanceRegister.getInn());
}
}

36
platform-parent/platform-imdg-api/src/main/java/ru/spcex/platform/imdg/api/predicate/specific/RegistryCodeSqlBuilder.java
View file

@ -21,13 +21,17 @@ public class RegistryCodeSqlBuilder {
this.registryTradingParams = tradingParams;
}
public String build() {
public String build(String prefix) {
List<StringBuilder> conditions = new ArrayList<>();
final String REGISTRY_DESIGNATION_FORMAT = prefix + "registryDesignation = '%s'";
final String REGISTRY_INSTRUMENT_TYPE_FORMAT = prefix + "registryInstrumentType = '%s'";
final String REGISTRY_CAPACITY_FORMAT = prefix + "registryCapacity = '%s'";
final String REGISTRY_UNIT_FORMAT = prefix + "registryUnit = '%s'";
for (RegistryTradingParams tradingParams : this.registryTradingParams) {
StringBuilder condition = new StringBuilder();
boolean wasAddedCondition = false;
if (tradingParams.registryDesignation() != null) {
condition.append(String.format("registryDesignation = '%s'", tradingParams.registryDesignation().getKey()));
condition.append(String.format(REGISTRY_DESIGNATION_FORMAT, tradingParams.registryDesignation().getKey()));
wasAddedCondition = true;
}
if (wasAddedCondition) {
@ -35,7 +39,7 @@ public class RegistryCodeSqlBuilder {
wasAddedCondition = false;
}
if (tradingParams.registryInstrumentType() != null) {
condition.append(String.format("registryInstrumentType = '%s'", tradingParams.registryInstrumentType().getKey()));
condition.append(String.format(REGISTRY_INSTRUMENT_TYPE_FORMAT, tradingParams.registryInstrumentType().getKey()));
wasAddedCondition = true;
}
if (wasAddedCondition) {
@ -43,7 +47,7 @@ public class RegistryCodeSqlBuilder {
wasAddedCondition = false;
}
if (tradingParams.registryCapacity() != null) {
condition.append(String.format("registryCapacity = '%s'", tradingParams.registryCapacity().getKey()));
condition.append(String.format(REGISTRY_CAPACITY_FORMAT, tradingParams.registryCapacity().getKey()));
wasAddedCondition = true;
}
if (wasAddedCondition) {
@ -51,7 +55,7 @@ public class RegistryCodeSqlBuilder {
wasAddedCondition = false;
}
if (tradingParams.registryUnit() != null) {
condition.append(String.format("registryUnit = '%s'", tradingParams.registryUnit().getKey()));
condition.append(String.format(REGISTRY_UNIT_FORMAT, tradingParams.registryUnit().getKey()));
wasAddedCondition = true;
}
if (!wasAddedCondition) {
@ -62,22 +66,30 @@ public class RegistryCodeSqlBuilder {
return conditions.stream().collect(Collectors.joining(") or (", "(", ")"));
}
public String build() {
return build("");
}
public ImdgPredicate buildPredicate(ImdgPredicateBuilder pb) {
public ImdgPredicate buildPredicate(ImdgPredicateBuilder pb, String prefix) {
List<ImdgPredicate> conditionsOr = new ArrayList<>();
final String REGISTRY_DESIGNATION_FIELD = prefix + "registryDesignation";
final String REGISTRY_INSTRUMENT_TYPE_FIELD = prefix + "registryInstrumentType";
final String REGISTRY_CAPACITY_FIELD = prefix + "registryCapacity";
final String REGISTRY_UNIT_FIELD = prefix + "registryUnit";
for (RegistryTradingParams tradingParams : this.registryTradingParams) {
List<ImdgPredicate> conditionsAnd = new ArrayList<>(4);
if (tradingParams.registryDesignation() != null) {
conditionsAnd.add(pb.equals("registryDesignation", tradingParams.registryDesignation().getKey()));
conditionsAnd.add(pb.equals(REGISTRY_DESIGNATION_FIELD, tradingParams.registryDesignation().getKey()));
}
if (tradingParams.registryInstrumentType() != null) {
conditionsAnd.add(pb.equals("registryInstrumentType", tradingParams.registryInstrumentType().getKey()));
conditionsAnd.add(pb.equals(REGISTRY_INSTRUMENT_TYPE_FIELD, tradingParams.registryInstrumentType().getKey()));
}
if (tradingParams.registryCapacity() != null) {
conditionsAnd.add(pb.equals("registryCapacity", tradingParams.registryCapacity().getKey()));
conditionsAnd.add(pb.equals(REGISTRY_CAPACITY_FIELD, tradingParams.registryCapacity().getKey()));
}
if (tradingParams.registryUnit() != null) {
conditionsAnd.add(pb.equals("registryUnit", tradingParams.registryUnit().getKey()));
conditionsAnd.add(pb.equals(REGISTRY_UNIT_FIELD, tradingParams.registryUnit().getKey()));
}
if (conditionsAnd.size() == 1)
conditionsOr.add(conditionsAnd.get(0));
@ -88,4 +100,8 @@ public class RegistryCodeSqlBuilder {
if (conditionsOr.size() == 1) return conditionsOr.get(0);
return pb.or(conditionsOr.toArray(new ImdgPredicate[conditionsOr.size()]));
}
public ImdgPredicate buildPredicate(ImdgPredicateBuilder pb) {
return buildPredicate(pb, "");
}
}