JNU-econovation · LJH098 · Sep 24, 2024 · Sep 18, 2024 · Sep 18, 2024 · Sep 18, 2024
@@ -82,8 +82,9 @@ public ResponseEntity<Map<String, Object>> getApplicantById(String applicantId)
     public ResponseEntity<AnswersResponseDto> getApplicantsByYear(
             @PathVariable(value = "year") Integer year,
             @PathVariable(value = "page") Integer page,
-            @ParameterObject String order) {
-        AnswersResponseDto result = applicantQueryUseCase.execute(year, page, order);
+            @ParameterObject String order,
+            @RequestParam(required = false) String searchKeyword) {
+        AnswersResponseDto result = applicantQueryUseCase.execute(year, page, order, searchKeyword);
         return new ResponseEntity<>(result, HttpStatus.OK);
     }
 

@@ -45,6 +45,44 @@ public Map<String, Object> execute(String answerId) {
         return qna;
     }
 
+    @Transactional(readOnly = true)
+    public AnswersResponseDto execute(Integer year, Integer page, String sortType, String searchKeyword) {
+        PageInfo pageInfo = getPageInfo(year, page, searchKeyword);
+        List<MongoAnswer> sortedResult = answerAdaptor.findByYearAndSearchKeyword(year, page, sortType, searchKeyword);
+
+        List<Map<String, Object>> qnaMapList = getQnaMapListWithIdAndPassState(sortedResult);
+
+        if (qnaMapList.isEmpty()) {
+            return AnswersResponseDto.of(Collections.emptyList(), pageInfo);
+        }
+        return AnswersResponseDto.of(qnaMapList, pageInfo);
+    }
+
+    private List<Map<String, Object>> getQnaMapListWithIdAndPassState(List<MongoAnswer> sortedResult) {
+        return sortedResult.stream().map(answer -> {
+            Map<String, Object> qna = answer.getQna();
+            qna.put("id", answer.getId());
+            qna.put(PASS_STATE_KEY, answer.getApplicantStateOrDefault());
+            return qna;
+        }).toList();
+    }
+
+    @Override
+    public PageInfo getPageInfo(Integer year, Integer page, String searchKeyword) {
+        long totalCount = answerAdaptor.getTotalCountByYearAndSearchKeyword(year, searchKeyword);
+        return new PageInfo(totalCount, page);
+    }
+
+    @Transactional(readOnly = true)
+    public List<MongoAnswer> execute(Integer page, Integer year, String sortType, String searchKeyword, List<String> applicantIds) {
+        return answerAdaptor.findByYearAndSearchKeywordAndApplicantIds(page, year, sortType, searchKeyword, applicantIds);
+    }
+
+    @Override
+    public List<MongoAnswer> execute(Integer year, String sortType, String searchKeyword, List<String> applicantIds) {
+        return answerAdaptor.findByYearAndSearchKeywordAndApplicantIds(year, sortType, searchKeyword, applicantIds);
+    }
+
     @Transactional(readOnly = true)
     public AnswersResponseDto execute(Integer year, Integer page, String sortType) {
         PageInfo pageInfo = getPageInfo(year, page);
@@ -182,13 +220,9 @@ public List<GetApplicantsStatusResponse> getApplicantsStatus(Integer year, Strin
     }
 
     private List<Map<String, Object>> sortAndAddIds(List<MongoAnswer> result, String sortType) {
-        sortHelper.sort(result, sortType);
-        return result.stream().map(
-                answer -> {
-                    Map<String, Object> qna = answer.getQna();
-                    qna.put("id", answer.getId());
-                    qna.put(PASS_STATE_KEY, answer.getApplicantStateOrDefault());
-                    return qna;
-                }).toList();
+        if (!result.isEmpty()) {
+            sortHelper.sort(result, sortType);
+        }
+        return getQnaMapListWithIdAndPassState(result);
     }
 }
@@ -2,6 +2,7 @@
 
 import com.econovation.recruit.api.applicant.dto.AnswersResponseDto;
 import com.econovation.recruit.api.applicant.dto.GetApplicantsStatusResponse;
+import com.econovation.recruit.utils.vo.PageInfo;
 import com.econovation.recruitcommon.annotation.UseCase;
 import com.econovation.recruitdomain.domains.applicant.domain.MongoAnswer;
 import java.util.List;
