CLAP-92 기간별 작업 처리량 조회

src/main/java/clap/server/adapter/inbound/web/statistics/StatisticsFindController.java

@@ -1,7 +1,9 @@
 package clap.server.adapter.inbound.web.statistics;
 
+import clap.server.application.port.inbound.statistics.CategoryTaskRequestUsecase;
 import clap.server.application.port.inbound.statistics.PeriodTaskProcessUsecase;
 import clap.server.application.port.inbound.statistics.PeriodTaskRequestUsecase;
+import clap.server.application.port.inbound.statistics.SubCategoryTaskRequestUsecase;
 import clap.server.common.annotation.architecture.WebAdapter;
 import lombok.RequiredArgsConstructor;
 import org.springframework.web.bind.annotation.GetMapping;
@@ -13,21 +15,28 @@
 @RequiredArgsConstructor
 public class StatisticsFindController {
     private final PeriodTaskRequestUsecase periodTaskRequestUsecase;
-//    private final PeriodTaskProcessUsecase periodTaskProcessUsecase;
-//    private final CategoryTaskRequestUsecase categoryTaskRequestUsecase;
-//    private final SubCategoryTaskRequestUsecase subCategoryTaskRequestUsecase;
+    private final PeriodTaskProcessUsecase periodTaskProcessUsecase;
+    private final CategoryTaskRequestUsecase categoryTaskRequestUsecase;
+    private final SubCategoryTaskRequestUsecase subCategoryTaskRequestUsecase;
 //    private final ManagerTaskProcessUsecase managerTaskProcessUsecase;
 
     @GetMapping(value = "/task/statistics/task-requests-by-period")
     public Map<String, Long> aggregatePeriodTaskRequest(@RequestParam String period) {
         return periodTaskRequestUsecase.periodTaskRequestAggregate(period);
     }
 
-//    @GetMapping("/task/statistics/task-processed-by-period")
-//
-//    @GetMapping("/task/statistics/task-requests-by-category")
-//
-//    @GetMapping("/task/statistics/task-requests-by-subcategory")
-//
+    @GetMapping("/task/statistics/task-processed-by-period")
+    public Map<String, Long> aggregatePeriodTaskProcess(@RequestParam String period) {
+        return periodTaskProcessUsecase.periodTaskProcessAggregate(period);
+    }
+    @GetMapping("/task/statistics/task-requests-by-category")
+    public Map<String, Long> aggregateCategoryTaskRequest(@RequestParam String period) {
+        return categoryTaskRequestUsecase.categoryTaskRequestAggregate(period);
+    }
+
+    @GetMapping("/task/statistics/task-requests-by-subcategory")
+    public Map<String, Long> aggregateSubCategoryTaskRequest(@RequestParam String period, @RequestParam String mainCategory) {
+        return subCategoryTaskRequestUsecase.subCategoryTaskRequestAggregate(period, mainCategory);
+    }
 //    @GetMapping("/task/statistics/tasks-processed-by-manager")
 }

src/main/java/clap/server/adapter/outbound/infrastructure/elastic/ElasticTaskAdapter.java

@@ -1,12 +1,10 @@
 package clap.server.adapter.outbound.infrastructure.elastic;
 
-import clap.server.adapter.outbound.infrastructure.elastic.dto.PeriodConfig;
 import clap.server.adapter.outbound.infrastructure.elastic.entity.ElasticTask;
 import clap.server.adapter.outbound.infrastructure.elastic.repository.TaskElasticRepository;
 import clap.server.application.port.outbound.task.ElasticTaskPort;
 import clap.server.common.annotation.architecture.InfrastructureAdapter;
 import co.elastic.clients.elasticsearch._types.aggregations.AggregationBuilders;
-import co.elastic.clients.elasticsearch._types.aggregations.CalendarInterval;
 import co.elastic.clients.elasticsearch._types.aggregations.MultiBucketBase;
 import lombok.RequiredArgsConstructor;
 import org.springframework.data.elasticsearch.client.elc.ElasticsearchAggregations;
