Merge pull request #14 from KGU-C-Lab/refactor/#11

필터링 정보 다중 선택이 가능하도록 구현 완료

Author: mingmingmon

src/main/java/page/time/api/domain/lecture/application/LectureRetrieveService.java

@@ -16,27 +16,25 @@
 
 @Service
 @RequiredArgsConstructor
+@Transactional(readOnly = true)
 public class LectureRetrieveService {
 
     private final LectureRepository lectureRepository;
 
-    @Transactional(readOnly = true)
     public CursorResult<LectureResponseDto> retrieveLectures(
-            String campus, Type type, Integer grade, List<String> day, List<String> time, String major, Boolean isExceeded, String lectureName, Long cursor, int limit
+            List<String> campuses, List<Type> types, List<Integer> grades, List<String> days, List<String> times, List<String> majors, Boolean isExceeded, String lectureName, Long cursor, int limit
     ) {
-        List<Lecture> lectures = lectureRepository.findByFilter(campus, type, grade, day, time, major, isExceeded, lectureName, cursor, limit);
+        List<Lecture> lectures = lectureRepository.findByFilter(campuses, types, grades, days, times, majors, isExceeded, lectureName, cursor, limit);
         List<LectureResponseDto> lectureDetailResponseDtos = lectures.stream()
                 .map(LectureResponseDto::toDto)
                 .collect(Collectors.toList());
         return CursorResult.of(lectureDetailResponseDtos, cursor, limit);
     }
 
-    @Transactional(readOnly = true)
     public List<String> retrieveMajor(String major) {
         return lectureRepository.findByMajor(major);
     }
 
-    @Transactional(readOnly = true)
     public List<LectureSelectResponseDto> retrieveSelectedLecturesByIds(List<Long> lectureIds) {
         return lectureIds.stream()
                 .map(lectureRepository::findById)

src/main/java/page/time/api/domain/lecture/controller/LectureRetrieveController.java

@@ -29,19 +29,19 @@ public class LectureRetrieveController {
             "모든 파라미터를 하나라도 입력하지 않으면 전체 조회됨<br>")
     @GetMapping("")
     public ApiResponse<CursorResult<LectureResponseDto>> retrieveLectures(
-            @RequestParam(name = "campus", required = false) String campus,
-            @RequestParam(name = "type", required = false) Type type,
-            @RequestParam(name = "grade", required = false) Integer grade,
-            @RequestParam(name = "day", required = false) List<String> day,
-            @RequestParam(name = "time", required = false) List<String> time,
-            @RequestParam(name = "major", required = false) String major,
+            @RequestParam(name = "campus", required = false) List<String> campuses,
+            @RequestParam(name = "type", required = false) List<Type> types,
+            @RequestParam(name = "grade", required = false) List<Integer> grades,
+            @RequestParam(name = "day", required = false) List<String> days,
+            @RequestParam(name = "time", required = false) List<String> times,
+            @RequestParam(name = "major", required = false) List<String> majors,
             @RequestParam(name = "isExceeded", required = false) Boolean isExceeded,
             @RequestParam(name = "lectureName", required = false) String lectureName,
             @RequestParam(name = "cursor", required = false) Long cursor,
             @RequestParam(name = "limit", defaultValue = "50") int limit
     ) {
         CursorResult<LectureResponseDto> lectures = lectureRetrieveService.retrieveLectures(
-                campus, type, grade, day, time, major, isExceeded, lectureName, cursor, limit
+                campuses, types, grades, days, times, majors, isExceeded, lectureName, cursor, limit
         );
         return ApiResponse.success(lectures);
     }

src/main/java/page/time/api/domain/lecture/dao/LectureRepositoryCustom.java

@@ -7,7 +7,7 @@
 
 public interface LectureRepositoryCustom {
 
-    List<Lecture> findByFilter(String campus, Type type, Integer grade, List<String> day, List<String> time, String major, Boolean isExceeded, String lectureName, Long cursor, int limit);
+    List<Lecture> findByFilter(List<String> campuses, List<Type> types, List<Integer> grades, List<String> days, List<String> times, List<String> majors, Boolean isExceeded, String lectureName, Long cursor, int limit);
 
     List<String> findByMajor(String major);
 }

src/main/java/page/time/api/domain/lecture/dao/LectureRepositoryCustomImpl.java

@@ -1,10 +1,10 @@
 package page.time.api.domain.lecture.dao;
 
-import com.querydsl.core.BooleanBuilder;
 import com.querydsl.core.types.dsl.BooleanExpression;
 import com.querydsl.jpa.impl.JPAQueryFactory;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Repository;
+import org.springframework.util.CollectionUtils;
 import page.time.api.domain.lecture.domain.Lecture;
 import page.time.api.domain.lecture.domain.Type;
 
@@ -21,17 +21,17 @@ public class LectureRepositoryCustomImpl implements LectureRepositoryCustom {
     private static final String NONE = "None";
 
     @Override
-    public List<Lecture> findByFilter(String campus, Type type, Integer grade, List<String> day, List<String> time, String major, Boolean isExceeded, String lectureName, Long cursor, int limit) {
+    public List<Lecture> findByFilter(List<String> campuses, List<Type> types, List<Integer> grades, List<String> days, List<String> times, List<String> majors, Boolean isExceeded, String lectureName, Long cursor, int limit) {
         return query
                 .selectFrom(lecture)
                 .where(
                         containsToLectureName(lectureName),
-                        eqToMajor(major),
-                        eqToDay(day),
-                        eqToTime(time),
-                        eqToGrade(grade),
-                        eqToType(type),
-                        eqToCampus(campus),
+                        eqToMajors(majors),
+                        eqToDays(days),
+                        eqToTimes(times),
+                        eqToGrades(grades),
+                        eqToTypes(types),
+                        eqToCampuses(campuses),
                         eqToIsExceeded(isExceeded),
                         gtCursor(cursor)
                 )
@@ -52,47 +52,54 @@ public List<String> findByMajor(String major) {
                 .fetch();
     }
 
-    private BooleanExpression eqToCampus(String campus) {
-        if (campus == null || campus.isEmpty()) {
+    private BooleanExpression eqToCampuses(List<String> campuses) {
+        if (CollectionUtils.isEmpty(campuses)) {
             return null;
         }
-        return lecture.campus.contains(campus);
+        return campuses.stream()
+                .map(lecture.campus::contains)
+                .reduce(BooleanExpression::or)
+                .orElse(null);
     }
 
-    private BooleanExpression eqToType(Type type) {
-        if (type == null) {
+    private BooleanExpression eqToTypes(List<Type> types) {
+        if (CollectionUtils.isEmpty(types)) {
             return null;
         }
-        return lecture.type.eq(type);
+        return types.stream()
+                .map(lecture.type::eq)
+                .reduce(BooleanExpression::or)
+                .orElse(null);
     }
 
-    private BooleanExpression eqToGrade(Integer grade) {
-        if (grade == null) {
+    private BooleanExpression eqToGrades(List<Integer> grades) {
+        if (CollectionUtils.isEmpty(grades)) {
             return null;
         }
-        return lecture.grade.eq(grade);
+        return grades.stream()
+                .map(lecture.grade::eq)
+                .reduce(BooleanExpression::or)
+                .orElse(null);
     }
 
-    private BooleanBuilder eqToDay(List<String> days) {
-        if (days == null || days.isEmpty()) {
+    private BooleanExpression eqToDays(List<String> days) {
+        if (CollectionUtils.isEmpty(days)) {
             return null;
         }
-        BooleanBuilder builder = new BooleanBuilder();
-        days.stream()
+        return days.stream()
                 .map(lecture.time::contains)
-                .forEach(builder::or);
-        return builder;
+                .reduce(BooleanExpression::or)
+                .orElse(null);
     }
 
-    private BooleanBuilder eqToTime(List<String> times) {
-        if (times == null || times.isEmpty()) {
+    private BooleanExpression eqToTimes(List<String> times) {
+        if (CollectionUtils.isEmpty(times)) {
             return null;
         }
-        BooleanBuilder builder = new BooleanBuilder();
-        times.stream()
+        return times.stream()
                 .map(lecture.time::contains)
-                .forEach(builder::or);
-        return builder;
+                .reduce(BooleanExpression::or)
+                .orElse(null);
     }
 
     private BooleanExpression eqToMajor(String major) {
@@ -102,6 +109,16 @@ private BooleanExpression eqToMajor(String major) {
         return lecture.major.contains(major);
     }
 
+    private BooleanExpression eqToMajors(List<String> majors) {
+        if (CollectionUtils.isEmpty(majors)) {
+            return null;
+        }
+        return majors.stream()
+                .map(lecture.major::contains)
+                .reduce(BooleanExpression::or)
+                .orElse(null);
+    }
+
     private BooleanExpression eqToIsExceeded(Boolean isExceeded) {
         if (isExceeded == null) {
             return null;
@@ -122,4 +139,4 @@ private BooleanExpression gtCursor(Long cursor) {
         }
         return lecture.id.gt(cursor);
     }
-}
+}