Feat: 동아리 소속 목록 조회 api, 동아리 목록 조회 api, 동아리 상세 정보 조회 api 구현

src/main/java/com/kustacks/kuring/club/adapter/in/web/ClubQueryApiV2.java

@@ -0,0 +1,113 @@
+package com.kustacks.kuring.club.adapter.in.web;
+
+import com.kustacks.kuring.auth.authentication.AuthorizationExtractor;
+import com.kustacks.kuring.auth.authentication.AuthorizationType;
+import com.kustacks.kuring.auth.token.JwtTokenProvider;
+import com.kustacks.kuring.club.adapter.in.web.dto.ClubDetailResponse;
+import com.kustacks.kuring.club.adapter.in.web.dto.ClubDivisionListResponse;
+import com.kustacks.kuring.club.adapter.in.web.dto.ClubListResponse;
+import com.kustacks.kuring.club.application.port.in.ClubQueryUseCase;
+import com.kustacks.kuring.club.application.port.in.dto.ClubDetailCommand;
+import com.kustacks.kuring.club.application.port.in.dto.ClubDetailResult;
+import com.kustacks.kuring.club.application.port.in.dto.ClubDivisionResult;
+import com.kustacks.kuring.club.application.port.in.dto.ClubListCommand;
+import com.kustacks.kuring.club.application.port.in.dto.ClubListResult;
+import com.kustacks.kuring.common.annotation.RestWebAdapter;
+import com.kustacks.kuring.common.dto.BaseResponse;
+import com.kustacks.kuring.common.exception.InvalidStateException;
+import com.kustacks.kuring.common.exception.code.ErrorCode;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.security.SecurityRequirement;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestHeader;
+import org.springframework.web.bind.annotation.RequestParam;
+
+import java.util.List;
+import java.util.Optional;
+
+import static com.kustacks.kuring.auth.authentication.AuthorizationExtractor.extractAuthorizationValue;
+import static com.kustacks.kuring.common.dto.ResponseCodeAndMessages.CLUB_DETAIL_SEARCH_SUCCESS;
+import static com.kustacks.kuring.common.dto.ResponseCodeAndMessages.CLUB_DIVISION_SEARCH_SUCCESS;
+import static com.kustacks.kuring.common.dto.ResponseCodeAndMessages.CLUB_LIST_SEARCH_SUCCESS;
+
+@Tag(name = "Club-Query", description = "동아리 정보 조회")
+@Validated
+@RequiredArgsConstructor
+@RestWebAdapter(path = "/api/v2/clubs")
+public class ClubQueryApiV2 {
+
+    private static final String FCM_TOKEN_HEADER_KEY = "User-Token";
+    private static final String JWT_TOKEN_HEADER_KEY = "JWT";
+
+    private final JwtTokenProvider jwtTokenProvider;
+    private final ClubQueryUseCase clubQueryUseCase;
+
+    @Operation(summary = "동아리 소속 목록 조회", description = "서버가 지원하는 동아리 소속 목록을 조회합니다")
+    @GetMapping("/divisions")
+    public ResponseEntity<BaseResponse<ClubDivisionListResponse>> getSupportedClubDivisions() {
+
+        List<ClubDivisionResult> results = clubQueryUseCase.getClubDivisions();
+
+        ClubDivisionListResponse response = ClubDivisionListResponse.from(results);
+
+        return ResponseEntity.ok().body(new BaseResponse<>(CLUB_DIVISION_SEARCH_SUCCESS, response));
+    }
+
+    @Operation(summary = "동아리 목록 조회", description = "필터 조건에 맞는 동아리 목록을 조회합니다")
+    @SecurityRequirement(name = JWT_TOKEN_HEADER_KEY)
+    @GetMapping
+    public ResponseEntity<BaseResponse<ClubListResponse>> getClubs(
+            @RequestParam(required = false) String category,
+            @RequestParam(required = false) String division,
+            @RequestHeader(value = AuthorizationExtractor.AUTHORIZATION, required = false) String bearerToken
+    ) {
+        String email = resolveLoginEmail(bearerToken);
+
+        ClubListCommand command = new ClubListCommand(category, division, email);
+
+        ClubListResult result = clubQueryUseCase.getClubs(command);
+
+        ClubListResponse response = ClubListResponse.from(result);
+
+        return ResponseEntity.ok().body(new BaseResponse<>(CLUB_LIST_SEARCH_SUCCESS, response));
+    }
+
+    @Operation(summary = "동아리 상세 조회", description = "특정 동아리의 상세 정보를 조회합니다.")
+    @SecurityRequirement(name = FCM_TOKEN_HEADER_KEY)
+    @SecurityRequirement(name = JWT_TOKEN_HEADER_KEY)
+    @GetMapping("/{id}")
+    public ResponseEntity<BaseResponse<ClubDetailResponse>> getClubDetail(
+            @PathVariable Long id,
+            @RequestHeader(value = FCM_TOKEN_HEADER_KEY, required = false) String userToken,
+            @RequestHeader(value = AuthorizationExtractor.AUTHORIZATION, required = false) String bearerToken
+    ) {
+        String email = resolveLoginEmail(bearerToken);
+
+        ClubDetailCommand command = new ClubDetailCommand(id, email);
+
+        ClubDetailResult result = clubQueryUseCase.getClubDetail(command);
+
+        ClubDetailResponse response = ClubDetailResponse.from(result);
+
+        return ResponseEntity.ok().body(new BaseResponse<>(CLUB_DETAIL_SEARCH_SUCCESS, response));
+    }
+
+    private String resolveLoginEmail(String bearerToken) {
+        return Optional.ofNullable(bearerToken)
+                .map(token -> extractAuthorizationValue(token, AuthorizationType.BEARER))
+                .map(this::validateJwtAndGetEmail)
+                .orElse(null);
+    }
+
+    private String validateJwtAndGetEmail(String jwtToken) {
+        if (!jwtTokenProvider.validateToken(jwtToken)) {
+            throw new InvalidStateException(ErrorCode.JWT_INVALID_TOKEN);
+        }
+        return jwtTokenProvider.getPrincipal(jwtToken);
+    }
+}

