From fae7a374245506ad340e0ec1cf05146da67d610c Mon Sep 17 00:00:00 2001 From: etreschenkov Date: Thu, 28 Sep 2023 14:19:26 +0300 Subject: [PATCH 01/15] http://jira.mfd.msk:8088/browse/CLS-522 --- clearing-parent/imdg-hist/pom.xml | 173 ++++++++++++++++++ .../historyimdg/IMDGHistApplication.java | 12 ++ .../config/HistoryDbConnectionConfig.java | 71 +++++++ .../config/HistoryHazelcastConfiguration.java | 62 +++++++ .../config/HistoryPoolMapConfigs.java | 94 ++++++++++ .../config/element/ControllerSettings.java | 25 +++ .../config/element/DatabaseSettings.java | 31 ++++ .../element/HazelcastServerSettings.java | 43 +++++ .../config/element/ImdgSettings.java | 38 ++++ .../historyimdg/index/SearchProxy.java | 29 +++ .../index/SearchProxyRegistry.java | 24 +++ .../index/field/SearchCompanyId.java | 7 + .../historyimdg/index/field/SearchWithId.java | 7 + .../index/field/SearchWithTradingDay.java | 9 + .../mapstores/AbstractSliceMapLoader.java | 95 ++++++++++ .../historyimdg/mapstores/HistMapStore.java | 4 + .../mapstores/HistoryMapConfig.java | 63 +++++++ .../mapstores/RegistryHistoryMapStore.java | 31 ++++ .../mapstores/SearchRegistryMapStore.java | 45 +++++ .../src/main/resources/application.properties | 12 ++ .../src/main/resources/hazelcast.yaml | 5 + .../imdg-hist/src/main/resources/logback.xml | 38 ++++ .../imdg/base/AutoconfiguredMap1.java | 17 ++ clearing-parent/pom.xml | 1 + .../clearing/imdg/IMDGDistributedNames.java | 2 + pom.xml | 5 + 26 files changed, 943 insertions(+) create mode 100644 clearing-parent/imdg-hist/pom.xml create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/IMDGHistApplication.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/HistoryDbConnectionConfig.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/HistoryHazelcastConfiguration.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/HistoryPoolMapConfigs.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/element/ControllerSettings.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/element/DatabaseSettings.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/element/HazelcastServerSettings.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/element/ImdgSettings.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxy.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyRegistry.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/field/SearchCompanyId.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/field/SearchWithId.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/field/SearchWithTradingDay.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/AbstractSliceMapLoader.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/HistMapStore.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/HistoryMapConfig.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/RegistryHistoryMapStore.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchRegistryMapStore.java create mode 100644 clearing-parent/imdg-hist/src/main/resources/application.properties create mode 100644 clearing-parent/imdg-hist/src/main/resources/hazelcast.yaml create mode 100644 clearing-parent/imdg-hist/src/main/resources/logback.xml create mode 100644 clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/base/AutoconfiguredMap1.java diff --git a/clearing-parent/imdg-hist/pom.xml b/clearing-parent/imdg-hist/pom.xml new file mode 100644 index 000000000..b97f12c19 --- /dev/null +++ b/clearing-parent/imdg-hist/pom.xml @@ -0,0 +1,173 @@ + + + 4.0.0 + + clearing-parent + ru.spcex.clearing + SPCEX-1.0.0.0 + + + imdg-hist + jar + + + 17 + 17 + UTF-8 + + + + + org.springframework.boot + spring-boot-starter + + + org.springframework.boot + spring-boot-autoconfigure + + + ru.spcex.clearing + imdg + SPCEX-1.0.0.0 + + + ru.spcex.clearing + classes + SPCEX-1.0.0.0 + compile + + + ru.spcex.clearing + dictionary + SPCEX-1.0.0.0 + compile + + + + + + org.springframework + spring-jdbc + + + org.postgresql + postgresql + + + com.mchange + c3p0 + + + + + com.hazelcast + hazelcast-all + ${external_libraries.hazelcast.version} + + + ru.spcex.platform + platform-imdg-api + + + ru.spcex.platform + platform-imdg-api-hazelcast-impl + + + ru.spcex.platform + platform-enum + + + ru.spcex.clearing + cleaning-builders + SPCEX-1.0.0.0 + compile + + + ru.spcex.clearing + clearing-validation + + + + + org.springframework + spring-test + test + + + org.skyscreamer + jsonassert + test + + + org.junit.jupiter + junit-jupiter + test + + + org.assertj + assertj-core + test + + + + + + + src/main/resources + + application.properties + + false + + + + + + org.apache.maven.plugins + maven-jar-plugin + + + + ru.spcex.clearing.historyimdg.IMDGHistApplication + + + + + + org.springframework.boot + spring-boot-maven-plugin + + + + repackage + + + + + true + exec + ${project.artifactId} + + + + org.apache.maven.plugins + maven-surefire-plugin + 2.21.0 + + + org.junit.platform + junit-platform-surefire-provider + 1.2.0-M1 + + + org.junit.jupiter + junit-jupiter-engine + 5.2.0-M1 + + + + + + \ No newline at end of file diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/IMDGHistApplication.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/IMDGHistApplication.java new file mode 100644 index 000000000..46f6ad798 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/IMDGHistApplication.java @@ -0,0 +1,12 @@ +package ru.spcex.clearing.historyimdg; + +import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.boot.builder.SpringApplicationBuilder; + +@SpringBootApplication +public class IMDGHistApplication { + public static void main(String[] args) { + SpringApplicationBuilder builder = new SpringApplicationBuilder(IMDGHistApplication.class); + builder.run(args); + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/HistoryDbConnectionConfig.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/HistoryDbConnectionConfig.java new file mode 100644 index 000000000..aefce5aa1 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/HistoryDbConnectionConfig.java @@ -0,0 +1,71 @@ +package ru.spcex.clearing.historyimdg.config; + +import com.mchange.v2.c3p0.ComboPooledDataSource; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.jdbc.core.JdbcTemplate; +import ru.spcex.clearing.historyimdg.config.element.DatabaseSettings; +import ru.spcex.clearing.historyimdg.config.element.ImdgSettings; +import ru.spcex.clearing.imdg.error.ModuleInitializeException; + +import javax.sql.DataSource; +import java.sql.Connection; + +@SuppressWarnings("UnnecessaryLocalVariable") +@Configuration +public class HistoryDbConnectionConfig { + private final Logger log = LoggerFactory.getLogger(this.getClass()); + + private final DatabaseSettings settings; + + public HistoryDbConnectionConfig(ImdgSettings settings) { + this.settings = settings.getDatabase(); + } + + @Bean(destroyMethod = "close") + public ComboPooledDataSource dataSource() { + String login = settings.getLogin(); + String password = settings.getPassword(); + String logTimeoutPart = ""; + String dbPath = settings.getUrl(); + int timeoutSec = 30; + + ComboPooledDataSource cpds = new ComboPooledDataSource(); + try { + cpds.setDriverClass("org.postgresql.Driver"); + } catch (Exception ue) { + throw new RuntimeException(ue); + } + cpds.setJdbcUrl(dbPath); + cpds.setUser(login); + cpds.setPassword(password); + cpds.setInitialPoolSize(10); + cpds.setMinPoolSize(10); + cpds.setMaxPoolSize(30); + int numHelperThreads = Runtime.getRuntime().availableProcessors() * 2; + cpds.setNumHelperThreads(numHelperThreads); + cpds.setCheckoutTimeout(timeoutSec * 1000); + logTimeoutPart = String.format(" (timeout=%ds)", timeoutSec); + + String OPERATION_DATABASE_CONNECTION_CHECK = String.format("Database [%s] connection check", dbPath); + try { + Connection conn = cpds.getConnection(); + conn.close(); + log.info("{}: success", OPERATION_DATABASE_CONNECTION_CHECK); + return cpds; + } catch (Throwable e) { + String msg = String.format("%s%s: failed: %s -> %s", + OPERATION_DATABASE_CONNECTION_CHECK, logTimeoutPart, e.getClass().getSimpleName(), e.getMessage()); + log.error(msg); + throw new ModuleInitializeException(msg, e); + } + } + + @Bean + public JdbcTemplate jdbcTemplate(DataSource dataSource) { + JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource); + return jdbcTemplate; + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/HistoryHazelcastConfiguration.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/HistoryHazelcastConfiguration.java new file mode 100644 index 000000000..9b5b5c990 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/HistoryHazelcastConfiguration.java @@ -0,0 +1,62 @@ +package ru.spcex.clearing.historyimdg.config; + +import com.hazelcast.config.*; +import com.hazelcast.core.Hazelcast; +import com.hazelcast.core.HazelcastInstance; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import ru.spcex.clearing.historyimdg.config.element.HazelcastServerSettings; +import ru.spcex.clearing.historyimdg.config.element.ImdgSettings; + +import java.util.List; + +@Configuration +public class HistoryHazelcastConfiguration { + + private final HistoryPoolMapConfigs poolMapConfigs; + private final HazelcastServerSettings hzSettings; + + @Autowired + public HistoryHazelcastConfiguration(HistoryPoolMapConfigs poolMapConfigs, + ImdgSettings imdgSettings) { + this.poolMapConfigs = poolMapConfigs; + this.hzSettings = imdgSettings.getHazelcast(); + } + + @Bean("hazelcastInstanceImdg") + public HazelcastInstance hazelcastServerInstance(Config config) { + return Hazelcast.newHazelcastInstance(config); + } + + @Bean + public Config hazelCastConfig() { + Config config = new Config(); + config.setInstanceName("instance"); + config.setGroupConfig(new GroupConfig() + .setName(hzSettings.getLogin()) + .setPassword(hzSettings.getPassword()) + ); + config.setProperty("hazelcast.shutdownhook.enabled", "true"); + config.setProperty("hazelcast.logging.type", "slf4j"); + config.setProperty("hazelcast.operation.call.timeout.millis", "600000"); + config.setNetworkConfig(new NetworkConfig() + .setPort(hzSettings.getListenPort()) + .setJoin(new JoinConfig() + .setMulticastConfig(new MulticastConfig() + .setEnabled(false)) + .setTcpIpConfig(new TcpIpConfig() + .setEnabled(true).setMembers(hzSettings.getClusterMembers()) + ) + ) + ); + + List autoMapCfg = poolMapConfigs.configureEachMapStore(); + for (MapConfig cfg : autoMapCfg) { + config.addMapConfig(cfg); + } + return config; + } + + +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/HistoryPoolMapConfigs.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/HistoryPoolMapConfigs.java new file mode 100644 index 000000000..dcd4012b0 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/HistoryPoolMapConfigs.java @@ -0,0 +1,94 @@ +package ru.spcex.clearing.historyimdg.config; + +import com.hazelcast.config.*; +import com.hazelcast.core.MapLoader; +import org.apache.commons.lang3.StringUtils; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Configuration; +import ru.spcex.clearing.imdg.base.AutoconfiguredMap1; +import ru.spcex.clearing.imdg.base.DictionaryTMapStore; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashSet; +import java.util.List; + +@Configuration +public class HistoryPoolMapConfigs { + private final Logger log = LoggerFactory.getLogger(getClass()); + + + private final List> autoconfiguredMaps; + + @Autowired + public HistoryPoolMapConfigs(List> autoconfiguredMaps) { + this.autoconfiguredMaps = autoconfiguredMaps; + } + + private MapStoreConfig makeDefaultMapStoreConfig(MapLoader mapBean) { + return new MapStoreConfig() + .setImplementation(mapBean); + } + + + public MapConfig makeDefaultMapConfig(String mapName, MapLoader mapBean) { + return new MapConfig() + .setName(mapName) + .setInMemoryFormat(InMemoryFormat.OBJECT) + .setMapStoreConfig(makeDefaultMapStoreConfig(mapBean)); + } + + private NearCacheConfig makeDefaultNearCacheConfig() { + return new NearCacheConfig() + .setMaxIdleSeconds(3600) + .setInMemoryFormat(InMemoryFormat.OBJECT) + .setSerializeKeys(true); + } + + private MapIndexConfig makeMapIndexConfig(String attributeName, boolean ordered) { + return new MapIndexConfig() + .setAttribute(attributeName) + .setOrdered(ordered); + } + + private MapIndexConfig makeMapIndexConfig(String attributeName) { + return makeMapIndexConfig(attributeName, false); + } + + public List configureEachMapStore() { + List out = new ArrayList<>(); + HashSet existMapStores = new HashSet<>(); + for (AutoconfiguredMap1 mapStore : autoconfiguredMaps) { + try { + log.debug("Link mapstore {} to map {}", mapStore.toString(), mapStore.getMapName()); + if (StringUtils.isEmpty(mapStore.getMapName())) { + throw new IllegalArgumentException("MapStore " + mapStore + " has empty mapName"); + } + if (existMapStores.contains(mapStore.getMapName())) { + throw new IllegalArgumentException("MapStore " + mapStore + " has wrong mapName=\"" + mapStore.getMapName() + "\" is duplicated"); + } + existMapStores.add(mapStore.getMapName()); // IMDGDistributedNames + MapConfig mapCfg = makeDefaultMapConfig(mapStore.getMapName(), mapStore); + if (mapStore.getIndexingField() != null && mapStore.getIndexingField().length > 0) { + if (log.isTraceEnabled()) { + log.trace("Create indexing filed on {}: {}", mapStore.getMapName(), Arrays.toString(mapStore.getIndexingField())); + } + for (String indexName : mapStore.getIndexingField()) { + mapCfg.addMapIndexConfig(makeMapIndexConfig(indexName)); + } + } + if (mapStore instanceof DictionaryTMapStore) { + log.trace("Use near cache for {}", mapStore.getMapName()); + mapCfg.setNearCacheConfig(makeDefaultNearCacheConfig()); + } + out.add(mapCfg); + } catch (RuntimeException e) { + throw new RuntimeException("Can not configure MapStore " + mapStore.getMapName() + "(" + mapStore + "): " + e, e); + } + } + log.debug("Configured {} mapStore's", out.size()); + return out; + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/element/ControllerSettings.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/element/ControllerSettings.java new file mode 100644 index 000000000..7ffe3144b --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/element/ControllerSettings.java @@ -0,0 +1,25 @@ +package ru.spcex.clearing.historyimdg.config.element; + +/** + * Debug config + */ +public class ControllerSettings { + private String port; + private String contextPath; + + public String getPort() { + return port; + } + + public void setPort(String port) { + this.port = port; + } + + public String getContextPath() { + return contextPath; + } + + public void setContextPath(String contextPath) { + this.contextPath = contextPath; + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/element/DatabaseSettings.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/element/DatabaseSettings.java new file mode 100644 index 000000000..ee8495f65 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/element/DatabaseSettings.java @@ -0,0 +1,31 @@ +package ru.spcex.clearing.historyimdg.config.element; + +public class DatabaseSettings { + private String login; + private String password; + private String url; + + public String getLogin() { + return login; + } + + public void setLogin(String login) { + this.login = login; + } + + public String getPassword() { + return password; + } + + public void setPassword(String password) { + this.password = password; + } + + public String getUrl() { + return url; + } + + public void setUrl(String url) { + this.url = url; + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/element/HazelcastServerSettings.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/element/HazelcastServerSettings.java new file mode 100644 index 000000000..05af0a7ef --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/element/HazelcastServerSettings.java @@ -0,0 +1,43 @@ +package ru.spcex.clearing.historyimdg.config.element; + +import java.util.List; + +public class HazelcastServerSettings { + + private int listenPort = 5701; + private String login; + private String password; + private List clusterMembers; + + public int getListenPort() { + return listenPort; + } + + public void setListenPort(int listenPort) { + this.listenPort = listenPort; + } + + public String getLogin() { + return login; + } + + public void setLogin(String login) { + this.login = login; + } + + public String getPassword() { + return password; + } + + public void setPassword(String password) { + this.password = password; + } + + public List getClusterMembers() { + return clusterMembers; + } + + public void setClusterMembers(List clusterMembers) { + this.clusterMembers = clusterMembers; + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/element/ImdgSettings.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/element/ImdgSettings.java new file mode 100644 index 000000000..d3bf410b2 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/element/ImdgSettings.java @@ -0,0 +1,38 @@ +package ru.spcex.clearing.historyimdg.config.element; + +import org.springframework.boot.context.properties.ConfigurationProperties; +import org.springframework.context.annotation.PropertySource; +import org.springframework.stereotype.Component; + +@Component +@PropertySource("file:${spring.config.location}/application.properties") +@ConfigurationProperties("imdg.hist") +public class ImdgSettings { + private HazelcastServerSettings hazelcast; + private DatabaseSettings database; + private ControllerSettings debugServer; + + public HazelcastServerSettings getHazelcast() { + return hazelcast; + } + + public void setHazelcast(HazelcastServerSettings hazelcast) { + this.hazelcast = hazelcast; + } + + public DatabaseSettings getDatabase() { + return database; + } + + public void setDatabase(DatabaseSettings database) { + this.database = database; + } + + public ControllerSettings getDebugServer() { + return debugServer; + } + + public void setDebugServer(ControllerSettings debugServer) { + this.debugServer = debugServer; + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxy.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxy.java new file mode 100644 index 000000000..0eb4fee26 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxy.java @@ -0,0 +1,29 @@ +package ru.spcex.clearing.historyimdg.index; + + +import ru.spcex.clearing.historyimdg.index.field.SearchWithId; +import ru.spcex.clearing.historyimdg.index.field.SearchWithTradingDay; +import ru.spcex.platform.classes.base.SpcexObjectBase; + +import java.time.LocalDate; + +public class SearchProxy extends SpcexObjectBase implements SearchWithTradingDay, SearchWithId { + private LocalDate tradingDate; + + @Override + public LocalDate getTradingDate() { + return tradingDate; + } + + @Override + public void setTradingDate(LocalDate tradingDate) { + this.tradingDate = tradingDate; + } + + @Override + public String toString() { + return "SearchProxy{" + + ", id=" + id + + '}'; + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyRegistry.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyRegistry.java new file mode 100644 index 000000000..d6ed646ee --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyRegistry.java @@ -0,0 +1,24 @@ +package ru.spcex.clearing.historyimdg.index; + +import ru.spcex.clearing.historyimdg.index.field.SearchCompanyId; + +import java.time.LocalDate; + +public class SearchProxyRegistry extends SearchProxy implements SearchCompanyId { + private Long companyId; + + @Override + public Long getCompanyId() { + return companyId; + } + + @Override + public void setCompanyId(Long companyId) { + this.companyId = companyId; + } + + @Override + public void setTradingDate(LocalDate tradingDate) { + + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/field/SearchCompanyId.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/field/SearchCompanyId.java new file mode 100644 index 000000000..e148c4530 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/field/SearchCompanyId.java @@ -0,0 +1,7 @@ +package ru.spcex.clearing.historyimdg.index.field; + +public interface SearchCompanyId { + Long getCompanyId(); + + void setCompanyId(Long id); +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/field/SearchWithId.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/field/SearchWithId.java new file mode 100644 index 000000000..01453c73e --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/field/SearchWithId.java @@ -0,0 +1,7 @@ +package ru.spcex.clearing.historyimdg.index.field; + +public interface SearchWithId { + Long getId(); + + void setId(Long id); +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/field/SearchWithTradingDay.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/field/SearchWithTradingDay.java new file mode 100644 index 000000000..f1cd6f3b8 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/field/SearchWithTradingDay.java @@ -0,0 +1,9 @@ +package ru.spcex.clearing.historyimdg.index.field; + +import java.time.LocalDate; + +public interface SearchWithTradingDay { + LocalDate getTradingDate(); + + void setTradingDate(LocalDate tradingDate); +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/AbstractSliceMapLoader.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/AbstractSliceMapLoader.java new file mode 100644 index 000000000..37c2005ac --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/AbstractSliceMapLoader.java @@ -0,0 +1,95 @@ +package ru.spcex.clearing.historyimdg.mapstores; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.dao.support.DataAccessUtils; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate; +import ru.spcex.clearing.imdg.base.AutoconfiguredMap; +import ru.spcex.platform.classes.base.interfaces.WithId; + +import java.sql.Date; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.time.Instant; +import java.time.LocalDate; +import java.time.ZoneId; +import java.time.format.DateTimeFormatter; +import java.time.temporal.ChronoUnit; +import java.util.*; + +import static ru.spcex.clearing.imdg.base.ObjectBaseMapStore.MAX_IN_CLAUSE_SIZE; + +public abstract class AbstractSliceMapLoader implements AutoconfiguredMap { + protected final Logger log = LoggerFactory.getLogger(getClass()); + + protected NamedParameterJdbcTemplate namedParameterJdbcTemplate; + protected JdbcTemplate jdbcTemplate; + protected final DateTimeFormatter FIREBIRD_INSTANT_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd").withZone(ZoneId.systemDefault()); + + public AbstractSliceMapLoader(JdbcTemplate jdbcTemplate) { + this.namedParameterJdbcTemplate = new NamedParameterJdbcTemplate(jdbcTemplate); + this.jdbcTemplate = jdbcTemplate; + } + + protected abstract String getTableName(); + + @Override + public T load(Long id) { + Collection rows; + List list = Collections.singletonList(id); + try { + rows = load(list); + } catch (Throwable e) { // one retry + rows = load(list); + } + return DataAccessUtils.singleResult(rows); + } + + @SuppressWarnings("Duplicates") + @Override + public Map loadAll(Collection keys) { + log.debug("loadAll from " + getTableName() + " " + keys.size() + " keys"); + Map result = new HashMap<>(); + long start = System.currentTimeMillis(); + + // загрузить данные по ключам частями, чтобы не выйти за ограничения базы по кол-ву элементов в in clause + List keysSubList = new ArrayList<>(MAX_IN_CLAUSE_SIZE); + for (Iterator iterator = keys.iterator(); iterator.hasNext(); ) { + Long key = iterator.next(); + keysSubList.add(key); + if (keysSubList.size() == MAX_IN_CLAUSE_SIZE || !iterator.hasNext()) { + Collection rows = load(keysSubList); + for (T row : rows) { + result.put(row.getId(), row); + } + keysSubList.clear(); + } + } + + log.debug("loadAll from " + getTableName() + " " + keys.size() + " keys done in " + (System.currentTimeMillis() - start) + "ms"); + + return result; + + } + + @Override + public Iterable loadAllKeys() { + log.debug("loading all keys from {}...", getTableName()); + Instant yesterdayInstant = Instant.now().minus(0, ChronoUnit.DAYS); + Instant halfYearAgo = yesterdayInstant.minus(365, ChronoUnit.DAYS); + List ids = jdbcTemplate.query("select id from " + getTableName() + " where CAST(tradingday as DATE) <= ? and CAST(tradingday as DATE) >= ? ", + new Object[]{FIREBIRD_INSTANT_FORMATTER.format(yesterdayInstant), FIREBIRD_INSTANT_FORMATTER.format(halfYearAgo)}, + (resultSet, i) -> resultSet.getObject("id", Long.class)); + log.debug("loading all keys from {} done; size={}", getTableName(), ids.size()); + return ids; + } + + protected LocalDate getLocalDateFromSqlDate(ResultSet rs, String column) throws SQLException { + Date date = rs.getDate(column); + return date != null ? date.toLocalDate() : null; + } + + protected abstract Collection load(Collection keys); + +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/HistMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/HistMapStore.java new file mode 100644 index 000000000..cff0d8d31 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/HistMapStore.java @@ -0,0 +1,4 @@ +package ru.spcex.clearing.historyimdg.mapstores; + +public interface HistMapStore { +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/HistoryMapConfig.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/HistoryMapConfig.java new file mode 100644 index 000000000..9164c2c68 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/HistoryMapConfig.java @@ -0,0 +1,63 @@ +package ru.spcex.clearing.historyimdg.mapstores; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Configuration; +import org.springframework.jdbc.core.JdbcTemplate; + +@Configuration +public class HistoryMapConfig { + + private final JdbcTemplate jdbcTemplate; + + @Autowired + public HistoryMapConfig(JdbcTemplate jdbcTemplate) { + this.jdbcTemplate = jdbcTemplate; + } + +// @Bean +// public AutoconfiguredMap registryHistMapStore() { +// return new RegistryMapStore(jdbcTemplate) { +// @Override +// protected boolean isLoadable(Long id) { +// return true; +// } +// +// @Override +// protected boolean isLoadable(Registry obj) { +// return true; +// } +// +// @Override +// public Iterable loadAllKeys() { +// log.debug("RegistryHistoryMapStore loadAllKeys is called"); +// return new ArrayList<>(); +// } +// }; +// } +// +// @Bean +// public AutoconfiguredMap registrySomeMapStore(Class> cl) { +// try { +// AutoconfiguredMap map = cl.getDeclaredConstructor().newInstance(jdbcTemplate); +// } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) { +// throw new RuntimeException(e); +// } +// return new RegistryMapStore(jdbcTemplate) { +// @Override +// protected boolean isLoadable(Long id) { +// return true; +// } +// +// @Override +// protected boolean isLoadable(Registry obj) { +// return true; +// } +// +// @Override +// public Iterable loadAllKeys() { +// log.debug("RegistryHistoryMapStore loadAllKeys is called"); +// return new ArrayList<>(); +// } +// }; +// } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/RegistryHistoryMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/RegistryHistoryMapStore.java new file mode 100644 index 000000000..dc180ddef --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/RegistryHistoryMapStore.java @@ -0,0 +1,31 @@ +package ru.spcex.clearing.historyimdg.mapstores; + +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; +import ru.clearing.classes.statics.data.registry.Registry; +import ru.spcex.clearing.imdg.businessobject.RegistryMapStore; + +import java.util.ArrayList; + +@Component +public class RegistryHistoryMapStore extends RegistryMapStore { + public RegistryHistoryMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + } + + @Override + protected boolean isLoadable(Long id) { + return true; + } + + @Override + protected boolean isLoadable(Registry obj) { + return true; + } + + @Override + public Iterable loadAllKeys() { + log.debug("RegistryHistoryMapStore loadAllKeys is called"); + return new ArrayList<>(); + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchRegistryMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchRegistryMapStore.java new file mode 100644 index 000000000..64ca0f478 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchRegistryMapStore.java @@ -0,0 +1,45 @@ +package ru.spcex.clearing.historyimdg.mapstores; + +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; +import ru.spcex.clearing.historyimdg.index.SearchProxyRegistry; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Collections; +import java.util.Map; + +@Component +public class SearchRegistryMapStore extends AbstractSliceMapLoader { + public SearchRegistryMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + } + + @Override + protected String getTableName() { + return "registry"; + } + + @Override + public Collection load(Collection keys) { + Map> paramMap = Collections.singletonMap("ids", keys); + return namedParameterJdbcTemplate.query("select * from " + getTableName() + " where id in (:ids)", paramMap, + (rs, rowNum) -> { + SearchProxyRegistry proxyRegistry = new SearchProxyRegistry(); + proxyRegistry.setId(rs.getObject("id", Long.class)); + proxyRegistry.setTradingDate(getLocalDateFromSqlDate(rs,"trading_date")); + proxyRegistry.setCompanyId(rs.getObject("company_id", Long.class)); + return proxyRegistry; + }); + } + + @Override + public String getMapName() { + return IMDGDistributedNames.Map_SearchRegistry; + } + + @Override + public String[] getIndexingField() { + return new String[]{"companyId"}; + } +} diff --git a/clearing-parent/imdg-hist/src/main/resources/application.properties b/clearing-parent/imdg-hist/src/main/resources/application.properties new file mode 100644 index 000000000..cc380fc77 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/resources/application.properties @@ -0,0 +1,12 @@ +imdg.hist.hazelcast.listenPort=5701 +imdg.hist.hazelcast.login=dev +imdg.hist.hazelcast.password=dev-pass +imdg.hist.hazelcast.cluster-members[0]=127.0.0.1 +imdg.hist.database.login=clearing +imdg.hist.database.password=Aa111111 +imdg.hist.database.url=jdbc:postgresql://10.200.200.133:5432/clearing?currentSchema=clearing_prod +#imdg.database.url=jdbc:postgresql://10.200.200.133:5432/postgres?currentSchema=clearing_tester + +#debug tester mode: +#imdg.debug-server.port=8701 +#imdg.debug-server.context-path=/imdg/reload \ No newline at end of file diff --git a/clearing-parent/imdg-hist/src/main/resources/hazelcast.yaml b/clearing-parent/imdg-hist/src/main/resources/hazelcast.yaml new file mode 100644 index 000000000..d8ca9f792 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/resources/hazelcast.yaml @@ -0,0 +1,5 @@ +hazelcast: + network: + join: + multicast: + enabled: true \ No newline at end of file diff --git a/clearing-parent/imdg-hist/src/main/resources/logback.xml b/clearing-parent/imdg-hist/src/main/resources/logback.xml new file mode 100644 index 000000000..bb03fe824 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/resources/logback.xml @@ -0,0 +1,38 @@ + + + + + + %date{HH:mm:ss.SSS} [%thread] %-5level %class{0}:%line - %message%n + utf-8 + + + + ./logs/imdg.log + + + %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %class{0}:%msg%n + utf8 + + + + ./logs/imdg.%i.log + + 1 + 10 + + + 500MB + + + + + + + + + + + + + diff --git a/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/base/AutoconfiguredMap1.java b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/base/AutoconfiguredMap1.java new file mode 100644 index 000000000..367e5450d --- /dev/null +++ b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/base/AutoconfiguredMap1.java @@ -0,0 +1,17 @@ +package ru.spcex.clearing.imdg.base; + +import com.hazelcast.core.MapLoader; + +public interface AutoconfiguredMap1 extends MapLoader { + /** + * + * @return IMDGDistributedNames.* + */ + String getMapName(); + + /** + * Список индексируемых полей, для быстрого поиска + * @return + */ + String[] getIndexingField(); +} diff --git a/clearing-parent/pom.xml b/clearing-parent/pom.xml index f67b743ed..b90e0b71c 100644 --- a/clearing-parent/pom.xml +++ b/clearing-parent/pom.xml @@ -41,6 +41,7 @@ swt-exporter swt-importer gateway-api + imdg-hist diff --git a/platform-parent/platform-imdg-api/src/main/java/ru/spcex/clearing/imdg/IMDGDistributedNames.java b/platform-parent/platform-imdg-api/src/main/java/ru/spcex/clearing/imdg/IMDGDistributedNames.java index d4fd82a6b..e5c7cf0a4 100644 --- a/platform-parent/platform-imdg-api/src/main/java/ru/spcex/clearing/imdg/IMDGDistributedNames.java +++ b/platform-parent/platform-imdg-api/src/main/java/ru/spcex/clearing/imdg/IMDGDistributedNames.java @@ -194,6 +194,8 @@ public final class IMDGDistributedNames { public static final String Map_ExecutionFondHistory = "Map_ExecutionFondHistory"; public static final String Map_PriorityDictionary = "Map_PriorityDictionary"; + //-------------------history and search tables + public static final String Map_SearchRegistry = "Map_SearchRegistry"; public static final String MAP_SEQUENCE_NAME = "MAP_SEQUENCE_NAME"; private IMDGDistributedNames() { diff --git a/pom.xml b/pom.xml index e8353b166..758139362 100644 --- a/pom.xml +++ b/pom.xml @@ -84,6 +84,11 @@ imdg ${global.project.version} + + ru.spcex.clearing + imdg-hist + ${global.project.version} + ru.spcex.clearing classes From ba438187e50f3aee8ba1cbd4be59e936c2d1b9ac Mon Sep 17 00:00:00 2001 From: etreschenkov Date: Wed, 11 Oct 2023 12:48:54 +0300 Subject: [PATCH 02/15] add history mapstores --- .../historyimdg/index/SearchProxy.java | 4 +- .../index/SearchProxyExecutionDeposit.java | 19 ++++++++ .../SearchProxyMoneyBalanceRegister.java | 19 ++++++++ ...hProxyMoneyPaymentInstructionRegister.java | 19 ++++++++ .../index/SearchProxyRegistry.java | 24 ---------- .../index/field/SearchWithClearingDate.java | 9 ++++ .../index/field/SearchWithCreated.java | 9 ++++ ...ingDay.java => SearchWithTradingDate.java} | 2 +- .../mapstores/AbstractSliceMapLoader.java | 6 +++ ...a => ExecutionDepositHistoryMapStore.java} | 12 ++--- .../MoneyBalanceRegisterHistoryMapStore.java | 31 +++++++++++++ ...entInstructionRegisterHistoryMapStore.java | 31 +++++++++++++ ...va => SearchExecutionDepositMapStore.java} | 17 ++++--- .../SearchMoneyBalanceRegisterMapStore.java | 44 +++++++++++++++++++ ...neyPaymentInstructionRegisterMapStore.java | 44 +++++++++++++++++++ .../clearing/imdg/IMDGDistributedNames.java | 11 ++++- 16 files changed, 258 insertions(+), 43 deletions(-) create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyExecutionDeposit.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyMoneyBalanceRegister.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyMoneyPaymentInstructionRegister.java delete mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyRegistry.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/field/SearchWithClearingDate.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/field/SearchWithCreated.java rename clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/field/{SearchWithTradingDay.java => SearchWithTradingDate.java} (80%) rename clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/{RegistryHistoryMapStore.java => ExecutionDepositHistoryMapStore.java} (52%) create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/MoneyBalanceRegisterHistoryMapStore.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/MoneyPaymentInstructionRegisterHistoryMapStore.java rename clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/{SearchRegistryMapStore.java => SearchExecutionDepositMapStore.java} (62%) create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchMoneyBalanceRegisterMapStore.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchMoneyPaymentInstructionRegisterMapStore.java diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxy.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxy.java index 0eb4fee26..fa96477e2 100644 --- a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxy.java +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxy.java @@ -2,12 +2,12 @@ package ru.spcex.clearing.historyimdg.index; import ru.spcex.clearing.historyimdg.index.field.SearchWithId; -import ru.spcex.clearing.historyimdg.index.field.SearchWithTradingDay; +import ru.spcex.clearing.historyimdg.index.field.SearchWithTradingDate; import ru.spcex.platform.classes.base.SpcexObjectBase; import java.time.LocalDate; -public class SearchProxy extends SpcexObjectBase implements SearchWithTradingDay, SearchWithId { +public class SearchProxy extends SpcexObjectBase implements SearchWithTradingDate, SearchWithId { private LocalDate tradingDate; @Override diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyExecutionDeposit.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyExecutionDeposit.java new file mode 100644 index 000000000..80406f433 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyExecutionDeposit.java @@ -0,0 +1,19 @@ +package ru.spcex.clearing.historyimdg.index; + +import ru.spcex.clearing.historyimdg.index.field.SearchWithTradingDate; + +import java.time.LocalDate; + +public class SearchProxyExecutionDeposit extends SearchProxy implements SearchWithTradingDate { + private LocalDate tradingDate; + + @Override + public LocalDate getTradingDate() { + return tradingDate; + } + + @Override + public void setTradingDate(LocalDate tradingDate) { + this.tradingDate = tradingDate; + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyMoneyBalanceRegister.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyMoneyBalanceRegister.java new file mode 100644 index 000000000..ab9286877 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyMoneyBalanceRegister.java @@ -0,0 +1,19 @@ +package ru.spcex.clearing.historyimdg.index; + +import ru.spcex.clearing.historyimdg.index.field.SearchWithCreated; + +import java.time.Instant; + +public class SearchProxyMoneyBalanceRegister extends SearchProxy implements SearchWithCreated { + private Instant created; + + @Override + public Instant getCreated() { + return created; + } + + @Override + public void setCreated(Instant created) { + this.created = created; + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyMoneyPaymentInstructionRegister.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyMoneyPaymentInstructionRegister.java new file mode 100644 index 000000000..f4204229f --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyMoneyPaymentInstructionRegister.java @@ -0,0 +1,19 @@ +package ru.spcex.clearing.historyimdg.index; + +import ru.spcex.clearing.historyimdg.index.field.SearchWithClearingDate; + +import java.time.LocalDate; + +public class SearchProxyMoneyPaymentInstructionRegister extends SearchProxy implements SearchWithClearingDate { + private LocalDate clearingDate; + + @Override + public LocalDate getClearingDate() { + return clearingDate; + } + + @Override + public void setClearingDate(LocalDate clearingDate) { + this.clearingDate = clearingDate; + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyRegistry.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyRegistry.java deleted file mode 100644 index d6ed646ee..000000000 --- a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyRegistry.java +++ /dev/null @@ -1,24 +0,0 @@ -package ru.spcex.clearing.historyimdg.index; - -import ru.spcex.clearing.historyimdg.index.field.SearchCompanyId; - -import java.time.LocalDate; - -public class SearchProxyRegistry extends SearchProxy implements SearchCompanyId { - private Long companyId; - - @Override - public Long getCompanyId() { - return companyId; - } - - @Override - public void setCompanyId(Long companyId) { - this.companyId = companyId; - } - - @Override - public void setTradingDate(LocalDate tradingDate) { - - } -} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/field/SearchWithClearingDate.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/field/SearchWithClearingDate.java new file mode 100644 index 000000000..b0cb1f134 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/field/SearchWithClearingDate.java @@ -0,0 +1,9 @@ +package ru.spcex.clearing.historyimdg.index.field; + +import java.time.LocalDate; + +public interface SearchWithClearingDate { + LocalDate getClearingDate(); + + void setClearingDate(LocalDate value); +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/field/SearchWithCreated.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/field/SearchWithCreated.java new file mode 100644 index 000000000..35f1b2d7b --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/field/SearchWithCreated.java @@ -0,0 +1,9 @@ +package ru.spcex.clearing.historyimdg.index.field; + +import java.time.Instant; + +public interface SearchWithCreated { + public Instant getCreated(); + + public void setCreated(Instant created); +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/field/SearchWithTradingDay.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/field/SearchWithTradingDate.java similarity index 80% rename from clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/field/SearchWithTradingDay.java rename to clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/field/SearchWithTradingDate.java index f1cd6f3b8..79bde1841 100644 --- a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/field/SearchWithTradingDay.java +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/field/SearchWithTradingDate.java @@ -2,7 +2,7 @@ package ru.spcex.clearing.historyimdg.index.field; import java.time.LocalDate; -public interface SearchWithTradingDay { +public interface SearchWithTradingDate { LocalDate getTradingDate(); void setTradingDate(LocalDate tradingDate); diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/AbstractSliceMapLoader.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/AbstractSliceMapLoader.java index 37c2005ac..15246e269 100644 --- a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/AbstractSliceMapLoader.java +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/AbstractSliceMapLoader.java @@ -11,6 +11,7 @@ import ru.spcex.platform.classes.base.interfaces.WithId; import java.sql.Date; import java.sql.ResultSet; import java.sql.SQLException; +import java.sql.Timestamp; import java.time.Instant; import java.time.LocalDate; import java.time.ZoneId; @@ -90,6 +91,11 @@ public abstract class AbstractSliceMapLoader implements Autoco return date != null ? date.toLocalDate() : null; } + protected Instant getInstantFromTimestamp(ResultSet rs, String column) throws SQLException { + Timestamp date = rs.getTimestamp(column); + return date != null ? date.toInstant() : null; + } + protected abstract Collection load(Collection keys); } diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/RegistryHistoryMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/ExecutionDepositHistoryMapStore.java similarity index 52% rename from clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/RegistryHistoryMapStore.java rename to clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/ExecutionDepositHistoryMapStore.java index dc180ddef..20e013886 100644 --- a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/RegistryHistoryMapStore.java +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/ExecutionDepositHistoryMapStore.java @@ -2,14 +2,14 @@ package ru.spcex.clearing.historyimdg.mapstores; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.stereotype.Component; -import ru.clearing.classes.statics.data.registry.Registry; -import ru.spcex.clearing.imdg.businessobject.RegistryMapStore; +import ru.clearing.classes.statics.data.execution.ExecutionDeposit; +import ru.spcex.clearing.imdg.businessobject.ExecutionDepositMapStore; import java.util.ArrayList; @Component -public class RegistryHistoryMapStore extends RegistryMapStore { - public RegistryHistoryMapStore(JdbcTemplate jdbcTemplate) { +public class ExecutionDepositHistoryMapStore extends ExecutionDepositMapStore { + public ExecutionDepositHistoryMapStore(JdbcTemplate jdbcTemplate) { super(jdbcTemplate); } @@ -19,13 +19,13 @@ public class RegistryHistoryMapStore extends RegistryMapStore { } @Override - protected boolean isLoadable(Registry obj) { + protected boolean isLoadable(ExecutionDeposit obj) { return true; } @Override public Iterable loadAllKeys() { - log.debug("RegistryHistoryMapStore loadAllKeys is called"); + log.debug("ExecutionDeposit loadAllKeys is called"); return new ArrayList<>(); } } diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/MoneyBalanceRegisterHistoryMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/MoneyBalanceRegisterHistoryMapStore.java new file mode 100644 index 000000000..eda7341b6 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/MoneyBalanceRegisterHistoryMapStore.java @@ -0,0 +1,31 @@ +package ru.spcex.clearing.historyimdg.mapstores; + +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; +import ru.clearing.classes.statics.data.register.MoneyBalanceRegister; +import ru.spcex.clearing.imdg.businessobject.MoneyBalanceRegisterMapStore; + +import java.util.ArrayList; + +@Component +public class MoneyBalanceRegisterHistoryMapStore extends MoneyBalanceRegisterMapStore { + public MoneyBalanceRegisterHistoryMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + } + + @Override + protected boolean isLoadable(Long id) { + return true; + } + + @Override + protected boolean isLoadable(MoneyBalanceRegister obj) { + return true; + } + + @Override + public Iterable loadAllKeys() { + log.debug("MoneyBalanceRegisterHistoryMapStore loadAllKeys is called"); + return new ArrayList<>(); + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/MoneyPaymentInstructionRegisterHistoryMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/MoneyPaymentInstructionRegisterHistoryMapStore.java new file mode 100644 index 000000000..fa4562daf --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/MoneyPaymentInstructionRegisterHistoryMapStore.java @@ -0,0 +1,31 @@ +package ru.spcex.clearing.historyimdg.mapstores; + +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; +import ru.clearing.classes.statics.data.register.MoneyPaymentInstructionRegister; +import ru.spcex.clearing.imdg.businessobject.MoneyPaymentInstructionRegisterMapStore; + +import java.util.ArrayList; + +@Component +public class MoneyPaymentInstructionRegisterHistoryMapStore extends MoneyPaymentInstructionRegisterMapStore { + public MoneyPaymentInstructionRegisterHistoryMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + } + + @Override + protected boolean isLoadable(Long id) { + return true; + } + + @Override + protected boolean isLoadable(MoneyPaymentInstructionRegister obj) { + return true; + } + + @Override + public Iterable loadAllKeys() { + log.debug("MoneyPaymentInstructionRegisterHistoryMapStore loadAllKeys is called"); + return new ArrayList<>(); + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchRegistryMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExecutionDepositMapStore.java similarity index 62% rename from clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchRegistryMapStore.java rename to clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExecutionDepositMapStore.java index 64ca0f478..5ba4c285a 100644 --- a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchRegistryMapStore.java +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExecutionDepositMapStore.java @@ -2,7 +2,7 @@ package ru.spcex.clearing.historyimdg.mapstores; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.stereotype.Component; -import ru.spcex.clearing.historyimdg.index.SearchProxyRegistry; +import ru.spcex.clearing.historyimdg.index.SearchProxyExecutionDeposit; import ru.spcex.clearing.imdg.IMDGDistributedNames; import java.util.Collection; @@ -10,36 +10,35 @@ import java.util.Collections; import java.util.Map; @Component -public class SearchRegistryMapStore extends AbstractSliceMapLoader { - public SearchRegistryMapStore(JdbcTemplate jdbcTemplate) { +public class SearchExecutionDepositMapStore extends AbstractSliceMapLoader { + public SearchExecutionDepositMapStore(JdbcTemplate jdbcTemplate) { super(jdbcTemplate); } @Override protected String getTableName() { - return "registry"; + return "execution_deposit"; } @Override - public Collection load(Collection keys) { + public Collection load(Collection keys) { Map> paramMap = Collections.singletonMap("ids", keys); return namedParameterJdbcTemplate.query("select * from " + getTableName() + " where id in (:ids)", paramMap, (rs, rowNum) -> { - SearchProxyRegistry proxyRegistry = new SearchProxyRegistry(); + SearchProxyExecutionDeposit proxyRegistry = new SearchProxyExecutionDeposit(); proxyRegistry.setId(rs.getObject("id", Long.class)); proxyRegistry.setTradingDate(getLocalDateFromSqlDate(rs,"trading_date")); - proxyRegistry.setCompanyId(rs.getObject("company_id", Long.class)); return proxyRegistry; }); } @Override public String getMapName() { - return IMDGDistributedNames.Map_SearchRegistry; + return IMDGDistributedNames.Map_SearchExecutionDeposit; } @Override public String[] getIndexingField() { - return new String[]{"companyId"}; + return new String[]{"tradingDate"}; } } diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchMoneyBalanceRegisterMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchMoneyBalanceRegisterMapStore.java new file mode 100644 index 000000000..8dbfce9cd --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchMoneyBalanceRegisterMapStore.java @@ -0,0 +1,44 @@ +package ru.spcex.clearing.historyimdg.mapstores; + +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; +import ru.spcex.clearing.historyimdg.index.SearchProxyMoneyBalanceRegister; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Collections; +import java.util.Map; + +@Component +public class SearchMoneyBalanceRegisterMapStore extends AbstractSliceMapLoader { + public SearchMoneyBalanceRegisterMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + } + + @Override + protected String getTableName() { + return "money_balance_register"; + } + + @Override + public Collection load(Collection keys) { + Map> paramMap = Collections.singletonMap("ids", keys); + return namedParameterJdbcTemplate.query("select * from " + getTableName() + " where id in (:ids)", paramMap, + (rs, rowNum) -> { + SearchProxyMoneyBalanceRegister proxyRegistry = new SearchProxyMoneyBalanceRegister(); + proxyRegistry.setId(rs.getObject("id", Long.class)); + proxyRegistry.setCreated(getInstantFromTimestamp(rs, "CREATED_AT")); + return proxyRegistry; + }); + } + + @Override + public String getMapName() { + return IMDGDistributedNames.Map_SearchMoneyBalanceRegister; + } + + @Override + public String[] getIndexingField() { + return new String[]{"created"}; + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchMoneyPaymentInstructionRegisterMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchMoneyPaymentInstructionRegisterMapStore.java new file mode 100644 index 000000000..82567a6fd --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchMoneyPaymentInstructionRegisterMapStore.java @@ -0,0 +1,44 @@ +package ru.spcex.clearing.historyimdg.mapstores; + +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; +import ru.spcex.clearing.historyimdg.index.SearchProxyMoneyPaymentInstructionRegister; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Collections; +import java.util.Map; + +@Component +public class SearchMoneyPaymentInstructionRegisterMapStore extends AbstractSliceMapLoader { + public SearchMoneyPaymentInstructionRegisterMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + } + + @Override + protected String getTableName() { + return "money_payment_instruction_register"; + } + + @Override + public Collection load(Collection keys) { + Map> paramMap = Collections.singletonMap("ids", keys); + return namedParameterJdbcTemplate.query("select * from " + getTableName() + " where id in (:ids)", paramMap, + (rs, rowNum) -> { + SearchProxyMoneyPaymentInstructionRegister proxyRegistry = new SearchProxyMoneyPaymentInstructionRegister(); + proxyRegistry.setId(rs.getObject("id", Long.class)); + proxyRegistry.setClearingDate(getLocalDateFromSqlDate(rs, "clearing_date")); + return proxyRegistry; + }); + } + + @Override + public String getMapName() { + return IMDGDistributedNames.Map_SearchMoneyPaymentInstructionRegister; + } + + @Override + public String[] getIndexingField() { + return new String[]{"created"}; + } +} diff --git a/platform-parent/platform-imdg-api/src/main/java/ru/spcex/clearing/imdg/IMDGDistributedNames.java b/platform-parent/platform-imdg-api/src/main/java/ru/spcex/clearing/imdg/IMDGDistributedNames.java index e5c7cf0a4..0047bd791 100644 --- a/platform-parent/platform-imdg-api/src/main/java/ru/spcex/clearing/imdg/IMDGDistributedNames.java +++ b/platform-parent/platform-imdg-api/src/main/java/ru/spcex/clearing/imdg/IMDGDistributedNames.java @@ -195,7 +195,16 @@ public final class IMDGDistributedNames { public static final String Map_PriorityDictionary = "Map_PriorityDictionary"; //-------------------history and search tables - public static final String Map_SearchRegistry = "Map_SearchRegistry"; + public static final String Map_SearchExecutionDeposit = "Map_SearchDeposit"; + public static final String Map_SearchExecutionFond = "Map_SearchExecutionFond"; + public static final String Map_SearchMoneyBalanceRegister = "Map_SearchMoneyBalanceRegister"; + public static final String Map_SearchAdmittedLiabilitiesRegister = "Map_SearchAdmittedLiabilitiesRegister"; + public static final String Map_SearchCoveredLiabilitiesRegister = "Map_SearchCoveredLiabilitiesRegister"; + public static final String Map_SearchMoneyPaymentInstructionRegister = "Map_SearchMoneyPaymentInstructionRegister"; + public static final String Map_SearchDepoPaymentInstructionRegister = "Map_SearchDepoPaymentInstructionRegister"; + public static final String Map_SearchExcludeLiabilitiesRegister = "Map_SearchExcludeLiabilitiesRegister"; + public static final String Map_SearchLiabilitiesRegister = "Map_SearchLiabilitiesRegister"; + public static final String Map_SearchExecutionRegister = "Map_SearchExecutionRegister"; public static final String MAP_SEQUENCE_NAME = "MAP_SEQUENCE_NAME"; private IMDGDistributedNames() { From 7b422acc4a104b7b7a8fa2103cf36490afda752c Mon Sep 17 00:00:00 2001 From: etreschenkov Date: Wed, 11 Oct 2023 21:44:02 +0300 Subject: [PATCH 03/15] add history mapstores --- clearing-parent/imdg-hist/pom.xml | 7 ++-- .../config/HistoryPoolMapConfigs.java | 8 ++--- clearing-parent/imdg/pom.xml | 1 + .../clearing/imdg/base/AutoconfiguredMap.java | 34 +++++++++---------- .../imdg/base/AutoconfiguredMap1.java | 17 ---------- 5 files changed, 26 insertions(+), 41 deletions(-) delete mode 100644 clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/base/AutoconfiguredMap1.java diff --git a/clearing-parent/imdg-hist/pom.xml b/clearing-parent/imdg-hist/pom.xml index b97f12c19..1653d470a 100644 --- a/clearing-parent/imdg-hist/pom.xml +++ b/clearing-parent/imdg-hist/pom.xml @@ -3,14 +3,16 @@ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> 4.0.0 + imdg-hist + jar + SPCEX-1.0.0.0 + clearing-parent ru.spcex.clearing SPCEX-1.0.0.0 - imdg-hist - jar 17 @@ -30,7 +32,6 @@ ru.spcex.clearing imdg - SPCEX-1.0.0.0 ru.spcex.clearing diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/HistoryPoolMapConfigs.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/HistoryPoolMapConfigs.java index dcd4012b0..ee8f1a414 100644 --- a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/HistoryPoolMapConfigs.java +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/HistoryPoolMapConfigs.java @@ -7,7 +7,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Configuration; -import ru.spcex.clearing.imdg.base.AutoconfiguredMap1; +import ru.spcex.clearing.imdg.base.AutoconfiguredMap; import ru.spcex.clearing.imdg.base.DictionaryTMapStore; import java.util.ArrayList; @@ -20,10 +20,10 @@ public class HistoryPoolMapConfigs { private final Logger log = LoggerFactory.getLogger(getClass()); - private final List> autoconfiguredMaps; + private final List> autoconfiguredMaps; @Autowired - public HistoryPoolMapConfigs(List> autoconfiguredMaps) { + public HistoryPoolMapConfigs(List> autoconfiguredMaps) { this.autoconfiguredMaps = autoconfiguredMaps; } @@ -60,7 +60,7 @@ public class HistoryPoolMapConfigs { public List configureEachMapStore() { List out = new ArrayList<>(); HashSet existMapStores = new HashSet<>(); - for (AutoconfiguredMap1 mapStore : autoconfiguredMaps) { + for (AutoconfiguredMap mapStore : autoconfiguredMaps) { try { log.debug("Link mapstore {} to map {}", mapStore.toString(), mapStore.getMapName()); if (StringUtils.isEmpty(mapStore.getMapName())) { diff --git a/clearing-parent/imdg/pom.xml b/clearing-parent/imdg/pom.xml index 24a1cef03..609a45138 100644 --- a/clearing-parent/imdg/pom.xml +++ b/clearing-parent/imdg/pom.xml @@ -143,6 +143,7 @@ true + exec ${project.artifactId} diff --git a/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/base/AutoconfiguredMap.java b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/base/AutoconfiguredMap.java index d3d1b44ff..0807f6c19 100644 --- a/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/base/AutoconfiguredMap.java +++ b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/base/AutoconfiguredMap.java @@ -1,17 +1,17 @@ -package ru.spcex.clearing.imdg.base; - -import com.hazelcast.core.MapLoader; - -public interface AutoconfiguredMap extends MapLoader { - /** - * - * @return IMDGDistributedNames.* - */ - String getMapName(); - - /** - * Список индексируемых полей, для быстрого поиска - * @return - */ - String[] getIndexingField(); -} +package ru.spcex.clearing.imdg.base; + +import com.hazelcast.core.MapLoader; + +public interface AutoconfiguredMap extends MapLoader { + /** + * + * @return IMDGDistributedNames.* + */ + String getMapName(); + + /** + * Список индексируемых полей, для быстрого поиска + * @return + */ + String[] getIndexingField(); +} diff --git a/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/base/AutoconfiguredMap1.java b/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/base/AutoconfiguredMap1.java deleted file mode 100644 index 367e5450d..000000000 --- a/clearing-parent/imdg/src/main/java/ru/spcex/clearing/imdg/base/AutoconfiguredMap1.java +++ /dev/null @@ -1,17 +0,0 @@ -package ru.spcex.clearing.imdg.base; - -import com.hazelcast.core.MapLoader; - -public interface AutoconfiguredMap1 extends MapLoader { - /** - * - * @return IMDGDistributedNames.* - */ - String getMapName(); - - /** - * Список индексируемых полей, для быстрого поиска - * @return - */ - String[] getIndexingField(); -} From 039f1f85104de2ec431b48b9b89185ad4ca78ba8 Mon Sep 17 00:00:00 2001 From: ialbert Date: Fri, 13 Oct 2023 16:35:11 +0300 Subject: [PATCH 04/15] imdg-hist example --- .../config/BackEndApiImdgConfig.java | 24 ++++ .../config/element/BackendApiSettings.java | 9 ++ .../src/main/resources/application.properties | 3 + .../config/HistoryPoolMapConfigs.java | 15 ++- .../mapstores/AbstractSliceMapLoader.java | 19 +-- .../SearchMoneyBalanceRegisterMapStore.java | 27 +++++ .../services/HazelcastLifecycleSupport.java | 111 ++++++++++++++++++ .../src/main/resources/application.properties | 6 +- .../iml/hazelcast/adapter/ImdgHazelcast.java | 6 + .../java/ru/spcex/platform/imdg/api/Imdg.java | 4 + z-distr/pom.xml | 2 +- 11 files changed, 209 insertions(+), 17 deletions(-) create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/services/HazelcastLifecycleSupport.java diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/BackEndApiImdgConfig.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/BackEndApiImdgConfig.java index b43a385db..b35c5af31 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/BackEndApiImdgConfig.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/BackEndApiImdgConfig.java @@ -21,6 +21,16 @@ public class BackEndApiImdgConfig { return createThreadPoolTaskExecutor(1, false); } + @Bean(name = "taskExecutorHazelcastClientInitializerHist") + public ThreadPoolTaskExecutor taskExecutorHazelcastClientInitializerHist() { + return createThreadPoolTaskExecutor(1, true); + } + + @Bean(name = "taskExecutorIdGeneratorAwaiterHist") + public ThreadPoolTaskExecutor taskExecutorIdGeneratorAwaiterHist() { + return createThreadPoolTaskExecutor(1, false); + } + @Autowired @Bean public ImdgProvider imdgProvider( @@ -35,6 +45,20 @@ public class BackEndApiImdgConfig { return imdg; } + @Autowired + @Bean + public ImdgProvider imdgProviderHist( + @Qualifier("taskExecutorHazelcastClientInitializerHist") ThreadPoolTaskExecutor taskExecutorHazelcastClientInitializer, + @Qualifier("taskExecutorIdGeneratorAwaiterHist") ThreadPoolTaskExecutor taskExecutorIdGeneratorAwaiter, + BackendApiSettings clientSetting + ) { + ImdgProvider imdg = new HazelcastService(taskExecutorHazelcastClientInitializer, + taskExecutorIdGeneratorAwaiter, + clientSetting.getHazelcastSearch()); +// todo корректное ожидание готовности imdg.waitAvailable(); + return imdg; + } + private static ThreadPoolTaskExecutor createThreadPoolTaskExecutor(int maxPoolSz, boolean waitForCompletion) { ThreadPoolTaskExecutor pool = new ThreadPoolTaskExecutor(); diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/element/BackendApiSettings.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/element/BackendApiSettings.java index 79ba99f2d..9b51e8890 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/element/BackendApiSettings.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/element/BackendApiSettings.java @@ -13,6 +13,7 @@ import ru.spcex.platform.imdg.iml.hazelcast.config.HazelcastClientParams; @ConfigurationProperties("backend-api") public class BackendApiSettings { private HazelcastClientParams hazelcast; + private HazelcastClientParams hazelcastSearch; private KafkaProducerSettings kafkaProducer; private KafkaConsumerSettings kafkaConsumer; private SecuritySettings security; @@ -57,4 +58,12 @@ public class BackendApiSettings { public void setSecurity(SecuritySettings security) { this.security = security; } + + public HazelcastClientParams getHazelcastSearch() { + return hazelcastSearch; + } + + public void setHazelcastSearch(HazelcastClientParams hazelcastSearch) { + this.hazelcastSearch = hazelcastSearch; + } } diff --git a/clearing-parent/backend-api/src/main/resources/application.properties b/clearing-parent/backend-api/src/main/resources/application.properties index 29cf01fe5..24016512d 100644 --- a/clearing-parent/backend-api/src/main/resources/application.properties +++ b/clearing-parent/backend-api/src/main/resources/application.properties @@ -9,6 +9,9 @@ backend-api.example-setting=test backend-api.hazelcast.cluster-members=127.0.0.1:5701 backend-api.hazelcast.login=dev backend-api.hazelcast.password=dev-pass +backend-api.hazelcast-search.cluster-members=127.0.0.1:5702 +backend-api.hazelcast-search.login=dev-hist +backend-api.hazelcast-search.password=dev-pass-hist backend-api.kafka-producer.bootstrap-servers=localhost:9092 backend-api.kafka-producer.acks=all backend-api.kafka-producer.retries=0 diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/HistoryPoolMapConfigs.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/HistoryPoolMapConfigs.java index ee8f1a414..eb670d92b 100644 --- a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/HistoryPoolMapConfigs.java +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/HistoryPoolMapConfigs.java @@ -6,14 +6,12 @@ import org.apache.commons.lang3.StringUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import ru.spcex.clearing.imdg.base.AutoconfiguredMap; import ru.spcex.clearing.imdg.base.DictionaryTMapStore; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.HashSet; -import java.util.List; +import java.util.*; @Configuration public class HistoryPoolMapConfigs { @@ -91,4 +89,13 @@ public class HistoryPoolMapConfigs { log.debug("Configured {} mapStore's", out.size()); return out; } + + //fixme remove + @Bean("historyMapNames") + public Set historyMaps() { + Set historyMaps = new HashSet<>(); +// historyMaps.add(IMDGDistributedNames.Map_MoneyBalanceRegister); + return historyMaps; + } + } diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/AbstractSliceMapLoader.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/AbstractSliceMapLoader.java index 15246e269..d278e1f96 100644 --- a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/AbstractSliceMapLoader.java +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/AbstractSliceMapLoader.java @@ -16,7 +16,6 @@ import java.time.Instant; import java.time.LocalDate; import java.time.ZoneId; import java.time.format.DateTimeFormatter; -import java.time.temporal.ChronoUnit; import java.util.*; import static ru.spcex.clearing.imdg.base.ObjectBaseMapStore.MAX_IN_CLAUSE_SIZE; @@ -76,14 +75,16 @@ public abstract class AbstractSliceMapLoader implements Autoco @Override public Iterable loadAllKeys() { - log.debug("loading all keys from {}...", getTableName()); - Instant yesterdayInstant = Instant.now().minus(0, ChronoUnit.DAYS); - Instant halfYearAgo = yesterdayInstant.minus(365, ChronoUnit.DAYS); - List ids = jdbcTemplate.query("select id from " + getTableName() + " where CAST(tradingday as DATE) <= ? and CAST(tradingday as DATE) >= ? ", - new Object[]{FIREBIRD_INSTANT_FORMATTER.format(yesterdayInstant), FIREBIRD_INSTANT_FORMATTER.format(halfYearAgo)}, - (resultSet, i) -> resultSet.getObject("id", Long.class)); - log.debug("loading all keys from {} done; size={}", getTableName(), ids.size()); - return ids; + //fixme понять какое поле подходит большинству таблиц. created_at??? + return Collections.emptyList(); +// log.debug("loading all keys from {}...", getTableName()); +// Instant yesterdayInstant = Instant.now().minus(0, ChronoUnit.DAYS); +// Instant halfYearAgo = yesterdayInstant.minus(365, ChronoUnit.DAYS); +// List ids = jdbcTemplate.query("select id from " + getTableName() + " where CAST(tradingday as DATE) <= ? and CAST(tradingday as DATE) >= ? ", +// new Object[]{FIREBIRD_INSTANT_FORMATTER.format(yesterdayInstant), FIREBIRD_INSTANT_FORMATTER.format(halfYearAgo)}, +// (resultSet, i) -> resultSet.getObject("id", Long.class)); +// log.debug("loading all keys from {} done; size={}", getTableName(), ids.size()); +// return ids; } protected LocalDate getLocalDateFromSqlDate(ResultSet rs, String column) throws SQLException { diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchMoneyBalanceRegisterMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchMoneyBalanceRegisterMapStore.java index 8dbfce9cd..68c929cb3 100644 --- a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchMoneyBalanceRegisterMapStore.java +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchMoneyBalanceRegisterMapStore.java @@ -5,8 +5,11 @@ import org.springframework.stereotype.Component; import ru.spcex.clearing.historyimdg.index.SearchProxyMoneyBalanceRegister; import ru.spcex.clearing.imdg.IMDGDistributedNames; +import java.time.LocalDate; +import java.time.temporal.ChronoUnit; import java.util.Collection; import java.util.Collections; +import java.util.List; import java.util.Map; @Component @@ -20,6 +23,30 @@ public class SearchMoneyBalanceRegisterMapStore extends AbstractSliceMapLoader loadAllKeys() { + //пример loadAllKeys + log.debug("loading all keys from {}...", getTableName()); + LocalDate upperInstant = LocalDate.now().plus(1, ChronoUnit.DAYS); + LocalDate halfYearAgo = upperInstant.minus(365, ChronoUnit.DAYS); + List ids = jdbcTemplate.query("select id from " + getTableName() + " where CAST(created_at as DATE) <= ? and CAST(created_at as DATE) >= ? ", + new Object[]{upperInstant, halfYearAgo}, + (resultSet, i) -> resultSet.getObject("id", Long.class)); + log.debug("loading all keys from {} done; size={}", getTableName(), ids.size()); + return ids; + //LocalDate today = LocalDate.now(); + // log.debug("loadAllKeys from {} on {} {} today", getTableName(), dateField, canBeGreat ? ">=" : "="); + // List keys; + // try { + // keys = jdbcTemplate.query("select id from " + getTableName() + " where " + dateField + (canBeGreat ? " >= ?" : " = ?"), + // (resultSet, i) -> resultSet.getLong("id"), + // new Object[]{today}); + // } catch (Throwable e) { + // log.error("At load keys from {} (by field {}): {}", getTableName(), dateField, ExceptionUtils.getStackTrace(e)); + // throw e; + // } + } + @Override public Collection load(Collection keys) { Map> paramMap = Collections.singletonMap("ids", keys); diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/services/HazelcastLifecycleSupport.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/services/HazelcastLifecycleSupport.java new file mode 100644 index 000000000..24d55cdec --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/services/HazelcastLifecycleSupport.java @@ -0,0 +1,111 @@ +package ru.spcex.clearing.historyimdg.services; + +import com.hazelcast.core.HazelcastInstance; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.DisposableBean; +import org.springframework.beans.factory.InitializingBean; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.stereotype.Service; +import ru.spcex.platform.imdg.iml.hazelcast.util.HazelcastHelper; + +import java.util.Collection; + +@Service +public class HazelcastLifecycleSupport implements InitializingBean, DisposableBean { + private final Logger log = LoggerFactory.getLogger(getClass()); + private final HazelcastInstance hazelcastServerInstance; + private final Collection historyMapNames; + + @Autowired + public HazelcastLifecycleSupport(@Qualifier("hazelcastInstanceImdg") HazelcastInstance hazelcastServerInstance, Collection historyMapNames) { + this.hazelcastServerInstance = hazelcastServerInstance; + this.historyMapNames = historyMapNames; + } + + @Override + public void afterPropertiesSet() throws Exception { + long loadTime = System.currentTimeMillis(); + log.debug("init maps started"); + for (String mapName : hazelcastServerInstance.getConfig().getMapConfigs().keySet()) { + //зачем historyMapNames - изначально чтобы соотв. MapStore не делал loadAllKeys + //по факту в Histry мапсторах метод loadAllKeys должен быть всегда переопределен в emptyList() + //можно потом убрать + if (historyMapNames.contains(mapName)) { + continue; + } + log.debug("configured '{}' map for hazelcast search server. size: {}", mapName, hazelcastServerInstance.getMap(mapName).size()); + } + loadTime = System.currentTimeMillis() - loadTime; + log.info("All map load time {} ms", loadTime); + HazelcastHelper.imdgSystem_setStorageState(true, hazelcastServerInstance); + } + + @Override + public void destroy() throws Exception { + + } + //package com.moex.corp.search.service; + // + //import com.hazelcast.core.HazelcastInstance; + //import com.moex.platform.errors.TextErrorService; + //import com.moex.platform.hazelcast.HazelcastCommon; + //import org.slf4j.Logger; + //import org.slf4j.LoggerFactory; + //import org.springframework.beans.factory.DisposableBean; + //import org.springframework.beans.factory.InitializingBean; + //import org.springframework.beans.factory.annotation.Autowired; + //import org.springframework.beans.factory.annotation.Qualifier; + //import org.springframework.stereotype.Service; + // + //import java.util.Collection; + // + //@SuppressWarnings("Duplicates") + //@Service + //public class HazelcastLifecycleSupport implements InitializingBean, DisposableBean { + // /** + // * Рабочая версия БД. Требуется вручную сверять с DDL.sql и накручивать эту переменную. + // */ + // public static final String CHECK_DB_VERSION = "2.39"; + // + // private final Logger log = LoggerFactory.getLogger(this.getClass()); + // + // private final HazelcastInstance hazelcastServerInstance; + // private final Collection historyMapNames; + // + // @Autowired + // public HazelcastLifecycleSupport(HazelcastInstance hazelcastServerInstance, + // @Qualifier("historyMapNames") Collection historyMapNames) { + // this.hazelcastServerInstance = hazelcastServerInstance; + // this.historyMapNames = historyMapNames; + // } + // + // @Override + // public void afterPropertiesSet() { + // long loadTime = System.currentTimeMillis(); + // log.debug("init maps started"); + // for (String mapName : hazelcastServerInstance.getConfig().getMapConfigs().keySet()) { + // if (historyMapNames.contains(mapName)) { + // continue; + // } + // log.debug("configured '{}' map for hazelcast search server. size: {}", mapName, hazelcastServerInstance.getMap(mapName).size()); + // } + // loadTime = System.currentTimeMillis() - loadTime; + // log.info("All map load time {} ms", loadTime); + // HazelcastCommon.otcSystem_setStorageState(true, hazelcastServerInstance); + // + // TextErrorService.setHazelcast(hazelcastServerInstance); + // + // } + // + // @Override + // public void destroy() { + // hazelcastServerInstance.shutdown(); + // } + // + // public HazelcastInstance getHazelcastServerInstance() { + // return hazelcastServerInstance; + // } + //} +} diff --git a/clearing-parent/imdg-hist/src/main/resources/application.properties b/clearing-parent/imdg-hist/src/main/resources/application.properties index cc380fc77..87fc068e3 100644 --- a/clearing-parent/imdg-hist/src/main/resources/application.properties +++ b/clearing-parent/imdg-hist/src/main/resources/application.properties @@ -1,6 +1,6 @@ -imdg.hist.hazelcast.listenPort=5701 -imdg.hist.hazelcast.login=dev -imdg.hist.hazelcast.password=dev-pass +imdg.hist.hazelcast.listenPort=5702 +imdg.hist.hazelcast.login=dev-hist +imdg.hist.hazelcast.password=dev-pass-hist imdg.hist.hazelcast.cluster-members[0]=127.0.0.1 imdg.hist.database.login=clearing imdg.hist.database.password=Aa111111 diff --git a/platform-parent/platform-imdg-api-hazelcast-impl/src/main/java/ru/spcex/platform/imdg/iml/hazelcast/adapter/ImdgHazelcast.java b/platform-parent/platform-imdg-api-hazelcast-impl/src/main/java/ru/spcex/platform/imdg/iml/hazelcast/adapter/ImdgHazelcast.java index 1722b07a8..195a9db37 100644 --- a/platform-parent/platform-imdg-api-hazelcast-impl/src/main/java/ru/spcex/platform/imdg/iml/hazelcast/adapter/ImdgHazelcast.java +++ b/platform-parent/platform-imdg-api-hazelcast-impl/src/main/java/ru/spcex/platform/imdg/iml/hazelcast/adapter/ImdgHazelcast.java @@ -232,6 +232,12 @@ public class ImdgHazelcast implements Imdg { return result; } + @Override + public Collection getCollectionIdsByPredicate(ImdgPredicate prdct) { + Predicate hazelcastPredicate = ((ImdgPredicateHazelcast) prdct).getRawPredicate(); + return new ArrayList<>(map.keySet(hazelcastPredicate)); + } + @Override public Long nextIDSequenceFor() { return idGenerator.newId(); diff --git a/platform-parent/platform-imdg-api/src/main/java/ru/spcex/platform/imdg/api/Imdg.java b/platform-parent/platform-imdg-api/src/main/java/ru/spcex/platform/imdg/api/Imdg.java index 9beb042df..eb8e6c182 100644 --- a/platform-parent/platform-imdg-api/src/main/java/ru/spcex/platform/imdg/api/Imdg.java +++ b/platform-parent/platform-imdg-api/src/main/java/ru/spcex/platform/imdg/api/Imdg.java @@ -64,6 +64,10 @@ public interface Imdg { throw new UnsupportedOperationException("not implemented getCollectionIdsBySQL"); } + default Collection getCollectionIdsByPredicate(ImdgPredicate prdct) { + throw new UnsupportedOperationException("not implemented getCollectionIdsByPredicate"); + } + default Collection getAllValues() { throw new UnsupportedOperationException("not implemented getAllValues"); } diff --git a/z-distr/pom.xml b/z-distr/pom.xml index a0e3395ad..1289682bf 100644 --- a/z-distr/pom.xml +++ b/z-distr/pom.xml @@ -147,7 +147,7 @@ - ${folder_root_clearing_imdg}/target/imdg.jar + ${folder_root_clearing_imdg}/target/imdg-exec.jar ${folder.clearing.distr.bin}/imdg.jar From 86a76a44888ff34da24bdaae3f47f5fd156b051d Mon Sep 17 00:00:00 2001 From: ialbert Date: Fri, 13 Oct 2023 16:44:28 +0300 Subject: [PATCH 05/15] history example controller --- .../controller/test/HistController.java | 71 +++++++++++++++++++ 1 file changed, 71 insertions(+) create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/test/HistController.java diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/test/HistController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/test/HistController.java new file mode 100644 index 000000000..1bd27d802 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/test/HistController.java @@ -0,0 +1,71 @@ +package ru.spcex.clearing.backendapi.controller.test; + +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiResponse; +import io.swagger.annotations.ApiResponses; +import org.springframework.beans.factory.InitializingBean; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.ResponseBody; +import ru.clearing.classes.statics.data.register.MoneyBalanceRegister; +import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; +import ru.spcex.clearing.backendapi.meta.GetResponseFactory; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.platform.classes.base.SpcexObjectBase; +import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.api.ImdgProvider; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder; +import ru.spcex.platform.utils.time.TimeUtil; + +import java.time.LocalDate; +import java.time.Month; +import java.util.Collection; +import java.util.List; +import java.util.Map; +import java.util.Objects; + +@Controller +@RequestMapping("/history") +public class HistController implements InitializingBean { + private final ImdgProvider imdgProviderHist; + private final ImdgProvider imdgProvider; + private final GetResponseFactory responseFactory; + + @Autowired + public HistController(@Qualifier("imdgProviderHist") ImdgProvider imdgProviderHist, + @Qualifier("imdgProvider") ImdgProvider imdgProvider, GetResponseFactory responseFactory) { + this.imdgProviderHist = imdgProviderHist; + this.imdgProvider = imdgProvider; + this.responseFactory = responseFactory; + } + + @ApiOperation(value = "get all accounts.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) + @RequestMapping(path = "/money-balance-register", method = RequestMethod.GET) + @ResponseBody + public CommonGetAllResponse getAll() { + Imdg searchMap = imdgProviderHist.getImdg(IMDGDistributedNames.Map_SearchMoneyBalanceRegister, SpcexObjectBase.class); + ImdgPredicateBuilder prdct = searchMap.predicateBuilder(); + LocalDate time = LocalDate.of(2023, Month.JUNE, 8);//2023-06-08 + Collection ids = searchMap.getCollectionIdsByPredicate(prdct.greatEqual("created", TimeUtil.localDateToInstant(time))); + Imdg histMap = imdgProviderHist.getImdg(IMDGDistributedNames.Map_MoneyBalanceRegister, MoneyBalanceRegister.class); + List> maps = ids.stream() + .map(histMap::getSingleObjectByID) + .filter(Objects::nonNull) + .map(responseFactory::responseFromObject) + .toList(); + CommonGetAllResponse response = new CommonGetAllResponse(); + response.fromEntity(maps); + return response; + } + + + @Override + public void afterPropertiesSet() throws Exception { + imdgProviderHist.waitAvailable(); + imdgProvider.waitAvailable(); + } +} From 1d36a64dd57754a6d00a707e868a674855d34197 Mon Sep 17 00:00:00 2001 From: etreschenkov Date: Fri, 13 Oct 2023 16:57:56 +0300 Subject: [PATCH 06/15] add history mapstores --- .../mapstores/AbstractSliceMapLoader.java | 12 +++-- .../SearchMoneyBalanceRegisterMapStore.java | 51 +++++++++---------- 2 files changed, 31 insertions(+), 32 deletions(-) diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/AbstractSliceMapLoader.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/AbstractSliceMapLoader.java index d278e1f96..b946d0d83 100644 --- a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/AbstractSliceMapLoader.java +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/AbstractSliceMapLoader.java @@ -76,15 +76,17 @@ public abstract class AbstractSliceMapLoader implements Autoco @Override public Iterable loadAllKeys() { //fixme понять какое поле подходит большинству таблиц. created_at??? - return Collections.emptyList(); -// log.debug("loading all keys from {}...", getTableName()); + //fixme пока выгружаются все ключи безотносительно даты +// return Collections.emptyList(); // Instant yesterdayInstant = Instant.now().minus(0, ChronoUnit.DAYS); // Instant halfYearAgo = yesterdayInstant.minus(365, ChronoUnit.DAYS); // List ids = jdbcTemplate.query("select id from " + getTableName() + " where CAST(tradingday as DATE) <= ? and CAST(tradingday as DATE) >= ? ", // new Object[]{FIREBIRD_INSTANT_FORMATTER.format(yesterdayInstant), FIREBIRD_INSTANT_FORMATTER.format(halfYearAgo)}, -// (resultSet, i) -> resultSet.getObject("id", Long.class)); -// log.debug("loading all keys from {} done; size={}", getTableName(), ids.size()); -// return ids; + log.debug("loading all keys from {}...", getTableName()); + List ids = jdbcTemplate.query("select id from " + getTableName(), + (resultSet, i) -> resultSet.getObject("id", Long.class)); + log.debug("loading all keys from {} done; size={}", getTableName(), ids.size()); + return ids; } protected LocalDate getLocalDateFromSqlDate(ResultSet rs, String column) throws SQLException { diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchMoneyBalanceRegisterMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchMoneyBalanceRegisterMapStore.java index 68c929cb3..cf163f2e6 100644 --- a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchMoneyBalanceRegisterMapStore.java +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchMoneyBalanceRegisterMapStore.java @@ -5,11 +5,8 @@ import org.springframework.stereotype.Component; import ru.spcex.clearing.historyimdg.index.SearchProxyMoneyBalanceRegister; import ru.spcex.clearing.imdg.IMDGDistributedNames; -import java.time.LocalDate; -import java.time.temporal.ChronoUnit; import java.util.Collection; import java.util.Collections; -import java.util.List; import java.util.Map; @Component @@ -22,30 +19,30 @@ public class SearchMoneyBalanceRegisterMapStore extends AbstractSliceMapLoader loadAllKeys() { - //пример loadAllKeys - log.debug("loading all keys from {}...", getTableName()); - LocalDate upperInstant = LocalDate.now().plus(1, ChronoUnit.DAYS); - LocalDate halfYearAgo = upperInstant.minus(365, ChronoUnit.DAYS); - List ids = jdbcTemplate.query("select id from " + getTableName() + " where CAST(created_at as DATE) <= ? and CAST(created_at as DATE) >= ? ", - new Object[]{upperInstant, halfYearAgo}, - (resultSet, i) -> resultSet.getObject("id", Long.class)); - log.debug("loading all keys from {} done; size={}", getTableName(), ids.size()); - return ids; - //LocalDate today = LocalDate.now(); - // log.debug("loadAllKeys from {} on {} {} today", getTableName(), dateField, canBeGreat ? ">=" : "="); - // List keys; - // try { - // keys = jdbcTemplate.query("select id from " + getTableName() + " where " + dateField + (canBeGreat ? " >= ?" : " = ?"), - // (resultSet, i) -> resultSet.getLong("id"), - // new Object[]{today}); - // } catch (Throwable e) { - // log.error("At load keys from {} (by field {}): {}", getTableName(), dateField, ExceptionUtils.getStackTrace(e)); - // throw e; - // } - } +// +// @Override +// public Iterable loadAllKeys() { +// //пример loadAllKeys +// log.debug("loading all keys from {}...", getTableName()); +// LocalDate upperInstant = LocalDate.now().plus(1, ChronoUnit.DAYS); +// LocalDate halfYearAgo = upperInstant.minus(365, ChronoUnit.DAYS); +// List ids = jdbcTemplate.query("select id from " + getTableName() + " where CAST(created_at as DATE) <= ? and CAST(created_at as DATE) >= ? ", +// new Object[]{upperInstant, halfYearAgo}, +// (resultSet, i) -> resultSet.getObject("id", Long.class)); +// log.debug("loading all keys from {} done; size={}", getTableName(), ids.size()); +// return ids; +// //LocalDate today = LocalDate.now(); +// // log.debug("loadAllKeys from {} on {} {} today", getTableName(), dateField, canBeGreat ? ">=" : "="); +// // List keys; +// // try { +// // keys = jdbcTemplate.query("select id from " + getTableName() + " where " + dateField + (canBeGreat ? " >= ?" : " = ?"), +// // (resultSet, i) -> resultSet.getLong("id"), +// // new Object[]{today}); +// // } catch (Throwable e) { +// // log.error("At load keys from {} (by field {}): {}", getTableName(), dateField, ExceptionUtils.getStackTrace(e)); +// // throw e; +// // } +// } @Override public Collection load(Collection keys) { From 6887b627c7f9cb0c985c9d2c3dacf75b988bbfc4 Mon Sep 17 00:00:00 2001 From: ialbert Date: Fri, 13 Oct 2023 19:29:55 +0300 Subject: [PATCH 07/15] imdg-hist example 2 --- .../cud/history/HistoryConditionRequest.java | 51 +++++++++++++ .../controller/test/HistController.java | 75 +++++++++++++++++-- 2 files changed, 119 insertions(+), 7 deletions(-) create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/history/HistoryConditionRequest.java diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/history/HistoryConditionRequest.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/history/HistoryConditionRequest.java new file mode 100644 index 000000000..58736077f --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/history/HistoryConditionRequest.java @@ -0,0 +1,51 @@ +package ru.spcex.clearing.backendapi.controller.request.cud.history; + +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import io.swagger.annotations.ApiModelProperty; +import ru.spcex.clearing.platform.messaging.domain.json.deserialize.LocalDateDeserializer; +import ru.spcex.clearing.platform.messaging.domain.json.serialize.LocalDateSerializer; + +import java.time.LocalDate; + +public class HistoryConditionRequest { + + @ApiModelProperty(value = "Таблица для поиска", example = "1200") + @JsonProperty + private String table; + @ApiModelProperty(value = "Начальный точка поиска по дате", example = "2022-12-25") + @JsonProperty + @JsonSerialize(using = LocalDateSerializer.class) + @JsonDeserialize(using = LocalDateDeserializer.class) + private LocalDate from; + @ApiModelProperty(value = "Конечная точка поиска по дате ", example = "2022-12-25") + @JsonProperty + @JsonSerialize(using = LocalDateSerializer.class) + @JsonDeserialize(using = LocalDateDeserializer.class) + private LocalDate to; + + public String getTable() { + return table; + } + + public void setTable(String table) { + this.table = table; + } + + public LocalDate getFrom() { + return from; + } + + public void setFrom(LocalDate from) { + this.from = from; + } + + public LocalDate getTo() { + return to; + } + + public void setTo(LocalDate to) { + this.to = to; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/test/HistController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/test/HistController.java index 1bd27d802..e67743c9f 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/test/HistController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/test/HistController.java @@ -1,22 +1,27 @@ package ru.spcex.clearing.backendapi.controller.test; import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiParam; import io.swagger.annotations.ApiResponse; import io.swagger.annotations.ApiResponses; import org.springframework.beans.factory.InitializingBean; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.ResponseBody; import ru.clearing.classes.statics.data.register.MoneyBalanceRegister; +import ru.spcex.clearing.backendapi.controller.request.cud.history.HistoryConditionRequest; import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; import ru.spcex.clearing.backendapi.meta.GetResponseFactory; +import ru.spcex.clearing.backendapi.service.IStateLoader; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.platform.classes.base.SpcexObjectBase; 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.utils.time.TimeUtil; @@ -26,6 +31,7 @@ import java.util.Collection; import java.util.List; import java.util.Map; import java.util.Objects; +import java.util.concurrent.ConcurrentHashMap; @Controller @RequestMapping("/history") @@ -33,20 +39,37 @@ public class HistController implements InitializingBean { private final ImdgProvider imdgProviderHist; private final ImdgProvider imdgProvider; private final GetResponseFactory responseFactory; + private final IStateLoader stateLoader; + private final ImdgPredicateBuilder pb; @Autowired public HistController(@Qualifier("imdgProviderHist") ImdgProvider imdgProviderHist, - @Qualifier("imdgProvider") ImdgProvider imdgProvider, GetResponseFactory responseFactory) { + @Qualifier("imdgProvider") ImdgProvider imdgProvider, + GetResponseFactory responseFactory, + IStateLoader stateLoader) { this.imdgProviderHist = imdgProviderHist; this.imdgProvider = imdgProvider; this.responseFactory = responseFactory; + this.stateLoader = stateLoader; + this.pb = imdgProviderHist + .getImdg(IMDGDistributedNames.Map_SearchMoneyBalanceRegister, SpcexObjectBase.class) + .predicateBuilder(); + } + + @Override + public void afterPropertiesSet() throws Exception { + //will stuck of not provided + imdgProviderHist.waitAvailable(); + imdgProvider.waitAvailable(); } @ApiOperation(value = "get all accounts.") @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) - @RequestMapping(path = "/money-balance-register", method = RequestMethod.GET) + @RequestMapping(path = "/money-balance-register", method = RequestMethod.POST) @ResponseBody - public CommonGetAllResponse getAll() { + public CommonGetAllResponse search( + @ApiParam(value = "Параметры команды в JSON формате.", required = true) + @RequestBody HistoryConditionRequest searchCondition) { Imdg searchMap = imdgProviderHist.getImdg(IMDGDistributedNames.Map_SearchMoneyBalanceRegister, SpcexObjectBase.class); ImdgPredicateBuilder prdct = searchMap.predicateBuilder(); LocalDate time = LocalDate.of(2023, Month.JUNE, 8);//2023-06-08 @@ -62,10 +85,48 @@ public class HistController implements InitializingBean { return response; } + @ApiOperation(value = "get all money balance registers.") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) + @RequestMapping(path = "/money-balance-register2", method = RequestMethod.POST) + @ResponseBody + public CommonGetAllResponse search2( + @ApiParam(value = "Параметры команды в JSON формате.", required = true) + @RequestBody HistoryConditionRequest searchCondition) { + //todo conditions by destination and filled fields + ImdgPredicate prdct = pb.and( + pb.greatEqual("created", TimeUtil.localDateToInstant(searchCondition.getFrom())), + pb.lessEqual("created", TimeUtil.localDateToInstant(searchCondition.getTo())) + ); + Collection> searchRes = getAllMetaTransform( + IMDGDistributedNames.Map_SearchMoneyBalanceRegister, + IMDGDistributedNames.Map_MoneyBalanceRegister, + MoneyBalanceRegister.class, + prdct + ); + CommonGetAllResponse response = new CommonGetAllResponse(); + response.fromEntity(searchRes); + return response; + } - @Override - public void afterPropertiesSet() throws Exception { - imdgProviderHist.waitAvailable(); - imdgProvider.waitAvailable(); + //mb move to IStateLoader getHistoryMetaTransofrm + Collection> getAllMetaTransform( + String searchMapName, + String mapName, + Class clazz, + ImdgPredicate conditions) { + Imdg imdgSearch = getImdg(searchMapName, clazz); + Imdg imdgHistory = getImdg(mapName, clazz); + Collection ids = imdgSearch.getCollectionIdsByPredicate(conditions); + return ids.stream() + .map(imdgHistory::getSingleObjectByID) + .filter(Objects::nonNull) + .map(o -> responseFactory.responseFromObject(o, clazz)) + .toList(); + } + + private final Map> allImdgMaps = new ConcurrentHashMap<>(); + @SuppressWarnings("unchecked") + private Imdg getImdg(String mapName, Class clazz) { + return (Imdg) allImdgMaps.computeIfAbsent(mapName, (mapName1) -> imdgProviderHist.getImdg(mapName, clazz)); } } From a048a46bf6b6f6afbbc721911646b9c0efa9e823 Mon Sep 17 00:00:00 2001 From: etreshenkov Date: Mon, 16 Oct 2023 18:22:02 +0300 Subject: [PATCH 08/15] add search mapstores --- ...earchProxyAdmittedLiabilitiesRegister.java | 19 ++++++++ ...SearchProxyCoveredLiabilitiesRegister.java | 19 ++++++++ .../index/SearchProxyExecutionFond.java | 19 ++++++++ ...chAdmittedLiabilitiesRegisterMapStore.java | 45 +++++++++++++++++++ ...rchCoveredLiabilitiesRegisterMapStore.java | 45 +++++++++++++++++++ .../SearchExecutionFondMapStore.java | 44 ++++++++++++++++++ 6 files changed, 191 insertions(+) create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyAdmittedLiabilitiesRegister.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyCoveredLiabilitiesRegister.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyExecutionFond.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchAdmittedLiabilitiesRegisterMapStore.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchCoveredLiabilitiesRegisterMapStore.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExecutionFondMapStore.java diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyAdmittedLiabilitiesRegister.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyAdmittedLiabilitiesRegister.java new file mode 100644 index 000000000..9c2102f03 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyAdmittedLiabilitiesRegister.java @@ -0,0 +1,19 @@ +package ru.spcex.clearing.historyimdg.index; + +import ru.spcex.clearing.historyimdg.index.field.SearchWithClearingDate; + +import java.time.LocalDate; + +public class SearchProxyAdmittedLiabilitiesRegister extends SearchProxy implements SearchWithClearingDate { + private LocalDate clearingDate; + + @Override + public LocalDate getClearingDate() { + return clearingDate; + } + + @Override + public void setClearingDate(LocalDate clearingDate) { + this.clearingDate = clearingDate; + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyCoveredLiabilitiesRegister.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyCoveredLiabilitiesRegister.java new file mode 100644 index 000000000..8b3aef3ee --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyCoveredLiabilitiesRegister.java @@ -0,0 +1,19 @@ +package ru.spcex.clearing.historyimdg.index; + +import ru.spcex.clearing.historyimdg.index.field.SearchWithClearingDate; + +import java.time.LocalDate; + +public class SearchProxyCoveredLiabilitiesRegister extends SearchProxy implements SearchWithClearingDate { + private LocalDate clearingDate; + + @Override + public LocalDate getClearingDate() { + return clearingDate; + } + + @Override + public void setClearingDate(LocalDate clearingDate) { + this.clearingDate = clearingDate; + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyExecutionFond.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyExecutionFond.java new file mode 100644 index 000000000..0da009281 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyExecutionFond.java @@ -0,0 +1,19 @@ +package ru.spcex.clearing.historyimdg.index; + +import ru.spcex.clearing.historyimdg.index.field.SearchWithTradingDate; + +import java.time.LocalDate; + +public class SearchProxyExecutionFond extends SearchProxy implements SearchWithTradingDate { + private LocalDate tradingDate; + + @Override + public LocalDate getTradingDate() { + return tradingDate; + } + + @Override + public void setTradingDate(LocalDate tradingDate) { + this.tradingDate = tradingDate; + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchAdmittedLiabilitiesRegisterMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchAdmittedLiabilitiesRegisterMapStore.java new file mode 100644 index 000000000..95d69b972 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchAdmittedLiabilitiesRegisterMapStore.java @@ -0,0 +1,45 @@ +package ru.spcex.clearing.historyimdg.mapstores; + +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; +import ru.spcex.clearing.historyimdg.index.SearchProxyAdmittedLiabilitiesRegister; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Collections; +import java.util.Map; + +@Component +public class SearchAdmittedLiabilitiesRegisterMapStore extends AbstractSliceMapLoader { + public SearchAdmittedLiabilitiesRegisterMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + } + + @Override + protected String getTableName() { + return "admitted_liabilities_register"; + } +// + + @Override + public Collection load(Collection keys) { + Map> paramMap = Collections.singletonMap("ids", keys); + return namedParameterJdbcTemplate.query("select * from " + getTableName() + " where id in (:ids)", paramMap, + (rs, rowNum) -> { + SearchProxyAdmittedLiabilitiesRegister proxyRegister = new SearchProxyAdmittedLiabilitiesRegister(); + proxyRegister.setId(rs.getObject("id", Long.class)); + proxyRegister.setClearingDate(getLocalDateFromSqlDate(rs, "clearing_date")); + return proxyRegister; + }); + } + + @Override + public String getMapName() { + return IMDGDistributedNames.Map_SearchAdmittedLiabilitiesRegister; + } + + @Override + public String[] getIndexingField() { + return new String[]{"created"}; + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchCoveredLiabilitiesRegisterMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchCoveredLiabilitiesRegisterMapStore.java new file mode 100644 index 000000000..7b6c4fcf7 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchCoveredLiabilitiesRegisterMapStore.java @@ -0,0 +1,45 @@ +package ru.spcex.clearing.historyimdg.mapstores; + +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; +import ru.spcex.clearing.historyimdg.index.SearchProxyCoveredLiabilitiesRegister; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Collections; +import java.util.Map; + +@Component +public class SearchCoveredLiabilitiesRegisterMapStore extends AbstractSliceMapLoader { + public SearchCoveredLiabilitiesRegisterMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + } + + @Override + protected String getTableName() { + return "covered_liabilities_register"; + } +// + + @Override + public Collection load(Collection keys) { + Map> paramMap = Collections.singletonMap("ids", keys); + return namedParameterJdbcTemplate.query("select * from " + getTableName() + " where id in (:ids)", paramMap, + (rs, rowNum) -> { + SearchProxyCoveredLiabilitiesRegister proxyRegister = new SearchProxyCoveredLiabilitiesRegister(); + proxyRegister.setId(rs.getObject("id", Long.class)); + proxyRegister.setClearingDate(getLocalDateFromSqlDate(rs, "clearing_date")); + return proxyRegister; + }); + } + + @Override + public String getMapName() { + return IMDGDistributedNames.Map_SearchAdmittedLiabilitiesRegister; + } + + @Override + public String[] getIndexingField() { + return new String[]{"created"}; + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExecutionFondMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExecutionFondMapStore.java new file mode 100644 index 000000000..f2c8a7c1e --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExecutionFondMapStore.java @@ -0,0 +1,44 @@ +package ru.spcex.clearing.historyimdg.mapstores; + +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; +import ru.spcex.clearing.historyimdg.index.SearchProxyExecutionFond; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Collections; +import java.util.Map; + +@Component +public class SearchExecutionFondMapStore extends AbstractSliceMapLoader { + public SearchExecutionFondMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + } + + @Override + protected String getTableName() { + return "execution_fond"; + } + + @Override + public Collection load(Collection keys) { + Map> paramMap = Collections.singletonMap("ids", keys); + return namedParameterJdbcTemplate.query("select * from " + getTableName() + " where id in (:ids)", paramMap, + (rs, rowNum) -> { + SearchProxyExecutionFond proxyFond = new SearchProxyExecutionFond(); + proxyFond.setId(rs.getObject("id", Long.class)); + proxyFond.setTradingDate(getLocalDateFromSqlDate(rs,"trading_date")); + return proxyFond; + }); + } + + @Override + public String getMapName() { + return IMDGDistributedNames.Map_SearchExecutionFond; + } + + @Override + public String[] getIndexingField() { + return new String[]{"tradingDate"}; + } +} From 205386d78a0335de9cf98fd57b766e522646b838 Mon Sep 17 00:00:00 2001 From: ialbert Date: Tue, 17 Oct 2023 11:43:33 +0300 Subject: [PATCH 09/15] http://jira.mfd.msk:8088/browse/CLS-523 imdg-hist --- .../mapstores/SearchAdmittedLiabilitiesRegisterMapStore.java | 2 +- .../mapstores/SearchCoveredLiabilitiesRegisterMapStore.java | 4 ++-- .../SearchMoneyPaymentInstructionRegisterMapStore.java | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchAdmittedLiabilitiesRegisterMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchAdmittedLiabilitiesRegisterMapStore.java index 95d69b972..791357068 100644 --- a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchAdmittedLiabilitiesRegisterMapStore.java +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchAdmittedLiabilitiesRegisterMapStore.java @@ -40,6 +40,6 @@ public class SearchAdmittedLiabilitiesRegisterMapStore extends AbstractSliceMapL @Override public String[] getIndexingField() { - return new String[]{"created"}; + return new String[]{"clearingDate"}; } } diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchCoveredLiabilitiesRegisterMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchCoveredLiabilitiesRegisterMapStore.java index 7b6c4fcf7..e0b21fbc6 100644 --- a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchCoveredLiabilitiesRegisterMapStore.java +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchCoveredLiabilitiesRegisterMapStore.java @@ -35,11 +35,11 @@ public class SearchCoveredLiabilitiesRegisterMapStore extends AbstractSliceMapLo @Override public String getMapName() { - return IMDGDistributedNames.Map_SearchAdmittedLiabilitiesRegister; + return IMDGDistributedNames.Map_SearchCoveredLiabilitiesRegister; } @Override public String[] getIndexingField() { - return new String[]{"created"}; + return new String[]{"clearingDate"}; } } diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchMoneyPaymentInstructionRegisterMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchMoneyPaymentInstructionRegisterMapStore.java index 82567a6fd..7c49cde3c 100644 --- a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchMoneyPaymentInstructionRegisterMapStore.java +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchMoneyPaymentInstructionRegisterMapStore.java @@ -39,6 +39,6 @@ public class SearchMoneyPaymentInstructionRegisterMapStore extends AbstractSlice @Override public String[] getIndexingField() { - return new String[]{"created"}; + return new String[]{"clearingDate"}; } } From 5023e922cf748f51a6bca10bba83630b4bf59ce4 Mon Sep 17 00:00:00 2001 From: ialbert Date: Tue, 17 Oct 2023 13:48:37 +0300 Subject: [PATCH 10/15] http://jira.mfd.msk:8088/browse/CLS-523 --- .../backendapi/config/HistoryConfig.java | 48 +++++++++ .../history}/HistController.java | 102 +++++++++++------- .../history/condition/ConditionProvider.java | 69 ++++++++++++ .../condition/HistorySubscription.java | 46 ++++++++ .../history/condition/IHistoryCondition.java | 15 +++ .../specific/CreatedFromCondition.java | 26 +++++ .../specific/CreatedToCondition.java | 26 +++++ ...ditionRequest.java => HistoryRequest.java} | 2 +- .../backendapi/meta/GetResponseFactory.java | 14 +++ .../clearing/backendapi/meta/MetaServer.java | 3 + .../backendapi/meta/ObjectElement.java | 12 +++ .../backendapi/service/IStateLoader.java | 5 + .../service/impl/StateLoaderImpl.java | 33 +++++- .../config/StateLoaderImplTestConfig.java | 2 +- .../spcex/platform/utils/collection/Pair.java | 9 ++ 15 files changed, 369 insertions(+), 43 deletions(-) create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/HistoryConfig.java rename clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/{test => queue/history}/HistController.java (58%) create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/ConditionProvider.java create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/HistorySubscription.java create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/IHistoryCondition.java create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/CreatedFromCondition.java create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/CreatedToCondition.java rename clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/history/{HistoryConditionRequest.java => HistoryRequest.java} (97%) diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/HistoryConfig.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/HistoryConfig.java new file mode 100644 index 000000000..bbe3a540a --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/HistoryConfig.java @@ -0,0 +1,48 @@ +package ru.spcex.clearing.backendapi.config; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import ru.spcex.clearing.backendapi.controller.queue.history.condition.HistorySubscription; +import ru.spcex.clearing.backendapi.controller.queue.history.condition.specific.CreatedFromCondition; +import ru.spcex.clearing.backendapi.controller.queue.history.condition.specific.CreatedToCondition; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.platform.classes.base.SpcexObjectBase; +import ru.spcex.platform.imdg.api.ImdgProvider; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder; + +import java.util.LinkedList; +import java.util.List; + +@Configuration +public class HistoryConfig { + + private final ImdgPredicateBuilder pb; + + @Autowired + public HistoryConfig(ImdgProvider imdgProvider) { + this.pb = imdgProvider.getImdg( + IMDGDistributedNames.Map_SearchMoneyBalanceRegister, + SpcexObjectBase.class + ).predicateBuilder(); + } + + @Bean + public List histSubscriptions() { + List hst = new LinkedList<>(); + hst.add(moneyBalanceRegister()); + return hst; + } + + private HistorySubscription moneyBalanceRegister() { + HistorySubscription sbscr = new HistorySubscription(); + sbscr.setDestination("money-balance-registers"); + sbscr.setSearchProxyMapName(IMDGDistributedNames.Map_SearchMoneyBalanceRegister); + sbscr.setFullHistoryMapName(IMDGDistributedNames.Map_MoneyBalanceRegister); + sbscr.setConditions(List.of( + new CreatedFromCondition(pb), + new CreatedToCondition(pb) + )); + return sbscr; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/test/HistController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/HistController.java similarity index 58% rename from clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/test/HistController.java rename to clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/HistController.java index e67743c9f..a1df1c7e6 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/test/HistController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/HistController.java @@ -1,4 +1,4 @@ -package ru.spcex.clearing.backendapi.controller.test; +package ru.spcex.clearing.backendapi.controller.queue.history; import io.swagger.annotations.ApiOperation; import io.swagger.annotations.ApiParam; @@ -7,14 +7,16 @@ import io.swagger.annotations.ApiResponses; import org.springframework.beans.factory.InitializingBean; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.format.annotation.DateTimeFormat; import org.springframework.stereotype.Controller; -import org.springframework.web.bind.annotation.RequestBody; -import org.springframework.web.bind.annotation.RequestMapping; -import org.springframework.web.bind.annotation.RequestMethod; -import org.springframework.web.bind.annotation.ResponseBody; +import org.springframework.web.bind.annotation.*; import ru.clearing.classes.statics.data.register.MoneyBalanceRegister; -import ru.spcex.clearing.backendapi.controller.request.cud.history.HistoryConditionRequest; +import ru.spcex.clearing.backendapi.controller.queue.history.condition.ConditionProvider; +import ru.spcex.clearing.backendapi.controller.queue.history.condition.HistorySubscription; +import ru.spcex.clearing.backendapi.controller.request.cud.history.HistoryRequest; import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; +import ru.spcex.clearing.backendapi.errors.ActionValidationException; +import ru.spcex.clearing.backendapi.errors.BackEndError; import ru.spcex.clearing.backendapi.meta.GetResponseFactory; import ru.spcex.clearing.backendapi.service.IStateLoader; import ru.spcex.clearing.imdg.IMDGDistributedNames; @@ -23,15 +25,12 @@ 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.utils.enumeration.EnumMessage; import ru.spcex.platform.utils.time.TimeUtil; import java.time.LocalDate; import java.time.Month; -import java.util.Collection; -import java.util.List; -import java.util.Map; -import java.util.Objects; -import java.util.concurrent.ConcurrentHashMap; +import java.util.*; @Controller @RequestMapping("/history") @@ -41,12 +40,13 @@ public class HistController implements InitializingBean { private final GetResponseFactory responseFactory; private final IStateLoader stateLoader; private final ImdgPredicateBuilder pb; + private final ConditionProvider conditionProvider; @Autowired public HistController(@Qualifier("imdgProviderHist") ImdgProvider imdgProviderHist, @Qualifier("imdgProvider") ImdgProvider imdgProvider, GetResponseFactory responseFactory, - IStateLoader stateLoader) { + IStateLoader stateLoader, ConditionProvider conditionProvider) { this.imdgProviderHist = imdgProviderHist; this.imdgProvider = imdgProvider; this.responseFactory = responseFactory; @@ -54,6 +54,7 @@ public class HistController implements InitializingBean { this.pb = imdgProviderHist .getImdg(IMDGDistributedNames.Map_SearchMoneyBalanceRegister, SpcexObjectBase.class) .predicateBuilder(); + this.conditionProvider = conditionProvider; } @Override @@ -69,7 +70,7 @@ public class HistController implements InitializingBean { @ResponseBody public CommonGetAllResponse search( @ApiParam(value = "Параметры команды в JSON формате.", required = true) - @RequestBody HistoryConditionRequest searchCondition) { + @RequestBody HistoryRequest searchCondition) { Imdg searchMap = imdgProviderHist.getImdg(IMDGDistributedNames.Map_SearchMoneyBalanceRegister, SpcexObjectBase.class); ImdgPredicateBuilder prdct = searchMap.predicateBuilder(); LocalDate time = LocalDate.of(2023, Month.JUNE, 8);//2023-06-08 @@ -85,19 +86,68 @@ public class HistController implements InitializingBean { return response; } + @ApiOperation(value = "Get history") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) + @RequestMapping(path = "/all", method = RequestMethod.POST) + @ResponseBody + public CommonGetAllResponse getHistory( + @ApiParam(value = "destination сущности по которой запрашивается история", example = "money-balance-registers", required = true) + @RequestParam("destination") + String destination, + @ApiParam(value = "Начальная точка поиска по дате", example = "2023-01-15", required = true) + @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) + @RequestParam(name = "from", required = false) + LocalDate from, + @ApiParam(value = "Конечная точка поиска по дате", example = "2023-01-15", required = true) + @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) + @RequestParam(name = "to", required = false) + LocalDate to + ) { + if (to == null && from == null) { + throw new ActionValidationException(new EnumMessage(BackEndError.ValidationError, "from/to url params both empty")); + } + + Optional> entityClass = responseFactory.classByDestination(destination); + //class may be added to HistorySubscription if needed + if (entityClass.isEmpty()) { + throw new ActionValidationException(new EnumMessage(BackEndError.ValidationError, + "destination " + "'" + destination + "' not supported (meta class not found)")); + } + + HistoryRequest req = new HistoryRequest(); + req.setTable(destination); + req.setFrom(from); + req.setTo(to); + + HistorySubscription[] subscr = new HistorySubscription[1]; + ImdgPredicate[] prdct = new ImdgPredicate[1]; + conditionProvider.conditionForRequest(req).map(s -> subscr[0] = s, p -> prdct[0] = p); + + Collection> searchRes = stateLoader.getAllMetaTransform( + subscr[0].getSearchProxyMapName(), + subscr[0].getFullHistoryMapName(), + entityClass.get(), + prdct[0] + ); + + CommonGetAllResponse response = new CommonGetAllResponse(); + response.fromEntity(searchRes); + return response; + } + @ApiOperation(value = "get all money balance registers.") @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) @RequestMapping(path = "/money-balance-register2", method = RequestMethod.POST) @ResponseBody public CommonGetAllResponse search2( @ApiParam(value = "Параметры команды в JSON формате.", required = true) - @RequestBody HistoryConditionRequest searchCondition) { + @RequestBody HistoryRequest searchCondition) { //todo conditions by destination and filled fields ImdgPredicate prdct = pb.and( pb.greatEqual("created", TimeUtil.localDateToInstant(searchCondition.getFrom())), pb.lessEqual("created", TimeUtil.localDateToInstant(searchCondition.getTo())) ); - Collection> searchRes = getAllMetaTransform( + Collection> searchRes = stateLoader.getAllMetaTransform( IMDGDistributedNames.Map_SearchMoneyBalanceRegister, IMDGDistributedNames.Map_MoneyBalanceRegister, MoneyBalanceRegister.class, @@ -107,26 +157,4 @@ public class HistController implements InitializingBean { response.fromEntity(searchRes); return response; } - - //mb move to IStateLoader getHistoryMetaTransofrm - Collection> getAllMetaTransform( - String searchMapName, - String mapName, - Class clazz, - ImdgPredicate conditions) { - Imdg imdgSearch = getImdg(searchMapName, clazz); - Imdg imdgHistory = getImdg(mapName, clazz); - Collection ids = imdgSearch.getCollectionIdsByPredicate(conditions); - return ids.stream() - .map(imdgHistory::getSingleObjectByID) - .filter(Objects::nonNull) - .map(o -> responseFactory.responseFromObject(o, clazz)) - .toList(); - } - - private final Map> allImdgMaps = new ConcurrentHashMap<>(); - @SuppressWarnings("unchecked") - private Imdg getImdg(String mapName, Class clazz) { - return (Imdg) allImdgMaps.computeIfAbsent(mapName, (mapName1) -> imdgProviderHist.getImdg(mapName, clazz)); - } } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/ConditionProvider.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/ConditionProvider.java new file mode 100644 index 000000000..8b2f983c3 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/ConditionProvider.java @@ -0,0 +1,69 @@ +package ru.spcex.clearing.backendapi.controller.queue.history.condition; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; +import ru.spcex.clearing.backendapi.controller.request.cud.history.HistoryRequest; +import ru.spcex.clearing.backendapi.errors.ActionValidationException; +import ru.spcex.clearing.backendapi.errors.BackEndError; +import ru.spcex.clearing.backendapi.meta.GetResponseFactory; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.platform.classes.base.SpcexObjectBase; +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.utils.collection.Pair; +import ru.spcex.platform.utils.enumeration.EnumMessage; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; + +@Component +public class ConditionProvider { + private final Logger log = LoggerFactory.getLogger(getClass()); + private final GetResponseFactory responseFactory; + private final ImdgPredicateBuilder pb; + + private final Map subscriptions; + + @Autowired + public ConditionProvider(GetResponseFactory responseFactory, ImdgProvider imdgProvider, + List subscriptions) { + this.responseFactory = responseFactory; + this.subscriptions = new HashMap<>(); + Imdg imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SearchMoneyBalanceRegister, SpcexObjectBase.class); + this.pb = imdg.predicateBuilder(); + subscriptions.forEach(s -> this.subscriptions.put(s.getDestination(), s)); + } + + public Pair conditionForRequest(HistoryRequest req) { + String destination = req.getTable(); + HistorySubscription subscription = subscriptions.get(destination); + if (subscription == null) { + throw new ActionValidationException(new EnumMessage(BackEndError.ValidationError, + "destination " + "'" + destination + "' not supported (subscription info not found)")); + } + + List predicates = subscription + .getConditions() + .stream() + .map(c -> c.condition(req)) + .filter(Optional::isPresent) + .map(Optional::get) + .toList(); + + ImdgPredicate result; + if (predicates.size() == 0) { + log.warn("destination {} zero predicates found", destination); + result = pb.alwaysTrue(); + } else { + result = pb.and(predicates.toArray(new ImdgPredicate[0])); + } + + return new Pair<>(subscription, result); + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/HistorySubscription.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/HistorySubscription.java new file mode 100644 index 000000000..d2fa9d4b6 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/HistorySubscription.java @@ -0,0 +1,46 @@ +package ru.spcex.clearing.backendapi.controller.queue.history.condition; + +import java.util.Collections; +import java.util.List; + +public class HistorySubscription { + private String destination; + + private List conditions; + private String searchProxyMapName; + private String fullHistoryMapName; + //class + + + public List getConditions() { + return conditions != null ? conditions : Collections.emptyList(); + } + + public void setConditions(List conditions) { + this.conditions = conditions; + } + + public String getSearchProxyMapName() { + return searchProxyMapName; + } + + public void setSearchProxyMapName(String searchProxyMapName) { + this.searchProxyMapName = searchProxyMapName; + } + + public String getFullHistoryMapName() { + return fullHistoryMapName; + } + + public void setFullHistoryMapName(String fullHistoryMapName) { + this.fullHistoryMapName = fullHistoryMapName; + } + + public String getDestination() { + return destination; + } + + public void setDestination(String destination) { + this.destination = destination; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/IHistoryCondition.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/IHistoryCondition.java new file mode 100644 index 000000000..28b42e829 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/IHistoryCondition.java @@ -0,0 +1,15 @@ +package ru.spcex.clearing.backendapi.controller.queue.history.condition; + + +import ru.spcex.clearing.backendapi.controller.request.cud.history.HistoryRequest; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicate; + +import java.util.Optional; + +public interface IHistoryCondition { + Optional condition(HistoryRequest req); + + default Optional of(ImdgPredicate predicate) { + return Optional.of(predicate); + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/CreatedFromCondition.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/CreatedFromCondition.java new file mode 100644 index 000000000..1198f8e8c --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/CreatedFromCondition.java @@ -0,0 +1,26 @@ +package ru.spcex.clearing.backendapi.controller.queue.history.condition.specific; + +import ru.spcex.clearing.backendapi.controller.queue.history.condition.IHistoryCondition; +import ru.spcex.clearing.backendapi.controller.request.cud.history.HistoryRequest; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicate; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder; +import ru.spcex.platform.utils.time.TimeUtil; + +import java.util.Optional; + +public class CreatedFromCondition implements IHistoryCondition { + + private final ImdgPredicateBuilder pb; + + public CreatedFromCondition(ImdgPredicateBuilder pb) { + this.pb = pb; + } + + @Override + public Optional condition(HistoryRequest req) { + if (req.getFrom() != null) { + pb.greatEqual("created", TimeUtil.localDateToInstant(req.getFrom())); + } + return Optional.empty(); + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/CreatedToCondition.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/CreatedToCondition.java new file mode 100644 index 000000000..65814d39b --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/CreatedToCondition.java @@ -0,0 +1,26 @@ +package ru.spcex.clearing.backendapi.controller.queue.history.condition.specific; + +import ru.spcex.clearing.backendapi.controller.queue.history.condition.IHistoryCondition; +import ru.spcex.clearing.backendapi.controller.request.cud.history.HistoryRequest; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicate; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder; +import ru.spcex.platform.utils.time.TimeUtil; + +import java.util.Optional; + +public class CreatedToCondition implements IHistoryCondition { + + private final ImdgPredicateBuilder pb; + + public CreatedToCondition(ImdgPredicateBuilder pb) { + this.pb = pb; + } + + @Override + public Optional condition(HistoryRequest req) { + if (req.getTo() != null) { + pb.lessEqual("created", TimeUtil.localDateToInstant(req.getTo())); + } + return Optional.empty(); + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/history/HistoryConditionRequest.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/history/HistoryRequest.java similarity index 97% rename from clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/history/HistoryConditionRequest.java rename to clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/history/HistoryRequest.java index 58736077f..84663cda8 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/history/HistoryConditionRequest.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/history/HistoryRequest.java @@ -9,7 +9,7 @@ import ru.spcex.clearing.platform.messaging.domain.json.serialize.LocalDateSeria import java.time.LocalDate; -public class HistoryConditionRequest { +public class HistoryRequest { @ApiModelProperty(value = "Таблица для поиска", example = "1200") @JsonProperty diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/GetResponseFactory.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/GetResponseFactory.java index 557ae545e..b94e4efba 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/GetResponseFactory.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/GetResponseFactory.java @@ -5,6 +5,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; +import ru.spcex.platform.classes.base.SpcexObjectBase; import ru.spcex.platform.utils.time.TimeUtil; import java.text.SimpleDateFormat; @@ -130,6 +131,19 @@ public class GetResponseFactory { response.put(name, data); } + public Optional> classByDestination(String destination) { + Map extracted = meta.getObjectsExtractedByDestination(); + ObjectExtracted objectExtracted = extracted.get(destination); + if (objectExtracted == null) return Optional.empty(); + try { + Class clazz = (Class) objectExtracted.getClazz(); + return Optional.ofNullable(clazz); + } catch (Exception e) { + log.error(ExceptionUtils.getStackTrace(e)); + return Optional.empty(); + } + } + private static final DateTimeFormatter dateTimeFormatter = DateTimeFormatter .ofPattern("yyyy-MM-dd'T'HH:mm:ss+03:00") .withLocale(Locale.US) diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/MetaServer.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/MetaServer.java index 82557d2ba..ec8ee3223 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/MetaServer.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/MetaServer.java @@ -3,6 +3,7 @@ package ru.spcex.clearing.backendapi.meta; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import ru.spcex.platform.utils.log.ExceptionUtils; +import ru.spcex.platform.utils.text.TextUtil; import java.lang.reflect.Constructor; import java.lang.reflect.Method; @@ -67,6 +68,8 @@ public class MetaServer extends MetaBase { objectsExtractedByClazz.put(String.valueOf(classNameMock++), oe); if (objectElement.getSubscription() != null && objectElement.getSubscription().destination != null) { objectsExtractedByDestination.put(objectElement.getSubscription().destination, oe); + } else if (!TextUtil.isEmpty(objectElement.getDestination())) { + objectsExtractedByDestination.put(objectElement.getDestination(), oe); } for (ActionElement actionElement : objectElement.getActions()) { if (actionElement.getClazz() == null) { diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ObjectElement.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ObjectElement.java index c554c5d29..2d508af78 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ObjectElement.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ObjectElement.java @@ -18,6 +18,10 @@ public class ObjectElement { @JsonInclude(JsonInclude.Include.NON_EMPTY) private String table = null; + @JsonProperty(required = false) + @JsonInclude(JsonInclude.Include.NON_EMPTY) + private String destination = null; + @JsonProperty(value = "fields", required = true) private List fields = new LinkedList<>(); @@ -76,4 +80,12 @@ public class ObjectElement { public Subscription getSubscriptionHistory() { return subscriptionHistory; } + + public String getDestination() { + return destination; + } + + public void setDestination(String destination) { + this.destination = destination; + } } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/IStateLoader.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/IStateLoader.java index 098508554..6b403ccc2 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/IStateLoader.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/IStateLoader.java @@ -17,4 +17,9 @@ public interface IStateLoader { Collection> getAllMetaTransformSpecificClass(String mapName, Class clazz); Collection> getAllMetaTransform(String mapName, Class clazz, Map> conditions); Collection> getAllMetaTransform(String mapName, Class clazz, ImdgPredicate conditions); + Collection> getAllMetaTransform( + String searchMapName, + String mapName, + Class clazz, + ImdgPredicate conditions); } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/StateLoaderImpl.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/StateLoaderImpl.java index a002dd5a2..183b1eda5 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/StateLoaderImpl.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/StateLoaderImpl.java @@ -1,6 +1,7 @@ package ru.spcex.clearing.backendapi.service.impl; import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.stereotype.Service; import ru.spcex.clearing.backendapi.meta.GetResponseFactory; import ru.spcex.clearing.backendapi.service.IStateLoader; @@ -9,21 +10,24 @@ import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.ImdgProvider; import ru.spcex.platform.imdg.api.predicate.ImdgPredicate; -import java.util.Collection; -import java.util.Map; -import java.util.Optional; +import java.util.*; import java.util.concurrent.ConcurrentHashMap; @Service public class StateLoaderImpl implements IStateLoader { private final Map> allImdgMaps; + private final Map> allHistMaps; private final ImdgProvider imdgProvider; + private final ImdgProvider imdgHistProvider; private final GetResponseFactory responseFactory; @Autowired - public StateLoaderImpl(ImdgProvider imdgProvider, GetResponseFactory responseFactory) { + public StateLoaderImpl(@Qualifier("imdgProvider") ImdgProvider imdgProvider, + @Qualifier("imdgProviderHist") ImdgProvider imdgHistProvider, GetResponseFactory responseFactory) { + this.imdgHistProvider = imdgHistProvider; this.responseFactory = responseFactory; this.allImdgMaps = new ConcurrentHashMap<>(); + this.allHistMaps = new HashMap<>(); this.imdgProvider = imdgProvider; } @@ -73,4 +77,25 @@ public class StateLoaderImpl implements IStateLoader { private Imdg getImdg(String mapName, Class clazz) { return (Imdg) allImdgMaps.computeIfAbsent(mapName, (mapName1) -> imdgProvider.getImdg(mapName, clazz)); } + + @SuppressWarnings("unchecked") + private Imdg getHistImdg(String mapName, Class clazz) { + return (Imdg) allHistMaps.computeIfAbsent(mapName, (mapName1) -> imdgHistProvider.getImdg(mapName, clazz)); + } + + @Override + public Collection> getAllMetaTransform( + String searchMapName, + String mapName, + Class clazz, + ImdgPredicate conditions) { + Imdg imdgSearch = getHistImdg(searchMapName, clazz); + Imdg imdgHistory = getHistImdg(mapName, clazz); + Collection ids = imdgSearch.getCollectionIdsByPredicate(conditions); + return ids.stream() + .map(imdgHistory::getSingleObjectByID) + .filter(Objects::nonNull) + .map(o -> responseFactory.responseFromObject(o, clazz)) + .toList(); + } } diff --git a/clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/config/StateLoaderImplTestConfig.java b/clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/config/StateLoaderImplTestConfig.java index da3f11400..b3d7d2c1a 100644 --- a/clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/config/StateLoaderImplTestConfig.java +++ b/clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/config/StateLoaderImplTestConfig.java @@ -27,6 +27,6 @@ public class StateLoaderImplTestConfig { @Bean(name = "stateLoaderImplTest") public StateLoaderImpl createStateLoaderImpl(@Qualifier("responseFactoryTest") GetResponseFactory responseFactory) { - return new StateLoaderImpl(hazelcastServiceTest, responseFactory); + return new StateLoaderImpl(hazelcastServiceTest, null, responseFactory); } } diff --git a/platform-parent/platform-utils/src/main/java/ru/spcex/platform/utils/collection/Pair.java b/platform-parent/platform-utils/src/main/java/ru/spcex/platform/utils/collection/Pair.java index 281bf36fb..83b3ca0d6 100644 --- a/platform-parent/platform-utils/src/main/java/ru/spcex/platform/utils/collection/Pair.java +++ b/platform-parent/platform-utils/src/main/java/ru/spcex/platform/utils/collection/Pair.java @@ -31,4 +31,13 @@ public class Pair { consumer.accept(p.getFirst()); consumer.accept(p.getSecond()); } + + public void map(Consumer firstConsumer, Consumer secondConsumer) { + if (first != null) { + firstConsumer.accept(first); + } + if (second != null) { + secondConsumer.accept(second); + } + } } From d0a359a97ee5e8324eebbfce708860590e71b640 Mon Sep 17 00:00:00 2001 From: ialbert Date: Tue, 17 Oct 2023 15:09:17 +0300 Subject: [PATCH 11/15] http://jira.mfd.msk:8088/browse/CLS-523 removed unnecessary methods --- .../queue/history/HistController.java | 58 +++---------------- .../history/condition/ConditionProvider.java | 3 +- 2 files changed, 9 insertions(+), 52 deletions(-) diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/HistController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/HistController.java index a1df1c7e6..dc0bb84f6 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/HistController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/HistController.java @@ -9,8 +9,10 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.format.annotation.DateTimeFormat; import org.springframework.stereotype.Controller; -import org.springframework.web.bind.annotation.*; -import ru.clearing.classes.statics.data.register.MoneyBalanceRegister; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.RequestParam; +import org.springframework.web.bind.annotation.ResponseBody; import ru.spcex.clearing.backendapi.controller.queue.history.condition.ConditionProvider; import ru.spcex.clearing.backendapi.controller.queue.history.condition.HistorySubscription; import ru.spcex.clearing.backendapi.controller.request.cud.history.HistoryRequest; @@ -21,16 +23,15 @@ import ru.spcex.clearing.backendapi.meta.GetResponseFactory; import ru.spcex.clearing.backendapi.service.IStateLoader; import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.platform.classes.base.SpcexObjectBase; -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.utils.enumeration.EnumMessage; -import ru.spcex.platform.utils.time.TimeUtil; import java.time.LocalDate; -import java.time.Month; -import java.util.*; +import java.util.Collection; +import java.util.Map; +import java.util.Optional; @Controller @RequestMapping("/history") @@ -64,28 +65,6 @@ public class HistController implements InitializingBean { imdgProvider.waitAvailable(); } - @ApiOperation(value = "get all accounts.") - @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) - @RequestMapping(path = "/money-balance-register", method = RequestMethod.POST) - @ResponseBody - public CommonGetAllResponse search( - @ApiParam(value = "Параметры команды в JSON формате.", required = true) - @RequestBody HistoryRequest searchCondition) { - Imdg searchMap = imdgProviderHist.getImdg(IMDGDistributedNames.Map_SearchMoneyBalanceRegister, SpcexObjectBase.class); - ImdgPredicateBuilder prdct = searchMap.predicateBuilder(); - LocalDate time = LocalDate.of(2023, Month.JUNE, 8);//2023-06-08 - Collection ids = searchMap.getCollectionIdsByPredicate(prdct.greatEqual("created", TimeUtil.localDateToInstant(time))); - Imdg histMap = imdgProviderHist.getImdg(IMDGDistributedNames.Map_MoneyBalanceRegister, MoneyBalanceRegister.class); - List> maps = ids.stream() - .map(histMap::getSingleObjectByID) - .filter(Objects::nonNull) - .map(responseFactory::responseFromObject) - .toList(); - CommonGetAllResponse response = new CommonGetAllResponse(); - response.fromEntity(maps); - return response; - } - @ApiOperation(value = "Get history") @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) @RequestMapping(path = "/all", method = RequestMethod.POST) @@ -134,27 +113,4 @@ public class HistController implements InitializingBean { response.fromEntity(searchRes); return response; } - - @ApiOperation(value = "get all money balance registers.") - @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) - @RequestMapping(path = "/money-balance-register2", method = RequestMethod.POST) - @ResponseBody - public CommonGetAllResponse search2( - @ApiParam(value = "Параметры команды в JSON формате.", required = true) - @RequestBody HistoryRequest searchCondition) { - //todo conditions by destination and filled fields - ImdgPredicate prdct = pb.and( - pb.greatEqual("created", TimeUtil.localDateToInstant(searchCondition.getFrom())), - pb.lessEqual("created", TimeUtil.localDateToInstant(searchCondition.getTo())) - ); - Collection> searchRes = stateLoader.getAllMetaTransform( - IMDGDistributedNames.Map_SearchMoneyBalanceRegister, - IMDGDistributedNames.Map_MoneyBalanceRegister, - MoneyBalanceRegister.class, - prdct - ); - CommonGetAllResponse response = new CommonGetAllResponse(); - response.fromEntity(searchRes); - return response; - } } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/ConditionProvider.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/ConditionProvider.java index 8b2f983c3..a33be2274 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/ConditionProvider.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/ConditionProvider.java @@ -58,7 +58,8 @@ public class ConditionProvider { ImdgPredicate result; if (predicates.size() == 0) { - log.warn("destination {} zero predicates found", destination); + //add boundary conditions? + log.warn("destination '{}' zero predicates found", destination); result = pb.alwaysTrue(); } else { result = pb.and(predicates.toArray(new ImdgPredicate[0])); From 488f7f999bd5e7f147fcc1834b242817c65624ea Mon Sep 17 00:00:00 2001 From: ialbert Date: Tue, 17 Oct 2023 15:13:09 +0300 Subject: [PATCH 12/15] http://jira.mfd.msk:8088/browse/CLS-523 --- .../queue/history/HistController.java | 29 +++---------------- 1 file changed, 4 insertions(+), 25 deletions(-) diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/HistController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/HistController.java index dc0bb84f6..4af1fc7fa 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/HistController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/HistController.java @@ -4,9 +4,7 @@ import io.swagger.annotations.ApiOperation; import io.swagger.annotations.ApiParam; import io.swagger.annotations.ApiResponse; import io.swagger.annotations.ApiResponses; -import org.springframework.beans.factory.InitializingBean; import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.format.annotation.DateTimeFormat; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping; @@ -21,11 +19,8 @@ import ru.spcex.clearing.backendapi.errors.ActionValidationException; import ru.spcex.clearing.backendapi.errors.BackEndError; import ru.spcex.clearing.backendapi.meta.GetResponseFactory; import ru.spcex.clearing.backendapi.service.IStateLoader; -import ru.spcex.clearing.imdg.IMDGDistributedNames; import ru.spcex.platform.classes.base.SpcexObjectBase; -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.utils.enumeration.EnumMessage; import java.time.LocalDate; @@ -35,36 +30,20 @@ import java.util.Optional; @Controller @RequestMapping("/history") -public class HistController implements InitializingBean { - private final ImdgProvider imdgProviderHist; - private final ImdgProvider imdgProvider; +public class HistController { private final GetResponseFactory responseFactory; private final IStateLoader stateLoader; - private final ImdgPredicateBuilder pb; private final ConditionProvider conditionProvider; @Autowired - public HistController(@Qualifier("imdgProviderHist") ImdgProvider imdgProviderHist, - @Qualifier("imdgProvider") ImdgProvider imdgProvider, - GetResponseFactory responseFactory, - IStateLoader stateLoader, ConditionProvider conditionProvider) { - this.imdgProviderHist = imdgProviderHist; - this.imdgProvider = imdgProvider; + public HistController(GetResponseFactory responseFactory, + IStateLoader stateLoader, + ConditionProvider conditionProvider) { this.responseFactory = responseFactory; this.stateLoader = stateLoader; - this.pb = imdgProviderHist - .getImdg(IMDGDistributedNames.Map_SearchMoneyBalanceRegister, SpcexObjectBase.class) - .predicateBuilder(); this.conditionProvider = conditionProvider; } - @Override - public void afterPropertiesSet() throws Exception { - //will stuck of not provided - imdgProviderHist.waitAvailable(); - imdgProvider.waitAvailable(); - } - @ApiOperation(value = "Get history") @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) @RequestMapping(path = "/all", method = RequestMethod.POST) From 63d0a12f55ed81eb539035fe02b3ea8205c089bb Mon Sep 17 00:00:00 2001 From: ialbert Date: Tue, 17 Oct 2023 16:04:00 +0300 Subject: [PATCH 13/15] http://jira.mfd.msk:8088/browse/CLS-523 conditions fix --- .../backendapi/config/HistoryConfig.java | 28 +++++++++++++++++++ .../queue/history/HistController.java | 4 +-- .../history/condition/ConditionProvider.java | 2 ++ .../specific/ClearingDateFromCondition.java | 25 +++++++++++++++++ .../specific/ClearingDateToCondition.java | 25 +++++++++++++++++ .../specific/CreatedFromCondition.java | 2 +- .../specific/CreatedToCondition.java | 2 +- .../service/impl/StateLoaderImpl.java | 2 +- 8 files changed, 85 insertions(+), 5 deletions(-) create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/ClearingDateFromCondition.java create mode 100644 clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/ClearingDateToCondition.java diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/HistoryConfig.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/HistoryConfig.java index bbe3a540a..ff53063d6 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/HistoryConfig.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/HistoryConfig.java @@ -4,6 +4,8 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import ru.spcex.clearing.backendapi.controller.queue.history.condition.HistorySubscription; +import ru.spcex.clearing.backendapi.controller.queue.history.condition.specific.ClearingDateFromCondition; +import ru.spcex.clearing.backendapi.controller.queue.history.condition.specific.ClearingDateToCondition; import ru.spcex.clearing.backendapi.controller.queue.history.condition.specific.CreatedFromCondition; import ru.spcex.clearing.backendapi.controller.queue.history.condition.specific.CreatedToCondition; import ru.spcex.clearing.imdg.IMDGDistributedNames; @@ -31,6 +33,8 @@ public class HistoryConfig { public List histSubscriptions() { List hst = new LinkedList<>(); hst.add(moneyBalanceRegister()); + hst.add(admittedLiabilitiesRegister()); + hst.add(moneyPaymentInstructionRegister()); return hst; } @@ -45,4 +49,28 @@ public class HistoryConfig { )); return sbscr; } + + private HistorySubscription admittedLiabilitiesRegister() { + HistorySubscription sbscr = new HistorySubscription(); + sbscr.setDestination("admitted-liabilities-registers"); + sbscr.setSearchProxyMapName(IMDGDistributedNames.Map_SearchAdmittedLiabilitiesRegister); + sbscr.setFullHistoryMapName(IMDGDistributedNames.Map_AdmittedLiabilitiesRegister); + sbscr.setConditions(List.of( + new ClearingDateFromCondition(pb), + new ClearingDateToCondition(pb) + )); + return sbscr; + } + + private HistorySubscription moneyPaymentInstructionRegister() { + HistorySubscription sbscr = new HistorySubscription(); + sbscr.setDestination("money-payment-instruction-registers"); + sbscr.setSearchProxyMapName(IMDGDistributedNames.Map_SearchMoneyPaymentInstructionRegister); + sbscr.setFullHistoryMapName(IMDGDistributedNames.Map_MoneyPaymentInstructionRegister); + sbscr.setConditions(List.of( + new ClearingDateFromCondition(pb), + new ClearingDateToCondition(pb) + )); + return sbscr; + } } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/HistController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/HistController.java index 4af1fc7fa..9659a9d76 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/HistController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/HistController.java @@ -52,11 +52,11 @@ public class HistController { @ApiParam(value = "destination сущности по которой запрашивается история", example = "money-balance-registers", required = true) @RequestParam("destination") String destination, - @ApiParam(value = "Начальная точка поиска по дате", example = "2023-01-15", required = true) + @ApiParam(value = "Начальная точка поиска по дате", example = "2023-01-15") @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) @RequestParam(name = "from", required = false) LocalDate from, - @ApiParam(value = "Конечная точка поиска по дате", example = "2023-01-15", required = true) + @ApiParam(value = "Конечная точка поиска по дате", example = "2023-01-15") @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) @RequestParam(name = "to", required = false) LocalDate to diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/ConditionProvider.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/ConditionProvider.java index a33be2274..f99e76c6b 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/ConditionProvider.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/ConditionProvider.java @@ -61,6 +61,8 @@ public class ConditionProvider { //add boundary conditions? log.warn("destination '{}' zero predicates found", destination); result = pb.alwaysTrue(); + } else if (predicates.size() == 1) { + result = predicates.iterator().next(); } else { result = pb.and(predicates.toArray(new ImdgPredicate[0])); } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/ClearingDateFromCondition.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/ClearingDateFromCondition.java new file mode 100644 index 000000000..461bb3e1c --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/ClearingDateFromCondition.java @@ -0,0 +1,25 @@ +package ru.spcex.clearing.backendapi.controller.queue.history.condition.specific; + +import ru.spcex.clearing.backendapi.controller.queue.history.condition.IHistoryCondition; +import ru.spcex.clearing.backendapi.controller.request.cud.history.HistoryRequest; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicate; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder; + +import java.util.Optional; + +public class ClearingDateFromCondition implements IHistoryCondition { + + private final ImdgPredicateBuilder pb; + + public ClearingDateFromCondition(ImdgPredicateBuilder pb) { + this.pb = pb; + } + + @Override + public Optional condition(HistoryRequest req) { + if (req.getFrom() != null) { + return Optional.ofNullable(pb.greatEqual("clearingDate", req.getFrom())); + } + return Optional.empty(); + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/ClearingDateToCondition.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/ClearingDateToCondition.java new file mode 100644 index 000000000..e7e70c4c7 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/ClearingDateToCondition.java @@ -0,0 +1,25 @@ +package ru.spcex.clearing.backendapi.controller.queue.history.condition.specific; + +import ru.spcex.clearing.backendapi.controller.queue.history.condition.IHistoryCondition; +import ru.spcex.clearing.backendapi.controller.request.cud.history.HistoryRequest; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicate; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder; + +import java.util.Optional; + +public class ClearingDateToCondition implements IHistoryCondition { + + private final ImdgPredicateBuilder pb; + + public ClearingDateToCondition(ImdgPredicateBuilder pb) { + this.pb = pb; + } + + @Override + public Optional condition(HistoryRequest req) { + if (req.getTo() != null) { + return Optional.ofNullable(pb.lessEqual("clearingDate", req.getTo())); + } + return Optional.empty(); + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/CreatedFromCondition.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/CreatedFromCondition.java index 1198f8e8c..6c2eca4ab 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/CreatedFromCondition.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/CreatedFromCondition.java @@ -19,7 +19,7 @@ public class CreatedFromCondition implements IHistoryCondition { @Override public Optional condition(HistoryRequest req) { if (req.getFrom() != null) { - pb.greatEqual("created", TimeUtil.localDateToInstant(req.getFrom())); + return Optional.of(pb.greatEqual("created", TimeUtil.localDateToInstant(req.getFrom()))); } return Optional.empty(); } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/CreatedToCondition.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/CreatedToCondition.java index 65814d39b..c71447b54 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/CreatedToCondition.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/CreatedToCondition.java @@ -19,7 +19,7 @@ public class CreatedToCondition implements IHistoryCondition { @Override public Optional condition(HistoryRequest req) { if (req.getTo() != null) { - pb.lessEqual("created", TimeUtil.localDateToInstant(req.getTo())); + return Optional.of(pb.lessEqual("created", TimeUtil.localDateToInstant(req.getTo()))); } return Optional.empty(); } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/StateLoaderImpl.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/StateLoaderImpl.java index 183b1eda5..dcc6f5fee 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/StateLoaderImpl.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/StateLoaderImpl.java @@ -89,7 +89,7 @@ public class StateLoaderImpl implements IStateLoader { String mapName, Class clazz, ImdgPredicate conditions) { - Imdg imdgSearch = getHistImdg(searchMapName, clazz); + Imdg imdgSearch = getHistImdg(searchMapName, SpcexObjectBase.class); Imdg imdgHistory = getHistImdg(mapName, clazz); Collection ids = imdgSearch.getCollectionIdsByPredicate(conditions); return ids.stream() From 41ce70416cfadc5152541aea0cf6b4994daf9a86 Mon Sep 17 00:00:00 2001 From: etreschenkov Date: Wed, 18 Oct 2023 12:04:27 +0300 Subject: [PATCH 14/15] http://jira.mfd.msk:8088/browse/CLS-522 --- ...chProxyDepoPaymentInstructionRegister.java | 19 ++++++++ ...SearchProxyExcludeLiabilitiesRegister.java | 19 ++++++++ .../index/SearchProxyExecutionRegister.java | 19 ++++++++ .../index/SearchProxyLiabilitiesRegister.java | 19 ++++++++ ...tedLiabilitiesRegisterHistoryMapStore.java | 31 +++++++++++++ ...redLiabilitiesRegisterHistoryMapStore.java | 31 +++++++++++++ .../DepoBalanceRegisterHistoryMapStore.java | 31 +++++++++++++ ...entInstructionRegisterHistoryMapStore.java | 31 +++++++++++++ ...udeLiabilitiesRegisterHistoryMapStore.java | 31 +++++++++++++ .../ExecutionFondHistoryMapStore.java | 31 +++++++++++++ .../ExecutionRegisterHistoryMapStore.java | 31 +++++++++++++ .../LiabilitiesRegisterHistoryMapStore.java | 31 +++++++++++++ ...epoPaymentInstructionRegisterMapStore.java | 44 +++++++++++++++++++ ...rchExcludeLiabilitiesRegisterMapStore.java | 44 +++++++++++++++++++ .../SearchExecutionRegisterMapStore.java | 44 +++++++++++++++++++ .../SearchLiabilitiesRegisterMapStore.java | 44 +++++++++++++++++++ 16 files changed, 500 insertions(+) create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyDepoPaymentInstructionRegister.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyExcludeLiabilitiesRegister.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyExecutionRegister.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyLiabilitiesRegister.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/AdmittedLiabilitiesRegisterHistoryMapStore.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/CoveredLiabilitiesRegisterHistoryMapStore.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/DepoBalanceRegisterHistoryMapStore.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/DepoPaymentInstructionRegisterHistoryMapStore.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/ExcludeLiabilitiesRegisterHistoryMapStore.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/ExecutionFondHistoryMapStore.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/ExecutionRegisterHistoryMapStore.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/LiabilitiesRegisterHistoryMapStore.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchDepoPaymentInstructionRegisterMapStore.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExcludeLiabilitiesRegisterMapStore.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExecutionRegisterMapStore.java create mode 100644 clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchLiabilitiesRegisterMapStore.java diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyDepoPaymentInstructionRegister.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyDepoPaymentInstructionRegister.java new file mode 100644 index 000000000..29a0d4c3a --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyDepoPaymentInstructionRegister.java @@ -0,0 +1,19 @@ +package ru.spcex.clearing.historyimdg.index; + +import ru.spcex.clearing.historyimdg.index.field.SearchWithCreated; + +import java.time.Instant; + +public class SearchProxyDepoPaymentInstructionRegister extends SearchProxy implements SearchWithCreated { + private Instant created; + + @Override + public Instant getCreated() { + return created; + } + + @Override + public void setCreated(Instant created) { + this.created = created; + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyExcludeLiabilitiesRegister.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyExcludeLiabilitiesRegister.java new file mode 100644 index 000000000..12372be5f --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyExcludeLiabilitiesRegister.java @@ -0,0 +1,19 @@ +package ru.spcex.clearing.historyimdg.index; + +import ru.spcex.clearing.historyimdg.index.field.SearchWithCreated; + +import java.time.Instant; + +public class SearchProxyExcludeLiabilitiesRegister extends SearchProxy implements SearchWithCreated { + private Instant created; + + @Override + public Instant getCreated() { + return created; + } + + @Override + public void setCreated(Instant created) { + this.created = created; + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyExecutionRegister.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyExecutionRegister.java new file mode 100644 index 000000000..3cb3bb09f --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyExecutionRegister.java @@ -0,0 +1,19 @@ +package ru.spcex.clearing.historyimdg.index; + +import ru.spcex.clearing.historyimdg.index.field.SearchWithTradingDate; + +import java.time.LocalDate; + +public class SearchProxyExecutionRegister extends SearchProxy implements SearchWithTradingDate { + private LocalDate tradingDate; + + @Override + public LocalDate getTradingDate() { + return tradingDate; + } + + @Override + public void setTradingDate(LocalDate tradingDate) { + this.tradingDate = tradingDate; + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyLiabilitiesRegister.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyLiabilitiesRegister.java new file mode 100644 index 000000000..a29ce7392 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/SearchProxyLiabilitiesRegister.java @@ -0,0 +1,19 @@ +package ru.spcex.clearing.historyimdg.index; + +import ru.spcex.clearing.historyimdg.index.field.SearchWithCreated; + +import java.time.Instant; + +public class SearchProxyLiabilitiesRegister extends SearchProxy implements SearchWithCreated { + private Instant created; + + @Override + public Instant getCreated() { + return created; + } + + @Override + public void setCreated(Instant created) { + this.created = created; + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/AdmittedLiabilitiesRegisterHistoryMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/AdmittedLiabilitiesRegisterHistoryMapStore.java new file mode 100644 index 000000000..a569cdd95 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/AdmittedLiabilitiesRegisterHistoryMapStore.java @@ -0,0 +1,31 @@ +package ru.spcex.clearing.historyimdg.mapstores; + +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; +import ru.clearing.classes.statics.data.register.AdmittedLiabilitiesRegister; +import ru.spcex.clearing.imdg.businessobject.AdmittedLiabilitiesRegisterMapStore; + +import java.util.ArrayList; + +@Component +public class AdmittedLiabilitiesRegisterHistoryMapStore extends AdmittedLiabilitiesRegisterMapStore { + public AdmittedLiabilitiesRegisterHistoryMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + } + + @Override + protected boolean isLoadable(Long id) { + return true; + } + + @Override + protected boolean isLoadable(AdmittedLiabilitiesRegister obj) { + return true; + } + + @Override + public Iterable loadAllKeys() { + log.debug("AdmittedLiabilitiesRegister loadAllKeys is called"); + return new ArrayList<>(); + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/CoveredLiabilitiesRegisterHistoryMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/CoveredLiabilitiesRegisterHistoryMapStore.java new file mode 100644 index 000000000..0d6231731 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/CoveredLiabilitiesRegisterHistoryMapStore.java @@ -0,0 +1,31 @@ +package ru.spcex.clearing.historyimdg.mapstores; + +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; +import ru.clearing.classes.statics.data.register.CoveredLiabilitiesRegister; +import ru.spcex.clearing.imdg.businessobject.CoveredLiabilitiesRegisterMapStore; + +import java.util.ArrayList; + +@Component +public class CoveredLiabilitiesRegisterHistoryMapStore extends CoveredLiabilitiesRegisterMapStore { + public CoveredLiabilitiesRegisterHistoryMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + } + + @Override + protected boolean isLoadable(Long id) { + return true; + } + + @Override + protected boolean isLoadable(CoveredLiabilitiesRegister obj) { + return true; + } + + @Override + public Iterable loadAllKeys() { + log.debug("CoveredLiabilitiesRegister loadAllKeys is called"); + return new ArrayList<>(); + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/DepoBalanceRegisterHistoryMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/DepoBalanceRegisterHistoryMapStore.java new file mode 100644 index 000000000..bb8b4843b --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/DepoBalanceRegisterHistoryMapStore.java @@ -0,0 +1,31 @@ +package ru.spcex.clearing.historyimdg.mapstores; + +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; +import ru.clearing.classes.statics.data.register.DepoBalanceRegister; +import ru.spcex.clearing.imdg.businessobject.DepoBalanceRegisterMapStore; + +import java.util.ArrayList; + +@Component +public class DepoBalanceRegisterHistoryMapStore extends DepoBalanceRegisterMapStore { + public DepoBalanceRegisterHistoryMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + } + + @Override + protected boolean isLoadable(Long id) { + return true; + } + + @Override + protected boolean isLoadable(DepoBalanceRegister obj) { + return true; + } + + @Override + public Iterable loadAllKeys() { + log.debug("DepoBalanceRegister loadAllKeys is called"); + return new ArrayList<>(); + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/DepoPaymentInstructionRegisterHistoryMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/DepoPaymentInstructionRegisterHistoryMapStore.java new file mode 100644 index 000000000..84a9a8a4e --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/DepoPaymentInstructionRegisterHistoryMapStore.java @@ -0,0 +1,31 @@ +package ru.spcex.clearing.historyimdg.mapstores; + +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; +import ru.clearing.classes.statics.data.register.DepoPaymentInstructionRegister; +import ru.spcex.clearing.imdg.businessobject.DepoPaymentInstructionRegisterMapStore; + +import java.util.ArrayList; + +@Component +public class DepoPaymentInstructionRegisterHistoryMapStore extends DepoPaymentInstructionRegisterMapStore { + public DepoPaymentInstructionRegisterHistoryMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + } + + @Override + protected boolean isLoadable(Long id) { + return true; + } + + @Override + protected boolean isLoadable(DepoPaymentInstructionRegister obj) { + return true; + } + + @Override + public Iterable loadAllKeys() { + log.debug("DepoPaymentInstructionRegister loadAllKeys is called"); + return new ArrayList<>(); + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/ExcludeLiabilitiesRegisterHistoryMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/ExcludeLiabilitiesRegisterHistoryMapStore.java new file mode 100644 index 000000000..3d5bd5cba --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/ExcludeLiabilitiesRegisterHistoryMapStore.java @@ -0,0 +1,31 @@ +package ru.spcex.clearing.historyimdg.mapstores; + +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; +import ru.clearing.classes.statics.data.register.ExcludeLiabilitiesRegister; +import ru.spcex.clearing.imdg.businessobject.ExcludeLiabilitiesRegisterMapStore; + +import java.util.ArrayList; + +@Component +public class ExcludeLiabilitiesRegisterHistoryMapStore extends ExcludeLiabilitiesRegisterMapStore { + public ExcludeLiabilitiesRegisterHistoryMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + } + + @Override + protected boolean isLoadable(Long id) { + return true; + } + + @Override + protected boolean isLoadable(ExcludeLiabilitiesRegister obj) { + return true; + } + + @Override + public Iterable loadAllKeys() { + log.debug("ExcludeLiabilitiesRegister loadAllKeys is called"); + return new ArrayList<>(); + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/ExecutionFondHistoryMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/ExecutionFondHistoryMapStore.java new file mode 100644 index 000000000..41b1ffa56 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/ExecutionFondHistoryMapStore.java @@ -0,0 +1,31 @@ +package ru.spcex.clearing.historyimdg.mapstores; + +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; +import ru.clearing.classes.statics.data.execution.ExecutionFond; +import ru.spcex.clearing.imdg.businessobject.ExecutionFondMapStore; + +import java.util.ArrayList; + +@Component +public class ExecutionFondHistoryMapStore extends ExecutionFondMapStore { + public ExecutionFondHistoryMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + } + + @Override + protected boolean isLoadable(Long id) { + return true; + } + + @Override + protected boolean isLoadable(ExecutionFond obj) { + return true; + } + + @Override + public Iterable loadAllKeys() { + log.debug("ExecutionFond loadAllKeys is called"); + return new ArrayList<>(); + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/ExecutionRegisterHistoryMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/ExecutionRegisterHistoryMapStore.java new file mode 100644 index 000000000..c7b4afb1b --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/ExecutionRegisterHistoryMapStore.java @@ -0,0 +1,31 @@ +package ru.spcex.clearing.historyimdg.mapstores; + +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; +import ru.clearing.classes.statics.data.register.ExecutionRegister; +import ru.spcex.clearing.imdg.businessobject.ExecutionRegisterMapStore; + +import java.util.ArrayList; + +@Component +public class ExecutionRegisterHistoryMapStore extends ExecutionRegisterMapStore { + public ExecutionRegisterHistoryMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + } + + @Override + protected boolean isLoadable(Long id) { + return true; + } + + @Override + protected boolean isLoadable(ExecutionRegister obj) { + return true; + } + + @Override + public Iterable loadAllKeys() { + log.debug("ExecutionRegister loadAllKeys is called"); + return new ArrayList<>(); + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/LiabilitiesRegisterHistoryMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/LiabilitiesRegisterHistoryMapStore.java new file mode 100644 index 000000000..86c78c12e --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/LiabilitiesRegisterHistoryMapStore.java @@ -0,0 +1,31 @@ +package ru.spcex.clearing.historyimdg.mapstores; + +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; +import ru.clearing.classes.statics.data.register.LiabilitiesRegister; +import ru.spcex.clearing.imdg.businessobject.LiabilitiesRegisterMapStore; + +import java.util.ArrayList; + +@Component +public class LiabilitiesRegisterHistoryMapStore extends LiabilitiesRegisterMapStore { + public LiabilitiesRegisterHistoryMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + } + + @Override + protected boolean isLoadable(Long id) { + return true; + } + + @Override + protected boolean isLoadable(LiabilitiesRegister obj) { + return true; + } + + @Override + public Iterable loadAllKeys() { + log.debug("LiabilitiesRegister loadAllKeys is called"); + return new ArrayList<>(); + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchDepoPaymentInstructionRegisterMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchDepoPaymentInstructionRegisterMapStore.java new file mode 100644 index 000000000..7e5234bb8 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchDepoPaymentInstructionRegisterMapStore.java @@ -0,0 +1,44 @@ +package ru.spcex.clearing.historyimdg.mapstores; + +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; +import ru.spcex.clearing.historyimdg.index.SearchProxyDepoPaymentInstructionRegister; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Collections; +import java.util.Map; + +@Component +public class SearchDepoPaymentInstructionRegisterMapStore extends AbstractSliceMapLoader { + public SearchDepoPaymentInstructionRegisterMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + } + + @Override + protected String getTableName() { + return "depo_payment_instruction_register"; + } + + @Override + public Collection load(Collection keys) { + Map> paramMap = Collections.singletonMap("ids", keys); + return namedParameterJdbcTemplate.query("select * from " + getTableName() + " where id in (:ids)", paramMap, + (rs, rowNum) -> { + SearchProxyDepoPaymentInstructionRegister proxyRegistry = new SearchProxyDepoPaymentInstructionRegister(); + proxyRegistry.setId(rs.getObject("id", Long.class)); + proxyRegistry.setCreated(getInstantFromTimestamp(rs, "CREATED_AT")); + return proxyRegistry; + }); + } + + @Override + public String getMapName() { + return IMDGDistributedNames.Map_SearchMoneyPaymentInstructionRegister; + } + + @Override + public String[] getIndexingField() { + return new String[]{}; + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExcludeLiabilitiesRegisterMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExcludeLiabilitiesRegisterMapStore.java new file mode 100644 index 000000000..9e0a538eb --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExcludeLiabilitiesRegisterMapStore.java @@ -0,0 +1,44 @@ +package ru.spcex.clearing.historyimdg.mapstores; + +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; +import ru.spcex.clearing.historyimdg.index.SearchProxyExcludeLiabilitiesRegister; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Collections; +import java.util.Map; + +@Component +public class SearchExcludeLiabilitiesRegisterMapStore extends AbstractSliceMapLoader { + public SearchExcludeLiabilitiesRegisterMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + } + + @Override + protected String getTableName() { + return "exclude_liabilities_register"; + } + + @Override + public Collection load(Collection keys) { + Map> paramMap = Collections.singletonMap("ids", keys); + return namedParameterJdbcTemplate.query("select * from " + getTableName() + " where id in (:ids)", paramMap, + (rs, rowNum) -> { + SearchProxyExcludeLiabilitiesRegister proxyRegistry = new SearchProxyExcludeLiabilitiesRegister(); + proxyRegistry.setId(rs.getObject("id", Long.class)); + proxyRegistry.setCreated(getInstantFromTimestamp(rs, "CREATED_AT")); + return proxyRegistry; + }); + } + + @Override + public String getMapName() { + return IMDGDistributedNames.Map_SearchMoneyPaymentInstructionRegister; + } + + @Override + public String[] getIndexingField() { + return new String[]{}; + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExecutionRegisterMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExecutionRegisterMapStore.java new file mode 100644 index 000000000..719ec012c --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExecutionRegisterMapStore.java @@ -0,0 +1,44 @@ +package ru.spcex.clearing.historyimdg.mapstores; + +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; +import ru.spcex.clearing.historyimdg.index.SearchProxyExecutionRegister; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Collections; +import java.util.Map; + +@Component +public class SearchExecutionRegisterMapStore extends AbstractSliceMapLoader { + public SearchExecutionRegisterMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + } + + @Override + protected String getTableName() { + return "execution_fond"; + } + + @Override + public Collection load(Collection keys) { + Map> paramMap = Collections.singletonMap("ids", keys); + return namedParameterJdbcTemplate.query("select * from " + getTableName() + " where id in (:ids)", paramMap, + (rs, rowNum) -> { + SearchProxyExecutionRegister proxyRegister = new SearchProxyExecutionRegister(); + proxyRegister.setId(rs.getObject("id", Long.class)); + proxyRegister.setTradingDate(getLocalDateFromSqlDate(rs,"trading_date")); + return proxyRegister; + }); + } + + @Override + public String getMapName() { + return IMDGDistributedNames.Map_SearchExecutionFond; + } + + @Override + public String[] getIndexingField() { + return new String[]{}; + } +} diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchLiabilitiesRegisterMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchLiabilitiesRegisterMapStore.java new file mode 100644 index 000000000..cf20f2497 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchLiabilitiesRegisterMapStore.java @@ -0,0 +1,44 @@ +package ru.spcex.clearing.historyimdg.mapstores; + +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; +import ru.spcex.clearing.historyimdg.index.SearchProxyLiabilitiesRegister; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Collections; +import java.util.Map; + +@Component +public class SearchLiabilitiesRegisterMapStore extends AbstractSliceMapLoader { + public SearchLiabilitiesRegisterMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + } + + @Override + protected String getTableName() { + return "liabilities_register"; + } + + @Override + public Collection load(Collection keys) { + Map> paramMap = Collections.singletonMap("ids", keys); + return namedParameterJdbcTemplate.query("select * from " + getTableName() + " where id in (:ids)", paramMap, + (rs, rowNum) -> { + SearchProxyLiabilitiesRegister proxyRegistry = new SearchProxyLiabilitiesRegister(); + proxyRegistry.setId(rs.getObject("id", Long.class)); + proxyRegistry.setCreated(getInstantFromTimestamp(rs, "CREATED_AT")); + return proxyRegistry; + }); + } + + @Override + public String getMapName() { + return IMDGDistributedNames.Map_SearchMoneyPaymentInstructionRegister; + } + + @Override + public String[] getIndexingField() { + return new String[]{}; + } +} From 657a3e79eb8447908d598e529c37927253d59d5b Mon Sep 17 00:00:00 2001 From: etreschenkov Date: Wed, 18 Oct 2023 13:37:43 +0300 Subject: [PATCH 15/15] http://jira.mfd.msk:8088/browse/CLS-522 --- .../mapstores/AbstractSliceMapLoader.java | 20 +++++++------ ...chAdmittedLiabilitiesRegisterMapStore.java | 7 ++++- ...rchCoveredLiabilitiesRegisterMapStore.java | 6 +++- ...epoPaymentInstructionRegisterMapStore.java | 6 +++- ...rchExcludeLiabilitiesRegisterMapStore.java | 6 +++- .../SearchExecutionDepositMapStore.java | 5 ++++ .../SearchExecutionFondMapStore.java | 5 ++++ .../SearchExecutionRegisterMapStore.java | 7 ++++- .../SearchLiabilitiesRegisterMapStore.java | 7 ++++- .../SearchMoneyBalanceRegisterMapStore.java | 29 ++++--------------- ...neyPaymentInstructionRegisterMapStore.java | 5 ++++ .../src/main/resources/application.properties | 4 +-- 12 files changed, 66 insertions(+), 41 deletions(-) diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/AbstractSliceMapLoader.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/AbstractSliceMapLoader.java index b946d0d83..0e91ada63 100644 --- a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/AbstractSliceMapLoader.java +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/AbstractSliceMapLoader.java @@ -16,6 +16,7 @@ import java.time.Instant; import java.time.LocalDate; import java.time.ZoneId; import java.time.format.DateTimeFormatter; +import java.time.temporal.ChronoUnit; import java.util.*; import static ru.spcex.clearing.imdg.base.ObjectBaseMapStore.MAX_IN_CLAUSE_SIZE; @@ -75,20 +76,21 @@ public abstract class AbstractSliceMapLoader implements Autoco @Override public Iterable loadAllKeys() { - //fixme понять какое поле подходит большинству таблиц. created_at??? - //fixme пока выгружаются все ключи безотносительно даты -// return Collections.emptyList(); -// Instant yesterdayInstant = Instant.now().minus(0, ChronoUnit.DAYS); -// Instant halfYearAgo = yesterdayInstant.minus(365, ChronoUnit.DAYS); -// List ids = jdbcTemplate.query("select id from " + getTableName() + " where CAST(tradingday as DATE) <= ? and CAST(tradingday as DATE) >= ? ", -// new Object[]{FIREBIRD_INSTANT_FORMATTER.format(yesterdayInstant), FIREBIRD_INSTANT_FORMATTER.format(halfYearAgo)}, log.debug("loading all keys from {}...", getTableName()); - List ids = jdbcTemplate.query("select id from " + getTableName(), - (resultSet, i) -> resultSet.getObject("id", Long.class)); + LocalDate yesterdayInstant = LocalDate.now().minus(0, ChronoUnit.DAYS); +// Instant yesterdayInstant = Instant.now().minus(0, ChronoUnit.DAYS); + LocalDate fewDaysAgo = yesterdayInstant.minus(2, ChronoUnit.DAYS); + String fieldOfDay = fieldOfDay(); + List ids = jdbcTemplate.query("select id from " + getTableName() + " where " + fieldOfDay + " <= ? " + + "and " + fieldOfDay + " >= ? ", + (resultSet, i) -> resultSet.getLong("id"), + yesterdayInstant, fewDaysAgo); log.debug("loading all keys from {} done; size={}", getTableName(), ids.size()); return ids; } + protected abstract String fieldOfDay(); + protected LocalDate getLocalDateFromSqlDate(ResultSet rs, String column) throws SQLException { Date date = rs.getDate(column); return date != null ? date.toLocalDate() : null; diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchAdmittedLiabilitiesRegisterMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchAdmittedLiabilitiesRegisterMapStore.java index 791357068..4bb973872 100644 --- a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchAdmittedLiabilitiesRegisterMapStore.java +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchAdmittedLiabilitiesRegisterMapStore.java @@ -19,7 +19,12 @@ public class SearchAdmittedLiabilitiesRegisterMapStore extends AbstractSliceMapL protected String getTableName() { return "admitted_liabilities_register"; } -// + + @Override + protected String fieldOfDay() { + return "clearing_date"; + } + @Override public Collection load(Collection keys) { diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchCoveredLiabilitiesRegisterMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchCoveredLiabilitiesRegisterMapStore.java index e0b21fbc6..50cc7b907 100644 --- a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchCoveredLiabilitiesRegisterMapStore.java +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchCoveredLiabilitiesRegisterMapStore.java @@ -19,7 +19,11 @@ public class SearchCoveredLiabilitiesRegisterMapStore extends AbstractSliceMapLo protected String getTableName() { return "covered_liabilities_register"; } -// + + @Override + protected String fieldOfDay() { + return "clearing_date"; + } @Override public Collection load(Collection keys) { diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchDepoPaymentInstructionRegisterMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchDepoPaymentInstructionRegisterMapStore.java index 7e5234bb8..5ff31e4e8 100644 --- a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchDepoPaymentInstructionRegisterMapStore.java +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchDepoPaymentInstructionRegisterMapStore.java @@ -20,6 +20,10 @@ public class SearchDepoPaymentInstructionRegisterMapStore extends AbstractSliceM return "depo_payment_instruction_register"; } + @Override + protected String fieldOfDay() { + return "CREATED_AT"; + } @Override public Collection load(Collection keys) { Map> paramMap = Collections.singletonMap("ids", keys); @@ -34,7 +38,7 @@ public class SearchDepoPaymentInstructionRegisterMapStore extends AbstractSliceM @Override public String getMapName() { - return IMDGDistributedNames.Map_SearchMoneyPaymentInstructionRegister; + return IMDGDistributedNames.Map_SearchDepoPaymentInstructionRegister; } @Override diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExcludeLiabilitiesRegisterMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExcludeLiabilitiesRegisterMapStore.java index 9e0a538eb..1b4e04950 100644 --- a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExcludeLiabilitiesRegisterMapStore.java +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExcludeLiabilitiesRegisterMapStore.java @@ -20,6 +20,10 @@ public class SearchExcludeLiabilitiesRegisterMapStore extends AbstractSliceMapLo return "exclude_liabilities_register"; } + @Override + protected String fieldOfDay() { + return "CREATED_AT"; + } @Override public Collection load(Collection keys) { Map> paramMap = Collections.singletonMap("ids", keys); @@ -34,7 +38,7 @@ public class SearchExcludeLiabilitiesRegisterMapStore extends AbstractSliceMapLo @Override public String getMapName() { - return IMDGDistributedNames.Map_SearchMoneyPaymentInstructionRegister; + return IMDGDistributedNames.Map_SearchExcludeLiabilitiesRegister; } @Override diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExecutionDepositMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExecutionDepositMapStore.java index 5ba4c285a..f362903a1 100644 --- a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExecutionDepositMapStore.java +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExecutionDepositMapStore.java @@ -20,6 +20,11 @@ public class SearchExecutionDepositMapStore extends AbstractSliceMapLoader load(Collection keys) { Map> paramMap = Collections.singletonMap("ids", keys); diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExecutionFondMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExecutionFondMapStore.java index f2c8a7c1e..184504b14 100644 --- a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExecutionFondMapStore.java +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExecutionFondMapStore.java @@ -20,6 +20,11 @@ public class SearchExecutionFondMapStore extends AbstractSliceMapLoader load(Collection keys) { Map> paramMap = Collections.singletonMap("ids", keys); diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExecutionRegisterMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExecutionRegisterMapStore.java index 719ec012c..67b0dd64c 100644 --- a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExecutionRegisterMapStore.java +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExecutionRegisterMapStore.java @@ -20,6 +20,11 @@ public class SearchExecutionRegisterMapStore extends AbstractSliceMapLoader load(Collection keys) { Map> paramMap = Collections.singletonMap("ids", keys); @@ -34,7 +39,7 @@ public class SearchExecutionRegisterMapStore extends AbstractSliceMapLoader load(Collection keys) { Map> paramMap = Collections.singletonMap("ids", keys); @@ -34,7 +39,7 @@ public class SearchLiabilitiesRegisterMapStore extends AbstractSliceMapLoader loadAllKeys() { -// //пример loadAllKeys -// log.debug("loading all keys from {}...", getTableName()); -// LocalDate upperInstant = LocalDate.now().plus(1, ChronoUnit.DAYS); -// LocalDate halfYearAgo = upperInstant.minus(365, ChronoUnit.DAYS); -// List ids = jdbcTemplate.query("select id from " + getTableName() + " where CAST(created_at as DATE) <= ? and CAST(created_at as DATE) >= ? ", -// new Object[]{upperInstant, halfYearAgo}, -// (resultSet, i) -> resultSet.getObject("id", Long.class)); -// log.debug("loading all keys from {} done; size={}", getTableName(), ids.size()); -// return ids; -// //LocalDate today = LocalDate.now(); -// // log.debug("loadAllKeys from {} on {} {} today", getTableName(), dateField, canBeGreat ? ">=" : "="); -// // List keys; -// // try { -// // keys = jdbcTemplate.query("select id from " + getTableName() + " where " + dateField + (canBeGreat ? " >= ?" : " = ?"), -// // (resultSet, i) -> resultSet.getLong("id"), -// // new Object[]{today}); -// // } catch (Throwable e) { -// // log.error("At load keys from {} (by field {}): {}", getTableName(), dateField, ExceptionUtils.getStackTrace(e)); -// // throw e; -// // } -// } + + @Override + protected String fieldOfDay() { + return "CREATED_AT"; + } @Override public Collection load(Collection keys) { diff --git a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchMoneyPaymentInstructionRegisterMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchMoneyPaymentInstructionRegisterMapStore.java index 7c49cde3c..0ff10ce22 100644 --- a/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchMoneyPaymentInstructionRegisterMapStore.java +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchMoneyPaymentInstructionRegisterMapStore.java @@ -20,6 +20,11 @@ public class SearchMoneyPaymentInstructionRegisterMapStore extends AbstractSlice return "money_payment_instruction_register"; } + @Override + protected String fieldOfDay() { + return "clearing_date"; + } + @Override public Collection load(Collection keys) { Map> paramMap = Collections.singletonMap("ids", keys); diff --git a/clearing-parent/imdg-hist/src/main/resources/application.properties b/clearing-parent/imdg-hist/src/main/resources/application.properties index 87fc068e3..3a50c9896 100644 --- a/clearing-parent/imdg-hist/src/main/resources/application.properties +++ b/clearing-parent/imdg-hist/src/main/resources/application.properties @@ -2,9 +2,9 @@ imdg.hist.hazelcast.listenPort=5702 imdg.hist.hazelcast.login=dev-hist imdg.hist.hazelcast.password=dev-pass-hist imdg.hist.hazelcast.cluster-members[0]=127.0.0.1 -imdg.hist.database.login=clearing +imdg.hist.database.login=cls_dev imdg.hist.database.password=Aa111111 -imdg.hist.database.url=jdbc:postgresql://10.200.200.133:5432/clearing?currentSchema=clearing_prod +imdg.hist.database.url=jdbc:postgresql://10.200.200.133:5432/clearing?currentSchema=clearing_dev #imdg.database.url=jdbc:postgresql://10.200.200.133:5432/postgres?currentSchema=clearing_tester #debug tester mode: