added pagination to get all registries controller

clearing-parent/backend-api/src/main/java/ru/spcex/clearing/backendapi/controller/queue/register/RegistryController.java

@@ -4,16 +4,33 @@ import io.swagger.annotations.ApiOperation;
 import io.swagger.annotations.ApiParam;
 import io.swagger.annotations.ApiResponse;
 import io.swagger.annotations.ApiResponses;
+import java.time.LocalDate;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
 import org.springframework.stereotype.Controller;
-import org.springframework.web.bind.annotation.*;
+import org.springframework.util.StopWatch;
+import org.springframework.web.bind.annotation.PathVariable;
+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.RequestParam;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.server.ResponseStatusException;
 import ru.clearing.classes.statics.data.execution.ExecutionDeposit;
 import ru.clearing.classes.statics.data.registry.Registry;
 import ru.spcex.clearing.backendapi.controller.queue.AbstractQueueController;
-import ru.spcex.clearing.backendapi.controller.request.cud.registry.*;
+import ru.spcex.clearing.backendapi.controller.request.cud.registry.ChangeRefundDateActionNew;
+import ru.spcex.clearing.backendapi.controller.request.cud.registry.ChangeStatusExtractActionNew;
+import ru.spcex.clearing.backendapi.controller.request.cud.registry.IdentificationFundsActionNew;
+import ru.spcex.clearing.backendapi.controller.request.cud.registry.RSplitDepositActionNew;
+import ru.spcex.clearing.backendapi.controller.request.cud.registry.ReturnDepositActionNew;
 import ru.spcex.clearing.backendapi.controller.response.BasicSpcexResponse;
 import ru.spcex.clearing.backendapi.controller.response.cud.CudResponse;
 import ru.spcex.clearing.backendapi.controller.response.entity.CommonGetAllResponse;
@@ -22,14 +39,11 @@ import ru.spcex.clearing.backendapi.service.IStateLoader;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.clearing.platform.messaging.domain.Consts;
 import ru.spcex.platform.enumeration.RegistryDesignation;
+import ru.spcex.platform.enumeration.RegistryStatus;
 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.IEnumKey;
-import java.time.LocalDate;
-import java.util.Collection;
-import java.util.Map;
-import java.util.concurrent.ExecutionException;
 
 @Controller
 @RequestMapping("/registries")
@@ -51,26 +65,64 @@ public class RegistryController extends AbstractQueueController {
     @ApiResponses(value = {@ApiResponse(code = 200, message = "OK", response = CommonGetAllResponse.class)})
     @RequestMapping(method = RequestMethod.GET)
     @ResponseBody
-    public CommonGetAllResponse getAll() {
+    public CommonGetAllResponse getAll(@RequestParam(name = "designation", required = false) List<String> designations,
-//        long t1 = System.currentTimeMillis();
+                                       @RequestParam(name = "status", required = false) String status,
-        ImdgPredicate filter = predicateBuilder.or(
+                                       @RequestParam(name = "pageSize", required = false) Integer pageSize,
+                                       @RequestParam(name = "pageIndex", required = false) Integer pageIndex) {
+        if (designations != null && !designations.isEmpty()) {
+            for (String designation : designations) {
+                if (IEnumKey.getEnumByKey(RegistryDesignation.class, designation) == null) {
+                    throw new ResponseStatusException(HttpStatus.NOT_ACCEPTABLE, "Unknown registry designation: " + designation);
+                }
+            }
+        }
+        if (status != null && !status.isEmpty() && IEnumKey.getEnumByKey(RegistryStatus.class, status) == null) {
+            throw new ResponseStatusException(HttpStatus.NOT_ACCEPTABLE, "Unknown registry status: " + status);
+        }
+
+        StopWatch sw = new StopWatch("registry-controller-stopwatch");
+        sw.start();
+        ImdgPredicate filter;
+        if (designations == null || designations.isEmpty()) {
+            filter = predicateBuilder.or(
                 predicateBuilder.equals("registryDesignation", RegistryDesignation.A.getKey()),
                 predicateBuilder.equals("registryDesignation", RegistryDesignation.D.getKey()),
                 predicateBuilder.and(
-                        predicateBuilder.or(
+                    predicateBuilder.or(
-                                predicateBuilder.equals("registryDesignation", RegistryDesignation.O.getKey()),
+                        predicateBuilder.equals("registryDesignation", RegistryDesignation.O.getKey()),
-                                predicateBuilder.equals("registryDesignation", RegistryDesignation.T.getKey())
+                        predicateBuilder.equals("registryDesignation", RegistryDesignation.T.getKey())
-                        ),
+                    ),
-                        predicateBuilder.greatEqual("settlementDate", LocalDate.now())
+                    predicateBuilder.greatEqual("settlementDate", LocalDate.now())
                 )
-        );
+            );
-        Collection<Map<String, Object>> all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_Registry, Registry.class,
+
-                filter);
+            if (status != null && !status.isEmpty()) {
-//        long t2 = System.currentTimeMillis();
+                filter = predicateBuilder.and(filter, predicateBuilder.in("status", status));
-//        log.info("Info select and format {} data {}", all.size(), t2 - t1);
+            }
+        } else if (status == null || status.isEmpty()) {
+            filter = predicateBuilder.in("registryDesignation", designations.toArray(String[]::new));
+        } else {
+            filter = predicateBuilder.and(
+                predicateBuilder.in("registryDesignation", designations.toArray(String[]::new)),
+                predicateBuilder.in("status", status)
+            );
+        }
+
+        Collection<Map<String, Object>> all;
+        if (pageSize != null && pageIndex != null) {
+            all = stateLoader.getAllMetaTransformWithPagination(IMDGDistributedNames.Map_Registry, Registry.class, filter, pageSize, pageIndex);
+        } else {
+            all = stateLoader.getAllMetaTransform(IMDGDistributedNames.Map_Registry, Registry.class, filter);
+        }
+
+        sw.stop();
+        log.info("Info select and format {} data took {} ms", all.size(), sw.getLastTaskTimeMillis());
+
+        sw.start();
         CommonGetAllResponse response = new CommonGetAllResponse();
         response.fromEntity(all);
-//        log.info("Info select and format {} data {}", all.size(), System.currentTimeMillis() - t2);
+        sw.stop();
+        log.info("Info select and format {} data {}", all.size(), sw.getLastTaskTimeMillis());
         return response;
     }
 

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

@@ -17,9 +17,10 @@ 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>> getAllMetaTransformWithPagination(String mapName, Class<T> clazz, ImdgPredicate conditions, Integer pageSize, Integer pageIndex);
     <T extends SpcexObjectBase> Collection<Map<String, Object>> getAllMetaTransform(
-            String searchMapName,
+        String searchMapName,
-            String mapName,
+        String mapName,
-            Class<T> clazz,
+        Class<T> clazz,
-            ImdgPredicate conditions);
+        ImdgPredicate conditions);
 }

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

