9주차 미션 / 서버 2조 강상민

src/main/java/kuit3/backend/common/argument_resolver/JwtAuthHandlerArgumentResolver.java

@@ -1,30 +1,55 @@
 package kuit3.backend.common.argument_resolver;
 
 import jakarta.servlet.http.HttpServletRequest;
+import kuit3.backend.common.exception.jwt.unauthorized.JwtInvalidTokenException;
+import kuit3.backend.jwt.JwtProvider;
+import kuit3.backend.service.AuthService;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.core.MethodParameter;
+import org.springframework.http.HttpHeaders;
 import org.springframework.security.access.prepost.PreAuthorize;
 import org.springframework.stereotype.Component;
 import org.springframework.web.bind.support.WebDataBinderFactory;
 import org.springframework.web.context.request.NativeWebRequest;
 import org.springframework.web.method.support.HandlerMethodArgumentResolver;
 import org.springframework.web.method.support.ModelAndViewContainer;
 
+import static kuit3.backend.common.response.status.BaseExceptionResponseStatus.INVALID_TOKEN;
+
 @Slf4j
 @Component
+@RequiredArgsConstructor
 public class JwtAuthHandlerArgumentResolver implements HandlerMethodArgumentResolver {
+
+    private final JwtProvider jwtProvider;
+    private final AuthService authService;
+
     @Override
     public boolean supportsParameter(MethodParameter parameter) {
+        log.info(parameter.getParameterName() + parameter.getParameterType());
         boolean hasAnnotation = parameter.hasParameterAnnotation(PreAuthorize.class);
-        boolean hasType = long.class.isAssignableFrom(parameter.getParameterType());
+        boolean hasType = Long.class.isAssignableFrom(parameter.getParameterType());
         log.info("hasAnnotation={}, hasType={}, hasAnnotation && hasType={}", hasAnnotation, hasType, hasAnnotation&&hasType);
-        return hasAnnotation && hasType;
+        return true;
     }
 
     @Override
-    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
+    public Object resolveArgument(@NonNull MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) {
         HttpServletRequest request = (HttpServletRequest) webRequest.getNativeRequest();
-        log.info("userId={}", request.getAttribute("userId"));
-        return request.getAttribute("userId");
+        String accessToken = (String)request.getAttribute("jwtToken");
+
+        String email = jwtProvider.getPrincipal(accessToken);
+        validatePayload(email);
+
+        return authService.getUserIdByEmail(email);
+    }
+
+    private void validatePayload(String email) {
+        if (email == null) {
+            throw new JwtInvalidTokenException(INVALID_TOKEN);
+        }
     }
+
 }

src/main/java/kuit3/backend/common/interceptor/JwtAuthInterceptor.java

@@ -8,6 +8,7 @@
 import kuit3.backend.common.exception.jwt.bad_request.JwtUnsupportedTokenException;
 import kuit3.backend.jwt.JwtProvider;
 import kuit3.backend.service.AuthService;
+import lombok.NonNull;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.HttpHeaders;
@@ -27,16 +28,11 @@ public class JwtAuthInterceptor implements HandlerInterceptor {
     private final AuthService authService;
 
     @Override
-    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
-
+    public boolean preHandle(@NonNull HttpServletRequest request, @NonNull HttpServletResponse response, @NonNull Object handler) {
         String accessToken = resolveAccessToken(request);
         validateAccessToken(accessToken);
+        request.setAttribute("jwtToken", accessToken);
 
-        String email = jwtProvider.getPrincipal(accessToken);
-        validatePayload(email);
-
-        long userId = authService.getUserIdByEmail(email);
-        request.setAttribute("userId", userId);
         return true;
     }
 
@@ -61,10 +57,4 @@ private void validateAccessToken(String accessToken) {
         }
     }
 
-    private void validatePayload(String email) {
-        if (email == null) {
-            throw new JwtInvalidTokenException(INVALID_TOKEN);
-        }
-    }
-
 }

src/main/java/kuit3/backend/config/WebConfig.java

@@ -1,16 +1,13 @@
 package kuit3.backend.config;
 
 import kuit3.backend.common.argument_resolver.JwtAuthHandlerArgumentResolver;
-import kuit3.backend.common.argument_resolver.JwtUserHandlerArgumentResolver;
 import kuit3.backend.common.interceptor.JwtAuthInterceptor;
-import kuit3.backend.common.interceptor.JwtUserInterceptor;
 import lombok.RequiredArgsConstructor;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.web.method.support.HandlerMethodArgumentResolver;
 import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 
-import java.util.ArrayList;
 import java.util.List;
 
 @Configuration
@@ -20,25 +17,18 @@ public class WebConfig implements WebMvcConfigurer {
     private final JwtAuthInterceptor jwtAuthenticationInterceptor;
     private final JwtAuthHandlerArgumentResolver jwtAuthHandlerArgumentResolver;
 
-    private final JwtUserInterceptor jwtUserInterceptor;
-    private final JwtUserHandlerArgumentResolver jwtUserHandlerArgumentResolver;
-
     @Override
     public void addInterceptors(InterceptorRegistry registry) {
         registry.addInterceptor(jwtAuthenticationInterceptor)
                 .order(1)
-                .addPathPatterns("/auth/test");
-
-        List<String> userUrls = new ArrayList<>();
-        userUrls.add("/users/{userId}/dormant");
-        registry.addInterceptor(jwtUserInterceptor)
-                .order(1)
-                .addPathPatterns(userUrls);
+                .addPathPatterns("/auth/test")
+                .addPathPatterns(("/users/**"))
+                .addPathPatterns("/restaurants")
+                .excludePathPatterns("/users");
     }
 
     @Override
     public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
         resolvers.add(jwtAuthHandlerArgumentResolver);
-        resolvers.add(jwtUserHandlerArgumentResolver);
     }
 }

