AipGateway/AipGateway.AIP.Service/Services/ApiFileService.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 System.Diagnostics;
using AipGateway.AIP.Service.Utils;

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


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

        public async Task<ResponseInfo> GetInfo(RequestFileInfo req)
        {
            try
            {
                string reqFileName = _aipFileService.GetRequestFileName(req.file.realFileName);
                if (!AipFileUtils.isExists(reqFileName))
                {
                    return new ResponseInfo
                    {
                        errorCode = 101,
                        errorMessage = "파일이 존재하지 않습니다.",
                    };
                }

                string? newFileExt = _aipFileService.GetSupportedFileType(reqFileName);
                if (newFileExt == null)
                {
                    return new ResponseInfo
                    {
                        errorCode = 102,
                        errorMessage = "지원하지 않는 파일형식 입니다.",
                    };
                }
                var task = Task.Run(() =>
                {
                    return ResponseGetFileInfo(_aipFileService.aipFileManager.GetFileInfo(reqFileName), req.file.dispFileName);
                });
                ResponseInfo result = await task;
                return result;
            }
            catch(AipFileException ex)
            {
                return ResponseInfoException(ex);
            }
            catch (Exception e)
            {
                return ResponseInfoException(e);
            }
        }

        public async Task<ResponseFile> SetLabel(RequestFileSet req)
        {
            try
            {
                CheckAip check = CheckAipRequest(req.apiGuid, req.file.dispFileName, req.file.realFileName, false, 1);
                if (check.errorCode != 0)
                {
                    return new ResponseFile
                    {
                        errorCode = check.errorCode,
                        errorMessage = check.errorMessage,
                        dispFileName = check.dispFileName,
                        realFileName = req.file.realFileName,
                        actualFileName = check.actualFileName,
                    };
                }

                var task = Task.Run(() =>
                {
                    Stopwatch sw = new Stopwatch();
                    sw.Start();
                    _log.LogInformation("SetLabel: [{0}], AipFileService............Start:  {1}", Task.CurrentId, req.file.dispFileName);

                    SetFileInfo fileInfo = _aipFileService.aipFileManager.SetLabel(check.reqFileName, check.actualFileName, req.email, req.aipGuid, "", req.comment);

                    sw.Stop();
                    _log.LogInformation("SetLabel: [{0}], AipFileService..............End: {1,6} ms. actualFileName: {2}", Task.CurrentId, sw.ElapsedMilliseconds.ToString("#,##0"), req.file.dispFileName);

                    return ResponseSetFile(fileInfo, req.file.dispFileName, req.file.realFileName, Path.GetFileName(fileInfo.newFileName));
                });
                ResponseFile result = await task;
                return result;
            }
            catch (AipFileException ex)
            {
                return ResponseFileException(ex, req.file.dispFileName);
            }
            catch (Exception e)
            {
                return ResponseFileException(e, req.file.dispFileName);
            }
        }
        
        public async Task<List<SetFileInfo>> SetAipFileLabels(RequestMultiFileSet reqSet)
        {
            var startTotal = Stopwatch.GetTimestamp();
            _log.LogError("SetAipFileLabels Tatal {0} EA. Start.", reqSet.files.Count);

            List<SetFileInfo> result = new List<SetFileInfo>();
            var tasks = new List<Task<SetFileInfo>>();
            foreach (RequestFile req in reqSet.files)
            {
                CheckAip check = CheckAipRequest(reqSet.apiGuid, req.dispFileName, req.realFileName, false, 1);
                if (check.errorCode != 0)
                {
                    continue;
                }

                tasks.Add(Task.Run(() =>
                {
                    //Thread.Sleep(100);
                    SetFileInfo fileInfo = _aipFileService.aipFileManager.SetLabel(check.reqFileName, check.actualFileName, reqSet.email, reqSet.aipGuid, "", reqSet.comment);
                    return fileInfo;
                }));
            }
            await Task.WhenAll(tasks);
            foreach (var task in tasks)
            {
                result.Add(task.Result);
            }
            _log.LogError("====================== SetAipFileLabels Tatal {0} EA. ..Stop. {1} ms.", reqSet.files.Count, TimeUtils.GetElapsedMilliseconds(startTotal));
            return result;
        }

