[Spring 장바구니 - 2단계] 조동현(후디) 미션 제출합니다.

build.gradle

@@ -15,7 +15,6 @@ repositories {
 dependencies {
     implementation 'org.springframework.boot:spring-boot-starter-jdbc'
     implementation 'org.springframework.boot:spring-boot-starter-web'
-    implementation 'org.springframework.boot:spring-boot-starter-security'
 
     testImplementation 'org.springframework.boot:spring-boot-starter-test'
     testImplementation 'io.rest-assured:rest-assured:4.4.0'

src/main/java/woowacourse/auth/controller/CustomerIdArgumentResolver.java

@@ -25,7 +25,7 @@ public boolean supportsParameter(MethodParameter parameter) {
 
     @Override
     public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
-                                  NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
+                                  NativeWebRequest webRequest, WebDataBinderFactory binderFactory) {
         String accessToken = AuthorizationExtractor.extract((HttpServletRequest) webRequest.getNativeRequest());
         return Long.parseLong(jwtTokenProvider.getPayload(accessToken));
     }

src/main/java/woowacourse/auth/dto/TokenResponse.java

@@ -2,12 +2,12 @@
 
 public class TokenResponse {
     private String accessToken;
-    private int userId;
+    private long userId;
 
     public TokenResponse() {
     }
 
-    public TokenResponse(String accessToken, int userId) {
+    public TokenResponse(String accessToken, long userId) {
         this.accessToken = accessToken;
         this.userId = userId;
     }
@@ -16,7 +16,7 @@ public String getAccessToken() {
         return accessToken;
     }
 
-    public int getUserId() {
+    public long getUserId() {
         return userId;
     }
 

src/main/java/woowacourse/auth/service/AuthService.java

@@ -1,50 +1,50 @@
 package woowacourse.auth.service;
 
-import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
 import org.springframework.stereotype.Service;
 import woowacourse.auth.dto.TokenRequest;
 import woowacourse.auth.dto.TokenResponse;
 import woowacourse.auth.exception.authentication.LoginFailedException;
 import woowacourse.auth.support.JwtTokenProvider;
-import woowacourse.shoppingcart.dao.CustomerDao;
+import woowacourse.shoppingcart.domain.customer.Customer;
 import woowacourse.shoppingcart.domain.customer.Password;
-import woowacourse.shoppingcart.entity.CustomerEntity;
+import woowacourse.shoppingcart.repository.CustomerRepository;
 
 @Service
 public class AuthService {
-    private final CustomerDao customerDao;
+    private final CustomerRepository customerRepository;
     private final JwtTokenProvider jwtTokenProvider;
 
-    public AuthService(CustomerDao customerDao, JwtTokenProvider jwtTokenProvider) {
-        this.customerDao = customerDao;
+    public AuthService(CustomerRepository customerRepository, JwtTokenProvider jwtTokenProvider) {
+        this.customerRepository = customerRepository;
         this.jwtTokenProvider = jwtTokenProvider;
     }
 
+    public void validateToken(String accessToken) {
+        jwtTokenProvider.validateToken(accessToken);
+    }
+
     public TokenResponse generateToken(TokenRequest tokenRequest) {
         String email = tokenRequest.getEmail();
         String password = tokenRequest.getPassword();
         validateEmailExisting(email);
-        CustomerEntity customerEntity = customerDao.findByEmail(email);
-        validatePassword(password, customerEntity);
 
-        int customerId = customerEntity.getId();
+        Customer customer = customerRepository.findByEmail(email);
+        validatePassword(password, customer);
+
+        long customerId = customer.getId();
         String token = jwtTokenProvider.createToken(String.valueOf(customerId));
 
         return new TokenResponse(token, customerId);
     }
 
-    public void validateToken(String accessToken) {
-        jwtTokenProvider.validateToken(accessToken);
-    }
-
     private void validateEmailExisting(String email) {
-        if (!customerDao.existsByEmail(email)) {
+        if (!customerRepository.existsByEmail(email)) {
             throw new LoginFailedException();
         }
     }
 
-    private void validatePassword(String password, CustomerEntity customerEntity) {
-        Password cipherPassword = new Password(customerEntity.getPassword(), new BCryptPasswordEncoder());
+    private void validatePassword(String password, Customer customer) {
+        Password cipherPassword = customer.getPassword();
         boolean isValid = cipherPassword.matches(password);
 
         if (!isValid) {

src/main/java/woowacourse/auth/support/AuthorizationExtractor.java

@@ -1,11 +1,11 @@
 package woowacourse.auth.support;
 
-import javax.servlet.http.HttpServletRequest;
 import java.util.Enumeration;
+import javax.servlet.http.HttpServletRequest;
 
 public class AuthorizationExtractor {
     public static final String AUTHORIZATION = "Authorization";
-    public static String BEARER_TYPE = "Bearer";
+    public static final String BEARER_TYPE = "Bearer";
     public static final String ACCESS_TOKEN_TYPE = AuthorizationExtractor.class.getSimpleName() + ".ACCESS_TOKEN_TYPE";
 
     public static String extract(HttpServletRequest request) {

src/main/java/woowacourse/auth/support/JwtTokenProvider.java

@@ -18,8 +18,8 @@ public class JwtTokenProvider {
     private final SecretKey secretKey;
     private final long validityInMilliseconds;
 
-    public JwtTokenProvider(@Value("${security.jwt.token.secret-key}") final String secretKey,
-                            @Value("${security.jwt.token.expire-length}") final long validityInMilliseconds) {
+    public JwtTokenProvider(@Value("${security.jwt.token.secret-key}") String secretKey,
+                            @Value("${security.jwt.token.expire-length}") long validityInMilliseconds) {
         this.secretKey = Keys.hmacShaKeyFor(secretKey.getBytes(StandardCharsets.UTF_8));
         this.validityInMilliseconds = validityInMilliseconds;
     }

src/main/java/woowacourse/common/controller/ControllerAdvice.java

@@ -61,9 +61,9 @@ public ResponseEntity<ErrorResponse> handle() {
     }
 
     @ExceptionHandler(MethodArgumentNotValidException.class)
-    public ResponseEntity<ErrorResponse> handleInvalidRequest(final BindingResult bindingResult) {
-        final List<FieldError> fieldErrors = bindingResult.getFieldErrors();
-        final FieldError mainError = fieldErrors.get(0);
+    public ResponseEntity<ErrorResponse> handleInvalidRequest(BindingResult bindingResult) {
+        List<FieldError> fieldErrors = bindingResult.getFieldErrors();
+        FieldError mainError = fieldErrors.get(0);
 
         return ResponseEntity.badRequest().body(new ErrorResponse(mainError.getDefaultMessage()));
     }
@@ -77,7 +77,7 @@ public ResponseEntity<ErrorResponse> handleInvalidArgument(RuntimeException e) {
             HttpMessageNotReadableException.class,
             ConstraintViolationException.class,
     })
-    public ResponseEntity<ErrorResponse> handleInvalidRequest(final RuntimeException e) {
+    public ResponseEntity<ErrorResponse> handleInvalidRequest(RuntimeException e) {
         return ResponseEntity.badRequest().body(new ErrorResponse(e.getMessage()));
     }
 
@@ -88,7 +88,7 @@ public ResponseEntity<ErrorResponse> handleInvalidRequest(final RuntimeException
             InvalidOrderException.class,
             NotInCustomerCartItemException.class,
     })
-    public ResponseEntity<ErrorResponse> handleInvalidAccess(final RuntimeException e) {
+    public ResponseEntity<ErrorResponse> handleInvalidAccess(RuntimeException e) {
         return ResponseEntity.badRequest().body(new ErrorResponse(e.getMessage()));
     }
 

src/main/java/woowacourse/shoppingcart/controller/CartItemController.java

@@ -23,20 +23,19 @@
 public class CartItemController {
     private final CartService cartService;
 
-    public CartItemController(final CartService cartService) {
+    public CartItemController(CartService cartService) {
         this.cartService = cartService;
     }
 
     @GetMapping
-    public ResponseEntity<List<CartItemResponse>> getCartItems(@CustomerId final Long customerId) {
+    public ResponseEntity<List<CartItemResponse>> getCartItems(@CustomerId Long customerId) {
         return ResponseEntity.ok().body(cartService.findCartItemsByCustomerId(customerId));
     }
 
     @PostMapping
-    public ResponseEntity<Void> addCartItem(@RequestBody final CartItemRequest cartItemRequest,
-                                            @CustomerId final Long customerId) {
-        final Long cartItemId = cartService.addCart(cartItemRequest, customerId);
-        final URI responseLocation = ServletUriComponentsBuilder
+    public ResponseEntity<Void> addCartItem(@RequestBody CartItemRequest cartItemRequest, @CustomerId Long customerId) {
+        Long cartItemId = cartService.addCart(cartItemRequest, customerId);
+        URI responseLocation = ServletUriComponentsBuilder
                 .fromCurrentRequest()
                 .path("/{cartItemId}")
                 .buildAndExpand(cartItemId)
@@ -45,22 +44,22 @@ public ResponseEntity<Void> addCartItem(@RequestBody final CartItemRequest cartI
     }
 
     @DeleteMapping("/{cartItemId}")
-    public ResponseEntity<Void> deleteCartItem(@CustomerId final Long customerId, @PathVariable final Long cartItemId) {
+    public ResponseEntity<Void> deleteCartItem(@CustomerId Long customerId, @PathVariable Long cartItemId) {
         cartService.deleteCart(customerId, cartItemId);
         return ResponseEntity.noContent().build();
     }
 
     @PutMapping("/{cartItemId}")
-    public ResponseEntity<Void> updateCartItem(@RequestBody final CartItemRequest cartItemRequest,
-                                               @PathVariable final Long cartItemId,
-                                               @CustomerId final Long customerId) {
+    public ResponseEntity<Void> updateCartItem(@RequestBody CartItemRequest cartItemRequest,
+                                               @PathVariable Long cartItemId,
+                                               @CustomerId Long customerId) {
         cartService.updateCartItem(customerId, cartItemId, cartItemRequest);
         return ResponseEntity.noContent().build();
     }
 
     @GetMapping("/{productId}")
-    public ResponseEntity<ProductExistingInCartResponse> checkIsProductExisting(@CustomerId final Long customerId,
-                                                                                @PathVariable final Long productId) {
+    public ResponseEntity<ProductExistingInCartResponse> checkIsProductExisting(@CustomerId Long customerId,
+                                                                                @PathVariable Long productId) {
         ProductExistingInCartResponse productExisting = cartService.isProductExisting(customerId, productId);
         return ResponseEntity.ok(productExisting);
     }

src/main/java/woowacourse/shoppingcart/controller/CustomerController.java

@@ -27,7 +27,7 @@ public CustomerController(CustomerService customerService) {
 
     @PostMapping("/customers")
     public ResponseEntity<Void> createCustomer(@RequestBody CustomerRequest customerRequest) {
-        int id = customerService.create(customerRequest);
+        long id = customerService.create(customerRequest);
         return ResponseEntity.created(URI.create("/api/customers/" + id)).build();
     }
 

src/main/java/woowacourse/shoppingcart/controller/OrderController.java

@@ -11,37 +11,35 @@
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 import woowacourse.auth.controller.CustomerId;
-import woowacourse.shoppingcart.dto.request.OrderRequest;
-import woowacourse.shoppingcart.dto.response.OrderResponse;
-import woowacourse.shoppingcart.service.OrderService;
+import woowacourse.shoppingcart.dto.request.OrdersRequest;
+import woowacourse.shoppingcart.dto.response.OrdersResponse;
+import woowacourse.shoppingcart.service.OrdersService;
 
 @Validated
 @RestController
 @RequestMapping("/api/customers/orders")
 public class OrderController {
-    private final OrderService orderService;
+    private final OrdersService ordersService;
 
-    public OrderController(final OrderService orderService) {
-        this.orderService = orderService;
+    public OrderController(final OrdersService ordersService) {
+        this.ordersService = ordersService;
     }
 
     @PostMapping
-    public ResponseEntity<Void> addOrder(@CustomerId final Long customerId,
-                                         @RequestBody final List<OrderRequest> orderDetails) {
-        final Long orderId = orderService.addOrder(orderDetails, customerId);
+    public ResponseEntity<Void> addOrder(@CustomerId Long customerId, @RequestBody List<OrdersRequest> orderDetails) {
+        Long orderId = ordersService.addOrder(orderDetails, customerId);
         return ResponseEntity.created(URI.create("/api/customers/orders/" + orderId)).build();
     }
 
     @GetMapping("/{orderId}")
-    public ResponseEntity<OrderResponse> findOrder(@CustomerId final Long customerId,
-                                                   @PathVariable final Long orderId) {
-        OrderResponse orderResponse = orderService.findOrderById(customerId, orderId);
-        return ResponseEntity.ok(orderResponse);
+    public ResponseEntity<OrdersResponse> findOrder(@CustomerId Long customerId, @PathVariable Long orderId) {
+        OrdersResponse ordersResponse = ordersService.findOrdersById(customerId, orderId);
+        return ResponseEntity.ok(ordersResponse);
     }
 
     @GetMapping
-    public ResponseEntity<List<OrderResponse>> findOrders(@CustomerId final Long customerId) {
-        List<OrderResponse> orderResponses = orderService.findOrdersByCustomerId(customerId);
-        return ResponseEntity.ok(orderResponses);
+    public ResponseEntity<List<OrdersResponse>> findOrders(@CustomerId Long customerId) {
+        List<OrdersResponse> ordersResponses = ordersService.findOrdersByCustomerId(customerId);
+        return ResponseEntity.ok(ordersResponses);
     }
 }

src/main/java/woowacourse/shoppingcart/controller/ProductController.java

@@ -22,7 +22,7 @@ public class ProductController {
 
     private final ProductService productService;
 
-    public ProductController(final ProductService productService) {
+    public ProductController(ProductService productService) {
         this.productService = productService;
     }
 
@@ -32,22 +32,22 @@ public ResponseEntity<List<Product>> products() {
     }
 
     @PostMapping
-    public ResponseEntity<Void> add(@Validated(Request.allProperties.class) @RequestBody final Product product) {
-        final Long productId = productService.addProduct(product);
-        final URI uri = ServletUriComponentsBuilder
+    public ResponseEntity<Void> add(@Validated(Request.allProperties.class) @RequestBody Product product) {
+        Long productId = productService.addProduct(product);
+        URI uri = ServletUriComponentsBuilder
                 .fromCurrentRequest()
                 .path("/" + productId)
                 .build().toUri();
         return ResponseEntity.created(uri).build();
     }
 
     @GetMapping("/{productId}")
-    public ResponseEntity<Product> product(@PathVariable final Long productId) {
+    public ResponseEntity<Product> product(@PathVariable Long productId) {
         return ResponseEntity.ok(productService.findProductById(productId));
     }
 
     @DeleteMapping("/{productId}")
-    public ResponseEntity<Void> delete(@PathVariable final Long productId) {
+    public ResponseEntity<Void> delete(@PathVariable Long productId) {
         productService.deleteProductById(productId);
         return ResponseEntity.noContent().build();
     }

src/main/java/woowacourse/shoppingcart/dao/AddressDao.java

@@ -1,13 +1,14 @@
 package woowacourse.shoppingcart.dao;
 
+import java.util.Optional;
 import woowacourse.shoppingcart.entity.AddressEntity;
 
 public interface AddressDao {
-    void save(AddressEntity addressEntity);
+    void save(long customerId, AddressEntity addressEntity);
 
-    AddressEntity findById(int id);
+    Optional<AddressEntity> findById(long customerId);
 
-    void update(AddressEntity addressEntity);
+    void update(long customerId, AddressEntity addressEntity);
 
-    void delete(int customerId);
+    void delete(long customerId);
 }

src/main/java/woowacourse/shoppingcart/dao/CartItemDao.java

@@ -1,11 +1,12 @@
 package woowacourse.shoppingcart.dao;
 
 import java.util.List;
+import java.util.Optional;
 import woowacourse.shoppingcart.domain.CartItem;
 import woowacourse.shoppingcart.entity.CartItemEntity;
 
 public interface CartItemDao {
-    CartItemEntity findById(Long cartItemId);
+    Optional<CartItemEntity> findById(Long cartItemId);
 
     List<CartItemEntity> findAllByCustomerId(Long customerId);
 

src/main/java/woowacourse/shoppingcart/dao/CustomerDao.java

@@ -1,17 +1,18 @@
 package woowacourse.shoppingcart.dao;
 
+import java.util.Optional;
 import woowacourse.shoppingcart.entity.CustomerEntity;
 
 public interface CustomerDao {
-    int save(CustomerEntity customerEntity);
+    long save(CustomerEntity customerEntity);
 
-    CustomerEntity findById(int id);
+    Optional<CustomerEntity> findById(long id);
 
-    CustomerEntity findByEmail(String email);
+    Optional<CustomerEntity> findByEmail(String email);
 
-    void update(int id, CustomerEntity customerEntity);
+    void update(long id, CustomerEntity customerEntity);
 
-    void delete(int id);
+    void delete(long id);
 
     boolean existsById(long id);