AipGateway/AipGateway.API/Controllers/ApiStreamController.cs

using AipGateway.API.Application;
using AipGateway.API.Application.Interfaces.Services;
using AipGateway.API.Domain.Models;
using AipGateway.API.Domain.Models.Request;
using AipGateway.API.Domain.Models.Response;
using AipGateway.API.Services;
using AipGateway.API.Services.Interfaces;
using Azure;
using Azure.Core;
using FluentValidation.Validators;
using Microsoft.AspNetCore.Mvc;
using Swashbuckle.AspNetCore.Annotations;
using System.ComponentModel.DataAnnotations;
using System.Diagnostics;

namespace AipGateway.API.Controllers
{
    [ApiController]
    [Route("/api/v1/stream")]
    [Produces("application/json")]
    public class ApiStreamController : BaseController
    {
        private readonly ILogger<ApiStreamController> _log;
        private readonly IApiStreamService _service;
        private readonly IApiAuthService _authService;

        public ApiStreamController(ILogger<ApiStreamController> log, IApiAuthService authService, IApiStreamService apiStreamService)
        {
            _log = log;
            _authService = authService;
            _service = apiStreamService;
        }


        [HttpPost("info")]
        [SwaggerResponse(200, type: typeof(ApiResponseModel<ResponseInfo>))]
        public async Task<IResult> GetStreamInfo([FromBody] RequestStreamInfo req)
        {
            return await CreateResponseAsync(async () =>
            {
                GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_STREAM_INFO, req.apiKey, req);
                HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
                int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_STREAM_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<ResponseStream>))]
        public async Task<IResult> SetStreamLabel([FromBody] RequestStreamSet req)
        {
            return await CreateResponseAsync(async () =>
            {
                GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_STREAM_SET_LABEL, req.apiKey, req);
                HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
                int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_STREAM_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<ResponseStream>>))]
        public async Task<IResult> SetStreamLabels([FromBody] RequestMultiStreamSet req)
        {
            return await CreateResponseAsync(async () =>
            {
                Stopwatch sw = new Stopwatch();
                sw.Start();
                _log.LogInformation("*** Start SetStreamLabels: {0} EA.", req.streams.Count); 
                GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_STREAM_SET_LABELS, req.apiKey, req);
                HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
                int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_STREAM_SET_LABELS);
                if (authError != 0)
                {
                    throw ResponseApiKeyValidationError(HttpContext, authError);
                }

                int ii = 0;
                int jobs = req.streams.Count;
                List<ResponseStream> result = new List<ResponseStream>();
                var tasks = new Task<ResponseStream>[jobs];
                foreach (var obj in req.streams)
                {
                    RequestStreamSet reqSet = new RequestStreamSet {
                        apiKey = req.apiKey,
                        email = req.email,
                        decryptKey = req.decryptKey,
                        aipGuid = req.aipGuid,
                        comment = req.comment,
                        stream = new RequestStream
                        {
                            dispFileName = obj.dispFileName,
                            fileData = obj.fileData,
                        }
                    };                    

                    tasks[ii++] = _service.SetLabel(reqSet);
                }
                await Task.WhenAll(tasks);
                foreach (var task in tasks)
                {
                    result.Add(task.Result);
                }
                HttpContext.Items[GlobalConstants.API_RESULT_CODE] = 0;
                HttpContext.Items[GlobalConstants.API_RESULT_MESSAGE] = GlobalConstants.API_RESULT_SUCCESS;

                sw.Stop();
                _log.LogInformation("*** ...End SetStreamLabels: {0} EA. {1,6} ms.", req.streams.Count, sw.ElapsedMilliseconds.ToString("#,##0"));
                return Results.Ok(new ApiResponseModel<List<ResponseStream>>()
                {
                    success = true,
                    errorCode = 0,
                    errorMessage = GlobalConstants.API_RESULT_SUCCESS,
                    result = result,
                });
            });
        }

        [HttpPost("delete-label")]
        [SwaggerResponse(200, type: typeof(ApiResponseModel<ResponseStream>))]
        public async Task<IResult> DelStreamLabel([FromBody] RequestStreamDel req)
        {
            return await CreateResponseAsync(async () =>
            {
                GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_STREAM_DELETE_LABELS, req.apiKey, req);
                HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
                int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_STREAM_DELETE_LABELS);
                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<List<ResponseStream>>))]
        public async Task<IResult> DelStreamLabels([FromBody] RequestMultiStreamDel req)
        {
            return await CreateResponseAsync(async () =>
            {
                Stopwatch sw = new Stopwatch();
                sw.Start();
                _log.LogInformation("*** Start DelStreamLabels: {0} EA.", req.streams.Count);
                GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_STREAM_DELETE_LABEL, req.apiKey, req);
                HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
                int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_STREAM_DELETE_LABEL);
                if (authError != 0)
                {
                    throw ResponseApiKeyValidationError(HttpContext, authError);
                }

                int ii = 0;
                int jobs = req.streams.Count;
                List<ResponseStream> result = new List<ResponseStream>();
                var tasks = new Task<ResponseStream>[jobs];
                foreach (var obj in req.streams)
                {
                    RequestStreamDel reqSet = new RequestStreamDel {
                        apiKey = req.apiKey,
                        email = req.email,
                        decryptKey = req.decryptKey,
                        comment = req.comment,
                        stream = new RequestStream {
                            dispFileName = obj.dispFileName,
                            fileData = obj.fileData,
                        }
                    };

                    tasks[ii++] = _service.DelLabel(reqSet);
                }
                await Task.WhenAll(tasks);
                foreach (var task in tasks)
                {
                    result.Add(task.Result);
                }
                HttpContext.Items[GlobalConstants.API_RESULT_CODE] = 0;
                HttpContext.Items[GlobalConstants.API_RESULT_MESSAGE] = GlobalConstants.API_RESULT_SUCCESS;

                sw.Stop();
                _log.LogInformation("*** ...End DelStreamLabels: {0} EA. {1,6} ms.", req.streams.Count, sw.ElapsedMilliseconds.ToString("#,##0"));
                return Results.Ok(new ApiResponseModel<List<ResponseStream>>()
                {
                    success = true,
                    errorCode = 0,
                    errorMessage = GlobalConstants.API_RESULT_SUCCESS,
                    result = result,
                });
            });
        }

        [HttpPost("set-protection")]
        [SwaggerResponse(200, type: typeof(ApiResponseModel<ResponseStream>))]
        public async Task<IResult> SetStreamProtection([FromBody] RequestStreamSet req)
        {
            return await CreateResponseAsync(async () =>
            {
                GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_STREAM_SET_PROTECTION, req.apiKey, req);
                HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
                int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_STREAM_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<ResponseStream>))]
        public async Task<IResult> DelStreamProtection([FromBody] RequestStreamDel req)
        {
            return await CreateResponseAsync(async () =>
            {
                GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_STREAM_DELETE_PROTECTIN, req.apiKey, req);
                HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
                int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_STREAM_DELETE_PROTECTIN);
                if (authError != 0)
                {
                    throw ResponseApiKeyValidationError(HttpContext, authError);
                }
                var response = await _service.DelProtection(req);
                return Results.Ok(ResponseSuccess(HttpContext, response));
            });
        }


        [HttpPost("set-label-protection")]
        [SwaggerResponse(200, type: typeof(ApiResponseModel<ResponseStream>))]
        public async Task<IResult> SetStreamLabelProtection([FromBody] RequestStreamAllSet req)
        {
            return await CreateResponseAsync(async () =>
            {
                GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_STREAM_SET_LABEL_PROTECTION, req.apiKey, req);
                HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
                int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_STREAM_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<ResponseStream>))]
        public async Task<IResult> DelStreamLabelProtection([FromBody] RequestStreamDel req)
        {
            return await CreateResponseAsync(async () =>
            {
                GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_STREAM_DELETE_LABEL_PROTECTION, req.apiKey, req);
                HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
                int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_STREAM_DELETE_LABEL_PROTECTION);
                if (authError != 0)
                {
                    throw ResponseApiKeyValidationError(HttpContext, authError);
                }
                var response = await _service.DelLabelProtection(req);
                return Results.Ok(ResponseSuccess(HttpContext, response));
            });
        }

        [HttpPost("encrypt")]
        [SwaggerResponse(200, type: typeof(ApiResponseModel<ResponseStream>))]
        public async Task<IResult> EncryptStream([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_STREAM_ENCRYPT, apiKey, req);
                HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
                int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_STREAM_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<ResponseStream>))]
        public async Task<IResult> DecryptStream([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_STREAM_DECRYPT, apiKey, req);
                HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
                int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_STREAM_DECRYPT);
                if (authError != 0)
                {
                    throw ResponseApiKeyValidationError(HttpContext, authError);
                }
                var response = await _service.DecryptFile(file, req);
                return Results.Ok(ResponseSuccess(HttpContext, response));
            });
        }
    }
}