[BE] feat: 축제 조회 필터링 구현(#602)

backend/src/main/java/com/festago/common/exception/ErrorCode.java

@@ -29,6 +29,7 @@ public enum ErrorCode {
     DELETE_CONSTRAINT_STAGE("티켓이 등록된 공연은 삭제할 수 없습니다."),
     DELETE_CONSTRAINT_SCHOOL("학생 또는 축제에 등록된 학교는 삭제할 수 없습니다."),
     DUPLICATE_SCHOOL("이미 존재하는 학교 정보입니다."),
+    INVALID_FESTIVAL_FILTER("유효하지 않은 필터 값입니다."),
 
 
     // 401

backend/src/main/java/com/festago/festival/application/FestivalService.java

@@ -11,6 +11,7 @@
 import com.festago.festival.dto.FestivalResponse;
 import com.festago.festival.dto.FestivalUpdateRequest;
 import com.festago.festival.dto.FestivalsResponse;
+import com.festago.festival.repository.FestivalFilter;
 import com.festago.festival.repository.FestivalRepository;
 import com.festago.school.domain.School;
 import com.festago.school.repository.SchoolRepository;
@@ -19,8 +20,8 @@
 import java.time.Clock;
 import java.time.LocalDate;
 import java.util.List;
-import org.springframework.dao.DataIntegrityViolationException;
 import lombok.RequiredArgsConstructor;
+import org.springframework.dao.DataIntegrityViolationException;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -49,8 +50,8 @@ private void validate(Festival festival) {
     }
 
     @Transactional(readOnly = true)
-    public FestivalsResponse findAll() {
-        List<Festival> festivals = festivalRepository.findAll();
+    public FestivalsResponse findFestivals(FestivalFilter festivalFilter) {
+        List<Festival> festivals = festivalRepository.findAll(festivalFilter.getSpecification());
         return FestivalsResponse.from(festivals);
     }
 

backend/src/main/java/com/festago/festival/repository/FestivalFilter.java

@@ -0,0 +1,40 @@
+package com.festago.festival.repository;
+
+import static com.festago.festival.repository.FestivalSpecification.afterEndDate;
+import static com.festago.festival.repository.FestivalSpecification.afterStartDate;
+import static com.festago.festival.repository.FestivalSpecification.all;
+import static com.festago.festival.repository.FestivalSpecification.beforeEndDate;
+import static com.festago.festival.repository.FestivalSpecification.beforeStartDate;
+
+import com.festago.common.exception.BadRequestException;
+import com.festago.common.exception.ErrorCode;
+import com.festago.festival.domain.Festival;
+import java.time.LocalDate;
+import java.util.Arrays;
+import java.util.function.Function;
+import org.springframework.data.jpa.domain.Specification;
+
+public enum FestivalFilter {
+    ALL(currentTime -> all()),
+    PROGRESS(currentTime -> afterStartDate(currentTime)
+        .and(beforeEndDate(currentTime))),
+    PLANNED(currentTime -> beforeStartDate(currentTime)),
+    END(currentTime -> afterEndDate(currentTime));
+
+    private final Function<LocalDate, Specification<Festival>> filter;
+
+    FestivalFilter(Function<LocalDate, Specification<Festival>> filter) {
+        this.filter = filter;
+    }
+
+    public static FestivalFilter from(String filterName) {
+        return Arrays.stream(FestivalFilter.values())
+            .filter(festivalFilter -> festivalFilter.name().equalsIgnoreCase(filterName))
+            .findAny()
+            .orElseThrow(() -> new BadRequestException(ErrorCode.INVALID_FESTIVAL_FILTER));
+    }
+
+    public Specification<Festival> getSpecification() {
+        return filter.apply(LocalDate.now());
+    }
+}

backend/src/main/java/com/festago/festival/repository/FestivalRepository.java

@@ -2,7 +2,8 @@
 
 import com.festago.festival.domain.Festival;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
 
-public interface FestivalRepository extends JpaRepository<Festival, Long> {
+public interface FestivalRepository extends JpaRepository<Festival, Long>, JpaSpecificationExecutor<Festival> {
 
 }

backend/src/main/java/com/festago/festival/repository/FestivalSpecification.java

@@ -0,0 +1,34 @@
+package com.festago.festival.repository;
+
+import com.festago.festival.domain.Festival;
+import java.time.LocalDate;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+import org.springframework.data.jpa.domain.Specification;
+
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public class FestivalSpecification {
+
+    private static final String START_DATE = "startDate";
+    private static final String END_DATE = "endDate";
+
+    public static Specification<Festival> all() {
+        return (root, query, criteriaBuilder) -> criteriaBuilder.conjunction();
+    }
+
+    public static Specification<Festival> afterStartDate(LocalDate currentTime) {
+        return (root, query, criteriaBuilder) -> criteriaBuilder.lessThan(root.get(START_DATE), currentTime);
+    }
+
+    public static Specification<Festival> beforeStartDate(LocalDate currentTime) {
+        return (root, query, criteriaBuilder) -> criteriaBuilder.greaterThan(root.get(START_DATE), currentTime);
+    }
+
+    public static Specification<Festival> afterEndDate(LocalDate currentTime) {
+        return (root, query, criteriaBuilder) -> criteriaBuilder.lessThan(root.get(END_DATE), currentTime);
+    }
+
+    public static Specification<Festival> beforeEndDate(LocalDate currentTime) {
+        return (root, query, criteriaBuilder) -> criteriaBuilder.greaterThan(root.get(END_DATE), currentTime);
+    }
+}

backend/src/main/java/com/festago/presentation/FestivalController.java

@@ -3,13 +3,15 @@
 import com.festago.festival.application.FestivalService;
 import com.festago.festival.dto.FestivalDetailResponse;
 import com.festago.festival.dto.FestivalsResponse;
+import com.festago.festival.repository.FestivalFilter;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 
 @RestController
@@ -21,9 +23,10 @@ public class FestivalController {
     private final FestivalService festivalService;
 
     @GetMapping
-    @Operation(description = "모든 축제들을 조회한다.", summary = "축제 목록 조회")
-    public ResponseEntity<FestivalsResponse> findAll() {
-        FestivalsResponse response = festivalService.findAll();
+    @Operation(description = "축제를 조건별로 조회한다. ALL: 전체, PROGRESS: 진행 중, PLANNED: 진행 예정, END: 종료", summary = "축제 목록 조회")
+    public ResponseEntity<FestivalsResponse> findFestivals(
+        @RequestParam(defaultValue = "ALL") String festivalFilter) {
+        FestivalsResponse response = festivalService.findFestivals(FestivalFilter.from(festivalFilter));
         return ResponseEntity.ok()
             .body(response);
     }

backend/src/test/java/com/festago/application/FestivalServiceTest.java

@@ -18,6 +18,7 @@
 import com.festago.festival.dto.FestivalDetailStageResponse;
 import com.festago.festival.dto.FestivalResponse;
 import com.festago.festival.dto.FestivalsResponse;
+import com.festago.festival.repository.FestivalFilter;
 import com.festago.festival.repository.FestivalRepository;
 import com.festago.school.domain.School;
 import com.festago.school.repository.SchoolRepository;
@@ -40,6 +41,7 @@
 import org.mockito.Mock;
 import org.mockito.Spy;
 import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.data.jpa.domain.Specification;
 
 @ExtendWith(MockitoExtension.class)
 @DisplayNameGeneration(ReplaceUnderscores.class)
@@ -66,10 +68,10 @@ class FestivalServiceTest {
         // given
         Festival festival1 = FestivalFixture.festival().id(1L).build();
         Festival festival2 = FestivalFixture.festival().id(2L).build();
-        given(festivalRepository.findAll()).willReturn(List.of(festival1, festival2));
+        given(festivalRepository.findAll(any(Specification.class))).willReturn(List.of(festival1, festival2));
 
         // when
-        FestivalsResponse response = festivalService.findAll();
+        FestivalsResponse response = festivalService.findFestivals(FestivalFilter.ALL);
 
         // then
         List<Long> festivalIds = response.festivals().stream().map(FestivalResponse::id).toList();

backend/src/test/java/com/festago/festival/domain/FestivalFilterTest.java

@@ -0,0 +1,21 @@
+package com.festago.festival.domain;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import com.festago.common.exception.BadRequestException;
+import com.festago.festival.repository.FestivalFilter;
+import org.junit.jupiter.api.DisplayNameGeneration;
+import org.junit.jupiter.api.DisplayNameGenerator.ReplaceUnderscores;
+import org.junit.jupiter.api.Test;
+
+@DisplayNameGeneration(ReplaceUnderscores.class)
+@SuppressWarnings("NonAsciiCharacters")
+class FestivalFilterTest {
+
+    @Test
+    void 유요하지_않은_name_이면_예외() {
+        // given && when && then
+        assertThatThrownBy(() -> FestivalFilter.from("unvalid"))
+            .isInstanceOf(BadRequestException.class);
+    }
+}

backend/src/test/java/com/festago/festival/repository/FestivalRepositoryTest.java

@@ -0,0 +1,98 @@
+package com.festago.festival.repository;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.SoftAssertions.assertSoftly;
+
+import com.festago.festival.domain.Festival;
+import com.festago.school.domain.School;
+import com.festago.school.repository.SchoolRepository;
+import java.time.LocalDate;
+import java.util.List;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayNameGeneration;
+import org.junit.jupiter.api.DisplayNameGenerator.ReplaceUnderscores;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+
+@DisplayNameGeneration(ReplaceUnderscores.class)
+@SuppressWarnings("NonAsciiCharacters")
+@DataJpaTest
+class FestivalRepositoryTest {
+
+    private static final String CURRENT_FESTIVAL = "현재 축제";
+    private static final String PAST_FESTIVAL = "과거 축제";
+    private static final String FUTURE_FESTIVAL = "미래 축제";
+
+    @Autowired
+    FestivalRepository festivalRepository;
+
+    @Autowired
+    SchoolRepository schoolRepository;
+
+    @BeforeEach
+    public void setting() {
+        School school = schoolRepository.save(new School("domain", "name"));
+        LocalDate now = LocalDate.now();
+        festivalRepository.save(new Festival(PAST_FESTIVAL, now.minusDays(10L), now.minusDays(8L), school));
+        festivalRepository.save(new Festival(CURRENT_FESTIVAL, now.minusDays(1L), now.plusDays(1L), school));
+        festivalRepository.save(new Festival(FUTURE_FESTIVAL, now.plusDays(1L), now.plusDays(3L), school));
+    }
+
+    @Test
+    void 모든_축제_반환() {
+        // given
+        FestivalFilter filter = FestivalFilter.ALL;
+
+        // when
+        List<Festival> actual = festivalRepository.findAll(filter.getSpecification());
+
+        // then
+        assertThat(actual).hasSize(3);
+    }
+
+    @Test
+    void 진행_예정_축제_반환() {
+        // given
+        FestivalFilter filter = FestivalFilter.PLANNED;
+
+        // when
+        List<Festival> actual = festivalRepository.findAll(filter.getSpecification());
+
+        // then
+        assertSoftly(softAssertions -> {
+            assertThat(actual).hasSize(1);
+            assertThat(actual.get(0)).matches(festival -> festival.getName().equals(FUTURE_FESTIVAL));
+        });
+    }
+
+    @Test
+    void 진행_중_축제_반환() {
+        // given
+        FestivalFilter filter = FestivalFilter.PROGRESS;
+
+        // when
+        List<Festival> actual = festivalRepository.findAll(filter.getSpecification());
+
+        // then
+        assertSoftly(softAssertions -> {
+            assertThat(actual).hasSize(1);
+            assertThat(actual.get(0)).matches(festival -> festival.getName().equals(CURRENT_FESTIVAL));
+        });
+    }
+
+    @Test
+    void 종료_축제_반환() {
+        // given
+        FestivalFilter filter = FestivalFilter.END;
+
+        // when
+        List<Festival> actual = festivalRepository.findAll(filter.getSpecification());
+
+        // then
+        assertSoftly(softAssertions -> {
+            assertThat(actual).hasSize(1);
+            assertThat(actual.get(0)).matches(festival -> festival.getName().equals(PAST_FESTIVAL));
+        });
+    }
+}

backend/src/test/java/com/festago/presentation/FestivalControllerTest.java

@@ -1,6 +1,7 @@
 package com.festago.presentation;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.BDDMockito.given;
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
@@ -12,6 +13,7 @@
 import com.festago.festival.dto.FestivalDetailResponse;
 import com.festago.festival.dto.FestivalResponse;
 import com.festago.festival.dto.FestivalsResponse;
+import com.festago.festival.repository.FestivalFilter;
 import com.festago.support.CustomWebMvcTest;
 import java.nio.charset.StandardCharsets;
 import java.time.LocalDate;
@@ -47,7 +49,7 @@ class FestivalControllerTest {
         FestivalResponse festivalResponse2 = new FestivalResponse(2L, 2L, "우테대학교", LocalDate.now().minusDays(3),
             LocalDate.now(), "https://image2.png");
         FestivalsResponse expected = new FestivalsResponse(List.of(festivalResponse1, festivalResponse2));
-        given(festivalService.findAll())
+        given(festivalService.findFestivals(any(FestivalFilter.class)))
             .willReturn(expected);
 
         // when & then