@@ -11,7 +12,13 @@
 public interface ApplicantQueryUseCase {
     Map<String, Object> execute(String applicantId);
 
-    AnswersResponseDto execute(Integer year, Integer page, String order);
+    AnswersResponseDto execute(Integer year, Integer page, String order, String searchKeyword);
+
+    List<MongoAnswer> execute(Integer page, Integer year, String sortType, String searchKeyword, List<String> applicantIds);
+
+    List<MongoAnswer> execute(Integer year, String sortType, String searchKeyword, List<String> applicantIds);
+
+    PageInfo getPageInfo(Integer year, Integer page, String searchKeyword);
 
     List<Map<String, Object>> execute();
 

@@ -67,7 +67,9 @@ public List<InterviewerResponseDto> findAll() {
     @Override
     public List<InterviewerResponseDto> findAll(String sortType) {
         List<Interviewer> interviewers = interviewerLoadPort.findAll();
-        interviewerSortHelper.sort(interviewers, sortType);
+        if (!interviewers.isEmpty()) {
+            interviewerSortHelper.sort(interviewers, sortType);
+        }
         return interviewers.stream().map(InterviewerResponseDto::from).toList();
     }
 

@@ -25,13 +25,15 @@
 import org.springframework.web.bind.annotation.PutMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 
 @RestController
 @RequestMapping("/api/v1/")
 @Tag(name = "[6.0] Record API", description = "면접 기록 Record API")
 @RequiredArgsConstructor
 public class RecordController {
+
     private final RecordUseCase recordUseCase;
 
     @Operation(summary = "지원자의 면접기록을 생성합니다")
@@ -55,8 +57,11 @@ public ResponseEntity<RecordResponseDto> findByApplicantId(String applicantId) {
     @ApiErrorExceptionsExample(RecordFindExceptionDocs.class)
     @GetMapping("/page/{page}/records")
     public ResponseEntity<RecordsViewResponseDto> findAll(
-            @PathVariable(name = "page") Integer page, @ParameterObject String sortType, @ParameterObject Integer year) {
-        return new ResponseEntity<>(recordUseCase.execute(page, year, sortType), HttpStatus.OK);
+            @PathVariable(name = "page") Integer page,
+            @ParameterObject String order,
+            @ParameterObject Integer year,
+            @RequestParam(required = false) String searchKeyword) {
+        return new ResponseEntity<>(recordUseCase.execute(page, year, order, searchKeyword), HttpStatus.OK);
     }
 
     @Operation(summary = "지원자의 면접기록을 전부 조회합니다")

@@ -1,5 +1,7 @@
 package com.econovation.recruit.api.record.service;
 
+import static com.econovation.recruit.utils.sort.SortHelper.paginateList;
+
 import com.econovation.recruit.api.applicant.usecase.ApplicantQueryUseCase;
 import com.econovation.recruit.api.record.dto.RecordsViewResponseDto;
 import com.econovation.recruit.api.record.usecase.RecordUseCase;
@@ -16,8 +18,13 @@
 import com.econovation.recruitdomain.out.RecordLoadPort;
 import com.econovation.recruitdomain.out.RecordRecordPort;
 import com.econovation.recruitdomain.out.ScoreLoadPort;
-
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
 import java.util.stream.Collectors;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
@@ -26,6 +33,7 @@
 @Service
 @RequiredArgsConstructor
 public class RecordService implements RecordUseCase {
+
     private final RecordRecordPort recordRecordPort;
     private final RecordLoadPort recordLoadPort;
     private final ScoreLoadPort scoreLoadPort;
@@ -53,71 +61,153 @@ public List<Record> findAll() {
     /**
      * 1. Newest // 시간 순 오름차순 2. Name // 이름순 오름차순 3. Object // 지원 분야별 오름차순 4. Score // 점수 내림차순
      *
-     * @return List<RecordResponseDto> // 지원자의 면접기록을 페이지별로 조회합니다 ( 이 화면에서는 Applicants,Scores,
-     *     Records를 모두 조회합니다 )
+     * @return List<RecordResponseDto> // 지원자의 면접기록을 페이지별로 조회합니다 ( 이 화면에서는 Applicants,Scores, Records를 모두 조회합니다 )
      */
     @Override
     public RecordsViewResponseDto execute(Integer page, Integer year, String sortType) {
         List<Record> result = recordLoadPort.findAll(page);
         PageInfo pageInfo = getPageInfo(page);
 
         List<String> applicantIds = result.stream().map(Record::getApplicantId).toList();
-        List<Score> scores = scoreLoadPort.findByApplicantIds(applicantIds);
-        List<MongoAnswer> applicants = applicantQueryUseCase.execute(applicantIds).stream().filter(applicant ->year == null || applicant.getYear().equals(year)).toList();
+        List<MongoAnswer> applicants = applicantQueryUseCase.execute(applicantIds).stream()
+                .filter(applicant -> year == null || applicant.getYear().equals(year)).toList();
 
         if (result.isEmpty() || applicants.isEmpty()) {
-            return RecordsViewResponseDto.of(
-                    pageInfo,
-                    Collections.emptyList(),
-                    Collections.emptyMap(),
-                    Collections.emptyList());
+            return createEmptyResponse(pageInfo);
         }
 
         Map<String, Integer> yearByAnswerIdMap = applicants.stream().collect(Collectors.toMap(MongoAnswer::getId, MongoAnswer::getYear));
-        Map<String, Double> scoreMap =
-                scores.stream()
-                        .filter(score ->year == null || yearByAnswerIdMap.get(score.getApplicantId()).equals(year))
-                        .collect(
-                                Collectors.groupingBy(
-                                        Score::getApplicantId,
-                                        Collectors.averagingDouble(Score::getScore)));
+        Map<String, Double> scoreMap = getScoreMap(year, applicantIds, yearByAnswerIdMap);
 
         result = result.stream().filter(record -> year == null ||
-            Optional.ofNullable(record.getApplicantId())
-                    .map(yearByAnswerIdMap::get)
-                    .map(y -> y.equals(year))
-                    .orElse(false)
-        )
-        .toList();
+                        Optional.ofNullable(record.getApplicantId())
+                                .map(yearByAnswerIdMap::get)
+                                .map(y -> y.equals(year))
+                                .orElse(false)
+                )
+                .toList();
 
         applicants = new ArrayList<>(applicants); // Unmodifiable List일 경우 Sort 불가. stream().toList()의 결과는 Unmodifiable List
 
+        List<Record> records;
         if (sortType.equals("score")) {
-            List<Record> records = sortRecordsByScoresDesc(result, scoreMap);
-            return RecordsViewResponseDto.of(pageInfo, records, scoreMap, applicants);
+            records = sortRecordsByScoresDesc(result, scoreMap);
         } else {
-            List<Record> records = sortRecordsByApplicantsAndSortType(result, applicants, sortType);
-            return RecordsViewResponseDto.of(pageInfo, records, scoreMap, applicants);
+            records = sortRecordsByApplicantsAndSortType(result, applicants, sortType);
         }
+
+        return RecordsViewResponseDto.of(pageInfo, records, scoreMap, applicants);
+    }
+
+    @Override
+    public RecordsViewResponseDto execute(Integer page, Integer year, String sortType, String searchKeyword) {
+        List<Record> result = recordLoadPort.findAll();
+        List<String> applicantIds = result.stream().map(Record::getApplicantId).toList();
+
+        List<MongoAnswer> applicants;
+        if (sortType.equals("score")) {
+            applicants = applicantQueryUseCase.execute(year, sortType, searchKeyword, applicantIds);
+        } else {
+            applicants = applicantQueryUseCase.execute(page, year, sortType, searchKeyword, applicantIds);
+        }
+
+        if (result.isEmpty() || applicants.isEmpty()) {
+            return createEmptyResponse(new PageInfo(0, page));
+        }
+
+        Map<String, Integer> yearByAnswerIdMap = applicants.stream().collect(Collectors.toMap(MongoAnswer::getId, MongoAnswer::getYear));
+
+        applicantIds = applicants.stream().map(MongoAnswer::getId).toList();    // 검색 결과에 따라 applicantIds 재할당
+        Map<String, Double> scoreMap = getScoreMap(year, applicantIds, yearByAnswerIdMap);
+
+        result = result.stream().filter(record -> year == null ||
+                        Optional.ofNullable(record.getApplicantId())
+                                .map(yearByAnswerIdMap::get)
+                                .map(y -> y.equals(year))
+                                .orElse(false)
+                )
+                .toList();
+
+        List<Record> records;
+        if (sortType.equals("score")) {
+            records = sortRecordsByScoresDesc(result, scoreMap, page);
+        } else {
+            records = sortRecordsByApplicantsAndSortType(result, applicants);
+        }
+
+        PageInfo pageInfo = applicantQueryUseCase.getPageInfo(year, page, searchKeyword);
+        return RecordsViewResponseDto.of(pageInfo, records, scoreMap, applicants);
+    }
+
+    private RecordsViewResponseDto createEmptyResponse(PageInfo pageInfo) {
+        return RecordsViewResponseDto.of(
+                pageInfo,
+                Collections.emptyList(),
+                Collections.emptyMap(),
+                Collections.emptyList());
+    }
+
+    private Map<String, Double> getScoreMap(Integer year, List<String> applicantIds, Map<String, Integer> yearByAnswerIdMap) {
+        List<Score> scores = scoreLoadPort.findByApplicantIds(applicantIds);
+        return scores.stream()
+                .filter(score -> year == null || yearByAnswerIdMap.get(score.getApplicantId()).equals(year))
+                .collect(
+                        Collectors.groupingBy(
+                                Score::getApplicantId,
+                                Collectors.averagingDouble(Score::getScore)));
     }
 
     private List<Record> sortRecordsByScoresDesc(
             List<Record> records, Map<String, Double> scoreMap) {
         // score 내림차순 정렬
-        return records.stream()
+        List<Record> sortedRecords = records.stream()
                 .sorted(
                         Comparator.comparing(
                                 record -> {
                                     Double score = scoreMap.get(record.getApplicantId());
                                     return score == null ? 0 : score;
                                 }))
                 .toList();
+        return sortedRecords;
+    }
+
+    private List<Record> sortRecordsByScoresDesc(
+            List<Record> records, Map<String, Double> scoreMap, Integer page) {
+        // score 내림차순 정렬
+        List<Record> sortedRecords = records.stream()
+                .sorted(
+                        Comparator.comparing(
+                                record -> scoreMap.getOrDefault(record.getApplicantId(), 0.0),
+                                Comparator.reverseOrder()
+                        )
+                )
+                .toList();
+        // 페이징 함수 호출
+        return paginateList(sortedRecords, page);
     }
 
     private List<Record> sortRecordsByApplicantsAndSortType(
             List<Record> records, List<MongoAnswer> applicants, String sortType) {
         // Newest, Name, Object 정렬
-        sortHelper.sort(applicants, sortType);
+        if (!applicants.isEmpty()) {
+            sortHelper.sort(applicants, sortType);
+        }
+        Map<String, Integer> applicantIndexMap = new HashMap<>();
+        for (int i = 0; i < applicants.size(); i++) {
+            applicantIndexMap.put(applicants.get(i).getId(), i);
+        }
+
+        return records.stream()
+                .sorted(
+                        Comparator.comparing(
+                                record ->
+                                        applicantIndexMap.getOrDefault(
+                                                record.getApplicantId(), Integer.MAX_VALUE)))
+                .toList();
+    }
+
+    private List<Record> sortRecordsByApplicantsAndSortType(List<Record> records, List<MongoAnswer> applicants) {
+
         Map<String, Integer> applicantIndexMap = new HashMap<>();
         for (int i = 0; i < applicants.size(); i++) {
             applicantIndexMap.put(applicants.get(i).getId(), i);
@@ -149,9 +239,7 @@ public void updateRecordUrl(String applicantId, String url) {
         recordLoadPort
                 .findByApplicantId(applicantId)
                 .ifPresent(
-                        record -> {
-                            record.updateUrl(url);
-                        });
+                        record -> record.updateUrl(url));
     }
 
     @Override
@@ -160,9 +248,7 @@ public void updateRecordContents(String applicantId, String contents) {
         recordLoadPort
                 .findByApplicantId(applicantId)
                 .ifPresent(
-                        record -> {
-                            record.updateRecord(contents);
-                        });
+                        record -> record.updateRecord(contents));
     }
 
     @Override

@@ -13,6 +13,8 @@ public interface RecordUseCase {
 
     RecordsViewResponseDto execute(Integer page, Integer year, String sortType);
 
+    RecordsViewResponseDto execute(Integer page, Integer year, String sortType, String searchKeyword);
+
     Record findByApplicantId(String applicantId);
 
     void updateRecordUrl(String applicantId, String url);