AcaMate_API/Program/Services/V1/UserService.cs

using System.Security.Claims;
using Back.Program.Common.Auth;
using Back.Program.Common.Model;
using Back.Program.Models.Entities;
using Back.Program.Repositories.V1.Interfaces;
using Back.Program.Services.V1.Interfaces;
using System.Text.Json;
using Back.Program.Common.Data;

namespace Back.Program.Services.V1
{
    public class UserService : IUserService
    {
        private readonly ILogger<IUserService> _logger;
        private readonly IUserRepository _userRepository;
        private readonly JwtTokenService _jwtTokenService;
        private readonly IRepositoryService _repositoryService;
        private readonly ILogRepository _logRepository;
        private readonly IAppService _appService;
        private readonly SessionManager _sessionManager;

        public UserService(ILogger<IUserService> logger, IUserRepository userRepository,
            JwtTokenService jwtTokenService,
            IRepositoryService repositoryService, ILogRepository logRepository,
            IAppService appService, SessionManager sessionManager)
        {
            _logger = logger;
            _userRepository = userRepository;
            _jwtTokenService = jwtTokenService;
            _repositoryService = repositoryService;
            _logRepository = logRepository;
            _appService = appService;
            _sessionManager = sessionManager;
        }


        public async Task<APIResponseStatus<object>> GetUser(string summary, string token)
        {
            var validToken = await _jwtTokenService.ValidateToken(token);
            if (validToken == null) return APIResponse.AccessExpireError();

            var uid = validToken.FindFirst(ClaimTypes.NameIdentifier)?.Value ?? string.Empty;
            var user = await _userRepository.FindUser(uid);

            return APIResponse.Send<object>("000", $"[{summary}], 정상", user);
            // user 없는 경우가 없네? 그거도 만들것 
        }

        public async Task<APIResponseStatus<object>> Login(string summary, string accType, string snsId)
        {
            var login = await _userRepository.FindLogin(accType, snsId);
            if (login == null)
                return APIResponse.Send<object>("001", $"[{summary}], 로그인 정보 없음", new { });

            var user = await _userRepository.FindUser(login.uid);
            if (user == null)
                return APIResponse.Send<object>("002", $"[{summary}], 회원 정보 오류", new { });

            user.login_date = DateTime.Now;
            var token = _jwtTokenService.GenerateJwtToken(user.uid);
            var refresh = _jwtTokenService.GenerateRefreshToken(user.uid);

            if (await _repositoryService.SaveData<RefreshToken>(refresh))
            {
                return APIResponse.Send<object>("000", $"[{summary}], 정상",
                    new { token = token, refresh = refresh.refresh_token });
            }

            // 토큰 저장에 실패 및 로그인도 실패
            return APIResponse.InternalSeverError($"[{summary}], 로그인 동작 실패");
        }

        public async Task<APIResponseStatus<object>> Register(string summary, UserAll request)
        {
            var localPartEmail = request.email.Substring(0, request.email.IndexOf('@'));
            var uid = $"AM{localPartEmail}{DateTime.Now:yyyyMMdd}";

            var user = new User
            {
                uid = uid,
                name = request.name,
                birth = request.birth,
                type = request.type,
                device_id = request.device_id,
                auto_login_yn = request.auto_login_yn,
                login_date = request.login_date,
                push_token = request.push_token
            };
            var login = new Login
            {
                uid = uid,
                sns_id = request.sns_id,
                sns_type = request.sns_type
            };

            var permission = new Permission
            {
                uid = uid,
                location_yn = request.location_yn,
                camera_yn = request.camera_yn,
                photo_yn = request.photo_yn,
                push_yn = request.push_yn,
                market_app_yn = request.market_app_yn,
                market_sms_yn = request.market_sms_yn,
                market_email_yn = request.market_email_yn
            };

            var contact = new Contact
            {
                uid = uid,
                email = request.email,
                phone = request.phone,
                address = request.address
            };

            var logUser = new LogUser
            {
                uid = login.uid,
                create_date = DateTime.Now,
                create_uid = "System",
                log = ""
            };

            var saveUser = await _repositoryService.SaveData<User>(user);
            var saveLogin = await _repositoryService.SaveData<Login>(login);
            var savePermission = await _repositoryService.SaveData<Permission>(permission);
            var saveContact = await _repositoryService.SaveData<Contact>(contact);

            if (saveUser && saveLogin && savePermission && saveContact)
            {
                var token = _jwtTokenService.GenerateJwtToken(uid);
                var refresh = _jwtTokenService.GenerateRefreshToken(uid);

                if (await _repositoryService.SaveData<RefreshToken>(refresh))
                {
                    logUser.log = $"[{summary}] : 정상";
                    if (await _logRepository.SaveLogUser(logUser))
                    {
                        _logger.LogInformation($"[{summary}]: 성공");
                    }
                    else
                    {
                        _logger.LogInformation($"[{summary}]: 성공 - 로그 저장 실패");
                    }

                    return APIResponse.Send<object>("000", $"[{summary}], 정상", new
                    {
                        token = token,
                        refresh = refresh.refresh_token
                    });
                }
                else
                {
                    logUser.log = $"[{summary}] : 실패";
                    if (await _logRepository.SaveLogUser(logUser))
                    {
                        _logger.LogInformation($"[{summary}]: 실패");
                    }
                    else
                    {
                        _logger.LogInformation($"[{summary}]: 실패 - 로그 저장 실패");
                    }
                }
            }

            return APIResponse.InternalSeverError($"[{summary}], 회원가입 동작 실패");
        }

