feat(Volunteer): 봉사자 조회, 상세 조회, 검증 (#95)

* refactor(Volunteer): Find UseCase/Service를 Query UseCase/Service 로 통합

* feat(BadRequestException): 메시지 타입을 ExceptionMessage도 가능하게 오버로딩

* refactor: 클래스 명 변경

* feat(VolunteerDetail): 레포지토리 인터페이스, 구현체 추가, 리픽토링

* feat(Volunteer): Volunteer 쿼리 서비스 추가

* feat(Volunteer): 레포지토리 인터페이스, 구현체 추가, 리팩토링

* feat(Volunteer): 존재하지 않는 봉사자 처리 메시지 추가

* feat(VolunteerDetail): baseEntity 상속

* feat: Volunteer 및 VolunteerDetail 엔티티를 위한 DTO 변환 기능 추가

- Volunteer, VolunteerDetail 데이터 매핑.
- VolunteerDetail 포함/미포함 두 가지 방식 지원.

* refactor: 기존의 findService를 QueryService로 리팩토링

* feat(VolunteerQueryController): 프로필 조회 기능 추가

* feat(VolunteerApply): 엔티티와 ApplyStatus ENUM 추가

* feat(VolunteerDetailRepository): 사용하지 않는 메서드 삭제

* test(VolunteerRepository): 봉사자 id, OAuth id로 봉사자 정보 조회 테스트 추가

* test(RecruitBoardFixture): completed 상태의 RecruitBoard 생성 추가

- 리플렉션을 이용해서 status를 수정.

* test(RecruitBoardRepository): findNotCompletedIdsByCenterId 추가

- 센터 아이디로 종료되지 않았고 삭제되지 않은 RecruitBoard의 아이디 리스트를 반환
- 자동 정렬

* feat(VolunteerApplyRepository): 봉사 신청 repository 추가

- save: 봉사 신청 데이터를 저장
- findById: 봉사 신청 ID로 조회
- findVolunteerIdsByRecruitIds: 모집글 ID 리스트로 봉사자 ID 리스트 조회
- findAllByRecruitId: 모집글 ID로 페이징된 봉사 신청 조회
- isNotDeleted: 논리 삭제된 데이터 제외 조건 추가
- toOrderSpecifiers: Sort 객체를 기반으로 정렬 조건 생성
- getCount: 페이징 처리를 위한 총 데이터 개수 조회 메서드 추가

* feat(RecruitBoardQueryService): 기관 아이디 기반으로 종료되지 않은 RecruitBoard 아이디 리스트 조회 추가

- getNotCompletedIdsByCenterIds

* feat(VolunteerApplyJpaRepository): JpaRepo 상속 추가

* feat(VolunteerQueryService): 닉네임 조회 값 null 처리

* feat(VolunteerApplyQueryService): 봉사 신청 Query Service/UseCase 추가

- getVolunteerIdsByRecruitIds: 모집글 ID 리스트로 봉사자 ID 리스트 조회

* test: tearDown을 @transactional로 변경

* feat(VolunteerDetailAccessValidator): 봉사자 상세 정보 접근 검증 로직 구현

- 완료되지 않은 모집글 ID 조회 및 봉사자 ID와의 매칭 검증
- 타겟 봉사자 ID가 모집글과 연관되지 않은 경우 예외 처리
- RecruitBoardQueryUseCase와 VolunteerApplyQueryUseCase를 활용

* test(RecruitBoardQueryService): 센터 아이디로 완료되지 않은 모집 게시글의 ID 조회 테스트 추가

* test(RecruitBoardQueryRepository): 센터 아이디로 완료되지 않은 모집 게시글의 ID 조회 테스트 추가

* test(VolunteerApplyQueryService): 모집 아이디로 봉사자 아이디 리스트 조회 테스트 추가

* test(VolunteerApplyRepository): 봉사 신청/조회, 모집 ID로 봉사자 ID 리스트/페이징 조회

* test(VolunteerDetailRepository): 봉사자 ID로 봉사자 상세 정보 조회/저장

* test(VolunteerQueryService): 기관의 봉사자 상세 정보 조회에 대한 권한 검증 추가

* test(VolunteerDetailAccessValidator): 봉사자 상세 정보를 기관이 조회하는 테스트 추가

* test(VolunteerQueryService): 봉사자 기본/상세 정보 조회 테스트, 닉네임 조회 테스트 추가

- beforeEach 를 transactional로 변경

* feat(IntegrationTestSupport): @AutoConfigureMockMvc 추가

* test(VolunteerSignController): ControllerTestSupport 상속받도록 변경

* test(center): 공백 제거

* test(VolunteerQueryController): 타인 프로필 조회 컨트롤러 테스트 추가

* test(ControllerTestSupport): 필터 OFF

* test(VolunteerController): 컨트롤러 테스트 삭제

* feat(VolunteerQueryController): @secured 적용, Mapping 리팩토링

* feat(UserRole): GrantedAuthority 상속, authority 필드, 정적 메서드 from 추가

* feat(UserRole): UserRole.name() 사용에서 명시적인 Authority 필드 반환 메서드로 변경

* feat(CookieService): 토큰 로그 추가

* feat(DevAccountSetUpConfig): repository 변경, .name()을 .getAuthority로 변경

* feat(HmacJwtGenerator): 일관성 있는 상수 처리

* refactor(JwtAuthFilter): 리팩토링, name() 사용 제거

* feat(SecurityConfig): @slf4j, (securedEnabled = true) 추가로 @secured 작동하도록 수정

* cicd(jacoco): controller 패키지를 테스트 커버리지에서 제외

- 나는 컨트롤러 테스트가 밉다.

* refactor(VolunteerDetailAccessValidator): elseThrow 반환이 없는 것을 anyMatch로 수정

* feat(VolunteerQueryController): 성공 메시지 변경

* refactor(sonar 반영): unused import, chaining join, 명시적인 엔티티 default fields

* fix(VolunteerApplyQueryServiceTest): builder는 기본 값이 설정되지 않는 문제 해결

* refactor(VolunteerQueryService): 인터페이스 의존으로 수정

* test(VolunteerResponseDto): 봉사자 응답 정보 스웨거 어노테이션 추가

* chore(package): 패키지이름 대문자 수정

* style(개행): git 잠재적인 문제 예방

Author: m-a-king

build.gradle

@@ -116,6 +116,8 @@ def jacocoExcludePatterns = [
         '**/domain/*',
         '**/domains/*',
         '**/fixture/*',
+        '**/controller/**',
+        '**/fixture/*',
         '**/*Factory*'
 ]
 
@@ -132,6 +134,8 @@ def jacocoExcludePatternsForVerify = [
         '*.domain.*',
         '*.domains.*',
         '*.fixture.*',
+        '*.controller.*',
+        '*.fixture.*',
         '*.*Factory*'
 ]
 

src/main/java/com/somemore/auth/cookie/CookieService.java

@@ -16,12 +16,14 @@ public class CookieService implements CookieUseCase {
     public void setAccessToken(HttpServletResponse response, String value) {
         ResponseCookie cookie = generateCookie(TokenType.ACCESS, value);
         response.addHeader("Set-Cookie", cookie.toString());
+        log.info("SET_COOKIE_ACCESS_TOKEN = {}", value);
     }
 
     @Override
     public void deleteAccessToken(HttpServletResponse response) {
         ResponseCookie cookie = generateCookie(TokenType.SIGNOUT, TokenType.SIGNOUT.name());
         response.addHeader("Set-Cookie", cookie.toString());
+        log.info("DELETE_COOKIE_ACCESS_TOKEN");
     }
 
     private static ResponseCookie generateCookie(TokenType tokenType, String value) {

src/main/java/com/somemore/auth/jwt/domain/UserRole.java

@@ -1,7 +1,30 @@
 package com.somemore.auth.jwt.domain;
 
-public enum UserRole {
-    VOLUNTEER,
-    CENTER,
-    ADMIN
+import com.somemore.auth.jwt.exception.JwtException;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.core.GrantedAuthority;
+
+import static com.somemore.auth.jwt.exception.JwtErrorType.UNKNOWN_ERROR;
+
+@RequiredArgsConstructor
+public enum UserRole implements GrantedAuthority {
+    VOLUNTEER("ROLE_VOLUNTEER"),
+    CENTER("ROLE_CENTER"),
+    ADMIN("ROLE_ADMIN");
+
+    private final String authority;
+
+    @Override
+    public String getAuthority() {
+        return this.authority;
+    }
+
+    public static UserRole from(String role) {
+        for (UserRole userRole : values()) {
+            if (userRole.name().equals(role)) {
+                return userRole;
+            }
+        }
+        throw new JwtException(UNKNOWN_ERROR);
+    }
 }

src/main/java/com/somemore/auth/jwt/filter/JwtAuthFilter.java

@@ -9,8 +9,6 @@
 import jakarta.servlet.ServletException;
 import jakarta.servlet.http.HttpServletRequest;
 import jakarta.servlet.http.HttpServletResponse;
-import java.io.IOException;
-import java.util.List;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.security.core.Authentication;
@@ -19,6 +17,9 @@
 import org.springframework.stereotype.Component;
 import org.springframework.web.filter.OncePerRequestFilter;
 
+import java.io.IOException;
+import java.util.List;
+
 @RequiredArgsConstructor
 @Slf4j
 @Component
@@ -34,7 +35,7 @@ protected boolean shouldNotFilter(HttpServletRequest request) {
 
     @Override
     protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response,
-            FilterChain filterChain) throws ServletException, IOException {
+                                    FilterChain filterChain) throws ServletException, IOException {
         EncodedToken accessToken = getAccessToken(request);
         jwtUseCase.processAccessToken(accessToken, response);
 
@@ -47,24 +48,24 @@ protected void doFilterInternal(HttpServletRequest request, HttpServletResponse
 
     private EncodedToken getAccessToken(HttpServletRequest request) {
         String accessToken = request.getHeader("Authorization");
-        if (!accessToken.startsWith("Bearer ")) {
-            throw new JwtException(JwtErrorType.MISSING_TOKEN);
-        }
 
-        accessToken = accessToken.substring(7);
+        String tokenPrefix = "Bearer ";
+        if (accessToken.startsWith(tokenPrefix)) {
+            return new EncodedToken(accessToken.substring(tokenPrefix.length()));
+        }
 
-        return new EncodedToken(accessToken);
+        throw new JwtException(JwtErrorType.MISSING_TOKEN);
     }
 
     private JwtAuthenticationToken createAuthenticationToken(Claims claims,
-            EncodedToken accessToken) {
+                                                             EncodedToken accessToken) {
         String userId = claims.get("id", String.class);
-        UserRole role = UserRole.valueOf(claims.get("role", String.class));
+        String role = claims.get("role", String.class);
 
         return new JwtAuthenticationToken(
                 userId,
                 accessToken,
-                List.of(new SimpleGrantedAuthority(role.name()))
+                List.of(new SimpleGrantedAuthority(role))
         );
     }
 }

src/main/java/com/somemore/auth/jwt/filter/UserRole.java

@@ -36,12 +36,10 @@ public EncodedToken generateToken(String userId, String role, TokenType tokenTyp
     }
 
     private static Claims buildClaims(String userId, String role) {
-        final String ID = "id";
-        final String ROLE = "role";
 
         return Jwts.claims()
-                .add(ID, userId)
-                .add(ROLE, role)
+                .add("id", userId)
+                .add("role", role)
                 .build();
     }
 }

src/main/java/com/somemore/auth/jwt/generator/HmacJwtGenerator.java

@@ -35,7 +35,7 @@ public EncodedToken saveRefreshTokenAndReturnAccessToken(UUID volunteerId) {
     private EncodedToken generateToken(UUID volunteerId, TokenType tokenType) {
         return jwtGenerator.generateToken(
                 volunteerId.toString(),
-                UserRole.VOLUNTEER.name(),
+                UserRole.VOLUNTEER.getAuthority(),
                 tokenType);
     }
 

src/main/java/com/somemore/auth/jwt/service/GenerateTokensOnLoginService.java

@@ -6,7 +6,7 @@
 import com.somemore.auth.oauth.OAuthProvider;
 import com.somemore.auth.oauth.naver.service.query.ProcessNaverOAuthUserService;
 import com.somemore.auth.redirect.RedirectUseCase;
-import com.somemore.volunteer.usecase.FindVolunteerIdUseCase;
+import com.somemore.volunteer.usecase.VolunteerQueryUseCase;
 import jakarta.servlet.http.HttpServletRequest;
 import jakarta.servlet.http.HttpServletResponse;
 import lombok.RequiredArgsConstructor;
@@ -26,7 +26,7 @@
 public class CustomOAuthSuccessHandler extends SimpleUrlAuthenticationSuccessHandler {
 
     private final ProcessNaverOAuthUserService processNaverOAuthService;
-    private final FindVolunteerIdUseCase findVolunteerIdUseCase;
+    private final VolunteerQueryUseCase volunteerQueryUseCase;
     private final GenerateTokensOnLoginUseCase generateTokensOnLoginUseCase;
     private final CookieUseCase cookieUseCase;
     private final RedirectUseCase redirectUseCase;
@@ -45,7 +45,7 @@ public void onAuthenticationSuccess(HttpServletRequest request, HttpServletRespo
             }
         }
 
-        UUID volunteerId = findVolunteerIdUseCase.findVolunteerIdByOAuthId(oAuthId);
+        UUID volunteerId = volunteerQueryUseCase.getVolunteerIdByOAuthId(oAuthId);
         EncodedToken accessToken = generateTokensOnLoginUseCase.saveRefreshTokenAndReturnAccessToken(volunteerId);
 
         cookieUseCase.setAccessToken(response, accessToken.value());

src/main/java/com/somemore/auth/oauth/handler/success/CustomOAuthSuccessHandler.java

@@ -11,7 +11,7 @@
 import com.somemore.center.domain.Center;
 import com.somemore.center.repository.CenterJpaRepository;
 import com.somemore.volunteer.domain.Volunteer;
-import com.somemore.volunteer.repository.VolunteerJpaRepository;
+import com.somemore.volunteer.repository.VolunteerRepository;
 import jakarta.annotation.PostConstruct;
 import jakarta.annotation.PreDestroy;
 import java.util.UUID;
@@ -25,7 +25,7 @@
 @Component
 public class DevAccountSetUpConfig {
 
-    private final VolunteerJpaRepository volunteerRepository;
+    private final VolunteerRepository volunteerRepository;
     private final CenterJpaRepository centerRepository;
     private final JwtGenerator jwtGenerator;
     private final RefreshTokenManager refreshTokenManager;
@@ -88,7 +88,7 @@ private EncodedToken saveRefreshTokenAndReturnAccessToken(UUID id, UserRole role
     }
 
     private EncodedToken generateToken(UUID id, UserRole role, TokenType tokenType) {
-        return jwtGenerator.generateToken(id.toString(), role.name(), tokenType);
+        return jwtGenerator.generateToken(id.toString(), role.getAuthority(), tokenType);
     }
 
     private RefreshToken generateRefreshToken(UUID id, UserRole role, EncodedToken accessToken) {