src/main/java/com/kustacks/kuring/club/adapter/in/web/dto/ClubDetailResponse.java

@@ -0,0 +1,68 @@
+package com.kustacks.kuring.club.adapter.in.web.dto;
+
+import com.kustacks.kuring.club.application.port.in.dto.ClubDetailResult;
+
+import java.time.LocalDateTime;
+
+public record ClubDetailResponse(
+        Long id,
+        String name,
+        String summary,
+        String category,
+        String division,
+        Long subscriberCount,
+        boolean isSubscribed,
+        String instagramUrl,
+        String youtubeUrl,
+        String etcUrl,
+        String description,
+        String qualifications,
+        String recruitmentStatus,
+        LocalDateTime recruitStartAt,
+        LocalDateTime recruitEndAt,
+        String applyUrl,
+        String posterImageUrl,
+        Location location
+) {
+
+    public static ClubDetailResponse from(ClubDetailResult result) {
+        return new ClubDetailResponse(
+                result.id(),
+                result.name(),
+                result.summary(),
+                result.category().getName(),
+                result.division().getName(),
+                result.subscriberCount(),
+                result.isSubscribed(),
+                result.instagramUrl(),
+                result.youtubeUrl(),
+                result.etcUrl(),
+                result.description(),
+                result.qualifications(),
+                result.recruitmentStatus().getValue(),
+                result.recruitStartAt(),
+                result.recruitEndAt(),
+                result.applyUrl(),
+                result.posterImageUrl(),
+                Location.from(result.location())
+        );
+    }
+
+    public record Location(
+            String building,
+            String room,
+            Double lon,
+            Double lat
+    ) {
+        public static Location from(ClubDetailResult.Location location) {
+            if (location == null) return null;
+
+            return new Location(
+                    location.building(),
+                    location.room(),
+                    location.lon(),
+                    location.lat()
+            );
+        }
+    }
+}

src/main/java/com/kustacks/kuring/club/adapter/in/web/dto/ClubDivisionListResponse.java

@@ -0,0 +1,13 @@
+package com.kustacks.kuring.club.adapter.in.web.dto;
+
+import com.kustacks.kuring.club.application.port.in.dto.ClubDivisionResult;
+
+import java.util.List;
+
+public record ClubDivisionListResponse(
+        List<ClubDivisionResult> divisions
+) {
+    public static ClubDivisionListResponse from(List<ClubDivisionResult> results) {
+        return new ClubDivisionListResponse(results);
+    }
+}

src/main/java/com/kustacks/kuring/club/adapter/in/web/dto/ClubListResponse.java

@@ -0,0 +1,15 @@
+package com.kustacks.kuring.club.adapter.in.web.dto;
+
+import com.kustacks.kuring.club.application.port.in.dto.ClubItemResult;
+import com.kustacks.kuring.club.application.port.in.dto.ClubListResult;
+
+import java.util.List;
+
+public record ClubListResponse(
+        List<ClubItemResult> clubs
+) {
+
+    public static ClubListResponse from(ClubListResult result) {
+        return new ClubListResponse(result.clubs());
+    }
+}

