[volume-1] 회원가입, 내 정보 조회, 비밀번호 변경 기능 구현

apps/commerce-api/build.gradle.kts

@@ -8,6 +8,7 @@ dependencies {
 
     // web
     implementation("org.springframework.boot:spring-boot-starter-web")
+    implementation("org.springframework.security:spring-security-crypto")
     implementation("org.springframework.boot:spring-boot-starter-actuator")
     implementation("org.springdoc:springdoc-openapi-starter-webmvc-ui:${project.properties["springDocOpenApiVersion"]}")
 

apps/commerce-api/src/main/java/com/loopers/application/user/AuthUserPrincipal.java

@@ -0,0 +1,23 @@
+package com.loopers.application.user;
+
+import com.loopers.domain.user.UserModel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+/**
+ * 인증된 사용자의 식별 정보. 컨트롤러에서 "현재 사용자"를 식별하는 용도로 사용한다.
+ */
+@Getter
+@AllArgsConstructor
+public class AuthUserPrincipal {
+
+    private final Long id;
+    private final String loginId;
+
+    public static AuthUserPrincipal from(UserModel user) {
+        return new AuthUserPrincipal(
+            user.getId(),
+            user.getLoginId()
+        );
+    }
+}

apps/commerce-api/src/main/java/com/loopers/application/user/SignUpCommand.java

@@ -0,0 +1,16 @@
+package com.loopers.application.user;
+
+import java.time.LocalDate;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+@Getter
+@RequiredArgsConstructor
+public class SignUpCommand {
+
+    private final String loginId;
+    private final String loginPw;
+    private final LocalDate birthDate;
+    private final String name;
+    private final String email;
+}

apps/commerce-api/src/main/java/com/loopers/application/user/UserFacade.java

@@ -0,0 +1,35 @@
+package com.loopers.application.user;
+
+import com.loopers.domain.user.UserModel;
+import com.loopers.domain.user.UserService;
+import com.loopers.interfaces.user.ChangePasswordRequest;
+import lombok.AllArgsConstructor;
+import org.springframework.stereotype.Component;
+
+@Component
+@AllArgsConstructor
+public class UserFacade {
+
+    private final UserService userService;
+
+    public UserInfo signUp(SignUpCommand command) {
+        UserModel userModel = userService.createUser(
+            command.getLoginId(),
+            command.getLoginPw(),
+            command.getBirthDate(),
+            command.getName(),
+            command.getEmail()
+        );
+
+        return UserInfo.from(userModel);
+    }
+
+    public UserInfo getMyInfo(Long userId) {
+        UserModel user = userService.findById(userId);
+        return UserInfo.from(user);
+    }
+
+    public void changePassword(Long userId, ChangePasswordRequest request) {
+        userService.changePassword(userId, request.currentPassword(), request.newPassword());
+    }
+}

apps/commerce-api/src/main/java/com/loopers/application/user/UserInfo.java

@@ -0,0 +1,17 @@
+package com.loopers.application.user;
+
+import com.loopers.domain.user.UserModel;
+import java.time.LocalDate;
+
+public record UserInfo(Long id, String loginId, String name, String email, LocalDate birthDate) {
+
+    public static UserInfo from(UserModel userModel) {
+        return new UserInfo(
+            userModel.getId(),
+            userModel.getLoginId(),
+            userModel.getName(),
+            userModel.getEmail(),
+            userModel.getBirthDate()
+        );
+    }
+}

apps/commerce-api/src/main/java/com/loopers/config/PasswordEncoderConfig.java

@@ -0,0 +1,15 @@
+package com.loopers.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.security.crypto.password.PasswordEncoder;
+
+@Configuration
+public class PasswordEncoderConfig {
+
+    @Bean
+    public PasswordEncoder passwordEncoder() {
+        return new BCryptPasswordEncoder();
+    }
+}

apps/commerce-api/src/main/java/com/loopers/config/WebMvcConfig.java

@@ -0,0 +1,23 @@
+package com.loopers.config;
+
+import com.loopers.interfaces.api.AuthUserArgumentResolver;
+import com.loopers.interfaces.api.CredentialsHeadersArgumentResolver;
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.method.support.HandlerMethodArgumentResolver;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+@Configuration
+@RequiredArgsConstructor
+public class WebMvcConfig implements WebMvcConfigurer {
+
+    private final CredentialsHeadersArgumentResolver credentialsHeadersArgumentResolver;
+    private final AuthUserArgumentResolver authUserArgumentResolver;
+
+    @Override
+    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
+        resolvers.add(credentialsHeadersArgumentResolver);
+        resolvers.add(authUserArgumentResolver);
+    }
+}

apps/commerce-api/src/main/java/com/loopers/domain/user/UserModel.java

@@ -0,0 +1,80 @@
+package com.loopers.domain.user;
+
+import com.loopers.domain.BaseEntity;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import java.time.LocalDate;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import org.hibernate.annotations.Comment;
+
+@Entity
+@Table(name = "users")
+@NoArgsConstructor
+@Getter
+public class UserModel extends BaseEntity {
+
+    @Id
+    @GeneratedValue
+    private Long id;
+
+    @Comment("아이디")
+    @Column(name = "login_id", nullable = false)
+    private String loginId;
+
+    @Comment("비밀번호")
+    @Column(name = "password", nullable = false)
+    private String password;
+
+    @Comment("생년월일")
+    @Column(name = "birth", nullable = false)
+    private LocalDate birthDate;
+
+    @Comment("이름")
+    @Column(name = "name", nullable = false)
+    private String name;
+
+    @Comment("이메일")
+    @Column(name = "email", nullable = false)
+    private String email;
+
+    private UserModel(String loginId, String password, LocalDate birthDate, String name, String email) {
+        this.loginId = loginId;
+        this.password = password;
+        this.birthDate = birthDate;
+        this.name = name;
+        this.email = email;
+    }
+
+    @Override
+    protected void guard() {
+        if (loginId == null || loginId.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "로그인 ID는 필수입니다.");
+        }
+        if (password == null || password.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호는 필수입니다.");
+        }
+        if (birthDate == null) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "생년월일은 필수입니다.");
+        }
+        if (name == null || name.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이름은 필수입니다.");
+        }
+        if (email == null || email.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이메일은 필수입니다.");
+        }
+    }
+
+    public static UserModel create(String loginId, String encodedPassword, LocalDate birthDate, String name, String email) {
+        return new UserModel(loginId, encodedPassword, birthDate, name, email);
+    }
+
+    public void changePassword(String newEncodedPassword) {
+        this.password = newEncodedPassword;
+    }
+}

