feat(web): 完善confirmation快照页面

gringotts-web/src/main/java/com/eshore/gringotts/web/domain/base/controller/ListController.java

@@ -1,5 +1,6 @@
 package com.eshore.gringotts.web.domain.base.controller;
 
+import com.eshore.gringotts.web.configuration.amis.AmisListResponse;
 import com.eshore.gringotts.web.configuration.amis.AmisResponse;
 import com.eshore.gringotts.web.domain.base.controller.query.Query;
 import org.eclipse.collections.api.list.ImmutableList;
@@ -12,4 +13,8 @@ public interface ListController<LIST_ITEM> {
   AmisResponse<ImmutableList<LIST_ITEM>> list() throws Exception;
 
   AmisResponse<ImmutableList<LIST_ITEM>> list(Query query) throws Exception;
+
+  AmisListResponse page() throws Exception;
+
+  AmisListResponse page(Query query) throws Exception;
 }

gringotts-web/src/main/java/com/eshore/gringotts/web/domain/base/controller/SimpleControllerSupport.java

@@ -1,13 +1,16 @@
 package com.eshore.gringotts.web.domain.base.controller;
 
 import cn.hutool.core.util.ObjectUtil;
+import com.eshore.gringotts.web.configuration.amis.AmisListResponse;
 import com.eshore.gringotts.web.configuration.amis.AmisResponse;
 import com.eshore.gringotts.web.domain.base.controller.query.Query;
 import com.eshore.gringotts.web.domain.base.entity.SimpleEntity;
 import com.eshore.gringotts.web.domain.base.service.SimpleServiceSupport;
+import java.util.stream.Collectors;
 import lombok.extern.slf4j.Slf4j;
 import org.eclipse.collections.api.factory.Lists;
 import org.eclipse.collections.api.list.ImmutableList;
+import org.springframework.data.domain.Page;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
@@ -21,6 +24,7 @@ import org.springframework.web.bind.annotation.RequestBody;
 public abstract class SimpleControllerSupport<ENTITY extends SimpleEntity, SAVE_ITEM, LIST_ITEM, DETAIL_ITEM> implements SimpleController<SAVE_ITEM, LIST_ITEM, DETAIL_ITEM> {
   protected static final String SAVE = "/save";
   protected static final String LIST = "/list";
+  protected static final String PAGE = "/page";
   protected static final String DETAIL = "/detail/{id}";
   protected static final String REMOVE = "/remove/{id}";
 
@@ -63,6 +67,44 @@ public abstract class SimpleControllerSupport<ENTITY extends SimpleEntity, SAVE_
     }));
   }
 