src/main/java/kuit3/backend/controller/RestaurantController.java

@@ -1,17 +1,19 @@
 package kuit3.backend.controller;
 
+import kuit3.backend.common.argument_resolver.PreAuthorize;
 import kuit3.backend.common.exception.RestaurantException;
 import kuit3.backend.common.response.BaseResponse;
+import kuit3.backend.dto.restaurant.GetRestaurantResponse;
 import kuit3.backend.dto.restaurant.PostRestaurantRequest;
 import kuit3.backend.service.RestaurantService;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.validation.BindingResult;
 import org.springframework.validation.annotation.Validated;
-import org.springframework.web.bind.annotation.PostMapping;
-import org.springframework.web.bind.annotation.RequestBody;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.ArrayList;
+import java.util.List;
 
 import static kuit3.backend.common.response.status.BaseExceptionResponseStatus.INVALID_RESTAURANT_VALUE;
 import static kuit3.backend.util.BindingResultUtils.getErrorMessages;
@@ -32,7 +34,11 @@ public BaseResponse<Long> makeNewRestaurant(@Validated @RequestBody PostRestaura
         return new BaseResponse<>(restaurantService.makeNewRestaurant(postRestaurantRequest));
     }
 
-//    @GetMapping("")
-//    public BaseResponse<Long> getRestaurant
+    @GetMapping("")
+    public BaseResponse<List<GetRestaurantResponse>> getRestaurant(
+            @RequestParam(required = false) Double star,
+            @RequestParam(required = false) Long lastId) {
+        return new BaseResponse<>(restaurantService.getRestaurants(star, lastId));
+    }
 
 }

src/main/java/kuit3/backend/controller/UserController.java

@@ -40,29 +40,26 @@ public BaseResponse<PostUserResponse> signUp(@Validated @RequestBody PostUserReq
     /**
      * 회원 휴면
      */
-    @PatchMapping("/{userId}/dormant")
-    public BaseResponse<Object> modifyUserStatus_dormant(@PathVariable long userId, @PreAuthorize Long jwtId) {
-        if(userId != jwtId) {
-            throw new JwtUnauthorizedTokenException(TOKEN_MISMATCH);
-        }
+    @PatchMapping("/dormant")
+    public BaseResponse<Object> modifyUserStatus_dormant(@PreAuthorize Long userId) {
         userService.modifyUserStatus_dormant(userId);
         return new BaseResponse<>(null);
     }
 
     /**
      * 회원 탈퇴
      */
-    @PatchMapping("/{userId}/deleted")
-    public BaseResponse<Object> modifyUserStatus_deleted(@PathVariable long userId) {
+    @PatchMapping("/deleted")
+    public BaseResponse<Object> modifyUserStatus_deleted(@PreAuthorize long userId) {
         userService.modifyUserStatus_deleted(userId);
         return new BaseResponse<>(null);
     }
 
     /**
      * 닉네임 변경
      */
-    @PatchMapping("/{userId}/nickname")
-    public BaseResponse<String> modifyNickname(@PathVariable long userId,
+    @PatchMapping("/nickname")
+    public BaseResponse<String> modifyNickname(@PreAuthorize long userId,
                                                @Validated @RequestBody PatchNicknameRequest patchNicknameRequest, BindingResult bindingResult) {
         if (bindingResult.hasErrors()) {
             throw new UserException(INVALID_USER_VALUE, getErrorMessages(bindingResult));

src/main/java/kuit3/backend/dao/RestaurantDao.java

@@ -1,6 +1,8 @@
 package kuit3.backend.dao;
 
+import kuit3.backend.dto.restaurant.GetRestaurantResponse;
 import kuit3.backend.dto.restaurant.PostRestaurantRequest;
+import kuit3.backend.dto.user.GetUserResponse;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource;
 import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
@@ -10,6 +12,9 @@
 import org.springframework.stereotype.Repository;
 
 import javax.sql.DataSource;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
 import java.util.Objects;
 
 @Slf4j
@@ -33,4 +38,18 @@ public long createRestaurant(PostRestaurantRequest postRestaurantRequest) {
         return Objects.requireNonNull(keyHolder.getKey()).longValue();
     }
 
+    public List<GetRestaurantResponse> getRestaurants(double star, Long lastId) {
+        String sql = "SELECT id, name FROM restaurant WHERE star >= :star AND id > :lastId " +
+                "ORDER BY id LIMIT 10";
+
+        Map<String, Object> param = Map.of(
+                "star", star,
+                "lastId", lastId);
+
+        return jdbcTemplate.query(sql, param,
+                (rs, rowNum) -> new GetRestaurantResponse(
+                        rs.getLong("id"),
+                        rs.getString("name")));
+    }
+
 }

src/main/java/kuit3/backend/dto/restaurant/GetRestaurantResponse.java

@@ -0,0 +1,17 @@
+package kuit3.backend.dto.restaurant;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+public class GetRestaurantResponse {
+
+    private Long id;
+    private String name;
+
+}