        public async Task<APIResponseStatus<object>> Logout(string summary, string token)
        {
            var validToken = await _jwtTokenService.ValidateToken(token);
            if (validToken == null) return APIResponse.AccessExpireError();

            var uid = validToken.FindFirst(ClaimTypes.NameIdentifier)?.Value ?? string.Empty;
            var refresh = await _userRepository.FindRefreshToken(uid);
            if (refresh != null)
            {
                refresh.revoke_Date = DateTime.Now;
                if (await _repositoryService.SaveData<RefreshToken>(refresh))
                {
                    return APIResponse.Send<object>("000", $"[{summary}], 로그아웃 정상", new { });
                }
            }

            return APIResponse.UnknownError();
        }

        public async Task<APIResponseStatus<object>> Cancel(string summary, string token)
        {
            var validToken = await _jwtTokenService.ValidateToken(token);
            if (validToken == null) return APIResponse.AccessExpireError();

            var uid = validToken.FindFirst(ClaimTypes.NameIdentifier)?.Value ?? string.Empty;
            var user = await _userRepository.FindUser(uid);
            if (user == null) return APIResponse.Send<object>("001", $"[{summary}], 회원 정보 확인 오류", new { });

            if (await _repositoryService.DeleteData<User>(user))
            {
                if (await _logRepository.SaveLogUser(new LogUser
                    {
                        uid = user.uid, create_date = DateTime.Now, create_uid = "System", log = $"[{summary}] : 정상"
                    }))
                {
                    _logger.LogInformation($"[{summary}]: 성공");
                }
                else
                {
                    _logger.LogInformation($"[{summary}]: 성공 - 로그 저장 실패");
                }

                return APIResponse.Send<object>("000", $"[{summary}], 정상", new { });
            }
            else
            {
                if (await _logRepository.SaveLogUser(new LogUser
                    {
                        uid = user.uid, create_date = DateTime.Now, create_uid = "System", log = $"[{summary}] : 실패"
                    }))
                {
                    _logger.LogInformation($"[{summary}]: 실패");
                }
                else
                {
                    _logger.LogInformation($"[{summary}]: 실패 - 로그 저장 실패");
                }
            }

            return APIResponse.InternalSeverError();
        }

        public async Task<APIResponseStatus<object>> GetAcademy(string summary, string token)
        {
            var validToken = await _jwtTokenService.ValidateToken(token);
            if (validToken == null) return APIResponse.AccessExpireError();

            var uid = validToken.FindFirst(ClaimTypes.NameIdentifier)?.Value ?? string.Empty;
            var user = await _userRepository.FindUser(uid);
            if (user == null) return APIResponse.Send<object>("001", $"[{summary}], 회원 정보 확인 오류", new { });
            var academyList = await _userRepository.FindAcademies(uid);
            _logger.LogInformation($"[{summary}]: 성공 - {System.Text.Json.JsonSerializer.Serialize(academyList)}");
            return APIResponse.Send<object>("000", $"[{summary}], 정상.", academyList);
        }
    }
}