src/main/java/com/kustacks/kuring/club/adapter/out/persistence/ClubPersistenceAdapter.java

@@ -3,7 +3,11 @@
 import com.kustacks.kuring.club.application.port.out.ClubQueryPort;
 import com.kustacks.kuring.club.application.port.out.ClubSubscriptionCommandPort;
 import com.kustacks.kuring.club.application.port.out.ClubSubscriptionQueryPort;
+import com.kustacks.kuring.club.application.port.out.dto.ClubDetailDto;
+import com.kustacks.kuring.club.application.port.out.dto.ClubReadModel;
 import com.kustacks.kuring.club.domain.Club;
+import com.kustacks.kuring.club.domain.ClubCategory;
+import com.kustacks.kuring.club.domain.ClubDivision;
 import com.kustacks.kuring.club.domain.ClubSubscribe;
 import com.kustacks.kuring.common.annotation.PersistenceAdapter;
 import com.kustacks.kuring.user.domain.RootUser;
@@ -12,7 +16,9 @@
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
+import java.util.stream.Collectors;
 
 @PersistenceAdapter
 @RequiredArgsConstructor
@@ -21,11 +27,58 @@ public class ClubPersistenceAdapter implements ClubQueryPort, ClubSubscriptionCo
     private final ClubRepository clubRepository;
     private final ClubSubscribeRepository clubSubscribeRepository;
 
+    @Override
+    public List<ClubReadModel> searchClubs(
+            ClubCategory category,
+            List<ClubDivision> divisions
+    ) {
+        return clubRepository.searchClubs(category, divisions);
+    }
+
+    @Override
+    public Optional<ClubDetailDto> findClubDetailById(Long id) {
+        return clubRepository.findClubDetailById(id);
+    }
+
     @Override
     public Optional<Club> findClubById(Long id) {
         return clubRepository.findById(id);
     }
 
+    @Override
+    public List<Long> findSubscribedClubIds(
+            List<Long> clubIds,
+            Long rootUserId
+    ) {
+        return clubSubscribeRepository
+                .findByClubIdInAndRootUserId(clubIds, rootUserId)
+                .stream()
+                .map(sub -> sub.getClub().getId())
+                .toList();
+    }
+
+
+    @Override
+    public Long countSubscribers(Long clubId) {
+        return clubSubscribeRepository.countByClubId(clubId);
+    }
+
+    @Override
+    public Map<Long, Long> countSubscribersByClubIds(List<Long> clubIds) {
+
+        if (clubIds == null || clubIds.isEmpty()) {
+            return Map.of();
+        }
+
+        List<Object[]> subscriptions = clubSubscribeRepository.countSubscribersByClubIds(clubIds);
+
+        return subscriptions.stream()
+                .collect(Collectors.toMap(
+                        row -> (Long) row[0],
+                        row -> (Long) row[1]
+                ));
+    }
+
     @Override
     public List<Club> findClubsBetweenDates(LocalDateTime start, LocalDateTime end) {
         return clubRepository.findClubsBetweenDates(start, end);
@@ -55,7 +108,7 @@ public void deleteSubscription(RootUser rootUser, Club club) {
     }
 
     @Override
-    public long countSubscriptions(Long rootUserId) {
+    public Long countSubscriptions(Long rootUserId) {
         return clubSubscribeRepository.countByRootUserId(rootUserId);
     }
 }

src/main/java/com/kustacks/kuring/club/adapter/out/persistence/ClubQueryRepository.java

@@ -1,11 +1,20 @@
 package com.kustacks.kuring.club.adapter.out.persistence;
 
+import com.kustacks.kuring.club.application.port.out.dto.ClubDetailDto;
+import com.kustacks.kuring.club.application.port.out.dto.ClubReadModel;
 import com.kustacks.kuring.club.domain.Club;
+import com.kustacks.kuring.club.domain.ClubCategory;
+import com.kustacks.kuring.club.domain.ClubDivision;
 
 import java.time.LocalDateTime;
 import java.util.List;
+import java.util.Optional;
 
 public interface ClubQueryRepository {
 
+    List<ClubReadModel> searchClubs(ClubCategory category, List<ClubDivision> divisions);
+
+    Optional<ClubDetailDto> findClubDetailById(Long id);
+
     List<Club> findClubsBetweenDates(LocalDateTime start, LocalDateTime end);
 }