#if false
        public async Task<ResponseFile> SetLabels(RequestFileSet req)
        {
            try
            {
                CheckAip check = CheckAipRequest(req.apiGuid, req.file.dispFileName, req.file.realFileName, false, 1);
                if (check.errorCode != 0)
                {
                    return new ResponseFile
                    {
                        errorCode = check.errorCode,
                        errorMessage = check.errorMessage,
                        dispFileName = check.dispFileName,
                        realFileName = req.file.realFileName,
                        actualFileName = check.actualFileName,
                    };
                }

                var task = Task.Run(() =>
                {
                    SetFileInfo fileInfo = _aipFileService.aipFileManager.SetLabel(check.reqFileName, check.actualFileName, req.email, req.aipGuid, "", req.comment);
                    return ResponseSetFile(fileInfo, req.file.dispFileName, req.file.realFileName, Path.GetFileName(fileInfo.newFileName));
                });
                ResponseFile result = await task;

                _log.LogWarning($"Completed SetLabel: {req.file.dispFileName}");
                return result;
            }
            catch (AipFileException ex)
            {
                return ResponseFileException(ex, req.file.dispFileName);
            }
            catch (Exception e)
            {
                return ResponseFileException(e, req.file.dispFileName);
            }
        }
#endif
        public async Task<List<ResponseFile>> SetLabels(RequestMultiFileSet reqSet)
        {
            List<ResponseFile> result = new List<ResponseFile>();
            var tasks = new List<Task<ResponseFile>>();
            try
            {
                foreach (RequestFile req in reqSet.files)
                {
                    CheckAip check = CheckAipRequest(reqSet.apiGuid, req.dispFileName, req.realFileName, false, 1);
                    if (check.errorCode != 0)
                    {
                        result.Add(new ResponseFile
                        {
                            errorCode = check.errorCode,
                            errorMessage = check.errorMessage,
                            dispFileName = check.dispFileName,
                            realFileName = req.realFileName,
                            actualFileName = check.actualFileName,
                        });
                        continue;
                    }
                    tasks.Add(Task.Run(() =>
                    {
                        Thread.Sleep(100);
                        SetFileInfo fileInfo = _aipFileService.aipFileManager.SetLabel(check.reqFileName, check.actualFileName, reqSet.email, reqSet.aipGuid, "", reqSet.comment);
                        return ResponseSetFile(fileInfo, req.dispFileName, req.realFileName, Path.GetFileName(fileInfo.newFileName));
                    }));
                }

                await Task.WhenAll(tasks);
                foreach (var task in tasks)
                {
                    result.Add(task.Result);
                }
            }
            catch (AipFileException ex)
            {
                var exceptionResult = ResponseFileException(ex, reqSet.apiKey);
                result.Add(exceptionResult);
            }
            catch (Exception e)
            {
                var exceptionResult = ResponseFileException(e, reqSet.apiKey);
                result.Add(exceptionResult);
            }
            return result;
        }
        public async Task<ResponseFile> DelLabel(RequestFileDel req)
        {
            try
            {
                CheckAip check = CheckAipRequest(req.apiGuid, req.file.dispFileName, req.file.realFileName, false, 2);
                if (check.errorCode != 0)
                {
                    return new ResponseFile
                    {
                        errorCode = check.errorCode,
                        errorMessage = check.errorMessage,
                        dispFileName = check.dispFileName,
                    };
                }

                var task = Task.Run(() =>
                {
                    SetFileInfo fileInfo = _aipFileService.aipFileManager.DeleteLabel(check.reqFileName, check.actualFileName, req.email, req.comment, false);
                    return ResponseSetFile(fileInfo, req.file.dispFileName, req.file.realFileName, Path.GetFileName(fileInfo.newFileName));
                });
                ResponseFile result = await task;
                return result;
            }
            catch (Exception e)
            {
                return ResponseFileException(e, req.file.dispFileName);
            }
        }

        public async Task<ResponseFile> SetProtection(RequestFileSet req)
        {
            try
            {
                CheckAip check = CheckAipRequest(req.apiGuid, req.file.dispFileName, req.file.realFileName, false, 3);
                if (check.errorCode != 0)
                {
                    return new ResponseFile
                    {
                        errorCode = check.errorCode,
                        errorMessage = check.errorMessage,
                        dispFileName = check.dispFileName,
                    };
                }

                var task = Task.Run(() =>
                {
                    SetFileInfo fileInfo = _aipFileService.aipFileManager.SetProtection(check.reqFileName, check.actualFileName, req.email, req.aipGuid, req.comment);
                    return ResponseSetFile(fileInfo, req.file.dispFileName, req.file.realFileName, Path.GetFileName(fileInfo.newFileName));
                });
                ResponseFile result = await task;
                return result;
            }
            catch (Exception e)
            {
                return ResponseFileException(e, req.file.dispFileName);
            }
        }

        public async Task<ResponseFile> DelProtection(RequestFileDel req)
        {
            try
            {
                CheckAip check = CheckAipRequest(req.apiGuid, req.file.dispFileName, req.file.realFileName, false, 4);
                if (check.errorCode != 0)
                {
                    return new ResponseFile
                    {
                        errorCode = check.errorCode,
                        errorMessage = check.errorMessage,
                        dispFileName = check.dispFileName,
                    };
                }

                var task = Task.Run(() =>
                {
                    SetFileInfo fileInfo = _aipFileService.aipFileManager.DeleteProtection(check.reqFileName, check.actualFileName, req.email, req.comment);
                    return ResponseSetFile(fileInfo, req.file.dispFileName, req.file.realFileName, Path.GetFileName(fileInfo.newFileName));
                });
                ResponseFile result = await task;
                return result;
            }
            catch (Exception e)
            {
                return ResponseFileException(e, req.file.dispFileName);
            }
        }

        public async Task<ResponseFile> SetLabelProtection(RequestFileAllSet req)
        {
            try
            {
                CheckAip check = CheckAipRequest(req.apiGuid, req.file.dispFileName, req.file.realFileName, false, 3);
                if (check.errorCode != 0)
                {
                    return new ResponseFile
                    {
                        errorCode = check.errorCode,
                        errorMessage = check.errorMessage,
                        dispFileName = check.dispFileName,
                    };
                }

                var task = Task.Run(() =>
                {
                    SetFileInfo fileInfo = _aipFileService.aipFileManager.SetLabel(check.reqFileName, check.actualFileName, req.email, req.aipGuid, req.templateGuid, req.comment);
                    return ResponseSetFile(fileInfo, req.file.dispFileName, req.file.realFileName, Path.GetFileName(fileInfo.newFileName));
                });
                ResponseFile result = await task;
                return result;
            }
            catch (Exception e)
            {
                return ResponseFileException(e, req.file.dispFileName);
            }
        }

        public async Task<ResponseFile> DelLabelProtection(RequestFileDel req)
        {
            try
            {
                CheckAip check = CheckAipRequest(req.apiGuid, req.file.dispFileName, req.file.realFileName, false, 4);
                if (check.errorCode != 0)
                {
                    return new ResponseFile
                    {
                        errorCode = check.errorCode,
                        errorMessage = check.errorMessage,
                        dispFileName = check.dispFileName,
                    };
                }

                var task = Task.Run(() =>
                {
                    SetFileInfo fileInfo = _aipFileService.aipFileManager.DeleteLabel(check.reqFileName, check.actualFileName, req.email, req.comment, true);
                    return ResponseSetFile(fileInfo, req.file.dispFileName, req.file.realFileName, Path.GetFileName(fileInfo.newFileName));
                });
                ResponseFile result = await task;
                return result;
            }
            catch (Exception e)
            {
                return ResponseFileException(e, req.file.dispFileName);
            }
        }

        public async Task<ResponseFile> EncryptFile(IFormFile file, RequestBase baseReq)
        {
            CheckMultipartFile check = ValidateMultipartFile(file, baseReq.apiGuid);
            try
            {
                if (check.errorCode != 0)
                {
                    return new ResponseFile
                    {
                        errorCode = check.errorCode,
                        errorMessage = check.errorMessage,
                        dispFileName = check.dispFileName,
                    };
                }
                RequestFileSet req = new RequestFileSet
                {
                    apiKey = baseReq.apiKey,
                    email = baseReq.email,
                    apiGuid = baseReq.apiGuid,
                    decryptKey = string.Empty,
                    file = new RequestFile
                    {
                        dispFileName = check.dispFileName,
                        realFileName = check.saveFileName,
                    },
                    aipGuid = _aipFileService.aipSetting.SetLabelId,
                    comment = "EncryptFile"
                };
                ResponseFile result = await SetLabel(req);
                return result;
            }
            catch (Exception e)
            {
                return ResponseFileException(e, file.FileName);
            }
            finally
            {
                AipFileUtils.delete(_aipFileService.GetRequestFileName(check.saveFileName));
            }
        }

        public async Task<ResponseFile> DecryptFile(IFormFile file, RequestBase baseReq)
        {
            CheckMultipartFile check = ValidateMultipartFile(file, baseReq.apiGuid);
            try
            {
                if (check.errorCode != 0)
                {
                    return new ResponseFile
                    {
                        errorCode = check.errorCode,
                        errorMessage = check.errorMessage,
                        dispFileName = check.dispFileName,
                    };
                }
                RequestFileDel req = new RequestFileDel
                {
                    apiKey = baseReq.apiKey,
                    email = baseReq.email,
                    apiGuid = baseReq.apiGuid,
                    decryptKey = string.Empty,
                    file = new RequestFile
                    {
                        dispFileName = check.dispFileName,
                        realFileName = check.saveFileName,
                    },
                    comment = "DecryptFile"
                };
                ResponseFile result = await DelLabel(req);
                return result;
            }
            catch (Exception e)
            {
                return ResponseFileException(e, file.FileName);
            }
            finally
            {
                AipFileUtils.delete(_aipFileService.GetRequestFileName(check.saveFileName));
            }
        }
    }
}