로그인 로직 수정

ImGdevel · ImGdevel · commit 9ad211b36772 · 2025-09-03T17:48:36.000+09:00
diff --git a/ProjectVG.Api/Controllers/AuthController.cs b/ProjectVG.Api/Controllers/AuthController.cs
@@ -4,24 +4,26 @@
 namespace ProjectVG.Api.Controllers
 {
     [ApiController]
-    [Route("api/v1/[controller]")]
+    [Route("api/v1/auth")]
     public class AuthController : ControllerBase
     {
-        private readonly IAuthService _authService;
+        private readonly IUserAuthService _authService;
 
-        public AuthController(IAuthService authService)
+        public AuthController(IUserAuthService authService)
         {
             _authService = authService;
         }
 
+        /// <summary>
+        /// Access Token 갱신
+        /// </summary>
         [HttpPost("refresh")]
         public async Task<IActionResult> RefreshToken()
         {
             var refreshToken = GetRefreshTokenFromHeader();
-            var result = await _authService.RefreshTokenAsync(refreshToken);
-            
-            return Ok(new
-            {
+            var result = await _authService.RefreshAccessTokenAsync(refreshToken);
+
+            return Ok(new {
                 success = true,
                 tokens = result.Tokens,
                 user = result.User
@@ -33,9 +35,8 @@ public async Task<IActionResult> Logout()
         {
             var refreshToken = GetRefreshTokenFromHeader();
             var success = await _authService.LogoutAsync(refreshToken);
-            
-            return Ok(new
-            {
+
+            return Ok(new {
                 success = success,
                 message = success ? "Logout successful" : "Logout failed"
             });
@@ -44,15 +45,13 @@ public async Task<IActionResult> Logout()
         [HttpPost("guest-login")]
         public async Task<IActionResult> GuestLogin([FromBody] string guestId)
         {
-            if (string.IsNullOrEmpty(guestId))
-            {
+            if (string.IsNullOrEmpty(guestId)) {
                 throw new ValidationException(ErrorCode.GUEST_ID_INVALID);
             }
 
-            var result = await _authService.LoginWithOAuthAsync("guest", guestId);
-            
-            return Ok(new
-            {
+            var result = await _authService.SignInWithOAuthAsync("guest", guestId);
+
+            return Ok(new {
                 success = true,
                 tokens = result.Tokens,
                 user = result.User
@@ -64,4 +63,4 @@ private string GetRefreshTokenFromHeader()
             return Request.Headers["X-Refresh-Credit"].FirstOrDefault() ?? string.Empty;
         }
     }
-} 
+}
diff --git a/ProjectVG.Api/Controllers/OAuthController.cs b/ProjectVG.Api/Controllers/OAuthController.cs
@@ -85,6 +85,7 @@ public async Task<IActionResult> OAuth2Callback(
             return Redirect(result.RedirectUrl!);
         }
 
+
         [HttpGet("oauth2/token")]
         public async Task<IActionResult> GetOAuth2Token([FromQuery] string state)
         {
diff --git a/ProjectVG.Application/ApplicationServiceCollectionExtensions.cs b/ProjectVG.Application/ApplicationServiceCollectionExtensions.cs
@@ -20,7 +20,7 @@ public static class ApplicationServiceCollectionExtensions
         public static IServiceCollection AddApplicationServices(this IServiceCollection services)
         {
             // Auth Services
-            services.AddScoped<IAuthService, AuthService>();
+            services.AddScoped<IUserAuthService, AuthService>();
             services.AddScoped<IOAuth2Service, OAuth2Service>();
             services.AddScoped<IOAuth2ProviderFactory, OAuth2ProviderFactory>();
 
diff --git a/ProjectVG.Application/Services/Auth/AuthService.cs b/ProjectVG.Application/Services/Auth/AuthService.cs
@@ -1,23 +1,25 @@
 using Microsoft.Extensions.Logging;
+using ProjectVG.Application.Models.Auth;
 using ProjectVG.Application.Models.User;
-using ProjectVG.Application.Services.Users;
 using ProjectVG.Application.Services.Credit;
-using ProjectVG.Infrastructure.Auth;
-using ProjectVG.Common.Exceptions;
+using ProjectVG.Application.Services.Users;
 using ProjectVG.Common.Constants;
+using ProjectVG.Common.Exceptions;
 using ProjectVG.Domain.Entities.Users;
+using ProjectVG.Infrastructure.Auth;
+using System;
 
 namespace ProjectVG.Application.Services.Auth
 {
-    public class AuthService : IAuthService
+    public class AuthService : IUserAuthService
     {
         private readonly IUserService _userService;
         private readonly ITokenService _tokenService;
         private readonly ICreditManagementService _tokenManagementService;
         private readonly ILogger<AuthService> _logger;
 
         public AuthService(
-            IUserService userService, 
+            IUserService userService,
             ITokenService tokenService,
             ICreditManagementService tokenManagementService,
             ILogger<AuthService> logger)
@@ -28,142 +30,143 @@ public AuthService(
             _logger = logger;
         }
 
-        public async Task<AuthResult> LoginWithOAuthAsync(string provider, string providerUserId)
+        public async Task<AuthResult> SignInWithOAuthAsync(string provider, string providerUserId)
         {
-            // OAuth 프로바이더별 사용자 처리
-            Guid userId;
-            UserDto user;
-
-            if (provider == "guest")
-            {
-                if (string.IsNullOrEmpty(providerUserId))
-                {
-                    throw new ValidationException(ErrorCode.GUEST_ID_INVALID);
-                }
-
-                // 기존 게스트 사용자가 있는지 확인
-                user = await _userService.TryGetByProviderAsync("guest", providerUserId);
-                
-                if (user == null)
-                {
-                    // 새로운 게스트 사용자 생성
-                    string uuid = GenerateGuestUuid(providerUserId);
-                    var createCommand = new UserCreateCommand(
-                        Username: $"guest_{uuid}",
-                        Email: $"guest@guest{uuid}.local",
-                        ProviderId: providerUserId,
-                        Provider: "guest"
-                    );
-                    
-                    user = await _userService.CreateUserAsync(createCommand);
-                    _logger.LogInformation("New guest user created: {UserId} with GuestId: {GuestId}", user.Id, providerUserId);
-                }
-                else
-                {
-                    _logger.LogInformation("Existing guest user logged in: {UserId} with GuestId: {GuestId}", user.Id, providerUserId);
-                }
+            return provider switch {
+                "guest" => await GuestLoginAsync(providerUserId),
+                "google" or "apple" => await OAuth2LoginAsync(provider, providerUserId),
+                _ => throw new ValidationException(ErrorCode.OAUTH2_PROVIDER_NOT_SUPPORTED)
+            };
+        }
+
+        private async Task<AuthResult> GuestLoginAsync(string guestId)
+        {
+            if (string.IsNullOrEmpty(guestId)) {
+                throw new ValidationException(ErrorCode.GUEST_ID_INVALID);
             }
-            // 실제 OAuth 프로바이더인 경우 (Google, Apple 등)
-            else if (provider == "google" || provider == "apple")
-            {
-                if (string.IsNullOrEmpty(providerUserId))
-                {
-                    throw new ValidationException(ErrorCode.PROVIDER_USER_ID_INVALID);
-                }
-
-                // 새로운 사용자 ID 생성
-                userId = Guid.NewGuid();
-                
-                user = new UserDto
-                {
-                    Id = userId,
-                    Username = $"{provider}_user_{providerUserId}",
-                    Email = $"{providerUserId}@{provider}.oauth",
-                    Status = AccountStatus.Active
-                };
 
-                _logger.LogInformation("New OAuth user created: {UserId} from {Provider} with ProviderId: {ProviderId}", 
-                    userId, provider, providerUserId);
+            var user = await _userService.TryGetByProviderAsync("guest", guestId);
+
+            if (user == null) {
+                string uuid = GenerateGuestUuid(guestId);
+                var createCommand = new UserCreateCommand(
+                    Username: $"guest_{uuid}",
+                    Email: $"guest@guest{uuid}.local",
+                    ProviderId: guestId,
+                    Provider: "guest"
+                );
+
+                user = await _userService.CreateUserAsync(createCommand);
+                _logger.LogInformation("새 게스트 사용자 생성됨: UserId={UserId}, GuestId={GuestId}", user.Id, guestId);
+            }
+            else {
+                _logger.LogDebug("기존 게스트 사용자 로그인: UserId={UserId}, GuestId={GuestId}", user.Id, guestId);
             }
-            else
-            {
-                throw new ValidationException(ErrorCode.OAUTH2_PROVIDER_NOT_SUPPORTED);
+
+            return await FinalizeLoginAsync(user, "guest");
+        }
+
+        private async Task<AuthResult> OAuth2LoginAsync(string provider, string providerUserId)
+        {
+            if (string.IsNullOrEmpty(providerUserId)) {
+                throw new ValidationException(ErrorCode.PROVIDER_USER_ID_INVALID);
             }
 
-            // OAuth2 사용자인 경우 Provider 정보를 포함하여 사용자 생성 (test와 guest는 이미 처리됨)
-            if (provider != "test" && provider != "guest")
-            {
-                user = user with { Provider = provider, ProviderId = providerUserId };
+            var user = await _userService.TryGetByProviderAsync(provider, providerUserId);
+
+            if (user == null) {
+                string uuid = GenerateGuestUuid(providerUserId);
+                var createCommand = new UserCreateCommand(
+                    Username: $"임시 유저 이름",
+                    Email: $"guest@guest{uuid}.local",
+                    ProviderId: providerUserId,
+                    Provider: provider
+                );
+
+
+                user = new UserDto {
+                    
+
+                    Id = Guid.NewGuid(),
+                    Username = $"{provider}_user_{providerUserId}",
+                    Email = $"{providerUserId}@{provider}.oauth",
+                    Status = AccountStatus.Active,
+                    Provider = provider,
+                    ProviderId = providerUserId
+                };
             }
 
-            // 첫 로그인 토큰 지급 시도
+            _logger.LogInformation("새 OAuth 사용자 생성됨: UserId={UserId}, Provider={Provider}, ProviderId={ProviderId}",
+                user.Id, provider, providerUserId);
+
+            return await FinalizeLoginAsync(user, provider);
+        }
+
+        private async Task<AuthResult> FinalizeLoginAsync(UserDto user, string provider)
+        {
+            // 초기 크레딧 지급
             var tokenGranted = await _tokenManagementService.GrantInitialCreditsAsync(user.Id);
-            if (tokenGranted)
-            {
-                _logger.LogInformation("Initial tokens (5000) granted successfully to user {UserId}", user.Id);
+            if (tokenGranted) {
+                _logger.LogInformation("사용자 {UserId}에게 최초 크레딧 지급 완료", user.Id);
             }
-            else
-            {
-                _logger.LogInformation("Initial tokens already granted or grant failed for user {UserId}", user.Id);
+            else {
+                _logger.LogDebug("사용자 {UserId}는 이미 크레딧이 지급되었거나 지급 실패", user.Id);
             }
 
+            // 최종 JWT 토큰 발급
             var tokens = await _tokenService.GenerateTokensAsync(user.Id);
-            
-            _logger.LogInformation("Users {UserId} logged in with OAuth provider: {Provider}", user.Id, provider);
-            
-            return new AuthResult
-            {
+
+            _logger.LogDebug("사용자 {UserId} 로그인 완료 (Provider={Provider})", user.Id, provider);
+
+            return new AuthResult {
                 Tokens = tokens,
                 User = user
             };
         }
 
-        public async Task<AuthResult> RefreshTokenAsync(string refreshToken)
+        public async Task<AuthResult> RefreshAccessTokenAsync(string? refreshToken)
         {
-            if (string.IsNullOrEmpty(refreshToken))
-            {
+            if (string.IsNullOrEmpty(refreshToken)) {
                 throw new ValidationException(ErrorCode.TOKEN_MISSING, "리프레시 토큰이 필요합니다");
             }
 
             var tokens = await _tokenService.RefreshAccessTokenAsync(refreshToken);
-            if (tokens == null)
-            {
+            if (tokens == null) {
                 throw new ValidationException(ErrorCode.TOKEN_REFRESH_FAILED, "유효하지 않거나 만료된 리프레시 토큰입니다");
             }
 
             var userId = await _tokenService.GetUserIdFromTokenAsync(refreshToken);
             var user = userId.HasValue ? await _userService.TryGetByIdAsync(userId.Value) : null;
 
-            return new AuthResult
-            {
+            return new AuthResult {
                 Tokens = tokens,
                 User = user
             };
         }
 
         public async Task<bool> LogoutAsync(string refreshToken)
         {
-            if (string.IsNullOrEmpty(refreshToken))
-            {
+            if (string.IsNullOrEmpty(refreshToken)) {
                 throw new ValidationException(ErrorCode.TOKEN_MISSING, "리프레시 토큰이 필요합니다");
             }
 
             var revoked = await _tokenService.RevokeRefreshTokenAsync(refreshToken);
-            if (revoked)
-            {
+            if (revoked) {
                 var userId = await _tokenService.GetUserIdFromTokenAsync(refreshToken);
-                _logger.LogInformation("Users {UserId} logged out successfully", userId);
+                _logger.LogInformation("사용자 {UserId} 로그아웃 성공", userId);
+            }
+            else {
+                _logger.LogWarning("리프레시 토큰 만료 또는 무효화 실패: {RefreshToken}", refreshToken);
             }
             return revoked;
         }
-
         private static string GenerateGuestUuid(string providerUserId)
         {
-            // SHA256 해시를 사용하여 일관된 UUID 생성
             using var sha256 = System.Security.Cryptography.SHA256.Create();
             var hash = sha256.ComputeHash(System.Text.Encoding.UTF8.GetBytes(providerUserId));
             var hashString = Convert.ToHexString(hash);
             return hashString.Substring(0, Math.Min(hashString.Length, 16)).ToLowerInvariant();
         }
+
     }
 }
diff --git a/ProjectVG.Application/Services/Auth/IUserAuthService.cs b/ProjectVG.Application/Services/Auth/IUserAuthService.cs
@@ -7,28 +7,21 @@ namespace ProjectVG.Application.Services.Auth
     /// 인증 및 토큰 관리 서비스
     /// JWT 토큰 생성, 검증, 갱신 및 OAuth 로그인 처리를 담당
     /// </summary>
-    public interface IAuthService
+    public interface IUserAuthService
     {
         /// <summary>
-        /// OAuth 제공자를 통한 로그인 처리 (Google, GitHub, Microsoft, 게스트 등)
+        /// OAuth 제공자를 통한 로그인 처리
         /// </summary>
-        /// <param name="provider">인증 제공자 (google, github, microsoft, guest, test)</param>
-        /// <param name="providerUserId">제공자별 사용자 ID</param>
-        /// <returns>로그인 결과 (토큰, 사용자 정보 포함)</returns>
-        Task<AuthResult> LoginWithOAuthAsync(string provider, string providerUserId);
+        Task<AuthResult> SignInWithOAuthAsync(string provider, string providerUserId);
 
         /// <summary>
         /// 리프레시 토큰을 사용하여 새로운 액세스 토큰 발급
         /// </summary>
-        /// <param name="refreshToken">유효한 리프레시 토큰</param>
-        /// <returns>새로운 토큰 쌍과 사용자 정보</returns>
-        Task<AuthResult> RefreshTokenAsync(string? refreshToken);
+        Task<AuthResult> RefreshAccessTokenAsync(string? refreshToken);
 
         /// <summary>
         /// 사용자 로그아웃 처리 (리프레시 토큰 무효화)
         /// </summary>
-        /// <param name="refreshToken">무효화할 리프레시 토큰</param>
-        /// <returns>로그아웃 성공 여부</returns>
         Task<bool> LogoutAsync(string? refreshToken);
     }
 
diff --git a/ProjectVG.Application/Services/Auth/OAuth2Service.cs b/ProjectVG.Application/Services/Auth/OAuth2Service.cs
diff --git a/ProjectVG.Tests/Auth/AuthServiceTests.cs b/ProjectVG.Tests/Auth/AuthServiceTests.cs

Original file line number	Diff line number	Diff line change
`@@ -85,6 +85,7 @@ public async Task<IActionResult> OAuth2Callback(`
`85`	`85`	`return Redirect(result.RedirectUrl!);`
`86`	`86`	`}`
`87`	`87`
	`88`	`+`
`88`	`89`	`[HttpGet("oauth2/token")]`
`89`	`90`	`public async Task<IActionResult> GetOAuth2Token([FromQuery] string state)`
`90`	`91`	`{`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ public static class ApplicationServiceCollectionExtensions`
`20`	`20`	`public static IServiceCollection AddApplicationServices(this IServiceCollection services)`
`21`	`21`	`{`
`22`	`22`	`// Auth Services`
`23`		`- services.AddScoped<IAuthService, AuthService>();`
	`23`	`+ services.AddScoped<IUserAuthService, AuthService>();`
`24`	`24`	`services.AddScoped<IOAuth2Service, OAuth2Service>();`
`25`	`25`	`services.AddScoped<IOAuth2ProviderFactory, OAuth2ProviderFactory>();`
`26`	`26`