apps/commerce-api/src/main/java/com/loopers/domain/user/UserRepository.java

@@ -0,0 +1,16 @@
+package com.loopers.domain.user;
+
+import java.util.Optional;
+
+public interface UserRepository {
+
+    UserModel save(UserModel userModel);
+
+    Optional<UserModel> findById(Long id);
+
+    Optional<UserModel> findByLoginId(String loginId);
+
+    Boolean existsByEmail(String email);
+
+    Boolean existsByLoginId(String loginId);
+}

apps/commerce-api/src/main/java/com/loopers/domain/user/UserService.java

@@ -0,0 +1,75 @@
+package com.loopers.domain.user;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.transaction.Transactional;
+import java.time.LocalDate;
+import lombok.AllArgsConstructor;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.stereotype.Service;
+
+@Service
+@AllArgsConstructor
+public class UserService {
+
+    private final UserRepository userRepository;
+    private final PasswordEncoder passwordEncoder;
+
+    @Transactional
+    public UserModel createUser(String loginId, String rawPassword, LocalDate birthDate, String name, String email) {
+        if (userRepository.existsByLoginId(loginId)) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이미 사용 중인 아이디입니다.");
+        }
+        if (userRepository.existsByEmail(email)) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이미 가입된 이메일입니다.");
+        }
+        validatePasswordNotContainsBirthDate(rawPassword, birthDate);
+
+        String encodedPassword = passwordEncoder.encode(rawPassword);
+        UserModel user = UserModel.create(loginId, encodedPassword, birthDate, name, email);
+        return userRepository.save(user);
+    }
+
+    public UserModel authenticate(String loginId, String rawPassword) {
+        UserModel user = userRepository.findByLoginId(loginId)
+            .orElseThrow(() -> new CoreException(ErrorType.UNAUTHORIZED, "로그인 정보가 올바르지 않습니다."));
+        if (!passwordEncoder.matches(rawPassword, user.getPassword())) {
+            throw new CoreException(ErrorType.UNAUTHORIZED, "로그인 정보가 올바르지 않습니다.");
+        }
+        return user;
+    }
+
+    public Boolean existsByEmail(String email) {
+        return userRepository.existsByEmail(email);
+    }
+
+    public UserModel findById(Long id) {
+        return userRepository.findById(id)
+            .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "사용자를 찾을 수 없습니다."));
+    }
+
+    @Transactional
+    public void changePassword(Long userId, String currentPassword, String newPassword) {
+        UserModel user = findById(userId);
+
+        if (!passwordEncoder.matches(currentPassword, user.getPassword())) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "기존 비밀번호가 일치하지 않습니다.");
+        }
+
+        if (passwordEncoder.matches(newPassword, user.getPassword())) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "새 비밀번호는 기존 비밀번호와 달라야 합니다.");
+        }
+
+        validatePasswordNotContainsBirthDate(newPassword, user.getBirthDate());
+
+        String newEncodedPassword = passwordEncoder.encode(newPassword);
+        user.changePassword(newEncodedPassword);
+    }
+
+    private void validatePasswordNotContainsBirthDate(String password, LocalDate birthDate) {
+        String birthStr = birthDate.toString().replace("-", "");
+        if (password.contains(birthStr)) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호에 생년월일을 포함할 수 없습니다.");
+        }
+    }
+}

apps/commerce-api/src/main/java/com/loopers/infrastructure/UserJpaRepository.java

@@ -0,0 +1,14 @@
+package com.loopers.infrastructure;
+
+import com.loopers.domain.user.UserModel;
+import java.util.Optional;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface UserJpaRepository extends JpaRepository<UserModel, Long> {
+
+    Boolean existsByEmail(String email);
+
+    Boolean existsByLoginId(String loginId);
+
+    Optional<UserModel> findByLoginId(String loginId);
+}

apps/commerce-api/src/main/java/com/loopers/infrastructure/UserRepositoryImpl.java

@@ -0,0 +1,38 @@
+package com.loopers.infrastructure;
+
+import com.loopers.domain.user.UserModel;
+import com.loopers.domain.user.UserRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+@RequiredArgsConstructor
+@Component
+public class UserRepositoryImpl implements UserRepository {
+
+    private final UserJpaRepository userJpaRepository;
+
+    @Override
+    public UserModel save(UserModel userModel) {
+        return userJpaRepository.save(userModel);
+    }
+
+    @Override
+    public java.util.Optional<UserModel> findById(Long id) {
+        return userJpaRepository.findById(id);
+    }
+
+    @Override
+    public java.util.Optional<UserModel> findByLoginId(String loginId) {
+        return userJpaRepository.findByLoginId(loginId);
+    }
+
+    @Override
+    public Boolean existsByEmail(String email) {
+        return userJpaRepository.existsByEmail(email);
+    }
+
+    @Override
+    public Boolean existsByLoginId(String loginId) {
+        return userJpaRepository.existsByLoginId(loginId);
+    }
+}