AipGateway/AipGateway.AIP.Service/Services/ApiStreamService.cs

using AipGateway.API.Application.Interfaces.Services;
using AipGateway.API.Application.Utils;
using AipGateway.API.Domain.Models.App;
using AipGateway.API.Domain.Models.Request;
using AipGateway.API.Domain.Models.Response;
using AipGateway.AIP.Service.Services.Interfaces;
using AipGateway.AIP.Service.Utils;

namespace AipGateway.AIP.Service.Services
{
    public class ApiStreamService : BaseService, IApiStreamService
    {
        private readonly ILogger<ApiStreamService> _log;


        public ApiStreamService(ILogger<ApiStreamService> log, IAipFileService aipFileService)
            : base(aipFileService)
        {
            _log = log;
        }

        public async Task<ResponseInfo> GetInfo(RequestStreamInfo req)
        {
            //string tempOrgFileName = _aipFileService.GetRequestFileName(req.apiGuid + AipFileUtils.getExtension(req.dispFileName));
            string actualFileName = _aipFileService.GetActualFileName(req.apiGuid + AipFileUtils.getExtension(req.stream.dispFileName));
            try
            {
                string? newFileExt = _aipFileService.GetSupportedFileType(req.stream.dispFileName);
                if (newFileExt == null)
                {
                    return new ResponseInfo
                    {
                        errorCode = 102,
                        errorMessage = "지원하지 않는 파일형식 입니다.",
                    };
                }

                var task = Task.Run(() =>
                {
                    using (var stream = new MemoryStream(Convert.FromBase64String(req.stream.fileData)))
                    {
                        return ResponseGetFileInfo(_aipFileService.aipFileManager.GetFileInfo(stream, actualFileName), req.stream.dispFileName);
                    }
                });
                ResponseInfo result = await task;
                return result;
            }
            catch (Exception e)
            {
                return ResponseInfoException(e);
            }
            finally
            {
                FileUtils.DeleteFile(actualFileName);
            }
        }

        public async Task<ResponseStream> SetLabel(RequestStreamSet req)
        {
            CheckAip check = CheckAipRequest(req.apiGuid, req.stream.dispFileName, "", true, 1);
            if (check.errorCode != 0)
            {
                return new ResponseStream
                {
                    errorCode = check.errorCode,
                    errorMessage = check.errorMessage,
                    dispFileName = check.dispFileName,
                };
            }

            try
            {
                var task = Task.Run(() =>
                {
                    using (var stream = new MemoryStream(Convert.FromBase64String(req.stream.fileData)))
                    {
                        SetFileInfo fileInfo = _aipFileService.aipFileManager.SetLabel(stream, check.actualFileName, req.email, req.aipGuid, "", req.comment);
                        return ResponseSetStream(fileInfo, req.stream.dispFileName, Path.GetFileName(fileInfo.newFileName));
                    }
                });
                ResponseStream result = await task;
                return result;
            }
            catch (Exception e)
            {
                return ResponseStreamException(e, req.stream.dispFileName);
            }
            finally
            {
                FileUtils.DeleteFile(check.actualFileName);
            }
        }

        public async Task<ResponseStream> DelLabel(RequestStreamDel req)
        {
            CheckAip check = CheckAipRequest(req.apiGuid, req.stream.dispFileName, "", true, 2);
            if (check.errorCode != 0)
            {
                return new ResponseStream
                {
                    errorCode = check.errorCode,
                    errorMessage = check.errorMessage,
                    dispFileName = check.dispFileName,
                };
            }

            try
            {
                var task = Task.Run(() =>
                {
                    using (var stream = new MemoryStream(Convert.FromBase64String(req.stream.fileData)))
                    {
                        SetFileInfo fileInfo = _aipFileService.aipFileManager.DeleteLabel(stream, check.actualFileName, req.email, req.comment);
                        return ResponseSetStream(fileInfo, req.stream.dispFileName, Path.GetFileName(fileInfo.newFileName));
                    }
                });
                ResponseStream result = await task;
                return result;
            }
            catch (Exception e)
            {
                return ResponseStreamException(e, req.stream.dispFileName);
            }
            finally
            {
                FileUtils.DeleteFile(check.actualFileName);
            }
        }

        public async Task<ResponseStream> SetProtection(RequestStreamSet req)
        {
            CheckAip check = CheckAipRequest(req.apiGuid, req.stream.dispFileName, "", true, 3);
            if (check.errorCode != 0)
            {
                return new ResponseStream
                {
                    errorCode = check.errorCode,
                    errorMessage = check.errorMessage,
                    dispFileName = check.dispFileName,
                };
            }

            try
            {
                var task = Task.Run(() =>
                {
                    using (var stream = new MemoryStream(Convert.FromBase64String(req.stream.fileData)))
                    {
                        SetFileInfo fileInfo = _aipFileService.aipFileManager.SetProtection(stream, check.actualFileName, req.email, req.aipGuid, req.comment);
                        return ResponseSetStream(fileInfo, req.stream.dispFileName, Path.GetFileName(fileInfo.newFileName));
                    }
                });
                ResponseStream result = await task;
                return result;
            }
            catch (Exception e)
            {
                return ResponseStreamException(e, req.stream.dispFileName);
            }
            finally
            {
                FileUtils.DeleteFile(check.actualFileName);
            }
        }

