AcaMate_API/Program/Services/V1/AppService.cs

using System.Security.Cryptography;
using System.Text;
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 Version = Back.Program.Models.Entities.Version;

namespace Back.Program.Services.V1;

public class AppService: IAppService
{
    private readonly ILogger<IAppService> _logger;
    private readonly IRepositoryService _repositoryService;
    private readonly JwtTokenService _jwtTokenService; 
    private readonly ILogRepository _logRepository;
    private readonly IAppRepository _appRepository;

    public AppService(ILogger<IAppService> logger, IRepositoryService repositoryService,
        JwtTokenService jwtTokenService, ILogRepository logRepository, IAppRepository appRepository)
    {
        _logger = logger;
        _repositoryService = repositoryService;
        _jwtTokenService = jwtTokenService;
        _logRepository = logRepository;
        _appRepository = appRepository;
    }

    public async Task<APIResponseStatus<object>> GetHeader(string summary, string type, string specific, string project)
    {
        bool valid = false;
        switch (type)
        {
            case "I":
                if (project == "me.myds.ipstein.acamate.AcaMate") valid = true;
                break;
            case "A":
                break;
            case "W":
                if (project == "AcaMate") valid = true;
                break;
            default:
                return APIResponse.InvalidInputError($"[{summary}], 타입 에러");
                break;
        }

        if (valid)
        {
            var apiHeader = await _appRepository.FindHeader(specific);
            
            string nowTime = DateTime.Now.ToString("o");
            string combineText = $"{project}_{nowTime}_{specific}";
            string headerValue = KeyGenerator(combineText);
            if (apiHeader != null)
            {
                if (DateTime.Now - apiHeader.connect_date > TimeSpan.FromHours(24))
                {
                    _logger.LogInformation($"[{summary}] : 해당 키 유효기간 경과");
                    apiHeader.h_value = headerValue;
                    apiHeader.connect_date = DateTime.Now;
                    if (await _repositoryService.SaveData<APIHeader>(apiHeader))
                    {
                        // 새로 업뎃해서 저장
                        if(await _logRepository.SaveLogProject( new LogProject { create_date = DateTime.Now , log = $"[{summary}] : 해당 키 유효시간 만료로 인한 새 키 부여"}))
                        {
                            _logger.LogInformation($"[{summary}] : 성공");
                        }
                        else
                        {
                            _logger.LogInformation($"[{summary}] : 성공 - 로그 저장 실패 ");
                        }
                        return APIResponse.Send<object>("000", $"[{summary}], 정상", new { header = headerValue });
                    }
                    else
                    {
                        // 저장이 안되었다? == 서버 오류
                        return APIResponse.InternalSeverError();
                    }
                }
                else
                {
                    return APIResponse.Send<object>("000", $"[{summary}], 정상", new { header = apiHeader.h_value });
                    // 유효기간 경과도 없고 정상적으로 잘 불러짐
                }
            }
            else
            {
                // API 저장된 거 없으니 저장 합시다.
                var newHeader = new APIHeader
                {
                    h_key = type == "I" ? "iOS_AM_Connect_Key" 
                        : (type == "A" ? "And_AM_Connect_Key" 
                            : (type == "W" ? "Web_AM_Connect_Key": throw new Exception("ERROR"))),
                    h_value = headerValue,
                    connect_date = DateTime.Now,
                    specific_id = specific
                };
                
                if (await _repositoryService.SaveData<APIHeader>(newHeader))
                {
                    // 새로 업뎃해서 저장
                    if(await _logRepository.SaveLogProject( new LogProject { create_date = DateTime.Now , log = $"[{summary}] : 새 기기 등록으로 인한 새 키 부여"}))
                    {
                        _logger.LogInformation($"[{summary}] : 성공");
                    }
                    else
                    {
                        _logger.LogInformation($"[{summary}] : 성공 - 로그 저장 실패 ");
                    }
                    return APIResponse.Send<object>("000", $"[{summary}], 정상", new { header = headerValue });
                }
                else
                {
                    // 저장이 안되었다? == 서버 오류
                    return APIResponse.InternalSeverError();
                }
            }
        }
        else
        {
            // 헤더 없단 소리 == 문제 있음
            return APIResponse.InvalidInputError();
        }
    }
    
    private string KeyGenerator(string combineText)
    {
        using (SHA256 sha256 = SHA256.Create())
        {
            byte[] hashBytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(combineText));
            return BitConverter.ToString(hashBytes).Replace("-", string.Empty).ToLowerInvariant();
        }
    }


    public async Task<APIResponseStatus<object>> GetVersion(string summary, string type)
    {
        var version = await _appRepository.FindVersion(type);
        if (version != null)
        {
            var sendVersion = new Version {
                os_type = (version.os_type == "VO01" ? "I" : (version.os_type == "VO02" ? "A" : "W")),
                final_ver = version.final_ver,
                force_ver = version.force_ver,
                dev_ver = version.dev_ver,
                choice_update_yn = version.choice_update_yn
            };
            return APIResponse.Send<object>("000", $"[{summary}], 정상", sendVersion);
        }
        else
        {
            return APIResponse.NotFoundError();
        }
    }

    public async Task<APIResponseStatus<object>> RetryAccess(string summary, string refresh)
    {
        var refreshToken = await _appRepository.FindRefreshToken(refresh);
        if (refreshToken == null) return APIResponse.InvalidInputError($"[{summary}] : 리프레시 토큰 문제");
        if (refreshToken.revoke_Date != null) return APIResponse.InvalidInputError($"[{summary}] : 리프레시 토큰 폐기");
        if (refreshToken.expire_date < DateTime.Now) return APIResponse.InvalidInputError($"[{summary}] : 리프레시 토큰 만료");

        string access = _jwtTokenService.GenerateJwtToken(refreshToken.uid);
        return APIResponse.Send<object>("000", $"[{summary}], 토큰 생성 완료", new { access = access });
    }
    
}