diff --git a/src/main/java/com/zerozero/auth/application/AuthorizeOAuthUseCase.java b/src/main/java/com/zerozero/auth/application/AuthorizeOAuthUseCase.java index a0ea520..d3ae080 100644 --- a/src/main/java/com/zerozero/auth/application/AuthorizeOAuthUseCase.java +++ b/src/main/java/com/zerozero/auth/application/AuthorizeOAuthUseCase.java @@ -1,28 +1,28 @@ package com.zerozero.auth.application; -import com.zerozero.auth.exception.AuthenticationErrorCode; -import com.zerozero.auth.infrastructure.oauth.OAuthRestClient; -import com.zerozero.auth.infrastructure.oauth.OAuthRestClientFactory; -import com.zerozero.auth.infrastructure.oauth.common.Provider; -import java.net.URI; +import com.zerozero.auth.exception.AuthErrorType; +import com.zerozero.auth.exception.AuthException; +import com.zerozero.auth.infrastructure.oauth.core.Provider; import lombok.RequiredArgsConstructor; import lombok.extern.log4j.Log4j2; import org.springframework.stereotype.Service; +import java.net.URI; + @Service @RequiredArgsConstructor @Log4j2 public class AuthorizeOAuthUseCase { - private final OAuthRestClientFactory oAuthRestClientFactory; + private final OAuthRestClientFactory oAuthRestClientFactory; - public URI getAuthorizeUrl(String providerName) { - if (providerName == null || providerName.isEmpty()) { - log.error("[AuthorizeOAuthService] Invalid provider name"); - throw AuthenticationErrorCode.NOT_EXIST_PROVIDER.toException(); + public URI getAuthorizeUrl(String providerName) { + if (providerName == null || providerName.isEmpty()) { + log.error("[AuthorizeOAuthService] Invalid provider name"); + throw new AuthException(AuthErrorType.NOT_EXIST_PROVIDER); + } + Provider provider = Provider.valueOf(providerName.toUpperCase()); + OAuthRestClient oAuthRestClient = oAuthRestClientFactory.getOAuthRestClient(provider); + return oAuthRestClient.getAuthUrl(); } - Provider provider = Provider.valueOf(providerName.toUpperCase()); - OAuthRestClient oAuthRestClient = oAuthRestClientFactory.getOAuthRestClient(provider); - return oAuthRestClient.getAuthUrl(); - } } diff --git a/src/main/java/com/zerozero/auth/application/HandleOAuthLoginUseCase.java b/src/main/java/com/zerozero/auth/application/HandleOAuthLoginUseCase.java index 4abe83d..daf8370 100644 --- a/src/main/java/com/zerozero/auth/application/HandleOAuthLoginUseCase.java +++ b/src/main/java/com/zerozero/auth/application/HandleOAuthLoginUseCase.java @@ -1,37 +1,20 @@ package com.zerozero.auth.application; -import com.zerozero.auth.application.HandleOAuthLoginUseCase.HandleOAuthLoginRequest; -import com.zerozero.auth.application.HandleOAuthLoginUseCase.HandleOAuthLoginResponse; -import com.zerozero.auth.application.HandleOAuthLoginUseCase.HandleOAuthLoginResponse.Token; -import com.zerozero.auth.exception.AuthenticationErrorCode; -import com.zerozero.auth.infrastructure.oauth.OAuthRestClient; -import com.zerozero.auth.infrastructure.oauth.OAuthRestClientFactory; -import com.zerozero.auth.infrastructure.oauth.common.OAuthAccessTokenResponse; -import com.zerozero.auth.infrastructure.oauth.common.OAuthResourceResponse; -import com.zerozero.auth.infrastructure.oauth.common.Provider; -import com.zerozero.core.application.BaseRequest; -import com.zerozero.core.application.BaseResponse; -import com.zerozero.core.application.BaseUseCase; -import com.zerozero.core.domain.entity.Status; -import com.zerozero.core.domain.entity.User; -import com.zerozero.core.domain.infra.repository.RefreshTokenRepository; -import com.zerozero.core.domain.infra.repository.UserJPARepository; -import com.zerozero.core.domain.vo.AccessToken; -import com.zerozero.core.domain.vo.RefreshToken; -import com.zerozero.core.exception.DomainException; -import com.zerozero.core.exception.error.BaseErrorCode; +import com.zerozero.auth.domain.repository.RefreshTokenRepository; +import com.zerozero.auth.exception.AuthErrorType; +import com.zerozero.auth.exception.AuthException; +import com.zerozero.auth.infrastructure.oauth.core.OAuthAccessTokenResponse; +import com.zerozero.auth.infrastructure.oauth.core.OAuthResourceResponse; +import com.zerozero.auth.infrastructure.oauth.core.Provider; +import com.zerozero.auth.presentation.response.LoginResponse; +import com.zerozero.auth.presentation.response.TokenResponse; import com.zerozero.core.util.JwtUtil; -import lombok.AccessLevel; -import lombok.AllArgsConstructor; -import lombok.Builder; -import lombok.Getter; -import lombok.NoArgsConstructor; +import com.zerozero.user.domain.model.User; +import com.zerozero.user.domain.model.UserStatus; +import com.zerozero.user.domain.repository.UserRepository; +import com.zerozero.user.domain.response.UserResponse; import lombok.RequiredArgsConstructor; -import lombok.Setter; -import lombok.ToString; -import lombok.experimental.SuperBuilder; import lombok.extern.log4j.Log4j2; -import org.springframework.http.HttpStatus; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; @@ -39,124 +22,54 @@ @Transactional @RequiredArgsConstructor @Log4j2 -public class HandleOAuthLoginUseCase implements BaseUseCase { - - private final OAuthRestClientFactory oAuthRestClientFactory; - - private final UserJPARepository userJPARepository; - - private final JwtUtil jwtUtil; - - private final RefreshTokenRepository refreshTokenRepository; - - @Override - public HandleOAuthLoginResponse execute(HandleOAuthLoginRequest request) { - if (request == null || !request.isValid()) { - log.error("[HandleOAuthLoginUseCase] Invalid request"); - return HandleOAuthLoginResponse.builder() - .success(false) - .errorCode(HandleOAuthLoginErrorCode.NOT_EXIST_LOGIN_CONDITION) - .build(); - } - Provider provider = Provider.valueOf(request.providerName.toUpperCase()); - OAuthRestClient oAuthRestClient = oAuthRestClientFactory.getOAuthRestClient(provider); - - OAuthAccessTokenResponse oAuthAccessTokenResponse = oAuthRestClient.getAccessToken(request.code); - if (oAuthAccessTokenResponse == null) { - log.error("[HandleOAuthLoginUseCase] OAuth access token is null"); - throw AuthenticationErrorCode.ACCESS_TOKEN_NOT_ISSUED.toException(); - } - OAuthResourceResponse oAuthResourceResponse = oAuthRestClient.getResource(oAuthAccessTokenResponse.accessToken()); - if (oAuthResourceResponse == null) { - log.error("[HandleOAuthLoginUseCase] OAuth resource is null"); - throw AuthenticationErrorCode.NOT_EXIST_RESOURCE_RESPONSE.toException(); - } - - String userEmail = oAuthResourceResponse.email(); - User user = userJPARepository.findByEmail(userEmail); - if (user == null) { - User pendingUser = User.builder() - .email(userEmail) - .status(Status.PENDING) - .build(); - userJPARepository.save(pendingUser); - return generateAndBuildResponse(pendingUser); - } else { - return generateAndBuildResponse(user); - } - } - - private HandleOAuthLoginResponse generateAndBuildResponse(User user) { - AccessToken accessToken = jwtUtil.generateAccessToken(user); - RefreshToken refreshToken = jwtUtil.generateRefreshToken(user); - refreshTokenRepository.save(refreshToken.toEntity(user.getId())); - - return HandleOAuthLoginResponse.builder() - .user(com.zerozero.core.domain.vo.User.of(user)) - .token(Token.builder() - .accessToken(accessToken) - .refreshToken(refreshToken) - .build()) - .build(); - } - - @Getter - @RequiredArgsConstructor - public enum HandleOAuthLoginErrorCode implements BaseErrorCode { - NOT_EXIST_LOGIN_CONDITION(HttpStatus.BAD_REQUEST, "로그인 요청 조건이 존재하지 않습니다."), - ; - - private final HttpStatus httpStatus; - - private final String message; - - @Override - public DomainException toException() { - return new DomainException(httpStatus, this); +public class HandleOAuthLoginUseCase { + + private final OAuthRestClientFactory oAuthRestClientFactory; + + private final UserRepository userRepository; + + private final JwtUtil jwtUtil; + + private final RefreshTokenRepository refreshTokenRepository; + + public LoginResponse execute(String code, String providerName) { + Provider provider = Provider.valueOf(providerName.toUpperCase()); + OAuthRestClient oAuthRestClient = oAuthRestClientFactory.getOAuthRestClient(provider); + + OAuthAccessTokenResponse oAuthAccessTokenResponse = oAuthRestClient.getAccessToken(code); + if (oAuthAccessTokenResponse == null) { + log.error("[HandleOAuthLoginUseCase] OAuth access token is null"); + throw new AuthException(AuthErrorType.ACCESS_TOKEN_NOT_ISSUED); + } + + OAuthResourceResponse oAuthResourceResponse = oAuthRestClient.getResource(oAuthAccessTokenResponse.accessToken()); + if (oAuthResourceResponse == null) { + log.error("[HandleOAuthLoginUseCase] OAuth resource is null"); + throw new AuthException(AuthErrorType.NOT_EXIST_RESOURCE_RESPONSE); + } + + String userEmail = oAuthResourceResponse.email(); + User user = userRepository.findByEmail(userEmail).orElse(null); + if (user == null) { + User pendingUser = User.builder() + .email(userEmail) + .userStatus(UserStatus.PENDING) + .build(); + userRepository.save(pendingUser); + return generateAndBuildResponse(pendingUser); + } else { + return generateAndBuildResponse(user); + } } - } - - @ToString - @Getter - @Setter - @SuperBuilder - @NoArgsConstructor(access = AccessLevel.PROTECTED) - @AllArgsConstructor(access = AccessLevel.PROTECTED) - public static class HandleOAuthLoginResponse extends BaseResponse { - - private com.zerozero.core.domain.vo.User user; - - private Token token; - @ToString - @Getter - @Setter - @Builder - @NoArgsConstructor(access = AccessLevel.PROTECTED) - @AllArgsConstructor(access = AccessLevel.PROTECTED) - public static class Token { - - private AccessToken accessToken; - - private RefreshToken refreshToken; + private LoginResponse generateAndBuildResponse(User user) { + String accessToken = jwtUtil.generateAccessToken(user); + String refreshToken = jwtUtil.generateRefreshToken(user); + refreshTokenRepository.save(com.zerozero.auth.domain.model.RefreshToken.builder() + .userId(user.getId()) + .refreshToken(refreshToken) + .build()); + return LoginResponse.of(UserResponse.from(user), TokenResponse.of(accessToken, refreshToken)); } - } - - @ToString - @Getter - @Setter - @Builder - @NoArgsConstructor(access = AccessLevel.PROTECTED) - @AllArgsConstructor(access = AccessLevel.PROTECTED) - public static class HandleOAuthLoginRequest implements BaseRequest { - private String providerName; - - private String code; - - @Override - public boolean isValid() { - return providerName != null && !providerName.isEmpty() && code != null && !code.isEmpty(); - } - } } diff --git a/src/main/java/com/zerozero/auth/application/OAuthRestClient.java b/src/main/java/com/zerozero/auth/application/OAuthRestClient.java new file mode 100644 index 0000000..629d146 --- /dev/null +++ b/src/main/java/com/zerozero/auth/application/OAuthRestClient.java @@ -0,0 +1,15 @@ +package com.zerozero.auth.application; + +import com.zerozero.auth.infrastructure.oauth.core.OAuthAccessTokenResponse; +import com.zerozero.auth.infrastructure.oauth.core.OAuthResourceResponse; + +import java.net.URI; + +public interface OAuthRestClient { + + URI getAuthUrl(); + + OAuthAccessTokenResponse getAccessToken(String authCode); + + OAuthResourceResponse getResource(String accessToken); +} diff --git a/src/main/java/com/zerozero/auth/application/OAuthRestClientFactory.java b/src/main/java/com/zerozero/auth/application/OAuthRestClientFactory.java new file mode 100644 index 0000000..266892a --- /dev/null +++ b/src/main/java/com/zerozero/auth/application/OAuthRestClientFactory.java @@ -0,0 +1,24 @@ +package com.zerozero.auth.application; + +import com.zerozero.auth.exception.AuthErrorType; +import com.zerozero.auth.exception.AuthException; +import com.zerozero.auth.infrastructure.oauth.core.Provider; +import com.zerozero.auth.infrastructure.oauth.kakao.KakaoOAuthRestClient; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Component; + +@Component +@RequiredArgsConstructor +public class OAuthRestClientFactory { + + private final KakaoOAuthRestClient kakaoOAuthRestClient; + + public OAuthRestClient getOAuthRestClient(Provider provider) { + switch (provider) { + case KAKAO -> { + return kakaoOAuthRestClient; + } + default -> throw new AuthException(AuthErrorType.INVALID_PROVIDER); + } + } +} diff --git a/src/main/java/com/zerozero/auth/application/RefreshUserTokenUseCase.java b/src/main/java/com/zerozero/auth/application/RefreshUserTokenUseCase.java index db09872..8c975f3 100644 --- a/src/main/java/com/zerozero/auth/application/RefreshUserTokenUseCase.java +++ b/src/main/java/com/zerozero/auth/application/RefreshUserTokenUseCase.java @@ -1,140 +1,49 @@ package com.zerozero.auth.application; -import com.zerozero.auth.application.RefreshUserTokenUseCase.RefreshUserTokenRequest; -import com.zerozero.auth.application.RefreshUserTokenUseCase.RefreshUserTokenResponse; -import com.zerozero.auth.application.RefreshUserTokenUseCase.RefreshUserTokenResponse.Tokens; -import com.zerozero.core.application.BaseRequest; -import com.zerozero.core.application.BaseResponse; -import com.zerozero.core.application.BaseUseCase; -import com.zerozero.core.domain.entity.User; -import com.zerozero.core.domain.infra.repository.RefreshTokenRepository; -import com.zerozero.core.domain.infra.repository.UserJPARepository; -import com.zerozero.core.domain.vo.AccessToken; -import com.zerozero.core.domain.vo.RefreshToken; -import com.zerozero.core.exception.DomainException; -import com.zerozero.core.exception.error.BaseErrorCode; +import com.zerozero.auth.domain.repository.RefreshTokenRepository; +import com.zerozero.auth.exception.AuthErrorType; +import com.zerozero.auth.exception.AuthException; +import com.zerozero.auth.presentation.response.TokenResponse; import com.zerozero.core.util.JwtUtil; -import java.util.UUID; -import lombok.AccessLevel; -import lombok.AllArgsConstructor; -import lombok.Builder; -import lombok.Getter; -import lombok.NoArgsConstructor; +import com.zerozero.user.domain.model.User; +import com.zerozero.user.domain.repository.UserRepository; +import com.zerozero.user.exception.UserErrorType; +import com.zerozero.user.exception.UserException; import lombok.RequiredArgsConstructor; -import lombok.Setter; -import lombok.ToString; -import lombok.experimental.SuperBuilder; import lombok.extern.log4j.Log4j2; -import org.springframework.http.HttpStatus; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; -@Log4j2 +import java.util.UUID; + @Service @RequiredArgsConstructor @Transactional -public class RefreshUserTokenUseCase implements BaseUseCase { - - private final JwtUtil jwtUtil; - - private final UserJPARepository userJPARepository; - - private final RefreshTokenRepository refreshTokenRepository; - - @Override - public RefreshUserTokenResponse execute(RefreshUserTokenRequest request) { - if (request == null || !request.isValid()) { - log.error("[RefreshUserTokenUseCase] RefreshToken is invalid"); - return RefreshUserTokenResponse.builder().success(false) - .errorCode(RefreshUserTokenErrorCode.NOT_EXIST_REFRESH_TOKEN).build(); - } - RefreshToken refreshToken = request.getRefreshToken(); - if (jwtUtil.isTokenExpired(refreshToken.getToken())) { - log.error("[RefreshUserTokenUseCase] Expired access token"); - return RefreshUserTokenResponse.builder().success(false) - .errorCode(RefreshUserTokenErrorCode.EXPIRED_TOKEN) - .build(); - } - UUID userId = jwtUtil.extractUserId(refreshToken.getToken()); - User user = userJPARepository.findById(userId).orElse(null); - if (user == null) { - log.error("[RefreshUserTokenUseCase] User not exist"); - return RefreshUserTokenResponse.builder().success(false) - .errorCode(RefreshUserTokenErrorCode.NOT_EXIST_USER).build(); - } - com.zerozero.core.domain.entity.RefreshToken alreadyExistRefreshToken = refreshTokenRepository.findById(user.getId()).orElse(null); - if (alreadyExistRefreshToken == null) { - log.error("[RefreshUserTokenUseCase] Refresh token not exist"); - return RefreshUserTokenResponse.builder().success(false) - .errorCode(RefreshUserTokenErrorCode.NOT_EXIST_REFRESH_TOKEN).build(); - } - if (RefreshToken.of(alreadyExistRefreshToken).equals(refreshToken) - && jwtUtil.isTokenValid(refreshToken.getToken(), user)) { - AccessToken accessToken = jwtUtil.generateAccessToken(user); - return RefreshUserTokenResponse.builder() - .tokens(Tokens.builder().accessToken(accessToken).refreshToken(refreshToken).build()) - .build(); - } - return RefreshUserTokenResponse.builder().success(false) - .errorCode(RefreshUserTokenErrorCode.TOKEN_REFRESH_FAILED).build(); - } - - @Getter - @RequiredArgsConstructor - public enum RefreshUserTokenErrorCode implements BaseErrorCode { - NOT_EXIST_REFRESH_TOKEN(HttpStatus.BAD_REQUEST, "리프레시 토큰이 존재하지 않습니다."), - EXPIRED_TOKEN(HttpStatus.UNAUTHORIZED, "만료된 토큰입니다."), - NOT_EXIST_USER(HttpStatus.BAD_REQUEST, "존재하지 않는 사용자입니다."), - TOKEN_REFRESH_FAILED(HttpStatus.INTERNAL_SERVER_ERROR, "토큰 재발급에 실패하였습니다."); - - private final HttpStatus httpStatus; - - private final String message; - - @Override - public DomainException toException() { - return new DomainException(httpStatus, this); - } - } - - @ToString - @Getter - @Setter - @SuperBuilder - @NoArgsConstructor(access = AccessLevel.PROTECTED) - @AllArgsConstructor(access = AccessLevel.PROTECTED) - public static class RefreshUserTokenResponse extends BaseResponse { +@Log4j2 +public class RefreshUserTokenUseCase { - private Tokens tokens; + private final JwtUtil jwtUtil; - @ToString - @Getter - @Setter - @Builder - @NoArgsConstructor(access = AccessLevel.PROTECTED) - @AllArgsConstructor(access = AccessLevel.PROTECTED) - public static class Tokens { + private final UserRepository userRepository; - private AccessToken accessToken; + private final RefreshTokenRepository refreshTokenRepository; - private RefreshToken refreshToken; - } - } + public TokenResponse execute(String refreshToken) { + if (jwtUtil.isTokenExpired(refreshToken)) { + log.error("[RefreshUserTokenUseCase] Expired access token"); + throw new AuthException(AuthErrorType.EXPIRED_TOKEN); + } - @ToString - @Getter - @Setter - @Builder - @NoArgsConstructor(access = AccessLevel.PROTECTED) - @AllArgsConstructor(access = AccessLevel.PROTECTED) - public static class RefreshUserTokenRequest implements BaseRequest { + UUID userId = jwtUtil.extractUserId(refreshToken); + User user = userRepository.findById(userId).orElseThrow(() -> new UserException(UserErrorType.NOT_EXIST_USER)); - private RefreshToken refreshToken; + com.zerozero.auth.domain.model.RefreshToken alreadyExistRefreshToken = refreshTokenRepository.findById(user.getId()).orElseThrow(() -> new AuthException(AuthErrorType.NOT_EXIST_REFRESH_TOKEN)); - @Override - public boolean isValid() { - return refreshToken != null; + if (alreadyExistRefreshToken.getRefreshToken().equals(refreshToken) && jwtUtil.isTokenValid(refreshToken, user)) { + String accessToken = jwtUtil.generateAccessToken(user); + return TokenResponse.of(accessToken, refreshToken); + } + throw new AuthException(AuthErrorType.TOKEN_REFRESH_FAILED); } - } } diff --git a/src/main/java/com/zerozero/auth/application/RegisterUserUseCase.java b/src/main/java/com/zerozero/auth/application/RegisterUserUseCase.java index 1babe20..392db48 100644 --- a/src/main/java/com/zerozero/auth/application/RegisterUserUseCase.java +++ b/src/main/java/com/zerozero/auth/application/RegisterUserUseCase.java @@ -1,114 +1,40 @@ package com.zerozero.auth.application; -import com.zerozero.auth.application.RegisterUserUseCase.RegisterUserRequest; -import com.zerozero.auth.application.RegisterUserUseCase.RegisterUserResponse; -import com.zerozero.core.application.BaseRequest; -import com.zerozero.core.application.BaseResponse; -import com.zerozero.core.application.BaseUseCase; -import com.zerozero.core.domain.entity.Status; -import com.zerozero.core.domain.entity.User; -import com.zerozero.core.domain.infra.repository.UserJPARepository; -import com.zerozero.core.exception.DomainException; -import com.zerozero.core.exception.error.BaseErrorCode; +import com.zerozero.auth.presentation.request.RegisterRequest; import com.zerozero.core.util.JwtUtil; -import java.util.UUID; -import lombok.AccessLevel; -import lombok.AllArgsConstructor; -import lombok.Builder; -import lombok.Getter; -import lombok.NoArgsConstructor; +import com.zerozero.user.domain.model.User; +import com.zerozero.user.domain.repository.UserRepository; +import com.zerozero.user.domain.response.UserResponse; +import com.zerozero.user.exception.UserErrorType; +import com.zerozero.user.exception.UserException; import lombok.RequiredArgsConstructor; -import lombok.Setter; -import lombok.ToString; -import lombok.experimental.SuperBuilder; import lombok.extern.log4j.Log4j2; -import org.springframework.http.HttpStatus; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; -@Log4j2 +import java.util.UUID; + @Service @RequiredArgsConstructor @Transactional -public class RegisterUserUseCase implements BaseUseCase { - - private final JwtUtil jwtUtil; - - private final UserJPARepository userJPARepository; - - @Override - public RegisterUserResponse execute(RegisterUserRequest request) { - if (request == null || !request.isValid()) { - log.error("[RegisterUserUseCase] Invalid register request"); - return RegisterUserResponse.builder() - .success(false) - .errorCode(RegisterUserErrorCode.NOT_EXIST_REGISTER_CONDITION) - .build(); - } - UUID userId = jwtUtil.extractUserId(request.getAccessToken()); - User user = userJPARepository.findById(userId).orElse(null); - if (user == null) { - log.error("[RegisterUserUseCase] User with id {} not found", userId); - return RegisterUserResponse.builder() - .success(false) - .errorCode(RegisterUserErrorCode.NOT_EXIST_USER) - .build(); - } - if (user.getStatus() == Status.COMPLETED) { - log.error("[RegisterUserUseCase] User with id {} is already registered", userId); - return RegisterUserResponse.builder() - .success(false) - .errorCode(RegisterUserErrorCode.ALREADY_REGISTERED_USER) - .build(); - } - user.completePendingUser(request.getNickname()); - return RegisterUserResponse.builder() - .user(com.zerozero.core.domain.vo.User.of(user)) - .build(); - } - - @Getter - @RequiredArgsConstructor - public enum RegisterUserErrorCode implements BaseErrorCode { - NOT_EXIST_REGISTER_CONDITION(HttpStatus.BAD_REQUEST, "회원가입 조건이 올바르지 않습니다."), - NOT_EXIST_USER(HttpStatus.BAD_REQUEST, "존재하지 않는 사용자입니다."), - ALREADY_REGISTERED_USER(HttpStatus.BAD_REQUEST, "이미 회원가입이 완료된 사용자입니다."), - ; - - private final HttpStatus httpStatus; - - private final String message; +@Log4j2 +public class RegisterUserUseCase { - @Override - public DomainException toException() { - return new DomainException(httpStatus, this); - } - } + private final JwtUtil jwtUtil; - @ToString - @Getter - @Setter - @SuperBuilder - @NoArgsConstructor(access = AccessLevel.PROTECTED) - public static class RegisterUserResponse extends BaseResponse { - private com.zerozero.core.domain.vo.User user; - } + private final UserRepository userRepository; - @ToString - @Getter - @Setter - @Builder - @NoArgsConstructor(access = AccessLevel.PROTECTED) - @AllArgsConstructor(access = AccessLevel.PROTECTED) - public static class RegisterUserRequest implements BaseRequest { - private String accessToken; + public UserResponse execute(RegisterRequest registerRequest, String accessToken) { + UUID userId = jwtUtil.extractUserId(accessToken); + User user = userRepository.findById(userId).orElseThrow(() -> new UserException(UserErrorType.NOT_EXIST_USER)); - private String nickname; + if (user.isRegistered()) { + log.error("[RegisterUserUseCase] User with id {} is already registered", userId); + throw new UserException(UserErrorType.ALREADY_REGISTERED_USER); + } - @Override - public boolean isValid() { - return accessToken != null && !accessToken.isEmpty() && nickname != null && !nickname.isEmpty(); + user.completePendingUser(registerRequest.nickname()); + return UserResponse.from(user); } - } }