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/HistoryConfig.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/HistoryConfig.java new file mode 100644 index 000000000..ff53063d6 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/HistoryConfig.java @@ -0,0 +1,76 @@ +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.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; +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()); + hst.add(admittedLiabilitiesRegister()); + hst.add(moneyPaymentInstructionRegister()); + 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; + } + + 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/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/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 new file mode 100644 index 000000000..9659a9d76 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/HistController.java @@ -0,0 +1,95 @@ +package ru.spcex.clearing.backendapi.controller.queue.history; + +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.annotation.Autowired; +import org.springframework.format.annotation.DateTimeFormat; +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.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; +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.platform.classes.base.SpcexObjectBase; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicate; +import ru.spcex.platform.utils.enumeration.EnumMessage; + +import java.time.LocalDate; +import java.util.Collection; +import java.util.Map; +import java.util.Optional; + +@Controller +@RequestMapping("/history") +public class HistController { + private final GetResponseFactory responseFactory; + private final IStateLoader stateLoader; + private final ConditionProvider conditionProvider; + + @Autowired + public HistController(GetResponseFactory responseFactory, + IStateLoader stateLoader, + ConditionProvider conditionProvider) { + this.responseFactory = responseFactory; + this.stateLoader = stateLoader; + this.conditionProvider = conditionProvider; + } + + @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") + @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) + @RequestParam(name = "from", required = false) + LocalDate from, + @ApiParam(value = "Конечная точка поиска по дате", example = "2023-01-15") + @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; + } +} 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..f99e76c6b --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/ConditionProvider.java @@ -0,0 +1,72 @@ +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) { + //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])); + } + + 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/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 new file mode 100644 index 000000000..6c2eca4ab --- /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) { + 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 new file mode 100644 index 000000000..c71447b54 --- /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) { + 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/controller/request/cud/history/HistoryRequest.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/history/HistoryRequest.java new file mode 100644 index 000000000..84663cda8 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/history/HistoryRequest.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 HistoryRequest { + + @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/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..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 @@ -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, SpcexObjectBase.class); + 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/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/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/clearing-parent/imdg-hist/pom.xml b/clearing-parent/imdg-hist/pom.xml new file mode 100644 index 000000000..1653d470a --- /dev/null +++ b/clearing-parent/imdg-hist/pom.xml @@ -0,0 +1,174 @@ + + + 4.0.0 + imdg-hist + jar + SPCEX-1.0.0.0 + + + clearing-parent + ru.spcex.clearing + SPCEX-1.0.0.0 + + + + + 17 + 17 + UTF-8 + + + + + org.springframework.boot + spring-boot-starter + + + org.springframework.boot + spring-boot-autoconfigure + + + ru.spcex.clearing + imdg + + + 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..eb670d92b --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/config/HistoryPoolMapConfigs.java @@ -0,0 +1,101 @@ +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.Bean; +import org.springframework.context.annotation.Configuration; +import ru.spcex.clearing.imdg.base.AutoconfiguredMap; +import ru.spcex.clearing.imdg.base.DictionaryTMapStore; + +import java.util.*; + +@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 (AutoconfiguredMap 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; + } + + //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/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..fa96477e2 --- /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.SearchWithTradingDate; +import ru.spcex.platform.classes.base.SpcexObjectBase; + +import java.time.LocalDate; + +public class SearchProxy extends SpcexObjectBase implements SearchWithTradingDate, 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/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/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/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/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/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/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/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/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/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/SearchWithTradingDate.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/field/SearchWithTradingDate.java new file mode 100644 index 000000000..79bde1841 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/index/field/SearchWithTradingDate.java @@ -0,0 +1,9 @@ +package ru.spcex.clearing.historyimdg.index.field; + +import java.time.LocalDate; + +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 new file mode 100644 index 000000000..0e91ada63 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/AbstractSliceMapLoader.java @@ -0,0 +1,106 @@ +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.sql.Timestamp; +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()); + 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; + } + + 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/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/ExecutionDepositHistoryMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/ExecutionDepositHistoryMapStore.java new file mode 100644 index 000000000..20e013886 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/ExecutionDepositHistoryMapStore.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.ExecutionDeposit; +import ru.spcex.clearing.imdg.businessobject.ExecutionDepositMapStore; + +import java.util.ArrayList; + +@Component +public class ExecutionDepositHistoryMapStore extends ExecutionDepositMapStore { + public ExecutionDepositHistoryMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + } + + @Override + protected boolean isLoadable(Long id) { + return true; + } + + @Override + protected boolean isLoadable(ExecutionDeposit obj) { + return true; + } + + @Override + public Iterable loadAllKeys() { + log.debug("ExecutionDeposit 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/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/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/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/SearchAdmittedLiabilitiesRegisterMapStore.java b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchAdmittedLiabilitiesRegisterMapStore.java new file mode 100644 index 000000000..4bb973872 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchAdmittedLiabilitiesRegisterMapStore.java @@ -0,0 +1,50 @@ +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 + protected String fieldOfDay() { + return "clearing_date"; + } + + + @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[]{"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 new file mode 100644 index 000000000..50cc7b907 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchCoveredLiabilitiesRegisterMapStore.java @@ -0,0 +1,49 @@ +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 + protected String fieldOfDay() { + return "clearing_date"; + } + + @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_SearchCoveredLiabilitiesRegister; + } + + @Override + public String[] getIndexingField() { + return new String[]{"clearingDate"}; + } +} 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..5ff31e4e8 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchDepoPaymentInstructionRegisterMapStore.java @@ -0,0 +1,48 @@ +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 + protected String fieldOfDay() { + return "CREATED_AT"; + } + @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_SearchDepoPaymentInstructionRegister; + } + + @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..1b4e04950 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExcludeLiabilitiesRegisterMapStore.java @@ -0,0 +1,48 @@ +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 + protected String fieldOfDay() { + return "CREATED_AT"; + } + @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_SearchExcludeLiabilitiesRegister; + } + + @Override + public String[] getIndexingField() { + return new String[]{}; + } +} 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 new file mode 100644 index 000000000..f362903a1 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExecutionDepositMapStore.java @@ -0,0 +1,49 @@ +package ru.spcex.clearing.historyimdg.mapstores; + +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; +import ru.spcex.clearing.historyimdg.index.SearchProxyExecutionDeposit; +import ru.spcex.clearing.imdg.IMDGDistributedNames; + +import java.util.Collection; +import java.util.Collections; +import java.util.Map; + +@Component +public class SearchExecutionDepositMapStore extends AbstractSliceMapLoader { + public SearchExecutionDepositMapStore(JdbcTemplate jdbcTemplate) { + super(jdbcTemplate); + } + + @Override + protected String getTableName() { + return "execution_deposit"; + } + + @Override + protected String fieldOfDay() { + return "trading_date"; + } + + @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) -> { + SearchProxyExecutionDeposit proxyRegistry = new SearchProxyExecutionDeposit(); + proxyRegistry.setId(rs.getObject("id", Long.class)); + proxyRegistry.setTradingDate(getLocalDateFromSqlDate(rs,"trading_date")); + return proxyRegistry; + }); + } + + @Override + public String getMapName() { + return IMDGDistributedNames.Map_SearchExecutionDeposit; + } + + @Override + public String[] getIndexingField() { + return new String[]{"tradingDate"}; + } +} 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..184504b14 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExecutionFondMapStore.java @@ -0,0 +1,49 @@ +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 + protected String fieldOfDay() { + return "trading_date"; + } + + @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"}; + } +} 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..67b0dd64c --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchExecutionRegisterMapStore.java @@ -0,0 +1,49 @@ +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 + protected String fieldOfDay() { + return "trading_date"; + } + + @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_SearchExecutionRegister; + } + + @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..db8968f68 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchLiabilitiesRegisterMapStore.java @@ -0,0 +1,49 @@ +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 + protected String fieldOfDay() { + return "CREATED_AT"; + } + + @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_SearchLiabilitiesRegister; + } + + @Override + public String[] getIndexingField() { + return new String[]{}; + } +} 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..3d25f8459 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchMoneyBalanceRegisterMapStore.java @@ -0,0 +1,49 @@ +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 + protected String fieldOfDay() { + return "CREATED_AT"; + } + + @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..0ff10ce22 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/java/ru/spcex/clearing/historyimdg/mapstores/SearchMoneyPaymentInstructionRegisterMapStore.java @@ -0,0 +1,49 @@ +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 + protected String fieldOfDay() { + return "clearing_date"; + } + + @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[]{"clearingDate"}; + } +} 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 new file mode 100644 index 000000000..3a50c9896 --- /dev/null +++ b/clearing-parent/imdg-hist/src/main/resources/application.properties @@ -0,0 +1,12 @@ +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=cls_dev +imdg.hist.database.password=Aa111111 +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: +#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/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/pom.xml b/clearing-parent/pom.xml index b001c2c8c..02a53252c 100644 --- a/clearing-parent/pom.xml +++ b/clearing-parent/pom.xml @@ -42,6 +42,7 @@ swt-exporter swt-importer gateway-api + imdg-hist 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/clearing/imdg/IMDGDistributedNames.java b/platform-parent/platform-imdg-api/src/main/java/ru/spcex/clearing/imdg/IMDGDistributedNames.java index d4fd82a6b..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 @@ -194,6 +194,17 @@ 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_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() { 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/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); + } + } } 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 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