        public async Task<ResponseStream> DelProtection(RequestStreamDel req)
        {
            CheckAip check = CheckAipRequest(req.apiGuid, req.stream.dispFileName, "", true, 4);
            if (check.errorCode != 0)
            {
                return new ResponseStream
                {
                    errorCode = check.errorCode,
                    errorMessage = check.errorMessage,
                    dispFileName = check.dispFileName,
                };
            }

            try
            {
                var task = Task.Run(() =>
                {
                    using (var stream = new MemoryStream(Convert.FromBase64String(req.stream.fileData)))
                    {
                        SetFileInfo fileInfo = _aipFileService.aipFileManager.DeleteLabel(stream, check.actualFileName, req.email, req.comment);
                        return ResponseSetStream(fileInfo, req.stream.dispFileName, Path.GetFileName(fileInfo.newFileName));
                    }
                });
                ResponseStream result = await task;
                return result;
            }
            catch (Exception e)
            {
                return ResponseStreamException(e, req.stream.dispFileName);
            }
            finally
            {
                FileUtils.DeleteFile(check.actualFileName);
            }
        }

        public async Task<ResponseStream> SetLabelProtection(RequestStreamAllSet req)
        {
            CheckAip check = CheckAipRequest(req.apiGuid, req.stream.dispFileName, "", true, 3);
            if (check.errorCode != 0)
            {
                return new ResponseStream
                {
                    errorCode = check.errorCode,
                    errorMessage = check.errorMessage,
                    dispFileName = check.dispFileName,
                };
            }

            try
            {
                var task = Task.Run(() =>
                {
                    using (var stream = new MemoryStream(Convert.FromBase64String(req.stream.fileData)))
                    {
                        SetFileInfo fileInfo = _aipFileService.aipFileManager.SetLabel(stream, check.actualFileName, req.email, req.aipGuid, req.templateGuid, req.comment);
                        return ResponseSetStream(fileInfo, req.stream.dispFileName, Path.GetFileName(fileInfo.newFileName));
                    }
                });
                ResponseStream result = await task;
                return result;
            }
            catch (Exception e)
            {
                return ResponseStreamException(e, req.stream.dispFileName);
            }
            finally
            {
                FileUtils.DeleteFile(check.actualFileName);
            }
        }

        public async Task<ResponseStream> DelLabelProtection(RequestStreamDel req)
        {
            CheckAip check = CheckAipRequest(req.apiGuid, req.stream.dispFileName, "", true, 4);
            if (check.errorCode != 0)
            {
                return new ResponseStream
                {
                    errorCode = check.errorCode,
                    errorMessage = check.errorMessage,
                    dispFileName = check.dispFileName,
                };
            }

            try
            {
                var task = Task.Run(() =>
                {
                    using (var stream = new MemoryStream(Convert.FromBase64String(req.stream.fileData)))
                    {
                        SetFileInfo fileInfo = _aipFileService.aipFileManager.DeleteLabel(stream, check.actualFileName, req.email, req.comment, true);
                        return ResponseSetStream(fileInfo, req.stream.dispFileName, Path.GetFileName(fileInfo.newFileName));
                    }
                });
                ResponseStream result = await task;
                return result;
            }
            catch (Exception e)
            {
                return ResponseStreamException(e, req.stream.dispFileName);
            }
            finally
            {
                FileUtils.DeleteFile(check.actualFileName);
            }
        }

        public async Task<ResponseStream> EncryptFile(IFormFile file, RequestBase baseReq)
        {
            CheckMultipartFile check = ValidateMultipartFile(file, baseReq.apiGuid);
            try
            {
                if (check.errorCode != 0)
                {
                    return new ResponseStream
                    {
                        errorCode = check.errorCode,
                        errorMessage = check.errorMessage,
                        dispFileName = check.dispFileName,
                    };
                }
                string savedFileName = _aipFileService.GetRequestFileName(check.saveFileName);
                RequestStreamSet req = new RequestStreamSet
                {
                    apiKey = baseReq.apiKey,
                    email = baseReq.email,
                    apiGuid = baseReq.apiGuid,
                    decryptKey = string.Empty,
                    stream = new RequestStream
                    {
                        dispFileName = check.dispFileName,
                        fileData = FileUtils.GetFileData(savedFileName),
                    },
                    aipGuid = _aipFileService.aipSetting.SetLabelId,
                    comment = "EncryptFile"
                };
                ResponseStream result = await SetLabel(req);
                return result;
            }
            catch (Exception e)
            {
                return ResponseStreamException(e, file.FileName);
            }
            finally
            {
                AipFileUtils.delete(_aipFileService.GetRequestFileName(check.saveFileName));
            }
        }

        public async Task<ResponseStream> DecryptFile(IFormFile file, RequestBase baseReq)
        {
            CheckMultipartFile check = ValidateMultipartFile(file, baseReq.apiGuid);
            try
            {
                if (check.errorCode != 0)
                {
                    return new ResponseStream
                    {
                        errorCode = check.errorCode,
                        errorMessage = check.errorMessage,
                        dispFileName = check.dispFileName,
                    };
                }
                string savedFileName = _aipFileService.GetRequestFileName(check.saveFileName);
                RequestStreamDel req = new RequestStreamDel
                {
                    apiKey = baseReq.apiKey,
                    email = baseReq.email,
                    apiGuid = baseReq.apiGuid,
                    decryptKey = string.Empty,
                    stream = new RequestStream
                    {
                        dispFileName = check.dispFileName,
                        fileData = FileUtils.GetFileData(savedFileName),
                    },
                    comment = "DecryptFile"
                };
                ResponseStream result = await DelLabel(req);
                return result;
            }
            catch (Exception e)
            {
                return ResponseStreamException(e, file.FileName);
            }
            finally
            {
                AipFileUtils.delete(_aipFileService.GetRequestFileName(check.saveFileName));
            }
        }
    }
}