@@ -1,5 +1,11 @@
 package ru.spcex.clearing.backendapi.service.impl;
 
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.stereotype.Service;
@@ -10,9 +16,6 @@ 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.*;
-import java.util.concurrent.ConcurrentHashMap;
-
 @Service
 public class StateLoaderImpl implements IStateLoader {
     private final Map<String, Imdg<?>> allImdgMaps;
@@ -73,6 +76,13 @@ public class StateLoaderImpl implements IStateLoader {
         return responseFactory.responseFromObjectCollection(all);
     }
 
+    @Override
+    public <T extends SpcexObjectBase> Collection<Map<String, Object>> getAllMetaTransformWithPagination(String mapName, Class<T> clazz, ImdgPredicate conditions, Integer pageSize, Integer pageIndex) {
+        Imdg<T> imdg = getImdg(mapName, clazz);
+        Collection<T> all = imdg.getCollectionObjectsByPredicateWithPaging(conditions, pageSize, pageIndex);
+        return responseFactory.responseFromObjectCollection(all);
+    }
+
     @SuppressWarnings("unchecked")
     private <T extends SpcexObjectBase> Imdg<T> getImdg(String mapName, Class<T> clazz) {
         return (Imdg<T>) allImdgMaps.computeIfAbsent(mapName, (mapName1) -> imdgProvider.getImdg(mapName, clazz));

platform-parent/platform-imdg-api-hazelcast-impl/src/main/java/ru/spcex/platform/imdg/iml/hazelcast/adapter/ImdgHazelcast.java

@@ -1,5 +1,6 @@
 package ru.spcex.platform.imdg.iml.hazelcast.adapter;
 
+import com.hazelcast.query.PagingPredicate;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
@@ -319,6 +320,23 @@ public class ImdgHazelcast<T extends SpcexObjectBase> implements Imdg<T> {
         return searchResult;
     }
 
+    public Collection<T> getCollectionObjectsByPredicateWithPaging(ImdgPredicate predicate, Integer pageSize, Integer pageIndex) {
+        Predicate hazelcastPredicate = ((ImdgPredicateHazelcast) predicate).getRawPredicate();
+        PagingPredicate pagingPredicate = new PagingPredicate(hazelcastPredicate, pageSize);
+        pagingPredicate.setPage(pageIndex);
+
+        Set<Long> ids = map.keySet(pagingPredicate);
+        Iterator<Long> idIterator = ids.iterator();
+        Collection<T> searchResult = new ArrayList<>();
+        while (idIterator.hasNext()) {
+            T element = map.get(idIterator.next());
+            if (element != null) {
+                searchResult.add(element);
+            }
+        }
+        return searchResult;
+    }
+
     @Override
     public T getSingleObjectByPredicate(ImdgPredicate predicate) {
         Collection<T> els = getCollectionObjectsByPredicate(predicate);

platform-parent/platform-imdg-api/src/main/java/ru/spcex/platform/imdg/api/Imdg.java

@@ -116,6 +116,10 @@ public interface Imdg<T extends SpcexObjectBase> {
         throw new UnsupportedOperationException("not implemented getCollectionObjectsByPredicate");
     }
 
+    default Collection<T> getCollectionObjectsByPredicateWithPaging(ImdgPredicate predicate, Integer pageSize, Integer pageIndex) {
+        throw new UnsupportedOperationException("not implemented getCollectionObjectsByPredicateWithPaging");
+    }
+
     // Predicate API
     default T getSingleObjectByPredicate(ImdgPredicate predicate) {
         throw new UnsupportedOperationException("not implemented getSingleObjectByPredicate");