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

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<HistorySubscription> histSubscriptions() {
+        List<HistorySubscription> 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;
+    }
+}

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.*;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestMethod;
-import org.springframework.web.bind.annotation.ResponseBody;
 import ru.clearing.classes.statics.data.register.MoneyBalanceRegister;
-import ru.spcex.clearing.backendapi.controller.request.cud.history.HistoryConditionRequest;
+import ru.spcex.clearing.backendapi.controller.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.*;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.concurrent.ConcurrentHashMap;
 
 @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<SpcexObjectBase> 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<Class<? extends SpcexObjectBase>> 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<Map<String, Object>> 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<Map<String, Object>> searchRes = getAllMetaTransform(
+        Collection<Map<String, Object>> 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
-    <T extends SpcexObjectBase> Collection<Map<String, Object>> getAllMetaTransform(
-            String searchMapName,
-            String mapName,
-            Class<T> clazz,
-            ImdgPredicate conditions) {
-        Imdg<T> imdgSearch = getImdg(searchMapName, clazz);
-        Imdg<T> imdgHistory = getImdg(mapName, clazz);
-        Collection<Long> ids = imdgSearch.getCollectionIdsByPredicate(conditions);
-        return ids.stream()
-                .map(imdgHistory::getSingleObjectByID)
-                .filter(Objects::nonNull)
-                .map(o -> responseFactory.responseFromObject(o, clazz))
-                .toList();
-    }
-
-    private final Map<String, Imdg<?>> allImdgMaps = new ConcurrentHashMap<>();
-    @SuppressWarnings("unchecked")
-    private <T extends SpcexObjectBase> Imdg<T> getImdg(String mapName, Class<T> clazz) {
-        return (Imdg<T>) allImdgMaps.computeIfAbsent(mapName, (mapName1) -> imdgProviderHist.getImdg(mapName, clazz));
-    }
 }

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<String, HistorySubscription> subscriptions;
+
+    @Autowired
+    public ConditionProvider(GetResponseFactory responseFactory, ImdgProvider imdgProvider,
+                             List<HistorySubscription> subscriptions) {
+        this.responseFactory = responseFactory;
+        this.subscriptions = new HashMap<>();
+        Imdg<SpcexObjectBase> imdg = imdgProvider.getImdg(IMDGDistributedNames.Map_SearchMoneyBalanceRegister, SpcexObjectBase.class);
+        this.pb = imdg.predicateBuilder();
+        subscriptions.forEach(s -> this.subscriptions.put(s.getDestination(), s));
+    }
+
+    public Pair<HistorySubscription, ImdgPredicate> 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<ImdgPredicate> 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);
+    }
+}

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<IHistoryCondition> conditions;
+    private String searchProxyMapName;
+    private String fullHistoryMapName;
+    //class
+
+
+    public List<IHistoryCondition> getConditions() {
+        return conditions != null ? conditions : Collections.emptyList();
+    }
+
+    public void setConditions(List<IHistoryCondition> 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;
+    }
+}

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<ImdgPredicate> condition(HistoryRequest req);
+
+    default Optional<ImdgPredicate> of(ImdgPredicate predicate) {
+        return Optional.of(predicate);
+    }
+}

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<ImdgPredicate> condition(HistoryRequest req) {
+        if (req.getFrom() != null) {
+            pb.greatEqual("created", TimeUtil.localDateToInstant(req.getFrom()));
+        }
+        return Optional.empty();
+    }
+}

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<ImdgPredicate> condition(HistoryRequest req) {
+        if (req.getTo() != null) {
+            pb.lessEqual("created", TimeUtil.localDateToInstant(req.getTo()));
+        }
+        return Optional.empty();
+    }
+}

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

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<Class<? extends SpcexObjectBase>> classByDestination(String destination) {
+        Map<String, ObjectExtracted> extracted = meta.getObjectsExtractedByDestination();
+        ObjectExtracted objectExtracted = extracted.get(destination);
+        if (objectExtracted == null) return Optional.empty();
+        try {
+            Class<? extends SpcexObjectBase> clazz = (Class<? extends SpcexObjectBase>) 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)

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) {

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<ActionField> 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;
+    }
 }

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/service/IStateLoader.java

@@ -17,4 +17,9 @@ public interface IStateLoader {
     <T extends SpcexObjectBase> Collection<Map<String, Object>> getAllMetaTransformSpecificClass(String mapName, Class<T> clazz);
     <T extends SpcexObjectBase> Collection<Map<String, Object>> getAllMetaTransform(String mapName, Class<T> clazz, Map<String, ? extends Comparable<?>> conditions);
     <T extends SpcexObjectBase> Collection<Map<String, Object>> getAllMetaTransform(String mapName, Class<T> clazz, ImdgPredicate conditions);
+    <T extends SpcexObjectBase> Collection<Map<String, Object>> getAllMetaTransform(
+            String searchMapName,
+            String mapName,
+            Class<T> clazz,
+            ImdgPredicate conditions);
 }

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.*;
-import java.util.Map;
-import java.util.Optional;
 import java.util.concurrent.ConcurrentHashMap;
 
 @Service
 public class StateLoaderImpl implements IStateLoader {
     private final Map<String, Imdg<?>> allImdgMaps;
+    private final Map<String, Imdg<?>> 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 <T extends SpcexObjectBase> Imdg<T> getImdg(String mapName, Class<T> clazz) {
         return (Imdg<T>) allImdgMaps.computeIfAbsent(mapName, (mapName1) -> imdgProvider.getImdg(mapName, clazz));
     }
+
+    @SuppressWarnings("unchecked")
+    private <T extends SpcexObjectBase> Imdg<T> getHistImdg(String mapName, Class<T> clazz) {
+        return (Imdg<T>) allHistMaps.computeIfAbsent(mapName, (mapName1) -> imdgHistProvider.getImdg(mapName, clazz));
+    }
+
+    @Override
+    public <T extends SpcexObjectBase> Collection<Map<String, Object>> getAllMetaTransform(
+            String searchMapName,
+            String mapName,
+            Class<T> clazz,
+            ImdgPredicate conditions) {
+        Imdg<T> imdgSearch = getHistImdg(searchMapName, clazz);
+        Imdg<T> imdgHistory = getHistImdg(mapName, clazz);
+        Collection<Long> ids = imdgSearch.getCollectionIdsByPredicate(conditions);
+        return ids.stream()
+                .map(imdgHistory::getSingleObjectByID)
+                .filter(Objects::nonNull)
+                .map(o -> responseFactory.responseFromObject(o, clazz))
+                .toList();
+    }
 }

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);
     }
 }

platform-parent/platform-utils/src/main/java/ru/spcex/platform/utils/collection/Pair.java

@@ -31,4 +31,13 @@ public class Pair<T1, T2> {
         consumer.accept(p.getFirst());
         consumer.accept(p.getSecond());
     }
+
+    public void map(Consumer<T1> firstConsumer, Consumer<T2> secondConsumer) {
+        if (first != null) {
+            firstConsumer.accept(first);
+        }
+        if (second != null) {
+            secondConsumer.accept(second);
+        }
+    }
 }