Change to api server

src/main/java/demo/api/auth/AuthController.java

@@ -1,63 +1,31 @@
 package demo.api.auth;
 
+import demo.api.auth.dtos.SignUpRes;
 import demo.api.jwt.dtos.TokenDto;
-import demo.api.user.domain.User;
+import demo.api.auth.dtos.SignInReq;
-import demo.api.user.dtos.UserSignInRequest;
+import demo.api.auth.dtos.SignUpReq;
-import demo.api.user.dtos.UserSignUpRequest;
-import java.util.Objects;
-import javax.servlet.http.Cookie;
 import javax.servlet.http.HttpServletResponse;
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Controller;
-import org.springframework.ui.Model;
 import org.springframework.validation.annotation.Validated;
-import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
 
-@Controller
+@RestController
 @RequestMapping("/auth")
 @RequiredArgsConstructor
 public class AuthController {
   private final AuthService authService;
 
-  @GetMapping("/signUp")
-  public String signUp() {
-    return "user/signUp";
-  }
-
   @PostMapping("/signUp")
-  public String signUp(@Validated UserSignUpRequest signUpReq) throws Exception {
+  public SignUpRes signUp(@Validated SignUpReq signUpReq) {
-    User user = authService.signUp(signUpReq);
+    return authService.signUp(signUpReq);
-
-    if(!Objects.isNull(user)) {
-      return "redirect:/user/signIn";
-    }
-
-    return "redirect:/user/signUp";
-  }
-
-  @GetMapping("/signIn")
-  public String signIn(@RequestParam(value = "fail", required = false) String flag, Model model) {
-    model.addAttribute("failed", flag != null);
-
-    return "user/signIn";
   }
 
   @PostMapping("/signIn")
-  public String signIn(@Validated UserSignInRequest signInReq, HttpServletResponse res) {
+  public ResponseEntity<TokenDto> signIn(@Validated SignInReq signInReq, HttpServletResponse res) {
-    ResponseEntity<TokenDto> tokenDtoResponseEntity = authService.signIn(signInReq);
+    return authService.signIn(signInReq);
-    Cookie cookie = new Cookie(
-        "access_token",
-        tokenDtoResponseEntity.getBody().getAccess_token()
-    );
-
-    cookie.setPath("/");
-    cookie.setMaxAge(Integer.MAX_VALUE);
-
-    res.addCookie(cookie);
-    return "redirect:/user/profile";
   }
 }

src/main/java/demo/api/auth/AuthService.java

@@ -1,9 +1,9 @@
 package demo.api.auth;
 
+import demo.api.auth.dtos.SignUpRes;
 import demo.api.jwt.dtos.TokenDto;
-import demo.api.user.domain.User;
+import demo.api.auth.dtos.SignInReq;
-import demo.api.user.dtos.UserSignInRequest;
+import demo.api.auth.dtos.SignUpReq;
-import demo.api.user.dtos.UserSignUpRequest;
 import org.springframework.http.ResponseEntity;
 
 public interface AuthService {
@@ -12,12 +12,12 @@ public interface AuthService {
    * @param signUpReq 가입할 유저의 정보 Dto
    * @return 가입된 유저 정보
    */
-  User signUp(UserSignUpRequest signUpReq) throws Exception;
+  SignUpRes signUp(SignUpReq signUpReq);
 
   /**
    * 유저 정보로 로그인
    * @param signInReq 유저의 이메일과 비밀번호
    * @return json web token
    */
-  ResponseEntity<TokenDto> signIn(UserSignInRequest signInReq);
+  ResponseEntity<TokenDto> signIn(SignInReq signInReq);
 }

src/main/java/demo/api/auth/AuthServiceImpl.java

@@ -1,14 +1,14 @@
 package demo.api.auth;
 
+import demo.api.auth.dtos.SignUpRes;
 import demo.api.exception.CustomException;
-import demo.api.jwt.JwtTokenFilter;
 import demo.api.jwt.JwtTokenProvider;
 import demo.api.jwt.dtos.TokenDto;
 import demo.api.user.domain.User;
-import demo.api.user.dtos.UserSignInRequest;
+import demo.api.auth.dtos.SignInReq;
-import demo.api.user.dtos.UserSignUpRequest;
+import demo.api.auth.dtos.SignUpReq;
 import demo.api.user.repository.UserRepository;
-import java.util.Optional;
+import java.util.Objects;
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpStatus;
@@ -31,19 +31,24 @@ public class AuthServiceImpl implements AuthService {
 
   @Override
   @Transactional
-  public User signUp(UserSignUpRequest signUpReq) throws Exception {
+  public SignUpRes signUp(SignUpReq signUpReq){
     System.out.println("signUpReq = " + signUpReq.toString());
 
     if(userRepository.existsByEmail(signUpReq.getEmail())) {
-      throw new Exception("Your Mail already Exist.");
+      return new SignUpRes(false, "Your Mail already Exist.");
     }
     User newUser = signUpReq.toUserEntity();
     newUser.hashPassword(bCryptPasswordEncoder);
-    return userRepository.save(newUser);
+
+    User user = userRepository.save(newUser);
+    if(!Objects.isNull(user)) {
+      return new SignUpRes(true, null);
+    }
+    return new SignUpRes(false, "Fail to Sign Up");
   }
 
   @Override
-  public ResponseEntity<TokenDto> signIn(UserSignInRequest signInReq) {
+  public ResponseEntity<TokenDto> signIn(SignInReq signInReq) {
     try {
       Authentication authentication = authenticationManager.authenticate(
           new UsernamePasswordAuthenticationToken(

src/main/java/demo/api/auth/dtos/SignInReq.java

@@ -1,16 +1,14 @@
-package demo.api.user.dtos;
+package demo.api.auth.dtos;
 
-import demo.api.user.domain.User;
 import javax.validation.constraints.Email;
 import javax.validation.constraints.NotEmpty;
 import lombok.Builder;
 import lombok.Getter;
-import lombok.Setter;
 import lombok.ToString;
 
 @Getter
 @ToString
-public class UserSignInRequest {
+public class SignInReq {
   @NotEmpty(message = "Please enter your Email")
   @Email
   private String email;
@@ -18,7 +16,7 @@ public class UserSignInRequest {
   private String password;
 
   @Builder
-  public UserSignInRequest(String email, String password) {
+  public SignInReq(String email, String password) {
     this.email = email;
     this.password = password;
   }

src/main/java/demo/api/auth/dtos/SignUpReq.java

@@ -1,16 +1,15 @@
-package demo.api.user.dtos;
+package demo.api.auth.dtos;
 
 import demo.api.user.domain.User;
 import javax.validation.constraints.Email;
 import javax.validation.constraints.NotEmpty;
 import lombok.Builder;
 import lombok.Getter;
-import lombok.Setter;
 import lombok.ToString;
 
 @Getter
 @ToString
-public class UserSignUpRequest {
+public class SignUpReq {
   @NotEmpty(message = "Please enter your Email")
   @Email
   private String email;
@@ -20,7 +19,7 @@ public class UserSignUpRequest {
   private String name;
 
   @Builder
-  public UserSignUpRequest(String email, String password, String name) {
+  public SignUpReq(String email, String password, String name) {
     this.email = email;
     this.password = password;
     this.name = name;

src/main/java/demo/api/auth/dtos/SignUpRes.java

@@ -0,0 +1,17 @@
+package demo.api.auth.dtos;
+
+import demo.api.common.dtos.CoreRes;
+import javax.validation.constraints.Email;
+import javax.validation.constraints.NotEmpty;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.ToString;
+
+
+@Getter
+public class SignUpRes extends CoreRes {
+  public SignUpRes(boolean ok, String error) {
+    super(ok, error);
+  }
+}

src/main/java/demo/api/common/dtos/CoreRes.java

@@ -0,0 +1,11 @@
+package demo.api.common.dtos;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class CoreRes {
+  private boolean ok;
+  private String error;
+}

src/main/java/demo/api/config/SecurityConfig.java

@@ -49,6 +49,7 @@ public class SecurityConfig {
             "/auth/signUp",
             "/user/userList",
             "/auth/signIn*",
+            "/user/profile/user/*",
             "/favicon.ico"
         ).permitAll()
         .anyRequest().authenticated();

src/main/java/demo/api/user/UserController.java

@@ -1,7 +1,8 @@
 package demo.api.user;
 
 import demo.api.user.domain.User;
-import demo.api.user.dtos.UserSignUpRequest;
+import demo.api.user.dtos.ProfileDto.ProfileReq;
+import demo.api.user.dtos.ProfileDto.ProfileRes;
 import demo.api.user.exception.UserNotFoundException;
 import java.util.List;
 import lombok.RequiredArgsConstructor;
@@ -9,49 +10,46 @@ import org.springframework.security.core.annotation.AuthenticationPrincipal;
 import org.springframework.security.core.userdetails.UserDetails;
 import org.springframework.stereotype.Controller;
 import org.springframework.ui.Model;
-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.PostMapping;
 import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
 
 /**
  * User 관련 HTTP 요청 처리
  */
-@Controller
+@RestController
 @RequestMapping("/user")
 @RequiredArgsConstructor
 public class UserController {
   private final UserService userService;
 
   @GetMapping("/profile")
-  public String profile(Model model, @AuthenticationPrincipal UserDetails userDetails) {
+  public ProfileRes profile(@AuthenticationPrincipal UserDetails userDetails) {
     System.out.println("userDetails = " + userDetails);
-    if (userDetails != null) {
     User userDetail = userService.findByEmail(userDetails.getUsername())
         .orElseThrow(() -> new UserNotFoundException());
 
-      model.addAttribute("userDetail", userDetail);
+    return ProfileRes.builder()
+        .email(userDetail.getEmail())
+        .name(userDetail.getName())
+        .build();
   }
 
-    return "user/profile";
+  @GetMapping("/profile/user/{username}")
-  }
+  public ProfileRes userProfile(@PathVariable ProfileReq username) {
+    System.out.println("username.toString() = " + username.toString());
+    User user = userService.findByName(username.getName())
+        .orElseThrow(UserNotFoundException::new);
 
-  @GetMapping("/profile/{username}")
+    return ProfileRes.builder()
-  public String userProfile(Model model, @PathVariable String username) {
+        .email(user.getEmail())
-    User user = userService.findByName(username)
+        .name(user.getName())
-        .orElseThrow(() -> new UserNotFoundException());
+        .build();
-    model.addAttribute("userDetail", user);
-
-    return "user/profile";
   }
 
   @GetMapping("/userList")
-  public String showUserList(Model model) {
+  public List<User> showUserList(Model model) {
-    List<User> userList = userService.findAll();
+    return userService.findAll();
-    model.addAttribute("userList", userList);
-
-    return "user/userList";
   }
 }

src/main/java/demo/api/user/UserService.java

@@ -1,7 +1,6 @@
 package demo.api.user;
 
 import demo.api.user.domain.User;
-import demo.api.user.dtos.UserSignUpRequest;
 import java.util.List;
 import java.util.Optional;
 

src/main/java/demo/api/user/UserServiceImpl.java

@@ -29,26 +29,6 @@ public class UserServiceImpl implements UserService {
     return userRepository.findByName(name);
   }
 
-//  @Override
-//  public Optional<User> getMyInfo() {
-//    Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
-//    String username = null;
-//
-//    if (authentication == null) {
-//      log.debug("Security Context에 인증 정보가 없습니다.");
-//      return Optional.empty();
-//    }
-//
-//    if (authentication.getPrincipal() instanceof UserDetails) {
-//      UserDetails springSecurityUserInfo = (UserDetails) authentication.getPrincipal();
-//      username = springSecurityUserInfo.getUsername();
-//    } else if (authentication.getPrincipal() instanceof String) {
-//      username = (String) authentication.getPrincipal();
-//    }
-//
-//    return Optional.ofNullable(userRepository.findByName(username).orElse(null));
-//  }
-
   @Override
   public User updateUser(User user, String newInfo) {
     return null;

src/main/java/demo/api/user/domain/User.java

@@ -23,7 +23,7 @@ public class User extends CoreEntity {
   private String email;
   @Column(nullable = false)
   private String password;
-  @Column(length = 10, nullable = false)
+  @Column(length = 10, nullable = false, unique = true)
   private String name;
 
 //  @Enumerated(EnumType.STRING)

src/main/java/demo/api/user/dtos/ProfileDto.java

@@ -0,0 +1,19 @@
+package demo.api.user.dtos;
+
+import lombok.Builder;
+import lombok.Data;
+
+public class ProfileDto {
+  @Data
+  @Builder
+  public static class ProfileReq {
+    private String name;
+  }
+
+  @Data
+  @Builder
+  public static class ProfileRes {
+    private String email;
+    private String name;
+  }
+}

src/test/java/demo/api/auth/service/AuthServiceTest.java

@@ -0,0 +1,91 @@
+package demo.api.auth.service;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import demo.api.auth.AuthService;
+import demo.api.auth.dtos.SignInReq;
+import demo.api.auth.dtos.SignUpReq;
+import demo.api.auth.dtos.SignUpRes;
+import demo.api.jwt.dtos.TokenDto;
+import demo.api.user.UserService;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.transaction.annotation.Transactional;
+
+@SpringBootTest
+@Transactional
+@DisplayName("Auth Service Test")
+class AuthServiceTest {
+  private static final String EMAIL = "test@email.com";
+  private static final String PASSWORD = "12345";
+  private static final String NAME = "김정호";
+
+  @Autowired
+  private PasswordEncoder bCryptPasswordEncoder;
+  @Autowired
+  private UserService userService;
+  @Autowired
+  private AuthService authService;
+
+  @Test
+  @DisplayName("유저 회원가입")
+  void signUp() {
+    // given
+    SignUpReq user = createSignUpRequest();
+    System.out.println("user = " + user.toString());
+
+    // when
+    SignUpRes signUpRes = authService.signUp(user);
+
+    // then
+    assertThat(signUpRes.isOk()).isEqualTo(true);
+  }
+
+  @Test
+  @DisplayName("유저 로그인")
+  void signIn() {
+    // given
+    SignUpReq user = createSignUpRequest();
+    System.out.println("user = " + user.toString());
+    authService.signUp(user);
+
+    // when
+    ResponseEntity<TokenDto> response = authService.signIn(createSignInRequest());
+
+    // then
+    assertThat(response.getBody().getAccess_token()).isNotEmpty();
+  }
+
+  @Test
+  @DisplayName("비밀번호는 암호화되어야 한다.")
+  void hashPassword() {
+    // given
+    SignUpReq user = createSignUpRequest();
+
+    // when
+    SignUpRes signUpRes  = authService.signUp(user);
+
+    // then
+//    System.out.println("newUser pw = " + newUser.getPassword());
+//    assertThat(newUser.getPassword()).isNotEqualTo(PASSWORD);
+  }
+
+  private SignUpReq createSignUpRequest() {
+    return SignUpReq.builder()
+        .email(EMAIL)
+        .password(PASSWORD)
+        .name(NAME)
+        .build();
+  }
+
+  private SignInReq createSignInRequest() {
+    return SignInReq.builder()
+        .email(EMAIL)
+        .password(PASSWORD)
+        .build();
+  }
+}

src/test/java/demo/api/user/service/UserServiceTest.java

@@ -1,13 +1,14 @@
 package demo.api.user.service;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.InstanceOfAssertFactories.completableFuture;
 import static org.junit.jupiter.api.Assertions.*;
 
 import demo.api.auth.AuthService;
+import demo.api.auth.dtos.SignUpRes;
 import demo.api.user.UserService;
 import demo.api.user.domain.User;
-import demo.api.user.dtos.UserSignUpRequest;
+import demo.api.auth.dtos.SignUpReq;
-import demo.api.user.repository.UserRepository;
 import java.util.List;
 import java.util.Optional;
 import org.junit.jupiter.api.DisplayName;
@@ -32,57 +33,13 @@ class UserServiceTest {
   @Autowired
   private AuthService authService;
 
-  @Test
-  @DisplayName("유저 회원가입")
-  void signUp() throws Exception {
-    // given
-    UserSignUpRequest user = createSignUpRequest();
-    System.out.println("user = " + user.toString());
-
-    // when
-    User newUser = authService.signUp(user);
-
-    // then
-    System.out.println("newUser = " + newUser.toString());
-    assertThat(newUser.getEmail()).isEqualTo(EMAIL);
-  }
-
-  @Test
-  @DisplayName("비밀번호는 암호화되어야 한다.")
-  void hashPassword() throws Exception {
-    // given
-    UserSignUpRequest user = createSignUpRequest();
-
-    // when
-    User newUser = authService.signUp(user);
-
-    // then
-    System.out.println("newUser pw = " + newUser.getPassword());
-    assertThat(newUser.getPassword()).isNotEqualTo(PASSWORD);
-  }
-
-  @Test
-  @DisplayName("유저 로그인")
-  void signIn() throws Exception {
-    // given
-    UserSignUpRequest user = createSignUpRequest();
-    System.out.println("user = " + user.toString());
-    User newUser = authService.signUp(user);
-
-    // when
-    boolean flag = newUser.checkPassword(PASSWORD, bCryptPasswordEncoder);
-    System.out.println("flag = " + flag);
-
-    // then
-  }
-
   @Test
   @DisplayName("모든 유저 리스트를 반환")
-  void findAll() throws Exception {
+  void findAll() {
     // given
     List<User> prevUserList = userService.findAll();
     int prevLen = prevUserList.size();
-    UserSignUpRequest user1 = createSignUpRequest();
+    SignUpReq user1 = createSignUpRequest();
     authService.signUp(user1);
 
     // when
@@ -94,9 +51,9 @@ class UserServiceTest {
 
   @Test
   @DisplayName("이메일로 유저 찾기")
-  void findByEmail() throws Exception {
+  void findByEmail() {
     // given
-    UserSignUpRequest user1 = createSignUpRequest();
+    SignUpReq user1 = createSignUpRequest();
     authService.signUp(user1);
 
     // when
@@ -110,8 +67,8 @@ class UserServiceTest {
   void updateUser() {
   }
 
-  private UserSignUpRequest createSignUpRequest() {
+  private SignUpReq createSignUpRequest() {
-    return UserSignUpRequest.builder()
+    return SignUpReq.builder()
         .email(EMAIL)
         .password(PASSWORD)
         .name(NAME)