AipGateway/Aip.Service/Controllers/ApiFileController.cs

using Aip.Service.Aip.Serivces;
using Aip.Service.Models.Request;
using Aip.Service.Models.Response;
using Aip.Service.Repositories;
using Aip.Service.Services.Interfaces;
using Aip.Service.Utils;
using AipGateway.Messaging.Models;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.InformationProtection;
using Swashbuckle.AspNetCore.Annotations;
using System;
using System.ComponentModel.DataAnnotations;
using System.Diagnostics;

namespace Aip.Service.Controllers;


[ApiController]
[Route("/api/v1/file")]
[Produces("application/json")]
public class ApiFileController : BaseController
{
    private readonly ILogger<ApiFileController> _log;
    private readonly IApiConfigService _configService;
    private readonly IApiAuthService _authService;
    private readonly IApiFileService _service;
    private readonly IAipDbLoggingService _aipDbLoggingService;

    public ApiFileController(ILogger<ApiFileController> log, IApiConfigService configService, IApiAuthService authService, IApiFileService apiFileService, IAipDbLoggingService aipDbLoggingService)
    {
        _log = log;
        _configService = configService;
        _authService = authService;
        _service = apiFileService;
        _aipDbLoggingService = aipDbLoggingService;
    }

    [HttpPost("info")]
    [SwaggerResponse(200, type: typeof(ApiResponseModel<ResponseInfo>))]
    public async Task<IResult> GetFileInfo([FromBody] RequestFileInfo req)
    {
        return await CreateResponseAsync(async () =>
        {
            GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_FILE_INFO, req.apiKey, req);
            HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
            int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_FILE_INFO);
            if (authError != 0)
            {
                throw ResponseApiKeyValidationError(HttpContext, authError);
            }
            var response = await _service.GetInfo(req);
            return Results.Ok(ResponseSuccess(HttpContext, response));
        });
    }
    [HttpPost("set-label")]
    [SwaggerResponse(200, type: typeof(ApiResponseModel<ResponseFile>))]
    public async Task<IResult> SetFileLabel([FromBody] RequestFileSet req)
    {
        return await CreateResponseAsync(async () =>
        {
            GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_FILE_SET_LABEL, req.apiKey, req);
            HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
            int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_FILE_SET_LABEL);
            if (authError != 0)
            {
                throw ResponseApiKeyValidationError(HttpContext, authError);
            }
            var response = await _service.SetLabel(req);
            return Results.Ok(ResponseSuccess(HttpContext, response));
        });
    }

    [HttpPost("set-labels")]
    [SwaggerResponse(200, type: typeof(ApiResponseModel<List<ResponseFile>>))]
    public async Task<IResult> SetFileLabels([FromBody] RequestMultiFileSet req)
    {
        return await CreateResponseAsync(async () =>
        {
            var start = Stopwatch.GetTimestamp();
            _log.LogInformation("SetFileLabels Request Start: {0} EA.", req.files.Count);

            GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_FILE_SET_LABELS, req.apiKey, req);
            HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
            int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_FILE_SET_LABELS);
            if (authError != 0)
            {
                throw ResponseApiKeyValidationError(HttpContext, authError);
            }

            DateTime dateTime = DateTime.Now;
            string? remoteIpAddr = HttpContext.Connection.RemoteIpAddress?.ToString();
            string guid = GlobalConstants.GetApiGuid(HttpContext);

            int jobs = req.files.Count;
            List<ResponseFile> result = new List<ResponseFile>();
            var tasks = new List<Task<ResponseFile>>();
            foreach (var obj in req.files)
            {
                RequestFileSet reqSet = new RequestFileSet
                {
                    apiKey = req.apiKey,
                    email = req.email,
                    decryptKey = req.decryptKey,
                    aipGuid = req.aipGuid,
                    comment = req.comment,
                    file = new RequestFile
                    {
                        dispFileName = obj.dispFileName,
                        realFileName = obj.realFileName,
                    }
                };

                tasks.Add(_service.SetLabel(reqSet));
            }
            await Task.WhenAll(tasks);
            foreach (var task in tasks)
            {
                result.Add(task.Result);
                _aipDbLoggingService.Send(new FileJobLog
                {
                    FileId = guid,
                    ApiGuid = guid,
                    ApiId = GlobalConstants.API_FILE_SET_LABEL,
                    ServerIpAddr = remoteIpAddr,

                    JobResult = task.Result.errorCode,
                    JobMessage = task.Result.errorMessage,

                    FileName = task.Result.dispFileName,
                    FileExt = Path.GetExtension(task.Result.dispFileName),
                    FileOwner = task.Result.FileOwner,
                    FileLabelGuid = task.Result.FileLabelGuid,
                    FileProtectionGuid = task.Result.FileProtectionGuid,
                    FileSize = task.Result.FileSize,

                    NewFileName = task.Result.NewFileName,
                    NewFileExt = Path.GetExtension(task.Result.NewFileName),
                    NewFileOwner = task.Result.NewFileOwner,
                    NewFileLabelGuid = task.Result.NewFileLabelGuid,
                    NewFileProtectionGuid = task.Result.NewFileProtectionGuid,
                    NewFileSize = task.Result.NewFileSize,


                    JobOwner = req.email,
                    ApiKey = req.apiKey,
                    DecryptKey = req.decryptKey,

                    JobTime = TimeUtils.GetElapsedMilliseconds(dateTime, task.Result.endDateTime),
                    TimeStamp = task.Result.endDateTime
                });
            }
            HttpContext.Items[GlobalConstants.API_RESULT_CODE] = GlobalConstants.API_RESULT_SUCCESS_CODE;
            HttpContext.Items[GlobalConstants.API_RESULT_MESSAGE] = GlobalConstants.API_RESULT_SUCCESS;

            _log.LogInformation("SetFileLabels Request ..End: {0} EA. {1} ms.", req.files.Count, TimeUtils.GetElapsedMilliseconds(start));

            return Results.Ok(new ApiResponseModel<List<ResponseFile>>()
            {
                success = true,
                errorCode = 0,
                errorMessage = GlobalConstants.API_RESULT_SUCCESS,
                result = result,
            });
        });
    }
    [HttpPost("set-labels1")]
    [SwaggerResponse(200, type: typeof(ApiResponseModel<List<ResponseFile>>))]
    public async Task<IResult> SetFileLabels1([FromBody] RequestMultiFileSet req)
    {
        return await CreateResponseAsync(async () =>
        {
            GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_FILE_SET_LABELS, req.apiKey, req);
            HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
            int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_FILE_SET_LABELS);
            if (authError != 0)
            {
                throw ResponseApiKeyValidationError(HttpContext, authError);
            }

            // 쓰레드를 모두 한번에 실행
            var result = await _service.SetLabels1(req);
            HttpContext.Items[GlobalConstants.API_RESULT_CODE] = GlobalConstants.API_RESULT_SUCCESS_CODE;
            HttpContext.Items[GlobalConstants.API_RESULT_MESSAGE] = GlobalConstants.API_RESULT_SUCCESS;

            return Results.Ok(new ApiResponseModel<List<ResponseFile>>()
            {
                success = true,
                errorCode = 0,
                errorMessage = GlobalConstants.API_RESULT_SUCCESS,
                result = result,
            });
        });

    }
    [HttpPost("set-labels2")]
    [SwaggerResponse(200, type: typeof(ApiResponseModel<List<ResponseFile>>))]
    public async Task<IResult> SetFileLabels2([FromBody] RequestMultiFileSet req)
    {
        return await CreateResponseAsync(async () =>
        {
            GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_FILE_SET_LABELS, req.apiKey, req);
            HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
            int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_FILE_SET_LABELS);
            if (authError != 0)
            {
                throw ResponseApiKeyValidationError(HttpContext, authError);
            }
            // 스레드 그룹으로 나누어서
            var response = await _service.SetLabels(req);
            return Results.Ok(new ApiResponseModel<List<ResponseFile>>()
            {
                success = true,
                errorCode = 0,
                errorMessage = GlobalConstants.API_RESULT_SUCCESS,
                result = response,
            });
        });
    }
    [HttpPost("set-labels3")]
    [SwaggerResponse(200, type: typeof(ApiResponseModel<List<ResponseFile>>))]
    public async Task<IResult> SetFileLabels3([FromBody] RequestMultiFileSet req)
    {
        return await CreateResponseAsync(async () =>
        {
            GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_FILE_SET_LABELS, req.apiKey, req);
            HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
            int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_FILE_SET_LABELS);
            if (authError != 0)
            {
                throw ResponseApiKeyValidationError(HttpContext, authError);
            }

            // 단일 쓰레드 방식
            var result = await _service.SetLabels3(req);
            HttpContext.Items[GlobalConstants.API_RESULT_CODE] = GlobalConstants.API_RESULT_SUCCESS_CODE;
            HttpContext.Items[GlobalConstants.API_RESULT_MESSAGE] = GlobalConstants.API_RESULT_SUCCESS;

            return Results.Ok(new ApiResponseModel<List<ResponseFile>>()
            {
                success = true,
                errorCode = 0,
                errorMessage = GlobalConstants.API_RESULT_SUCCESS,
                result = result,
            });
        });
    }
    [HttpPost("set-labels4")]
    [SwaggerResponse(200, type: typeof(ApiResponseModel<List<ResponseFile>>))]
    public async Task<IResult> SetFileLabels4([FromBody] RequestMultiFileSet req)
    {
        return await CreateResponseAsync(async () =>
        {
            GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_FILE_SET_LABELS, req.apiKey, req);
            HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
            int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_FILE_SET_LABELS);
            if (authError != 0)
            {
                throw ResponseApiKeyValidationError(HttpContext, authError);
            }

            // 단일 쓰레드 방식
            var result = await _service.SetLabels4(req);
            HttpContext.Items[GlobalConstants.API_RESULT_CODE] = GlobalConstants.API_RESULT_SUCCESS_CODE;
            HttpContext.Items[GlobalConstants.API_RESULT_MESSAGE] = GlobalConstants.API_RESULT_SUCCESS;

            return Results.Ok(new ApiResponseModel<List<ResponseFile>>()
            {
                success = true,
                errorCode = 0,
                errorMessage = GlobalConstants.API_RESULT_SUCCESS,
                result = result,
            });
        });
    }
    [HttpPost("delete-label")]
    [SwaggerResponse(200, type: typeof(ApiResponseModel<ResponseFile>))]
    public async Task<IResult> DelFileLabel([FromBody] RequestFileDel req)
    {
        return await CreateResponseAsync(async () =>
        {
            GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_FILE_DELETE_LABEL, req.apiKey, req);
            HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
            int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_FILE_DELETE_LABEL);
            if (authError != 0)
            {
                throw ResponseApiKeyValidationError(HttpContext, authError);
            }
            var response = await _service.DelLabel(req);
            return Results.Ok(ResponseSuccess(HttpContext, response));
        });
    }

    [HttpPost("delete-labels")]
    [SwaggerResponse(200, type: typeof(ApiResponseModel<ResponseFile>))]
    public async Task<IResult> DelFileLabels([FromBody] RequestMultiFileDel req)
    {
        return await CreateResponseAsync(async () =>
        {
            var start = Stopwatch.GetTimestamp();
            _log.LogInformation("DelFileLabels Request Start: {0} EA.", req.files.Count);

            GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_FILE_DELETE_LABELS, req.apiKey, req);
            HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
            int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_FILE_DELETE_LABELS);
            if (authError != 0)
            {
                throw ResponseApiKeyValidationError(HttpContext, authError);
            }

            DateTime dateTime = DateTime.Now;
            string? remoteIpAddr = HttpContext.Connection.RemoteIpAddress?.ToString();
            string guid = GlobalConstants.GetApiGuid(HttpContext);
            
            int jobs = req.files.Count;
            List<ResponseFile> result = new List<ResponseFile>();
            var tasks = new List<Task<ResponseFile>>();
            foreach (var obj in req.files)
            {
                RequestFileDel reqSet = new RequestFileDel
                {
                    apiKey = req.apiKey,
                    email = req.email,
                    decryptKey = req.decryptKey,
                    comment = req.comment,
                    file = new RequestFile
                    {
                        dispFileName = obj.dispFileName,
                        realFileName = obj.realFileName,
                    }
                };

                tasks.Add(_service.DelLabel(reqSet));
            }
            await Task.WhenAll(tasks);
            foreach (var task in tasks)
            {
                result.Add(task.Result);
                _aipDbLoggingService.Send(new FileJobLog
                {
                    FileId = guid,
                    ApiGuid = guid,
                    ApiId = GlobalConstants.API_FILE_DELETE_LABEL,
                    ServerIpAddr = remoteIpAddr,

                    JobResult = task.Result.errorCode,
                    JobMessage = task.Result.errorMessage,

                    FileName = task.Result.dispFileName,
                    FileExt = Path.GetExtension(task.Result.dispFileName),
                    FileOwner = task.Result.FileOwner,
                    FileLabelGuid = task.Result.FileLabelGuid,
                    FileProtectionGuid = task.Result.FileProtectionGuid,
                    FileSize = task.Result.FileSize,

                    NewFileName = task.Result.NewFileName,
                    NewFileExt = Path.GetExtension(task.Result.NewFileName),
                    NewFileOwner = task.Result.NewFileOwner,
                    NewFileLabelGuid = task.Result.NewFileLabelGuid,
                    NewFileProtectionGuid = task.Result.NewFileProtectionGuid,
                    NewFileSize = task.Result.NewFileSize,


                    JobOwner = req.email,
                    ApiKey = req.apiKey,
                    DecryptKey = req.decryptKey,

                    JobTime = TimeUtils.GetElapsedMilliseconds(dateTime, task.Result.endDateTime),
                    TimeStamp = task.Result.endDateTime
                });
            }
            HttpContext.Items[GlobalConstants.API_RESULT_CODE] = GlobalConstants.API_RESULT_SUCCESS_CODE;
            HttpContext.Items[GlobalConstants.API_RESULT_MESSAGE] = GlobalConstants.API_RESULT_SUCCESS;

            _log.LogInformation("DelFileLabels Request ..End: {0} EA. {1} ms.", req.files.Count, TimeUtils.GetElapsedMilliseconds(start));

            return Results.Ok(new ApiResponseModel<List<ResponseFile>>()
            {
                success = true,
                errorCode = 0,
                errorMessage = GlobalConstants.API_RESULT_SUCCESS,
                result = result,
            });
        });
    }

    [HttpPost("set-protection")]
    [SwaggerResponse(200, type: typeof(ApiResponseModel<ResponseFile>))]
    public async Task<IResult> SetFileProtection([FromBody] RequestFileSet req)
    {
        return await CreateResponseAsync(async () =>
        {
            GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_FILE_SET_PROTECTION, req.apiKey, req);
            HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
            int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_FILE_SET_PROTECTION);
            if (authError != 0)
            {
                throw ResponseApiKeyValidationError(HttpContext, authError);
            }
            var response = await _service.SetProtection(req);
            return Results.Ok(ResponseSuccess(HttpContext, response));
        });
    }

    [HttpPost("delete-protection")]
    [SwaggerResponse(200, type: typeof(ApiResponseModel<ResponseFile>))]
    public async Task<IResult> DelFileProtection([FromBody] RequestFileDel req)
    {
        return await CreateResponseAsync(async () =>
        {
            GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_FILE_DELETE_PROTECTIN, req.apiKey, req);
            HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
            int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_FILE_DELETE_PROTECTIN);
            if (authError != 0)
            {
                throw ResponseApiKeyValidationError(HttpContext, authError);
            }
            var response = await _service.RemoveProtection(req);
            return Results.Ok(ResponseSuccess(HttpContext, response));
        });
    }


    [HttpPost("set-label-protection")]
    [SwaggerResponse(200, type: typeof(ApiResponseModel<ResponseFile>))]
    public async Task<IResult> SetFileLabelProtection([FromBody] RequestFileAllSet req)
    {
        return await CreateResponseAsync(async () =>
        {
            GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_FILE_SET_LABEL_PROTECTION, req.apiKey, req);
            HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
            int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_FILE_SET_LABEL_PROTECTION);
            if (authError != 0)
            {
                throw ResponseApiKeyValidationError(HttpContext, authError);
            }
            var response = await _service.SetLabelProtection(req);
            return Results.Ok(ResponseSuccess(HttpContext, response));
        });
    }

    [HttpPost("delete-label-protection")]
    [SwaggerResponse(200, type: typeof(ApiResponseModel<ResponseFile>))]
    public async Task<IResult> DelFileLabelProtection([FromBody] RequestFileDel req)
    {
        return await CreateResponseAsync(async () =>
        {
            GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_FILE_DELETE_LABEL_PROTECTION, req.apiKey, req);
            HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
            int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_FILE_DELETE_LABEL_PROTECTION);
            if (authError != 0)
            {
                throw ResponseApiKeyValidationError(HttpContext, authError);
            }
            var response = await _service.RemoveLabelProtection(req);
            return Results.Ok(ResponseSuccess(HttpContext, response));
        });
    }

    [HttpPost("encrypt")]
    [SwaggerResponse(200, type: typeof(ApiResponseModel<ResponseFile>))]
    public async Task<IResult> EncryptFile([Required] IFormFile file, [Required] string apiKey, [Required] string email)
    {
        return await CreateResponseAsync(async () =>
        {
            RequestBase req = new RequestBase
            {
                apiKey = apiKey,
                email = email,
                decryptKey = string.Empty,
                apiGuid = string.Empty
            };
            GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_FILE_ENCRYPT, apiKey, req);
            HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
            int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_FILE_ENCRYPT);
            if (authError != 0)
            {
                throw ResponseApiKeyValidationError(HttpContext, authError);
            }
            var response = await _service.EncryptFile(file, req);
            return Results.Ok(ResponseSuccess(HttpContext, response));
        });
    }
    [HttpPost("decrypt")]
    [SwaggerResponse(200, type: typeof(ApiResponseModel<ResponseFile>))]
    public async Task<IResult> DecryptFile([Required] IFormFile file, [Required] string apiKey, [Required] string email)
    {
        return await CreateResponseAsync(async () =>
        {
            RequestBase req = new RequestBase
            {
                apiKey = apiKey,
                email = email,
                decryptKey = string.Empty,
                apiGuid = string.Empty
            };
            GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_FILE_DECRYPT, apiKey, req);
            HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
            int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_FILE_DECRYPT);
            if (authError != 0)
            {
                throw ResponseApiKeyValidationError(HttpContext, authError);
            }
            var response = await _service.DecryptFile(file, req);
            return Results.Ok(ResponseSuccess(HttpContext, response));
        });
    }
}