feat: collection search endpoint with condition. (#771)

chivehao · web-flow · commit 0ff9f1cc5c0d · 2025-03-31T00:07:04.000+08:00
* build: to v0.20.10

* fix: CollectionEndpoint api pattern

* feat: add collection search endpoint in CollectionEndpoint

* feat: impl CollectionEndpoint#getCollectionsWithCondition
diff --git a/CHANGELOG.MD b/CHANGELOG.MD
@@ -2,6 +2,11 @@
 
 更新日志文档，版本顺序从新到旧，最新版本在最前(上)面。
 
+# 0.20.10
+
+- 新增历史记录(收藏)条件查询接口
+- 修正根据条目ID查询收藏类型的接口
+
 # 0.20.9
 
 ## 问题修复
diff --git a/api/src/main/java/run/ikaros/api/core/collection/EpisodeCollection.java b/api/src/main/java/run/ikaros/api/core/collection/EpisodeCollection.java
@@ -46,4 +46,6 @@ public class EpisodeCollection {
     private Integer sequence;
     @JsonProperty("ep_group")
     private EpisodeGroup group;
+    @JsonProperty("update_time")
+    private LocalDateTime updateTime;
 }
diff --git a/api/src/main/java/run/ikaros/api/core/collection/vo/FindCollectionCondition.java b/api/src/main/java/run/ikaros/api/core/collection/vo/FindCollectionCondition.java
@@ -0,0 +1,29 @@
+package run.ikaros.api.core.collection.vo;
+
+import jakarta.annotation.Nullable;
+import lombok.Builder;
+import lombok.Data;
+import run.ikaros.api.store.enums.CollectionCategory;
+import run.ikaros.api.store.enums.CollectionType;
+
+@Data
+@Builder
+public class FindCollectionCondition {
+    /**
+     * default is 1.
+     */
+    private Integer page;
+    /**
+     * default is 10.
+     */
+    private Integer size;
+    private CollectionCategory category;
+    @Nullable
+    private CollectionType type;
+    @Nullable
+    private String time;
+    /**
+     * default is false.
+     */
+    private Boolean updateTimeDesc;
+}
diff --git a/api/src/main/java/run/ikaros/api/store/enums/CollectionCategory.java b/api/src/main/java/run/ikaros/api/store/enums/CollectionCategory.java
@@ -0,0 +1,6 @@
+package run.ikaros.api.store.enums;
+
+public enum CollectionCategory {
+    SUBJECT,
+    EPISODE;
+}
diff --git a/gradle.properties b/gradle.properties
@@ -1 +1 @@
-version=0.20.9
+version=0.20.10
diff --git a/server/src/main/java/run/ikaros/server/core/collection/CollectionEndpoint.java b/server/src/main/java/run/ikaros/server/core/collection/CollectionEndpoint.java
@@ -12,7 +12,10 @@
 import org.springframework.web.reactive.function.server.ServerResponse;
 import reactor.core.publisher.Mono;
 import run.ikaros.api.constant.OpenApiConst;
+import run.ikaros.api.core.collection.vo.FindCollectionCondition;
+import run.ikaros.api.store.enums.CollectionCategory;
 import run.ikaros.api.store.enums.CollectionType;
+import run.ikaros.api.wrap.PagingWrap;
 import run.ikaros.server.endpoint.CoreEndpoint;
 
 @Slf4j
@@ -29,7 +32,7 @@ public RouterFunction<ServerResponse> endpoint() {
         var tag = OpenApiConst.CORE_VERSION + "/collection";
         return SpringdocRouteBuilder.route()
 
-            .GET("/collection/subjectId/{id}", this::getTypeBySubjectId,
+            .GET("/collection/type/subjectId/{id}", this::getTypeBySubjectId,
                 builder -> builder.operationId("GetTypeBySubjectId")
                     .tag(tag).description("Get collection type by subject id.")
                     .parameter(parameterBuilder()
@@ -40,6 +43,35 @@ public RouterFunction<ServerResponse> endpoint() {
                         .implementation(CollectionType.class))
             )
 
+            .GET("/collections/condition", this::getCollectionsWithCondition,
+                builder -> builder.operationId("GetCollectionsWithCondition")
+                    .tag(tag).description("Get collections with conditions.")
+                    .parameter(parameterBuilder()
+                        .name("category").description("Collection category, default is EPISODE.")
+                        .implementation(CollectionCategory.class))
+                    .parameter(parameterBuilder()
+                        .name("type")
+                        .description("Collection type, default is null.")
+                        .implementation(CollectionType.class))
+                    .parameter(parameterBuilder()
+                        .name("page")
+                        .description("第几页，从1开始, 默认为1.")
+                        .implementation(Integer.class))
+                    .parameter(parameterBuilder()
+                        .name("size")
+                        .description("每页条数，默认为10.")
+                        .implementation(Integer.class))
+                    .parameter(parameterBuilder()
+                        .name("time")
+                        .implementation(String.class)
+                        .description("时间范围，格式范围类型: 2000.9-2010.8 或者 单个类型2020.8"))
+                    .parameter(parameterBuilder()
+                        .name("updateTimeDesc")
+                        .implementation(Boolean.class)
+                        .description("是否根据更新时间倒序，默认为 true."))
+                    .response(responseBuilder().implementation(PagingWrap.class))
+            )
+
             .build();
     }
 
@@ -49,4 +81,23 @@ private Mono<ServerResponse> getTypeBySubjectId(ServerRequest serverRequest) {
         return collectionService.findTypeBySubjectId(subjectId)
             .flatMap(collectionType -> ServerResponse.ok().bodyValue(collectionType));
     }
+
+    private Mono<ServerResponse> getCollectionsWithCondition(ServerRequest serverRequest) {
+        CollectionCategory category = CollectionCategory.valueOf(
+            serverRequest.queryParam("category").orElse(CollectionCategory.EPISODE.name()));
+        CollectionType type = serverRequest.queryParam("type").map(CollectionType::valueOf)
+            .orElse(null);
+        int page = serverRequest.queryParam("page").map(Integer::parseInt).orElse(1);
+        int size = serverRequest.queryParam("size").map(Integer::parseInt).orElse(10);
+        String time = serverRequest.queryParam("time").orElse(null);
+        boolean updateTimeDesc = serverRequest.queryParam("updateTimeDesc")
+            .map(Boolean::parseBoolean).orElse(false);
+        FindCollectionCondition condition = FindCollectionCondition
+            .builder().page(page).size(size)
+            .category(category).type(type).time(time).updateTimeDesc(updateTimeDesc)
+            .build();
+
+        return collectionService.listCollectionsByCondition(condition)
+            .flatMap(pagingWrap -> ServerResponse.ok().bodyValue(pagingWrap));
+    }
 }
diff --git a/server/src/main/java/run/ikaros/server/core/collection/CollectionService.java b/server/src/main/java/run/ikaros/server/core/collection/CollectionService.java
@@ -1,8 +1,12 @@
 package run.ikaros.server.core.collection;
 
 import reactor.core.publisher.Mono;
+import run.ikaros.api.core.collection.vo.FindCollectionCondition;
 import run.ikaros.api.store.enums.CollectionType;
+import run.ikaros.api.wrap.PagingWrap;
 
 public interface CollectionService {
     Mono<CollectionType> findTypeBySubjectId(Long subjectId);
+
+    Mono<PagingWrap> listCollectionsByCondition(FindCollectionCondition condition);
 }
diff --git a/server/src/main/java/run/ikaros/server/core/collection/DefaultCollectionService.java b/server/src/main/java/run/ikaros/server/core/collection/DefaultCollectionService.java
@@ -1,25 +1,52 @@
 package run.ikaros.server.core.collection;
 
+import static run.ikaros.api.infra.utils.ReactiveBeanUtils.copyProperties;
+
+import java.time.LocalDateTime;
+import java.time.Year;
+import java.util.Objects;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
+import org.springframework.data.relational.core.query.Criteria;
+import org.springframework.data.relational.core.query.Query;
 import org.springframework.stereotype.Service;
 import org.springframework.util.Assert;
+import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
+import run.ikaros.api.core.collection.EpisodeCollection;
+import run.ikaros.api.core.collection.SubjectCollection;
+import run.ikaros.api.core.collection.vo.FindCollectionCondition;
+import run.ikaros.api.infra.utils.StringUtils;
+import run.ikaros.api.store.enums.CollectionCategory;
 import run.ikaros.api.store.enums.CollectionType;
+import run.ikaros.api.wrap.PagingWrap;
 import run.ikaros.server.core.user.UserService;
+import run.ikaros.server.store.entity.EpisodeCollectionEntity;
 import run.ikaros.server.store.entity.SubjectCollectionEntity;
+import run.ikaros.server.store.repository.EpisodeCollectionRepository;
 import run.ikaros.server.store.repository.SubjectCollectionRepository;
 
 @Slf4j
 @Service
 public class DefaultCollectionService implements CollectionService {
     private final SubjectCollectionRepository subjectCollectionRepository;
+    private final EpisodeCollectionRepository episodeCollectionRepository;
 
     private final UserService userService;
+    private final R2dbcEntityTemplate template;
 
+    /**
+     * Construct a {@link CollectionService} instance.
+     */
     public DefaultCollectionService(SubjectCollectionRepository subjectCollectionRepository,
-                                    UserService userService) {
+                                    EpisodeCollectionRepository episodeCollectionRepository,
+                                    UserService userService, R2dbcEntityTemplate template) {
         this.subjectCollectionRepository = subjectCollectionRepository;
+        this.episodeCollectionRepository = episodeCollectionRepository;
         this.userService = userService;
+        this.template = template;
     }
 
     @Override
@@ -29,4 +56,108 @@ public Mono<CollectionType> findTypeBySubjectId(Long subjectId) {
             .flatMap(uid -> subjectCollectionRepository.findByUserIdAndSubjectId(uid, subjectId))
             .map(SubjectCollectionEntity::getType);
     }
+
+    @Override
+    public Mono<PagingWrap> listCollectionsByCondition(FindCollectionCondition condition) {
+        Assert.notNull(condition, "'condition' must not null.");
+        final Integer page = condition.getPage();
+        Assert.isTrue(page > 0, "'page' must gt 0.");
+        final Integer size = condition.getSize();
+        Assert.isTrue(size > 0, "'size' must gt 0.");
+        final PageRequest pageRequest = PageRequest.of(page - 1, size);
+
+        Criteria criteria = Criteria.empty();
+
+        if (CollectionCategory.SUBJECT == condition.getCategory()
+            && !Objects.isNull(condition.getType())) {
+            criteria = criteria.and("type").is(condition.getType());
+        }
+
+        // 范围查询更新时间，用于查询指定时间段的收藏纪录
+        String time = condition.getTime();
+        if (CollectionCategory.EPISODE == condition.getCategory()
+            && StringUtils.isNotBlank(time)
+        ) {
+            if (time.indexOf('-') > 0) {
+                // 日期范围，例如；2000.9-2010.8
+                String[] split = time.split("-");
+                String first = split[0];
+                String second = split[1];
+                LocalDateTime startTime;
+                if (first.indexOf(".") > 0) {
+                    String[] split1 = first.split("\\.");
+                    startTime =
+                        Year.parse(split1[0]).atMonth(Integer.parseInt(split1[1])).atDay(1)
+                            .atStartOfDay();
+                } else {
+                    startTime = Year.parse(first).atMonth(1).atDay(1).atStartOfDay();
+                }
+                LocalDateTime endTime;
+                if (second.indexOf(".") > 0) {
+                    String[] split2 = second.split("\\.");
+                    endTime =
+                        Year.parse(split2[0]).atMonth(Integer.parseInt(split2[1])).atDay(1)
+                            .atStartOfDay().plusMonths(1);
+                } else {
+                    endTime = Year.parse(second).atDay(1).atStartOfDay().plusMonths(1);
+                }
+                criteria = criteria.and(Criteria.where("update_time").between(startTime, endTime));
+            } else {
+                // 单个类型，例如：2020.8
+                if (time.indexOf('.') > 0) {
+                    String[] split = time.split("\\.");
+                    LocalDateTime startTime =
+                        Year.parse(split[0]).atMonth(Integer.parseInt(split[1])).atDay(1)
+                            .atStartOfDay();
+                    criteria = criteria.and(
+                        Criteria.where("update_time").between(startTime, startTime.plusMonths(1)));
+                } else {
+                    LocalDateTime startTime = Year.parse(time).atMonth(1).atDay(1).atStartOfDay();
+                    criteria = criteria.and(
+                        Criteria.where("update_time").between(startTime, startTime.plusYears(1)));
+                }
+            }
+        }
+
+        Query query = Query.query(criteria);
+
+        if (CollectionCategory.EPISODE == condition.getCategory()
+            && condition.getUpdateTimeDesc()) {
+            query = query.sort(Sort.by(Sort.Order.desc("update_time").nullsLast()));
+        }
+
+        if (CollectionCategory.EPISODE == condition.getCategory()) {
+            query = query
+                .sort(Sort.by(
+                    condition.getUpdateTimeDesc() ? Sort.Order.desc("update_time").nullsLast()
+                        : Sort.Order.asc("update_time").nullsLast()));
+        }
+
+        query = query.with(pageRequest);
+
+        Mono<Long> countMono;
+        if (CollectionCategory.EPISODE == condition.getCategory()) {
+            Flux<EpisodeCollectionEntity> episodeCollectionEntityFlux =
+                template.select(query, EpisodeCollectionEntity.class);
+            countMono = template.count(query, EpisodeCollectionEntity.class);
+            return episodeCollectionEntityFlux.map(EpisodeCollectionEntity::getId)
+                .flatMap(episodeCollectionRepository::findById)
+                .flatMap(entity -> copyProperties(entity, new EpisodeCollection()))
+                .collectList()
+                .flatMap(episodeCollections -> countMono
+                    .map(count -> new PagingWrap<>(page, size, count, episodeCollections)));
+        } else if (CollectionCategory.SUBJECT == condition.getCategory()) {
+            Flux<SubjectCollectionEntity> subjectCollectionEntityFlux =
+                template.select(query, SubjectCollectionEntity.class);
+            countMono = template.count(query, SubjectCollectionEntity.class);
+            return subjectCollectionEntityFlux.map(SubjectCollectionEntity::getId)
+                .flatMap(subjectCollectionRepository::findById)
+                .flatMap(entity -> copyProperties(entity, new SubjectCollection()))
+                .collectList()
+                .flatMap(subjects -> countMono
+                    .map(count -> new PagingWrap<>(page, size, count, subjects)));
+        } else {
+            return Mono.empty();
+        }
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -46,4 +46,6 @@ public class EpisodeCollection {`
`46`	`46`	`private Integer sequence;`
`47`	`47`	`@JsonProperty("ep_group")`
`48`	`48`	`private EpisodeGroup group;`
	`49`	`+ @JsonProperty("update_time")`
	`50`	`+ private LocalDateTime updateTime;`
`49`	`51`	`}`