AipGateway/AipGateway.API/Controllers/ApiDbController.cs

using AipGateway.API.Application;
using AipGateway.API.Application.Interfaces.Services;
using AipGateway.API.Domain.Models;
using AipGateway.API.Domain.Models.Dto;
using AipGateway.API.Domain.Models.Response;
using AipGateway.API.Services;
using AipGateway.API.Services.Interfaces;
using Microsoft.AspNetCore.Mvc;
using Swashbuckle.AspNetCore.Annotations;
using System.ComponentModel.DataAnnotations;

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

        public ApiDbController(ILogger<ApiDbController> log, IApiAuthService authService, IApiDbService apiDbService)
        {
            _log = log;
            _authService = authService;
            _service = apiDbService;
        }

        [HttpPost("reload")]
        [SwaggerResponse(200, type: typeof(ApiResponseModel<GeneralResponse>))]
        public async Task<IResult> ReloadDatabase([Required] string apiKey)
        {
            return await CreateResponseAsync(async () =>
            {
                GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_DB_RELOAD, apiKey, null);
                int authError = _authService.CheckApiKeyValidation(HttpContext, apiKey, GlobalConstants.API_DB_RELOAD);
                if (authError != 0)
                {
                    throw ResponseApiKeyValidationError(HttpContext, authError);
                }
                var response = await _service.ReloadDatabase();
                var result = Results.Ok(ResponseSuccess(HttpContext, response));
                HttpContext.Items[GlobalConstants.API_RESULT] = result;
                return result;
            });
        }

        [HttpGet("linked-systems")]
        [SwaggerResponse(200, type: typeof(ApiResponseModel<List<LinkedSystemDto>>))]
        public async Task<IResult> GetDbLinkedSystems([Required] string apiKey)
        {
            return await CreateResponseAsync(async () =>
            {
                GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_DB_LINKED_SYSTEMS, apiKey, null);
                int authError = _authService.CheckApiKeyValidation(HttpContext, apiKey, GlobalConstants.API_DB_LINKED_SYSTEMS);
                if (authError != 0)
                {
                    throw ResponseApiKeyValidationError(HttpContext, authError);
                }
                var response = await _service.GetLinkedSystems();
                var result = Results.Ok(new ApiResponseModel<List<LinkedSystemDto>>()
                {
                    success = true,
                    errorCode = 0,
                    errorMessage = GlobalConstants.API_RESULT_SUCCESS,
                    result = response,
                });
                HttpContext.Items[GlobalConstants.API_RESULT_CODE] = 0;
                HttpContext.Items[GlobalConstants.API_RESULT_MESSAGE] = GlobalConstants.API_RESULT_SUCCESS;
                HttpContext.Items[GlobalConstants.API_RESULT] = result;
                return result;
            });
        }

        [HttpGet("linked-servers")]
        [SwaggerResponse(200, type: typeof(ApiResponseModel<List<LinkedServerDto>>))]
        public async Task<IResult> GetDbLinkedServers([Required] string apiKey)
        {
            return await CreateResponseAsync(async () =>
            {
                GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_DB_LINKED_SERVERS, apiKey, null);
                int authError = _authService.CheckApiKeyValidation(HttpContext, apiKey, GlobalConstants.API_DB_LINKED_SERVERS);
                if (authError != 0)
                {
                    throw ResponseApiKeyValidationError(HttpContext, authError);
                }
                var response = await _service.GetLinkedServers();
                var result = Results.Ok(new ApiResponseModel<List<LinkedServerDto>>()
                {
                    success = true,
                    errorCode = 0,
                    errorMessage = GlobalConstants.API_RESULT_SUCCESS,
                    result = response,
                });
                HttpContext.Items[GlobalConstants.API_RESULT_CODE] = 0;
                HttpContext.Items[GlobalConstants.API_RESULT_MESSAGE] = GlobalConstants.API_RESULT_SUCCESS;
                HttpContext.Items[GlobalConstants.API_RESULT] = result;
                return result;
            });
        }

        [HttpGet("linked-api-keys")]
        [SwaggerResponse(200, type: typeof(ApiResponseModel<List<LinkedApiKeyDto>>))]
        public async Task<IResult> GetDbLinkedApiKeys([Required] string apiKey)
        {
            return await CreateResponseAsync(async () =>
            {
                GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_DB_LINKED_API_KEYS, apiKey, null);
                int authError = _authService.CheckApiKeyValidation(HttpContext, apiKey, GlobalConstants.API_DB_LINKED_API_KEYS);
                if (authError != 0)
                {
                    throw ResponseApiKeyValidationError(HttpContext, authError);
                }
                var response = await _service.GetLinkedApiKeys();
                var result = Results.Ok(new ApiResponseModel<List<LinkedApiKeyDto>>()
                {
                    success = true,
                    errorCode = 0,
                    errorMessage = GlobalConstants.API_RESULT_SUCCESS,
                    result = response,
                });
                HttpContext.Items[GlobalConstants.API_RESULT_CODE] = 0;
                HttpContext.Items[GlobalConstants.API_RESULT_MESSAGE] = GlobalConstants.API_RESULT_SUCCESS;
                HttpContext.Items[GlobalConstants.API_RESULT] = result;
                return result;
            });
        }

        [HttpGet("linked-decrypt-keys")]
        [SwaggerResponse(200, type: typeof(ApiResponseModel<List<LinkedDecryptKeyDto>>))]
        public async Task<IResult> GetDbLinkedDecryptKeys([Required] string apiKey)
        {
            return await CreateResponseAsync(async () =>
            {
                GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_DB_LINKED_DECRYPT_KEYS, apiKey, null);
                int authError = _authService.CheckApiKeyValidation(HttpContext, apiKey, GlobalConstants.API_DB_LINKED_DECRYPT_KEYS);
                if (authError != 0)
                {
                    throw ResponseApiKeyValidationError(HttpContext, authError);
                }
                var response = await _service.GetLinkedDecryptKeys();
                var result = Results.Ok(new ApiResponseModel<List<LinkedDecryptKeyDto>>()
                {
                    success = true,
                    errorCode = 0,
                    errorMessage = GlobalConstants.API_RESULT_SUCCESS,
                    result = response,
                });
                HttpContext.Items[GlobalConstants.API_RESULT_CODE] = 0;
                HttpContext.Items[GlobalConstants.API_RESULT_MESSAGE] = GlobalConstants.API_RESULT_SUCCESS;
                HttpContext.Items[GlobalConstants.API_RESULT] = result;
                return result;
            });
        }

    }
}