diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/HistoryConfig.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/HistoryConfig.java new file mode 100644 index 000000000..bbe3a540a --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/config/HistoryConfig.java @@ -0,0 +1,48 @@ +package ru.spcex.clearing.backendapi.config; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import ru.spcex.clearing.backendapi.controller.queue.history.condition.HistorySubscription; +import ru.spcex.clearing.backendapi.controller.queue.history.condition.specific.CreatedFromCondition; +import ru.spcex.clearing.backendapi.controller.queue.history.condition.specific.CreatedToCondition; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.platform.classes.base.SpcexObjectBase; +import ru.spcex.platform.imdg.api.ImdgProvider; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder; + +import java.util.LinkedList; +import java.util.List; + +@Configuration +public class HistoryConfig { + + private final ImdgPredicateBuilder pb; + + @Autowired + public HistoryConfig(ImdgProvider imdgProvider) { + this.pb = imdgProvider.getImdg( + IMDGDistributedNames.Map_SearchMoneyBalanceRegister, + SpcexObjectBase.class + ).predicateBuilder(); + } + + @Bean + public List histSubscriptions() { + List hst = new LinkedList<>(); + hst.add(moneyBalanceRegister()); + return hst; + } + + private HistorySubscription moneyBalanceRegister() { + HistorySubscription sbscr = new HistorySubscription(); + sbscr.setDestination("money-balance-registers"); + sbscr.setSearchProxyMapName(IMDGDistributedNames.Map_SearchMoneyBalanceRegister); + sbscr.setFullHistoryMapName(IMDGDistributedNames.Map_MoneyBalanceRegister); + sbscr.setConditions(List.of( + new CreatedFromCondition(pb), + new CreatedToCondition(pb) + )); + return sbscr; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/test/HistController.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/HistController.java similarity index 58% rename from clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/test/HistController.java rename to clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/HistController.java index e67743c9f..a1df1c7e6 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/test/HistController.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/HistController.java @@ -1,4 +1,4 @@ -package ru.spcex.clearing.backendapi.controller.test; +package ru.spcex.clearing.backendapi.controller.queue.history; import io.swagger.annotations.ApiOperation; import io.swagger.annotations.ApiParam; @@ -7,14 +7,16 @@ import io.swagger.annotations.ApiResponses; import org.springframework.beans.factory.InitializingBean; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.format.annotation.DateTimeFormat; import org.springframework.stereotype.Controller; -import org.springframework.web.bind.annotation.RequestBody; -import org.springframework.web.bind.annotation.RequestMapping; -import org.springframework.web.bind.annotation.RequestMethod; -import org.springframework.web.bind.annotation.ResponseBody; +import org.springframework.web.bind.annotation.*; import ru.clearing.classes.statics.data.register.MoneyBalanceRegister; -import ru.spcex.clearing.backendapi.controller.request.cud.history.HistoryConditionRequest; +import ru.spcex.clearing.backendapi.controller.queue.history.condition.ConditionProvider; +import ru.spcex.clearing.backendapi.controller.queue.history.condition.HistorySubscription; +import ru.spcex.clearing.backendapi.controller.request.cud.history.HistoryRequest; import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse; +import ru.spcex.clearing.backendapi.errors.ActionValidationException; +import ru.spcex.clearing.backendapi.errors.BackEndError; import ru.spcex.clearing.backendapi.meta.GetResponseFactory; import ru.spcex.clearing.backendapi.service.IStateLoader; import ru.spcex.clearing.imdg.IMDGDistributedNames; @@ -23,15 +25,12 @@ import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.ImdgProvider; import ru.spcex.platform.imdg.api.predicate.ImdgPredicate; import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder; +import ru.spcex.platform.utils.enumeration.EnumMessage; import ru.spcex.platform.utils.time.TimeUtil; import java.time.LocalDate; import java.time.Month; -import java.util.Collection; -import java.util.List; -import java.util.Map; -import java.util.Objects; -import java.util.concurrent.ConcurrentHashMap; +import java.util.*; @Controller @RequestMapping("/history") @@ -41,12 +40,13 @@ public class HistController implements InitializingBean { private final GetResponseFactory responseFactory; private final IStateLoader stateLoader; private final ImdgPredicateBuilder pb; + private final ConditionProvider conditionProvider; @Autowired public HistController(@Qualifier("imdgProviderHist") ImdgProvider imdgProviderHist, @Qualifier("imdgProvider") ImdgProvider imdgProvider, GetResponseFactory responseFactory, - IStateLoader stateLoader) { + IStateLoader stateLoader, ConditionProvider conditionProvider) { this.imdgProviderHist = imdgProviderHist; this.imdgProvider = imdgProvider; this.responseFactory = responseFactory; @@ -54,6 +54,7 @@ public class HistController implements InitializingBean { this.pb = imdgProviderHist .getImdg(IMDGDistributedNames.Map_SearchMoneyBalanceRegister, SpcexObjectBase.class) .predicateBuilder(); + this.conditionProvider = conditionProvider; } @Override @@ -69,7 +70,7 @@ public class HistController implements InitializingBean { @ResponseBody public CommonGetAllResponse search( @ApiParam(value = "Параметры команды в JSON формате.", required = true) - @RequestBody HistoryConditionRequest searchCondition) { + @RequestBody HistoryRequest searchCondition) { Imdg searchMap = imdgProviderHist.getImdg(IMDGDistributedNames.Map_SearchMoneyBalanceRegister, SpcexObjectBase.class); ImdgPredicateBuilder prdct = searchMap.predicateBuilder(); LocalDate time = LocalDate.of(2023, Month.JUNE, 8);//2023-06-08 @@ -85,19 +86,68 @@ public class HistController implements InitializingBean { return response; } + @ApiOperation(value = "Get history") + @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) + @RequestMapping(path = "/all", method = RequestMethod.POST) + @ResponseBody + public CommonGetAllResponse getHistory( + @ApiParam(value = "destination сущности по которой запрашивается история", example = "money-balance-registers", required = true) + @RequestParam("destination") + String destination, + @ApiParam(value = "Начальная точка поиска по дате", example = "2023-01-15", required = true) + @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) + @RequestParam(name = "from", required = false) + LocalDate from, + @ApiParam(value = "Конечная точка поиска по дате", example = "2023-01-15", required = true) + @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) + @RequestParam(name = "to", required = false) + LocalDate to + ) { + if (to == null && from == null) { + throw new ActionValidationException(new EnumMessage(BackEndError.ValidationError, "from/to url params both empty")); + } + + Optional> entityClass = responseFactory.classByDestination(destination); + //class may be added to HistorySubscription if needed + if (entityClass.isEmpty()) { + throw new ActionValidationException(new EnumMessage(BackEndError.ValidationError, + "destination " + "'" + destination + "' not supported (meta class not found)")); + } + + HistoryRequest req = new HistoryRequest(); + req.setTable(destination); + req.setFrom(from); + req.setTo(to); + + HistorySubscription[] subscr = new HistorySubscription[1]; + ImdgPredicate[] prdct = new ImdgPredicate[1]; + conditionProvider.conditionForRequest(req).map(s -> subscr[0] = s, p -> prdct[0] = p); + + Collection> searchRes = stateLoader.getAllMetaTransform( + subscr[0].getSearchProxyMapName(), + subscr[0].getFullHistoryMapName(), + entityClass.get(), + prdct[0] + ); + + CommonGetAllResponse response = new CommonGetAllResponse(); + response.fromEntity(searchRes); + return response; + } + @ApiOperation(value = "get all money balance registers.") @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)}) @RequestMapping(path = "/money-balance-register2", method = RequestMethod.POST) @ResponseBody public CommonGetAllResponse search2( @ApiParam(value = "Параметры команды в JSON формате.", required = true) - @RequestBody HistoryConditionRequest searchCondition) { + @RequestBody HistoryRequest searchCondition) { //todo conditions by destination and filled fields ImdgPredicate prdct = pb.and( pb.greatEqual("created", TimeUtil.localDateToInstant(searchCondition.getFrom())), pb.lessEqual("created", TimeUtil.localDateToInstant(searchCondition.getTo())) ); - Collection> searchRes = getAllMetaTransform( + Collection> searchRes = stateLoader.getAllMetaTransform( IMDGDistributedNames.Map_SearchMoneyBalanceRegister, IMDGDistributedNames.Map_MoneyBalanceRegister, MoneyBalanceRegister.class, @@ -107,26 +157,4 @@ public class HistController implements InitializingBean { response.fromEntity(searchRes); return response; } - - //mb move to IStateLoader getHistoryMetaTransofrm - Collection> getAllMetaTransform( - String searchMapName, - String mapName, - Class clazz, - ImdgPredicate conditions) { - Imdg imdgSearch = getImdg(searchMapName, clazz); - Imdg imdgHistory = getImdg(mapName, clazz); - Collection ids = imdgSearch.getCollectionIdsByPredicate(conditions); - return ids.stream() - .map(imdgHistory::getSingleObjectByID) - .filter(Objects::nonNull) - .map(o -> responseFactory.responseFromObject(o, clazz)) - .toList(); - } - - private final Map> allImdgMaps = new ConcurrentHashMap<>(); - @SuppressWarnings("unchecked") - private Imdg getImdg(String mapName, Class clazz) { - return (Imdg) allImdgMaps.computeIfAbsent(mapName, (mapName1) -> imdgProviderHist.getImdg(mapName, clazz)); - } } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/ConditionProvider.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/ConditionProvider.java new file mode 100644 index 000000000..8b2f983c3 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/ConditionProvider.java @@ -0,0 +1,69 @@ +package ru.spcex.clearing.backendapi.controller.queue.history.condition; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; +import ru.spcex.clearing.backendapi.controller.request.cud.history.HistoryRequest; +import ru.spcex.clearing.backendapi.errors.ActionValidationException; +import ru.spcex.clearing.backendapi.errors.BackEndError; +import ru.spcex.clearing.backendapi.meta.GetResponseFactory; +import ru.spcex.clearing.imdg.IMDGDistributedNames; +import ru.spcex.platform.classes.base.SpcexObjectBase; +import ru.spcex.platform.imdg.api.Imdg; +import ru.spcex.platform.imdg.api.ImdgProvider; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicate; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder; +import ru.spcex.platform.utils.collection.Pair; +import ru.spcex.platform.utils.enumeration.EnumMessage; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; + +@Component +public class ConditionProvider { + private final Logger log = LoggerFactory.getLogger(getClass()); + private final GetResponseFactory responseFactory; + private final ImdgPredicateBuilder pb; + + private final Map subscriptions; + + @Autowired + public ConditionProvider(GetResponseFactory responseFactory, ImdgProvider imdgProvider, + List subscriptions) { + this.responseFactory = responseFactory; + this.subscriptions = new HashMap<>(); + Imdg imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SearchMoneyBalanceRegister, SpcexObjectBase.class); + this.pb = imdg.predicateBuilder(); + subscriptions.forEach(s -> this.subscriptions.put(s.getDestination(), s)); + } + + public Pair conditionForRequest(HistoryRequest req) { + String destination = req.getTable(); + HistorySubscription subscription = subscriptions.get(destination); + if (subscription == null) { + throw new ActionValidationException(new EnumMessage(BackEndError.ValidationError, + "destination " + "'" + destination + "' not supported (subscription info not found)")); + } + + List predicates = subscription + .getConditions() + .stream() + .map(c -> c.condition(req)) + .filter(Optional::isPresent) + .map(Optional::get) + .toList(); + + ImdgPredicate result; + if (predicates.size() == 0) { + log.warn("destination {} zero predicates found", destination); + result = pb.alwaysTrue(); + } else { + result = pb.and(predicates.toArray(new ImdgPredicate[0])); + } + + return new Pair<>(subscription, result); + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/HistorySubscription.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/HistorySubscription.java new file mode 100644 index 000000000..d2fa9d4b6 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/HistorySubscription.java @@ -0,0 +1,46 @@ +package ru.spcex.clearing.backendapi.controller.queue.history.condition; + +import java.util.Collections; +import java.util.List; + +public class HistorySubscription { + private String destination; + + private List conditions; + private String searchProxyMapName; + private String fullHistoryMapName; + //class + + + public List getConditions() { + return conditions != null ? conditions : Collections.emptyList(); + } + + public void setConditions(List conditions) { + this.conditions = conditions; + } + + public String getSearchProxyMapName() { + return searchProxyMapName; + } + + public void setSearchProxyMapName(String searchProxyMapName) { + this.searchProxyMapName = searchProxyMapName; + } + + public String getFullHistoryMapName() { + return fullHistoryMapName; + } + + public void setFullHistoryMapName(String fullHistoryMapName) { + this.fullHistoryMapName = fullHistoryMapName; + } + + public String getDestination() { + return destination; + } + + public void setDestination(String destination) { + this.destination = destination; + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/IHistoryCondition.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/IHistoryCondition.java new file mode 100644 index 000000000..28b42e829 --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/IHistoryCondition.java @@ -0,0 +1,15 @@ +package ru.spcex.clearing.backendapi.controller.queue.history.condition; + + +import ru.spcex.clearing.backendapi.controller.request.cud.history.HistoryRequest; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicate; + +import java.util.Optional; + +public interface IHistoryCondition { + Optional condition(HistoryRequest req); + + default Optional of(ImdgPredicate predicate) { + return Optional.of(predicate); + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/CreatedFromCondition.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/CreatedFromCondition.java new file mode 100644 index 000000000..1198f8e8c --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/CreatedFromCondition.java @@ -0,0 +1,26 @@ +package ru.spcex.clearing.backendapi.controller.queue.history.condition.specific; + +import ru.spcex.clearing.backendapi.controller.queue.history.condition.IHistoryCondition; +import ru.spcex.clearing.backendapi.controller.request.cud.history.HistoryRequest; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicate; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder; +import ru.spcex.platform.utils.time.TimeUtil; + +import java.util.Optional; + +public class CreatedFromCondition implements IHistoryCondition { + + private final ImdgPredicateBuilder pb; + + public CreatedFromCondition(ImdgPredicateBuilder pb) { + this.pb = pb; + } + + @Override + public Optional condition(HistoryRequest req) { + if (req.getFrom() != null) { + pb.greatEqual("created", TimeUtil.localDateToInstant(req.getFrom())); + } + return Optional.empty(); + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/CreatedToCondition.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/CreatedToCondition.java new file mode 100644 index 000000000..65814d39b --- /dev/null +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/history/condition/specific/CreatedToCondition.java @@ -0,0 +1,26 @@ +package ru.spcex.clearing.backendapi.controller.queue.history.condition.specific; + +import ru.spcex.clearing.backendapi.controller.queue.history.condition.IHistoryCondition; +import ru.spcex.clearing.backendapi.controller.request.cud.history.HistoryRequest; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicate; +import ru.spcex.platform.imdg.api.predicate.ImdgPredicateBuilder; +import ru.spcex.platform.utils.time.TimeUtil; + +import java.util.Optional; + +public class CreatedToCondition implements IHistoryCondition { + + private final ImdgPredicateBuilder pb; + + public CreatedToCondition(ImdgPredicateBuilder pb) { + this.pb = pb; + } + + @Override + public Optional condition(HistoryRequest req) { + if (req.getTo() != null) { + pb.lessEqual("created", TimeUtil.localDateToInstant(req.getTo())); + } + return Optional.empty(); + } +} diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/history/HistoryConditionRequest.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/history/HistoryRequest.java similarity index 97% rename from clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/history/HistoryConditionRequest.java rename to clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/history/HistoryRequest.java index 58736077f..84663cda8 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/history/HistoryConditionRequest.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/request/cud/history/HistoryRequest.java @@ -9,7 +9,7 @@ import ru.spcex.clearing.platform.messaging.domain.json.serialize.LocalDateSeria import java.time.LocalDate; -public class HistoryConditionRequest { +public class HistoryRequest { @ApiModelProperty(value = "Таблица для поиска", example = "1200") @JsonProperty diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/GetResponseFactory.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/GetResponseFactory.java index 557ae545e..b94e4efba 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/GetResponseFactory.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/GetResponseFactory.java @@ -5,6 +5,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; +import ru.spcex.platform.classes.base.SpcexObjectBase; import ru.spcex.platform.utils.time.TimeUtil; import java.text.SimpleDateFormat; @@ -130,6 +131,19 @@ public class GetResponseFactory { response.put(name, data); } + public Optional> classByDestination(String destination) { + Map extracted = meta.getObjectsExtractedByDestination(); + ObjectExtracted objectExtracted = extracted.get(destination); + if (objectExtracted == null) return Optional.empty(); + try { + Class clazz = (Class) objectExtracted.getClazz(); + return Optional.ofNullable(clazz); + } catch (Exception e) { + log.error(ExceptionUtils.getStackTrace(e)); + return Optional.empty(); + } + } + private static final DateTimeFormatter dateTimeFormatter = DateTimeFormatter .ofPattern("yyyy-MM-dd'T'HH:mm:ss+03:00") .withLocale(Locale.US) diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/MetaServer.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/MetaServer.java index 82557d2ba..ec8ee3223 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/MetaServer.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/MetaServer.java @@ -3,6 +3,7 @@ package ru.spcex.clearing.backendapi.meta; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import ru.spcex.platform.utils.log.ExceptionUtils; +import ru.spcex.platform.utils.text.TextUtil; import java.lang.reflect.Constructor; import java.lang.reflect.Method; @@ -67,6 +68,8 @@ public class MetaServer extends MetaBase { objectsExtractedByClazz.put(String.valueOf(classNameMock++), oe); if (objectElement.getSubscription() != null && objectElement.getSubscription().destination != null) { objectsExtractedByDestination.put(objectElement.getSubscription().destination, oe); + } else if (!TextUtil.isEmpty(objectElement.getDestination())) { + objectsExtractedByDestination.put(objectElement.getDestination(), oe); } for (ActionElement actionElement : objectElement.getActions()) { if (actionElement.getClazz() == null) { diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ObjectElement.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ObjectElement.java index c554c5d29..2d508af78 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ObjectElement.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/meta/ObjectElement.java @@ -18,6 +18,10 @@ public class ObjectElement { @JsonInclude(JsonInclude.Include.NON_EMPTY) private String table = null; + @JsonProperty(required = false) + @JsonInclude(JsonInclude.Include.NON_EMPTY) + private String destination = null; + @JsonProperty(value = "fields", required = true) private List fields = new LinkedList<>(); @@ -76,4 +80,12 @@ public class ObjectElement { public Subscription getSubscriptionHistory() { return subscriptionHistory; } + + public String getDestination() { + return destination; + } + + public void setDestination(String destination) { + this.destination = destination; + } } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/IStateLoader.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/IStateLoader.java index 098508554..6b403ccc2 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/IStateLoader.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/IStateLoader.java @@ -17,4 +17,9 @@ public interface IStateLoader { Collection> getAllMetaTransformSpecificClass(String mapName, Class clazz); Collection> getAllMetaTransform(String mapName, Class clazz, Map> conditions); Collection> getAllMetaTransform(String mapName, Class clazz, ImdgPredicate conditions); + Collection> getAllMetaTransform( + String searchMapName, + String mapName, + Class clazz, + ImdgPredicate conditions); } diff --git a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/StateLoaderImpl.java b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/StateLoaderImpl.java index a002dd5a2..183b1eda5 100644 --- a/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/StateLoaderImpl.java +++ b/clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/impl/StateLoaderImpl.java @@ -1,6 +1,7 @@ package ru.spcex.clearing.backendapi.service.impl; import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.stereotype.Service; import ru.spcex.clearing.backendapi.meta.GetResponseFactory; import ru.spcex.clearing.backendapi.service.IStateLoader; @@ -9,21 +10,24 @@ import ru.spcex.platform.imdg.api.Imdg; import ru.spcex.platform.imdg.api.ImdgProvider; import ru.spcex.platform.imdg.api.predicate.ImdgPredicate; -import java.util.Collection; -import java.util.Map; -import java.util.Optional; +import java.util.*; import java.util.concurrent.ConcurrentHashMap; @Service public class StateLoaderImpl implements IStateLoader { private final Map> allImdgMaps; + private final Map> allHistMaps; private final ImdgProvider imdgProvider; + private final ImdgProvider imdgHistProvider; private final GetResponseFactory responseFactory; @Autowired - public StateLoaderImpl(ImdgProvider imdgProvider, GetResponseFactory responseFactory) { + public StateLoaderImpl(@Qualifier("imdgProvider") ImdgProvider imdgProvider, + @Qualifier("imdgProviderHist") ImdgProvider imdgHistProvider, GetResponseFactory responseFactory) { + this.imdgHistProvider = imdgHistProvider; this.responseFactory = responseFactory; this.allImdgMaps = new ConcurrentHashMap<>(); + this.allHistMaps = new HashMap<>(); this.imdgProvider = imdgProvider; } @@ -73,4 +77,25 @@ public class StateLoaderImpl implements IStateLoader { private Imdg getImdg(String mapName, Class clazz) { return (Imdg) allImdgMaps.computeIfAbsent(mapName, (mapName1) -> imdgProvider.getImdg(mapName, clazz)); } + + @SuppressWarnings("unchecked") + private Imdg getHistImdg(String mapName, Class clazz) { + return (Imdg) allHistMaps.computeIfAbsent(mapName, (mapName1) -> imdgHistProvider.getImdg(mapName, clazz)); + } + + @Override + public Collection> getAllMetaTransform( + String searchMapName, + String mapName, + Class clazz, + ImdgPredicate conditions) { + Imdg imdgSearch = getHistImdg(searchMapName, clazz); + Imdg imdgHistory = getHistImdg(mapName, clazz); + Collection ids = imdgSearch.getCollectionIdsByPredicate(conditions); + return ids.stream() + .map(imdgHistory::getSingleObjectByID) + .filter(Objects::nonNull) + .map(o -> responseFactory.responseFromObject(o, clazz)) + .toList(); + } } diff --git a/clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/config/StateLoaderImplTestConfig.java b/clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/config/StateLoaderImplTestConfig.java index da3f11400..b3d7d2c1a 100644 --- a/clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/config/StateLoaderImplTestConfig.java +++ b/clearing-parent/backend-api/src/test/java/ru/spcex/clearing/backendapi/controller/config/StateLoaderImplTestConfig.java @@ -27,6 +27,6 @@ public class StateLoaderImplTestConfig { @Bean(name = "stateLoaderImplTest") public StateLoaderImpl createStateLoaderImpl(@Qualifier("responseFactoryTest") GetResponseFactory responseFactory) { - return new StateLoaderImpl(hazelcastServiceTest, responseFactory); + return new StateLoaderImpl(hazelcastServiceTest, null, responseFactory); } } diff --git a/platform-parent/platform-utils/src/main/java/ru/spcex/platform/utils/collection/Pair.java b/platform-parent/platform-utils/src/main/java/ru/spcex/platform/utils/collection/Pair.java index 281bf36fb..83b3ca0d6 100644 --- a/platform-parent/platform-utils/src/main/java/ru/spcex/platform/utils/collection/Pair.java +++ b/platform-parent/platform-utils/src/main/java/ru/spcex/platform/utils/collection/Pair.java @@ -31,4 +31,13 @@ public class Pair { consumer.accept(p.getFirst()); consumer.accept(p.getSecond()); } + + public void map(Consumer firstConsumer, Consumer secondConsumer) { + if (first != null) { + firstConsumer.accept(first); + } + if (second != null) { + secondConsumer.accept(second); + } + } }