+  @GetMapping(PAGE)
+  @Override
+  public AmisListResponse page() throws Exception {
+    Page<ENTITY> page = service.page();
+    return AmisResponse.responseListData(
+        page.getContent()
+            .stream()
+            .map(entity -> {
+              try {
+                return toListItem(entity);
+              } catch (Exception e) {
+                throw new RuntimeException(e);
+              }
+            })
+            .collect(Collectors.toList()),
+        page.getTotalElements()
+    );
+  }
+
+  @PostMapping(PAGE)
+  @Override
+  public AmisListResponse page(@RequestBody Query query) throws Exception {
+    Page<ENTITY> page = service.page(query);
+    return AmisResponse.responseListData(
+        page.getContent()
+            .stream()
+            .map(entity -> {
+              try {
+                return toListItem(entity);
+              } catch (Exception e) {
+                throw new RuntimeException(e);
+              }
+            })
+            .collect(Collectors.toList()),
+        page.getTotalElements()
+    );
+  }
+
   @GetMapping(DETAIL)
   @Override
   public AmisResponse<DETAIL_ITEM> detail(@PathVariable Long id) throws Exception {

gringotts-web/src/main/java/com/eshore/gringotts/web/domain/base/service/SimpleService.java

@@ -5,6 +5,7 @@ import com.eshore.gringotts.web.domain.base.entity.SimpleEntity;
 import java.util.Optional;
 import org.eclipse.collections.api.list.ImmutableList;
 import org.eclipse.collections.api.set.ImmutableSet;
+import org.springframework.data.domain.Page;
 
 /**
  * @author lanyuanxiaoyao
@@ -21,6 +22,10 @@ public interface SimpleService<ENTITY extends SimpleEntity> {
 
   ImmutableList<ENTITY> list(Query query) throws Exception;
 
+  Page<ENTITY> page() throws Exception;
+
+  Page<ENTITY> page(Query query) throws Exception;
+
   Optional<ENTITY> detailOptional(Long id) throws Exception;
 
   ENTITY detail(Long id) throws Exception;

gringotts-web/src/main/java/com/eshore/gringotts/web/domain/base/service/SimpleServiceSupport.java

@@ -2,7 +2,6 @@ package com.eshore.gringotts.web.domain.base.service;
 
 import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.core.bean.copier.CopyOptions;
-import cn.hutool.core.util.EnumUtil;
 import cn.hutool.core.util.ObjectUtil;
 import cn.hutool.core.util.StrUtil;
 import com.eshore.gringotts.web.domain.base.controller.query.Query;
@@ -12,10 +11,10 @@ import com.eshore.gringotts.web.domain.base.entity.SimpleEntity_;
 import com.eshore.gringotts.web.domain.base.repository.SimpleRepository;
 import com.eshore.gringotts.web.domain.entity.User;
 import com.eshore.gringotts.web.domain.service.UserService;
+import com.eshore.gringotts.web.helper.QueryHelper;
 import java.util.Optional;
 import javax.persistence.criteria.CriteriaBuilder;
 import javax.persistence.criteria.CriteriaQuery;
-import javax.persistence.criteria.Path;
 import javax.persistence.criteria.Predicate;
 import javax.persistence.criteria.Root;
 import javax.transaction.Transactional;
@@ -24,6 +23,8 @@ import org.eclipse.collections.api.factory.Lists;
 import org.eclipse.collections.api.list.ImmutableList;
 import org.eclipse.collections.api.list.MutableList;
 import org.eclipse.collections.api.set.ImmutableSet;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Sort;
 
 /**
@@ -99,87 +100,6 @@ public abstract class SimpleServiceSupport<ENTITY extends SimpleEntity> implemen
     ));
   }
 
-  private <Y> Path<Y> column(Root<ENTITY> root, String column) {
-    String[] columns = StrUtil.splitToArray(column, "/");
-    Path<Y> path = root.get(columns[0]);
-    for (int i = 1; i < columns.length; i++) {
-      path = path.get(columns[i]);
-    }
-    return path;
-  }
-
-  @SuppressWarnings({"unchecked", "rawtypes"})
-  private <Y> Object value(Path<Y> column, Object value) {
-    Class<?> javaType = column.getJavaType();
-    if (EnumUtil.isEnum(javaType)) {
-      return EnumUtil.fromString((Class<Enum>) javaType, (String) value);
-    }
-    return value;
-  }
-
-  @SuppressWarnings("unchecked")
-  protected ImmutableList<Predicate> queryPredicates(Query.Queryable queryable, Root<ENTITY> root, CriteriaQuery<?> query, CriteriaBuilder builder) {
-    MutableList<Predicate> predicates = Lists.mutable.empty();
-    if (ObjectUtil.isEmpty(queryable)) {
-      return predicates.toImmutable();
-    }
-    if (ObjectUtil.isNotEmpty(queryable.getNullEqual())) {
-      queryable.getNullEqual().forEach(column -> predicates.add(builder.isNull(column(root, column))));
-    }
-    if (ObjectUtil.isNotEmpty(queryable.getNotNullEqual())) {
-      queryable.getNotNullEqual().forEach(column -> predicates.add(builder.isNull(column(root, column))));
-    }
-    if (ObjectUtil.isNotEmpty(queryable.getEmpty())) {
-      queryable.getEmpty().forEach(column -> predicates.add(builder.isEmpty(column(root, column))));
-    }
-    if (ObjectUtil.isNotEmpty(queryable.getNotEmpty())) {
-      queryable.getNotEmpty().forEach(column -> predicates.add(builder.isNotEmpty(column(root, column))));
-    }
-    if (ObjectUtil.isNotEmpty(queryable.getEqual())) {
-      queryable.getEqual().forEachKeyValue((column, value) -> {
-        Path<Object> path = column(root, column);
-        predicates.add(builder.equal(path, value(path, value)));
-      });
-    }
-    if (ObjectUtil.isNotEmpty(queryable.getNotEqual())) {
-      queryable.getEqual().forEachKeyValue((column, value) -> {
-        Path<Object> path = column(root, column);
-        predicates.add(builder.notEqual(path, value(path, value)));
-      });
-    }
-    if (ObjectUtil.isNotEmpty(queryable.getLike())) {
-      queryable.getLike().forEachKeyValue((column, value) -> predicates.add(builder.like(column(root, column), value)));
-    }
-    if (ObjectUtil.isNotEmpty(queryable.getNotLike())) {
-      queryable.getNotLike().forEachKeyValue((column, value) -> predicates.add(builder.notLike(column(root, column), value)));
-    }
-    if (ObjectUtil.isNotEmpty(queryable.getGreat())) {
-      queryable.getGreat().forEachKeyValue((column, value) -> predicates.add(builder.greaterThan(column(root, column), (Comparable<Object>) value)));
-    }
-    if (ObjectUtil.isNotEmpty(queryable.getLess())) {
-      queryable.getLess().forEachKeyValue((column, value) -> predicates.add(builder.lessThan(column(root, column), (Comparable<Object>) value)));
-    }
-    if (ObjectUtil.isNotEmpty(queryable.getGreatEqual())) {
-      queryable.getGreatEqual().forEachKeyValue((column, value) -> predicates.add(builder.greaterThanOrEqualTo(column(root, column), (Comparable<Object>) value)));
-    }
-    if (ObjectUtil.isNotEmpty(queryable.getLessEqual())) {
-      queryable.getLessEqual().forEachKeyValue((column, value) -> predicates.add(builder.lessThanOrEqualTo(column(root, column), (Comparable<Object>) value)));
-    }
-    if (ObjectUtil.isNotEmpty(queryable.getIn())) {
-      queryable.getIn().forEachKeyValue((column, value) -> predicates.add(builder.in(column(root, column)).value(value)));
-    }
-    if (ObjectUtil.isNotEmpty(queryable.getNotIn())) {
-      queryable.getNotIn().forEachKeyValue((column, value) -> predicates.add(builder.in(column(root, column)).value(value).not()));
-    }
-    if (ObjectUtil.isNotEmpty(queryable.getBetween())) {
-      queryable.getBetween().forEachKeyValue((column, value) -> predicates.add(builder.between(column(root, column), value.getStart(), value.getEnd())));
-    }
-    if (ObjectUtil.isNotEmpty(queryable.getNotBetween())) {
-      queryable.getNotBetween().forEachKeyValue((column, value) -> predicates.add(builder.between(column(root, column), value.getStart(), value.getEnd())));
-    }
-    return predicates.toImmutable();
-  }
-
   protected ImmutableList<Predicate> listPredicate(Root<ENTITY> root, CriteriaQuery<?> query, CriteriaBuilder builder) {
     User user = userService.currentLoginUser();
     if (User.isNotAdministrator(user)) {
@@ -193,13 +113,36 @@ public abstract class SimpleServiceSupport<ENTITY extends SimpleEntity> implemen
     return Lists.immutable.ofAll(repository.findAll(
         (root, query, builder) -> {
           MutableList<Predicate> predicates = Lists.mutable.ofAll(listPredicate(root, query, builder));
-          predicates.addAllIterable(queryPredicates(listQuery.getQuery(), root, query, builder));
+          predicates.addAllIterable(QueryHelper.queryPredicates(listQuery.getQuery(), root, query, builder));
           return builder.and(predicates.reject(ObjectUtil::isNull).toArray(new Predicate[predicates.size()]));
         },
         Sort.by(SimpleEntity_.CREATED_TIME).descending()
     ));
   }
 
+  @Override
+  public Page<ENTITY> page() throws Exception {
+    return repository.findAll(
+        (root, query, builder) -> {
+          MutableList<Predicate> predicates = Lists.mutable.ofAll(listPredicate(root, query, builder));
+          return builder.and(predicates.reject(ObjectUtil::isNull).toArray(new Predicate[predicates.size()]));
+        },
+        PageRequest.of(0, 10, Sort.by(SimpleEntity_.CREATED_TIME).descending())
+    );
+  }
+
+  @Override
+  public Page<ENTITY> page(Query listQuery) throws Exception {
+    return repository.findAll(
+        (root, query, builder) -> {
+          MutableList<Predicate> predicates = Lists.mutable.ofAll(listPredicate(root, query, builder));
+          predicates.addAllIterable(QueryHelper.queryPredicates(listQuery.getQuery(), root, query, builder));
+          return builder.and(predicates.reject(ObjectUtil::isNull).toArray(new Predicate[predicates.size()]));
+        },
+        PageRequest.of(listQuery.getPage().getPage(), listQuery.getPage().getSize(), Sort.by(SimpleEntity_.CREATED_TIME).descending())
+    );
+  }
+
   @Override
   public Optional<ENTITY> detailOptional(Long id) {
     if (ObjectUtil.isNull(id)) {

gringotts-web/src/main/java/com/eshore/gringotts/web/domain/controller/CheckOrderController.java

@@ -1,16 +1,19 @@
 package com.eshore.gringotts.web.domain.controller;
 
+import com.eshore.gringotts.web.configuration.amis.AmisListResponse;
 import com.eshore.gringotts.web.configuration.amis.AmisResponse;
 import com.eshore.gringotts.web.domain.base.controller.ListController;
 import com.eshore.gringotts.web.domain.base.controller.query.Query;
 import com.eshore.gringotts.web.domain.entity.User;
 import com.eshore.gringotts.web.domain.service.UserService;
+import com.eshore.gringotts.web.helper.QueryHelper;
 import com.lanyuanxiaoyao.flowable.core.model.FlowableHistory;
 import com.lanyuanxiaoyao.flowable.core.model.FlowableInstance;
 import com.lanyuanxiaoyao.flowable.core.model.FlowableNode;
 import com.lanyuanxiaoyao.flowable.jpa.SpringFlowableManager;
 import java.time.LocalDateTime;
 import java.util.List;
+import java.util.stream.Collectors;
 import lombok.Data;
 import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
@@ -18,6 +21,7 @@ import org.eclipse.collections.api.factory.Lists;
 import org.eclipse.collections.api.factory.Maps;
 import org.eclipse.collections.api.list.ImmutableList;
 import org.eclipse.collections.api.map.ImmutableMap;
+import org.springframework.data.domain.Page;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
@@ -64,10 +68,41 @@ public class CheckOrderController implements ListController<CheckOrderController
 
   @PostMapping("/list")
   @Override
-  public AmisResponse<ImmutableList<ListItem>> list(@RequestBody Query query) throws Exception {
+  public AmisResponse<ImmutableList<ListItem>> list(@RequestBody Query listQuery) throws Exception {
     throw new UnsupportedOperationException();
   }
 
+  @GetMapping("/page")
+  @Override
+  public AmisListResponse page() throws Exception {
+    throw new UnsupportedOperationException();
+  }
+
+  @PostMapping("/page")
+  @Override
+  public AmisListResponse page(@RequestBody Query listQuery) throws Exception {
+    User user = userService.currentLoginUser();
+    Page<FlowableInstance> page = flowableManager.listInstances(
+        (root, query, builder) -> {
+          if (User.isAdministrator(user)) {
+            return null;
+          }
+          return builder.or(
+              builder.like(root.get("extra"), user.getRole().name()),
+              builder.like(root.get("extra"), user.getId().toString())
+          );
+        },
+        QueryHelper.pageable(listQuery)
+    );
+    return AmisListResponse.responseListData(
+        page.getContent()
+            .stream()
+            .map(this::toListItem)
+            .collect(Collectors.toList()),
+        page.getTotalElements()
+    );
+  }
+
   @GetMapping("/approve/{instanceId}")
   public AmisResponse<Object> approve(@PathVariable String instanceId) {
     flowableManager.approve(instanceId);

gringotts-web/src/main/java/com/eshore/gringotts/web/domain/controller/DataFileController.java

@@ -3,6 +3,7 @@ package com.eshore.gringotts.web.domain.controller;
 import cn.hutool.core.io.FileUtil;
 import cn.hutool.core.io.IoUtil;
 import cn.hutool.core.util.StrUtil;
+import cn.hutool.core.util.URLUtil;
 import cn.hutool.crypto.SecureUtil;
 import com.eshore.gringotts.web.configuration.HostConfiguration;
 import com.eshore.gringotts.web.configuration.UploadConfiguration;
@@ -86,7 +87,7 @@ public class DataFileController {
     response.setHeader("Access-Control-Expose-Headers", "Content-Type");
     response.setHeader("Content-Type", dataFile.getType());
     response.setHeader("Access-Control-Expose-Headers", "Content-Disposition");
-    response.setHeader("Content-Disposition", StrUtil.format("attachment; filename={}", dataFile.getFilename()));
+    response.setHeader("Content-Disposition", StrUtil.format("attachment; filename={}", URLUtil.encodeAll(dataFile.getFilename())));
     IoUtil.copy(new FileInputStream(targetFile), response.getOutputStream());
   }
 

gringotts-web/src/main/java/com/eshore/gringotts/web/domain/service/ConfirmationService.java

@@ -81,7 +81,13 @@ public class ConfirmationService extends CheckingService<Confirmation> {
         AmisHelper.divider(),
         AmisHelper.property(entity),
         AmisHelper.divider(),
-        AmisHelper.property(resource.getExample())
+        AmisHelper.property(resource.getExample()),
+        AmisHelper.divider(),
+        AmisHelper.property(
+            "确权申请信息",
+            AmisHelper.propertyItem("描述", entity.getDescription()),
+            AmisHelper.propertyItem(entity.getEvidences())
+        )
     );
   }
 

gringotts-web/src/main/java/com/eshore/gringotts/web/helper/AmisHelper.java

@@ -190,8 +190,8 @@ public class AmisHelper {
     return propertyItem(Lists.immutable.of(dataFile));
   }
 
-  public static ImmutableMap<Object, Object> propertyItem(ImmutableList<DataFile> dataFiles) {
-    return propertyItem("文件", dataFiles);
+  public static ImmutableMap<Object, Object> propertyItem(Iterable<DataFile> dataFiles) {
+    return propertyItem("文件", Lists.immutable.ofAll(dataFiles));
   }
 
   public static ImmutableMap<Object, Object> propertyItem(String label, ImmutableList<DataFile> dataFiles) {

gringotts-web/src/main/java/com/eshore/gringotts/web/helper/QueryHelper.java

@@ -0,0 +1,121 @@
+package com.eshore.gringotts.web.helper;
+
+import cn.hutool.core.util.EnumUtil;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.StrUtil;
+import com.eshore.gringotts.web.domain.base.controller.query.Query;
+import com.eshore.gringotts.web.domain.base.entity.SimpleEntity_;
+import java.util.List;
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Path;
+import javax.persistence.criteria.Predicate;
+import javax.persistence.criteria.Root;
+import org.eclipse.collections.api.factory.Lists;
+import org.eclipse.collections.api.list.ImmutableList;
+import org.eclipse.collections.api.list.MutableList;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+
+/**
+ * @author lanyuanxiaoyao
+ * @version 20250114
+ */
+public class QueryHelper {
+  private static <ENTITY, Y> Path<Y> column(Root<ENTITY> root, String column) {
+    String[] columns = StrUtil.splitToArray(column, "/");
+    Path<Y> path = root.get(columns[0]);
+    for (int i = 1; i < columns.length; i++) {
+      path = path.get(columns[i]);
+    }
+    return path;
+  }
+
+  @SuppressWarnings({"unchecked", "rawtypes"})
+  private static <Y> Object value(Path<Y> column, Object value) {
+    Class<?> javaType = column.getJavaType();
+    if (EnumUtil.isEnum(javaType)) {
+      return EnumUtil.fromString((Class<Enum>) javaType, (String) value);
+    }
+    return value;
+  }
+
+  @SuppressWarnings("unchecked")
+  public static <ENTITY> ImmutableList<Predicate> queryPredicates(Query.Queryable queryable, Root<ENTITY> root, CriteriaQuery<?> query, CriteriaBuilder builder) {
+    MutableList<Predicate> predicates = Lists.mutable.empty();
+    if (ObjectUtil.isEmpty(queryable)) {
+      return predicates.toImmutable();
+    }
+    if (ObjectUtil.isNotEmpty(queryable.getNullEqual())) {
+      queryable.getNullEqual().forEach(column -> predicates.add(builder.isNull(column(root, column))));
+    }
+    if (ObjectUtil.isNotEmpty(queryable.getNotNullEqual())) {
+      queryable.getNotNullEqual().forEach(column -> predicates.add(builder.isNull(column(root, column))));
+    }
+    if (ObjectUtil.isNotEmpty(queryable.getEmpty())) {
+      queryable.getEmpty().forEach(column -> predicates.add(builder.isEmpty(column(root, column))));
+    }
+    if (ObjectUtil.isNotEmpty(queryable.getNotEmpty())) {
+      queryable.getNotEmpty().forEach(column -> predicates.add(builder.isNotEmpty(column(root, column))));
+    }
+    if (ObjectUtil.isNotEmpty(queryable.getEqual())) {
+      queryable.getEqual().forEachKeyValue((column, value) -> {
+        Path<Object> path = column(root, column);
+        predicates.add(builder.equal(path, value(path, value)));
+      });
+    }
+    if (ObjectUtil.isNotEmpty(queryable.getNotEqual())) {
+      queryable.getEqual().forEachKeyValue((column, value) -> {
+        Path<Object> path = column(root, column);
+        predicates.add(builder.notEqual(path, value(path, value)));
+      });
+    }
+    if (ObjectUtil.isNotEmpty(queryable.getLike())) {
+      queryable.getLike().forEachKeyValue((column, value) -> predicates.add(builder.like(column(root, column), value)));
+    }
+    if (ObjectUtil.isNotEmpty(queryable.getNotLike())) {
+      queryable.getNotLike().forEachKeyValue((column, value) -> predicates.add(builder.notLike(column(root, column), value)));
+    }
+    if (ObjectUtil.isNotEmpty(queryable.getGreat())) {
+      queryable.getGreat().forEachKeyValue((column, value) -> predicates.add(builder.greaterThan(column(root, column), (Comparable<Object>) value)));
+    }
+    if (ObjectUtil.isNotEmpty(queryable.getLess())) {
+      queryable.getLess().forEachKeyValue((column, value) -> predicates.add(builder.lessThan(column(root, column), (Comparable<Object>) value)));
+    }
+    if (ObjectUtil.isNotEmpty(queryable.getGreatEqual())) {
+      queryable.getGreatEqual().forEachKeyValue((column, value) -> predicates.add(builder.greaterThanOrEqualTo(column(root, column), (Comparable<Object>) value)));
+    }
+    if (ObjectUtil.isNotEmpty(queryable.getLessEqual())) {
+      queryable.getLessEqual().forEachKeyValue((column, value) -> predicates.add(builder.lessThanOrEqualTo(column(root, column), (Comparable<Object>) value)));
+    }
+    if (ObjectUtil.isNotEmpty(queryable.getIn())) {
+      queryable.getIn().forEachKeyValue((column, value) -> predicates.add(builder.in(column(root, column)).value(value)));
+    }
+    if (ObjectUtil.isNotEmpty(queryable.getNotIn())) {
+      queryable.getNotIn().forEachKeyValue((column, value) -> predicates.add(builder.in(column(root, column)).value(value).not()));
+    }
+    if (ObjectUtil.isNotEmpty(queryable.getBetween())) {
+      queryable.getBetween().forEachKeyValue((column, value) -> predicates.add(builder.between(column(root, column), value.getStart(), value.getEnd())));
+    }
+    if (ObjectUtil.isNotEmpty(queryable.getNotBetween())) {
+      queryable.getNotBetween().forEachKeyValue((column, value) -> predicates.add(builder.between(column(root, column), value.getStart(), value.getEnd())));
+    }
+    return predicates.toImmutable();
+  }
+
+  public static Pageable pageable(Query query) {
+    if (ObjectUtil.isNull(query)) {
+      return PageRequest.of(0, 10);
+    }
+    int page = Math.max(query.getPage().getPage() - 1, 0);
+    if (ObjectUtil.isEmpty(query.getSort())) {
+      return org.springframework.data.domain.PageRequest.of(page, query.getPage().getSize(), Sort.by(Sort.Direction.DESC, SimpleEntity_.CREATED_TIME));
+    } else {
+      List<Sort.Order> orders = query.getSort()
+          .collect(sortable -> new Sort.Order(Sort.Direction.fromString(sortable.getDirection().name()), sortable.getColumn()))
+          .toList();
+      return org.springframework.data.domain.PageRequest.of(page, query.getPage().getSize(), Sort.by(orders));
+    }
+  }
+}