@@ -32,30 +30,111 @@ public void saveStatistics(List<ElasticTask> statistics) {
 
     @Override
     public Map<String, Long> findPeriodTaskRequestByPeriod(String period) {
-        PeriodConfig periodConfig = getPeriodConfig(period);
+        PeriodConfig periodConfig = PeriodConfig.valueOf(period.toUpperCase());
 
-        NativeQuery query = buildQuery(periodConfig);
-        ElasticsearchAggregations result = executeQuery(query);
-        return processResults(result, periodConfig);
+        NativeQuery query = buildPeriodTaskRequestQuery(periodConfig);
+        return getPeriodTaskResults(executeQuery(query), periodConfig);
     }
 
-    private PeriodConfig getPeriodConfig(String period) {
-        if (period.equals("week")) {
-            return new PeriodConfig(14, CalendarInterval.Day, 0, 10);
-        }
-        return new PeriodConfig(1, CalendarInterval.Hour, 11, 19);
+    @Override
+    public Map<String, Long> findPeriodTaskProcessByPeriod(String period) {
+        PeriodConfig periodConfig = PeriodConfig.valueOf(period.toUpperCase());
+
+        NativeQuery query = buildPeriodTaskProcessQuery(periodConfig);
+        return getPeriodTaskResults(executeQuery(query), periodConfig);
+    }
+
+    @Override
+    public Map<String, Long> findCategoryTaskRequestByPeriod(String period) {
+        PeriodConfig periodConfig = PeriodConfig.valueOf(period.toUpperCase());
+
+        NativeQuery query = buildCategoryTaskRequestQuery(periodConfig);
+        return getCategoryTaskResults(executeQuery(query));
     }
 
-    private NativeQuery buildQuery(PeriodConfig config) {
+    @Override
+    public Map<String, Long> findSubCategoryTaskRequestByPeriod(String period, String mainCategory) {
+        PeriodConfig periodConfig = PeriodConfig.valueOf(period.toUpperCase());
+
+        NativeQuery query = buildSubCategoryTaskRequestQuery(periodConfig, mainCategory);
+        return getCategoryTaskResults(executeQuery(query));
+    }
+
+    private NativeQuery buildPeriodTaskRequestQuery(PeriodConfig config) {
         return NativeQuery.builder()
                 .withQuery(q -> q
                         .range(r -> r
                                 .date(d -> d
                                         .field("created_at")
-                                        .gte(String.valueOf(LocalDate.now().minusDays(config.daysToSubtract()))))))
-                .withAggregation("period_task_request", AggregationBuilders.dateHistogram()
+                                        .gte(String.valueOf(LocalDate.now().minusDays(config.getDaysToSubtract()))))))
+                .withAggregation("period_task", AggregationBuilders.dateHistogram()
+                        .field("created_at")
+                        .calendarInterval(config.getCalendarInterval())
+                        .build()._toAggregation())
+                .withMaxResults(0)
+                .build();
+    }
+
+    private NativeQuery buildPeriodTaskProcessQuery(PeriodConfig config) {
+        NativeQuery rangeQuery = NativeQuery.builder()
+                .withQuery(q -> q
+                        .range(r -> r
+                                .date(d -> d
+                                        .field("created_at")
+                                        .gte(String.valueOf(LocalDate.now().minusDays(config.getDaysToSubtract())))))).build();
+        NativeQuery statusQuery = NativeQuery.builder()
+                .withQuery(q -> q
+                        .term(v -> v
+                                .field("status")
+                                .value("completed"))).build();
+
+        return NativeQuery.builder()
+                .withQuery(q -> q
+                        .bool(b -> b
+                                .must(rangeQuery.getQuery(), statusQuery.getQuery()))
+                )
+                .withAggregation("period_task", AggregationBuilders.dateHistogram()
                         .field("created_at")
-                        .calendarInterval(config.calendarInterval())
+                        .calendarInterval(config.getCalendarInterval())
+                        .build()._toAggregation())
+                .withMaxResults(0)
+                .build();
+    }
+
+    private NativeQuery buildCategoryTaskRequestQuery(PeriodConfig config) {
+        return NativeQuery.builder()
+                .withQuery(q -> q
+                        .range(r -> r
+                                .date(d -> d
+                                        .field("created_at")
+                                        .gte(String.valueOf(LocalDate.now().minusDays(config.getDaysToSubtract()))))))
+                .withAggregation("category_task", AggregationBuilders.terms()
+                        .field("main_category")
+                        .build()._toAggregation())
+                .withMaxResults(0)
+                .build();
+    }
+
+    private NativeQuery buildSubCategoryTaskRequestQuery(PeriodConfig config, String mainCategory) {
+        NativeQuery rangeQuery = NativeQuery.builder()
+                .withQuery(q -> q
+                        .range(r -> r
+                                .date(d -> d
+                                        .field("created_at")
+                                        .gte(String.valueOf(LocalDate.now().minusDays(config.getDaysToSubtract())))))).build();
+        NativeQuery categoryQuery = NativeQuery.builder()
+                .withQuery(q -> q
+                        .term(v -> v
+                                .field("main_category")
+                                .value(mainCategory))).build();
+
+        return NativeQuery.builder()
+                .withQuery(q -> q
+                        .bool(b -> b
+                                .must(rangeQuery.getQuery(), categoryQuery.getQuery()))
+                )
+                .withAggregation("category_task", AggregationBuilders.terms()
+                        .field("sub_category")
                         .build()._toAggregation())
                 .withMaxResults(0)
                 .build();
@@ -67,9 +146,9 @@ private ElasticsearchAggregations executeQuery(NativeQuery query) {
                 .getAggregations();
     }
 
-    private Map<String, Long> processResults(ElasticsearchAggregations aggregations, PeriodConfig config) {
+    private Map<String, Long> getPeriodTaskResults(ElasticsearchAggregations aggregations, PeriodConfig config) {
         return new TreeMap<>(
-                aggregations.get("period_task_request")
+                aggregations.get("period_task")
                         .aggregation()
                         .getAggregate()
                         .dateHistogram()
@@ -78,11 +157,27 @@ private Map<String, Long> processResults(ElasticsearchAggregations aggregations,
                         .stream()
                         .collect(Collectors.toMap(
                                 bucket -> bucket.keyAsString().substring(
-                                        config.substringStart(),
-                                        config.substringEnd()
+                                        config.getSubstringStart(),
+                                        config.getSubstringEnd()
                                 ),
                                 MultiBucketBase::docCount
                         ))
         );
     }
+
+    private Map<String, Long> getCategoryTaskResults(ElasticsearchAggregations aggregations) {
+        return new TreeMap<>(
+                aggregations.get("category_task")
+                        .aggregation()
+                        .getAggregate()
+                        .sterms()
+                        .buckets()
+                        .array()
+                        .stream()
+                        .collect(Collectors.toMap(
+                                bucket -> bucket.key().stringValue(),
+                                MultiBucketBase::docCount
+                        ))
+        );
+    }
 }

src/main/java/clap/server/adapter/outbound/infrastructure/elastic/PeriodConfig.java

@@ -0,0 +1,18 @@
+package clap.server.adapter.outbound.infrastructure.elastic;
+
+import co.elastic.clients.elasticsearch._types.aggregations.CalendarInterval;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+@Getter
+@RequiredArgsConstructor
+public enum PeriodConfig {
+    DAY(1, CalendarInterval.Hour, 11, 19),
+    WEEK(14, CalendarInterval.Day, 0, 10);
+
+    private final long daysToSubtract;
+    private final CalendarInterval calendarInterval;
+    private final int substringStart;
+    private final int substringEnd;
+
+}

src/main/java/clap/server/adapter/outbound/infrastructure/elastic/entity/ElasticTask.java

@@ -33,7 +33,7 @@ public ElasticTask(TaskEntity taskEntity) {
         this.taskCode = taskEntity.getTaskCode();
         this.mainCategory = taskEntity.getCategory().getMainCategory().getName();
         this.subCategory = taskEntity.getCategory().getName();
-        this.status = taskEntity.getStatus().getName();
+        this.status = taskEntity.getStatus().getStatusName().name().toLowerCase();
         this.processor = taskEntity.getProcessor().getNickname();
         this.createdAt = taskEntity.getCreatedAt().toLocalDate();
     }

src/main/java/clap/server/adapter/outbound/persistense/MemberPersistenceAdapter.java

@@ -4,8 +4,8 @@
 import clap.server.adapter.outbound.persistense.entity.member.constant.MemberStatus;
 import clap.server.adapter.outbound.persistense.mapper.MemberPersistenceMapper;
 import clap.server.adapter.outbound.persistense.repository.member.MemberRepository;
-import clap.server.application.port.outbound.member.LoadMemberPort;
 import clap.server.application.port.outbound.member.CommandMemberPort;
+import clap.server.application.port.outbound.member.LoadMemberPort;
 import clap.server.common.annotation.architecture.PersistenceAdapter;
 import clap.server.domain.model.member.Member;
 import lombok.RequiredArgsConstructor;
@@ -26,7 +26,7 @@ public Optional<Member> findById(final Long id) {
 
     @Override
     public Optional<Member> findActiveMemberById(final Long id) {
-        Optional<MemberEntity> memberEntity = memberRepository.findByMemberStatusAndMemberId(MemberStatus.ACTIVE, id);
+        Optional<MemberEntity> memberEntity = memberRepository.findByStatusAndMemberId(MemberStatus.ACTIVE, id);
         return memberEntity.map(memberPersistenceMapper::toDomain);
     }
 

src/main/java/clap/server/adapter/outbound/persistense/repository/member/MemberRepository.java

@@ -9,5 +9,5 @@
 
 @Repository
 public interface MemberRepository extends JpaRepository<MemberEntity, Long> {
-    Optional<MemberEntity> findByMemberStatusAndMemberId(MemberStatus memberStatus, Long memberId);
+    Optional<MemberEntity> findByStatusAndMemberId(MemberStatus Status, Long memberId);
 }

src/main/java/clap/server/application/port/inbound/statistics/CategoryTaskRequestUsecase.java

@@ -0,0 +1,7 @@
+package clap.server.application.port.inbound.statistics;
+
+import java.util.Map;
+
+public interface CategoryTaskRequestUsecase {
+    Map<String, Long> categoryTaskRequestAggregate(String period);
+}

src/main/java/clap/server/application/port/inbound/statistics/PeriodTaskProcessUsecase.java

@@ -0,0 +1,7 @@
+package clap.server.application.port.inbound.statistics;
+
+import java.util.Map;
+
+public interface PeriodTaskProcessUsecase {
+    Map<String, Long> periodTaskProcessAggregate(String period);
+}

src/main/java/clap/server/application/port/inbound/statistics/SubCategoryTaskRequestUsecase.java

@@ -0,0 +1,7 @@
+package clap.server.application.port.inbound.statistics;
+
+import java.util.Map;
+
+public interface SubCategoryTaskRequestUsecase {
+    Map<String, Long> subCategoryTaskRequestAggregate(String period, String mainCategory);
+}

src/main/java/clap/server/application/port/outbound/task/ElasticTaskPort.java

@@ -9,4 +9,10 @@ public interface ElasticTaskPort {
     void saveStatistics(List<ElasticTask> statistics);
 
     Map<String, Long> findPeriodTaskRequestByPeriod(String period);
+
+    Map<String, Long> findPeriodTaskProcessByPeriod(String period);
+
+    Map<String, Long> findCategoryTaskRequestByPeriod(String period);
+
+    Map<String, Long> findSubCategoryTaskRequestByPeriod(String period, String mainCategory);
 }

src/main/java/clap/server/application/statistics/CategoryTaskRequestService.java

@@ -0,0 +1,19 @@
+package clap.server.application.statistics;
+
+import clap.server.application.port.inbound.statistics.CategoryTaskRequestUsecase;
+import clap.server.application.port.outbound.task.ElasticTaskPort;
+import clap.server.common.annotation.architecture.ApplicationService;
+import lombok.RequiredArgsConstructor;
+
+import java.util.Map;
+
+@ApplicationService
+@RequiredArgsConstructor
+public class CategoryTaskRequestService implements CategoryTaskRequestUsecase {
+    private final ElasticTaskPort elasticTaskPort;
+
+    @Override
+    public Map<String, Long> categoryTaskRequestAggregate(String period) {
+        return elasticTaskPort.findCategoryTaskRequestByPeriod(period);
+    }
+}

src/main/java/clap/server/application/statistics/PeriodTaskProcessService.java

@@ -0,0 +1,19 @@
+package clap.server.application.statistics;
+
+import clap.server.application.port.inbound.statistics.PeriodTaskProcessUsecase;
+import clap.server.application.port.outbound.task.ElasticTaskPort;
+import clap.server.common.annotation.architecture.ApplicationService;
+import lombok.RequiredArgsConstructor;
+
+import java.util.Map;
+
+@ApplicationService
+@RequiredArgsConstructor
+public class PeriodTaskProcessService implements PeriodTaskProcessUsecase {
+    private final ElasticTaskPort elasticTaskPort;
+
+    @Override
+    public Map<String, Long> periodTaskProcessAggregate(String period) {
+        return elasticTaskPort.findPeriodTaskProcessByPeriod(period);
+    }
+}

src/main/java/clap/server/application/statistics/SubCategoryTaskRequestService.java

@@ -0,0 +1,19 @@
+package clap.server.application.statistics;
+
+import clap.server.application.port.inbound.statistics.SubCategoryTaskRequestUsecase;
+import clap.server.application.port.outbound.task.ElasticTaskPort;
+import clap.server.common.annotation.architecture.ApplicationService;
+import lombok.RequiredArgsConstructor;
+
+import java.util.Map;
+
+@ApplicationService
+@RequiredArgsConstructor
+public class SubCategoryTaskRequestService implements SubCategoryTaskRequestUsecase {
+    private final ElasticTaskPort elasticTaskPort;
+
+    @Override
+    public Map<String, Long> subCategoryTaskRequestAggregate(String period, String mainCategory) {
+        return elasticTaskPort.findSubCategoryTaskRequestByPeriod(period, mainCategory);
+    }
+}