[jinyoungchoi95-issue16] 현재 유저 정보 반환 및 업데이트 기능 구현

build.gradle

@@ -24,6 +24,8 @@ dependencies {
     implementation 'org.springframework.boot:spring-boot-starter-web'
     implementation 'org.springframework.boot:spring-boot-starter-validation'
     implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
+    implementation group: 'com.google.guava', name: 'guava', version: '30.1.1-jre'
+    implementation group: 'org.apache.commons', name: 'commons-lang3', version: '3.12.0'
     runtimeOnly 'com.h2database:h2'
     testImplementation 'org.springframework.boot:spring-boot-starter-test'
     testImplementation 'org.springframework.security:spring-security-test'

src/main/java/com/study/realworld/user/controller/UserController.java

@@ -5,13 +5,18 @@
 import com.study.realworld.security.JwtService;
 import com.study.realworld.user.controller.request.UserJoinRequest;
 import com.study.realworld.user.controller.request.UserLoginRequest;
+import com.study.realworld.user.controller.request.UserUpdateRequest;
 import com.study.realworld.user.controller.response.UserResponse;
 import com.study.realworld.user.domain.Email;
 import com.study.realworld.user.domain.Password;
 import com.study.realworld.user.domain.User;
 import com.study.realworld.user.service.UserService;
 import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
@@ -44,4 +49,25 @@ public ResponseEntity<UserResponse> login(@RequestBody UserLoginRequest request)
             .body(fromUserAndToken(user, jwtService.createToken(user)));
     }
 
+    @GetMapping("/user")
+    public ResponseEntity<UserResponse> getCurrentUser(@AuthenticationPrincipal Long loginId) {
+        User user = userService
+            .findById(loginId).orElseThrow(RuntimeException::new);   // 임시
+        return ResponseEntity.ok()
+            .body(fromUserAndToken(user, getTokenByContextHolder()));
+    }
+
+    @PutMapping("/user")
+    public ResponseEntity<UserResponse> update(@RequestBody UserUpdateRequest request,
+        @AuthenticationPrincipal Long loginId) {
+        User user = userService
+            .update(request.toUserUpdateModel(), loginId);
+        return ResponseEntity.ok()
+            .body(fromUserAndToken(user, getTokenByContextHolder()));
+    }
+
+    private String getTokenByContextHolder() {
+        return SecurityContextHolder.getContext().getAuthentication().getCredentials().toString();
+    }
+
 }

src/main/java/com/study/realworld/user/controller/request/UserUpdateRequest.java

@@ -0,0 +1,64 @@
+package com.study.realworld.user.controller.request;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import com.fasterxml.jackson.annotation.JsonTypeName;
+import com.study.realworld.user.domain.Email;
+import com.study.realworld.user.domain.Password;
+import com.study.realworld.user.domain.Username;
+import com.study.realworld.user.service.model.UserUpdateModel;
+import java.util.Optional;
+
+@JsonTypeName(value = "user")
+@JsonTypeInfo(include = JsonTypeInfo.As.WRAPPER_OBJECT, use = JsonTypeInfo.Id.NAME)
+public class UserUpdateRequest {
+
+    @JsonProperty("username")
+    private String username;
+
+    @JsonProperty("email")
+    private String email;
+
+    @JsonProperty("password")
+    private String password;
+
+    @JsonProperty("bio")
+    private String bio;
+
+    @JsonProperty("image")
+    private String image;
+
+    protected UserUpdateRequest() {
+    }
+
+    public String getUsername() {
+        return username;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public String getBio() {
+        return bio;
+    }
+
+    public String getImage() {
+        return image;
+    }
+
+    public UserUpdateModel toUserUpdateModel() {
+        return new UserUpdateModel(
+            Optional.ofNullable(getUsername()).map(Username::new).orElse(null),
+            Optional.ofNullable(getEmail()).map(Email::new).orElse(null),
+            Optional.ofNullable(getPassword()).map(Password::new).orElse(null),
+            getBio(),
+            getImage()
+        );
+    }
+
+}

src/main/java/com/study/realworld/user/controller/response/UserResponse.java

@@ -61,8 +61,8 @@ public static UserResponse fromUserAndToken(User user, String accessToken) {
         return new UserResponse(
             valueOf(user.getUsername()),
             valueOf(user.getEmail()),
-            valueOf(user.getBio()),
-            valueOf(user.getImage()),
+            user.getBio(),
+            user.getImage(),
             valueOf(accessToken)
         );
     }

src/main/java/com/study/realworld/user/domain/Password.java

@@ -1,27 +1,37 @@
 package com.study.realworld.user.domain;
 
-import org.springframework.security.crypto.password.PasswordEncoder;
+import static com.google.common.base.Preconditions.checkArgument;
 
 import javax.persistence.Column;
 import javax.persistence.Embeddable;
 import javax.validation.constraints.NotBlank;
 import javax.validation.constraints.Size;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.security.crypto.password.PasswordEncoder;
 
 @Embeddable
 public class Password {
 
-    @NotBlank(message = "password must be provided.")
-    @Size(min = 6, max = 20, message = "password length must be between 6 and 20 characters.")
     @Column(name = "password", nullable = false)
     private String password;
 
     protected Password() {
     }
 
     public Password(String password) {
+        checkPassword(password);
+
         this.password = password;
     }
 
+    private static void checkPassword(String password) {
+        checkArgument(StringUtils.isNotBlank(password), "password must be provided.");
+        checkArgument(
+            password.length() >= 6 && password.length() <= 20,
+            "password length must be between 6 and 20 characters."
+        );
+    }
+
     public String getPassword() {
         return password;
     }
@@ -32,7 +42,7 @@ public static Password encode(Password password, PasswordEncoder passwordEncoder
 
     public void matchPassword(Password rawPassword, PasswordEncoder passwordEncoder) {
         if (!passwordEncoder.matches(rawPassword.password, this.password)) {
-            throw new RuntimeException("비밀번호가 다릅니다.");
+            throw new RuntimeException("password is different from old password.");
         }
     }
 

src/main/java/com/study/realworld/user/domain/User.java

@@ -70,6 +70,26 @@ public String getImage() {
         return image;
     }
 
+    public void changeUsername(Username username) {
+        this.username = username;
+    }
+
+    public void changeEmail(Email email) {
+        this.email = email;
+    }
+
+    public void changePassword(Password password) {
+        this.password = password;
+    }
+
+    public void changeBio(String bio) {
+        this.bio = bio;
+    }
+
+    public void changeImage(String image) {
+        this.image = image;
+    }
+
     public void encodePassword(PasswordEncoder passwordEncoder) {
         this.password = Password.encode(this.password, passwordEncoder);
     }

src/main/java/com/study/realworld/user/service/UserService.java

@@ -5,6 +5,7 @@
 import com.study.realworld.user.domain.User;
 import com.study.realworld.user.domain.UserRepository;
 import com.study.realworld.user.domain.Username;
+import com.study.realworld.user.service.model.UserUpdateModel;
 import java.util.Optional;
 import javax.validation.Valid;
 import org.springframework.security.crypto.password.PasswordEncoder;
@@ -26,7 +27,8 @@ public UserService(UserRepository userRepository, PasswordEncoder passwordEncode
 
     @Transactional
     public User join(@Valid User user) {
-        checkDuplicatedByUsernameOrEmail(user.getUsername(), user.getEmail());
+        checkDuplicatedByUsername(user.getUsername());
+        checkDuplicatedByEmail(user.getEmail());
 
         user.encodePassword(passwordEncoder);
         return userRepository.save(user);
@@ -39,11 +41,55 @@ public User login(@Valid Email email, @Valid Password password) {
         return user;
     }
 
-    private void checkDuplicatedByUsernameOrEmail(Username username, Email email) {
+    @Transactional(readOnly = true)
+    public Optional<User> findById(Long userId) {
+        return userRepository.findById(userId);
+    }
+
+    @Transactional
+    public User update(UserUpdateModel updateUser, Long userId) {
+        User user = userRepository.findById(userId).orElseThrow(RuntimeException::new);
+
+        updateUser.getUsername()
+            .filter(username -> !user.getUsername().equals(username))
+            .ifPresent(
+                username -> {
+                    checkDuplicatedByUsername(username);
+                    user.changeUsername(username);
+                });
+        updateUser.getEmail()
+            .filter(email -> !user.getEmail().equals(email))
+            .ifPresent(
+                email -> {
+                    checkDuplicatedByEmail(email);
+                    user.changeEmail(email);
+                });
+        updateUser.getPassword()
+            .filter(
+                password -> !passwordEncoder
+                    .matches(password.getPassword(), user.getPassword().getPassword()))
+            .ifPresent(
+                password -> {
+                    user.changePassword(Password.encode(password, passwordEncoder));
+                });
+        updateUser.getBio()
+            .filter(bio -> !user.getBio().equals(bio))
+            .ifPresent(user::changeBio);
+        updateUser.getImage()
+            .filter(image -> !user.getImage().equals(image))
+            .ifPresent(user::changeImage);
+
+        return user;
+    }
+
+    private void checkDuplicatedByUsername(@Valid Username username) {
         findByUsername(username)
             .ifPresent(param -> {
                 throw new RuntimeException("already user username");
             });
+    }
+
+    private void checkDuplicatedByEmail(@Valid Email email) {
         findByEmail(email)
             .ifPresent(param -> {
                 throw new RuntimeException("already user email");

src/main/java/com/study/realworld/user/service/model/UserUpdateModel.java

@@ -0,0 +1,45 @@
+package com.study.realworld.user.service.model;
+
+import com.study.realworld.user.domain.Email;
+import com.study.realworld.user.domain.Password;
+import com.study.realworld.user.domain.Username;
+import java.util.Optional;
+
+public class UserUpdateModel {
+
+    private final Username username;
+    private final Email email;
+    private final Password password;
+    private final String bio;
+    private final String image;
+
+    public UserUpdateModel(Username username, Email email, Password password, String bio,
+        String image) {
+        this.username = username;
+        this.email = email;
+        this.password = password;
+        this.bio = bio;
+        this.image = image;
+    }
+
+    public Optional<Username> getUsername() {
+        return Optional.ofNullable(username);
+    }
+
+    public Optional<Email> getEmail() {
+        return Optional.ofNullable(email);
+    }
+
+    public Optional<Password> getPassword() {
+        return Optional.ofNullable(password);
+    }
+
+    public Optional<String> getBio() {
+        return Optional.ofNullable(bio);
+    }
+
+    public Optional<String> getImage() {
+        return Optional.ofNullable(image);
+    }
+
+}