AipGateway/AipDatabase.API/Controllers/LinkedServerController.cs

using AipDatabase.API.Controllers.Base;
using AipDatabase.API.Domain;
using AipDatabase.API.Interfaces;
using AipDatabase.API.Models;
using AipDatabase.API.Models.Response;
using Microsoft.AspNetCore.Mvc;
using Swashbuckle.AspNetCore.Annotations;
using System.ComponentModel.DataAnnotations;

namespace AipDatabase.API.Controllers
{
    [ApiController]
    [Route("/service/api/db/linkedServer")]
    [Produces("application/json")]
    public class LinkedServerController : BaseModule
    {
        private readonly ILogger<LinkedServerController> _log;
        private readonly ILinkedServerRepository _service;
        public LinkedServerController(ILogger<LinkedServerController> log, ILinkedServerRepository service)
        {
            _log = log;
            _service = service;
        }

        [HttpPost("findByIp")]
        [SwaggerResponse(200, type: typeof(ApiResponseModel<DataCount>))]
        public async Task<IResult> FindByIp([Required] int systemId, [Required] string serverIpAddr)
        {
            return await CreateResponseAsync(async () =>
            {
                var response = await _service.FindByIp(systemId, serverIpAddr);
                var result = Results.Ok(new ApiResponseModel<DataCount>()
                {
                    success = true,
                    errorCode = 0,
                    errorMessage = GlobalConstants.API_RESULT_SUCCESS,
                    result = response,
                });
                return result;
            });
        }

        [HttpPost("add")]
        [SwaggerResponse(200, type: typeof(ApiResponseModel<DataCount>))]
        public async Task<IResult> Add([Required] int systemId, [Required] string serverIpAddr, [Required] string serverDesc,
            [Required] string apiKey, [Required] DateTime expiredAt,
            [Required] bool policyLookupYn,
            [Required] bool fileInfoLookupYn,
            [Required] bool applyLabelYn,
            [Required] bool releaseLabelYn,
            [Required] bool encryptionFileYn,
            [Required] bool decryptionFileYn)
        {
            return await CreateResponseAsync(async () =>
            {
                var response = await _service.Add(systemId, serverIpAddr, serverDesc,
                                                  apiKey, expiredAt,
                                                  policyLookupYn, fileInfoLookupYn, applyLabelYn, releaseLabelYn, encryptionFileYn, decryptionFileYn);
                var result = Results.Ok(new ApiResponseModel<DataCount>()
                {
                    success = true,
                    errorCode = 0,
                    errorMessage = GlobalConstants.API_RESULT_SUCCESS,
                    result = response,
                });
                return result;
            });
        }

        [HttpPost("delete")]
        [SwaggerResponse(200, type: typeof(ApiResponseModel<DataCount>))]
        public async Task<IResult> Delete([Required] int serverId)
        {
            return await CreateResponseAsync(async () =>
            {
                var response = await _service.Delete(serverId);
                var result = Results.Ok(new ApiResponseModel<DataCount>()
                {
                    success = true,
                    errorCode = 0,
                    errorMessage = GlobalConstants.API_RESULT_SUCCESS,
                    result = response,
                });
                return result;
            });
        }

        [HttpPost("update")]
        [SwaggerResponse(200, type: typeof(ApiResponseModel<DataCount>))]
        public async Task<IResult> Update([Required] int serverId, [Required] string serverIpAddr, [Required] string serverDesc,
            [Required] int apiId, [Required] DateTime expiredAt,
            [Required] bool policyLookupYn,
            [Required] bool fileInfoLookupYn,
            [Required] bool applyLabelYn,
            [Required] bool releaseLabelYn,
            [Required] bool encryptionFileYn,
            [Required] bool decryptionFileYn)
        {
            return await CreateResponseAsync(async () =>
            {
                var response = await _service.Update(serverId, serverIpAddr, serverDesc,
                                                  apiId, expiredAt,
                                                  policyLookupYn, fileInfoLookupYn, applyLabelYn, releaseLabelYn, encryptionFileYn, decryptionFileYn);
                var result = Results.Ok(new ApiResponseModel<DataCount>()
                {
                    success = true,
                    errorCode = 0,
                    errorMessage = GlobalConstants.API_RESULT_SUCCESS,
                    result = response,
                });
                return result;
            });
        }


        [HttpPost("list")]
        [SwaggerResponse(200, type: typeof(ApiResponseModel<Pagination<LinkedServer>>))]
        public async Task<IResult> GetLists([Required] int pagePerCount, [Required] int pageSize, [Required] int systemId, int? page)
        {
            return await CreateResponseAsync(async () =>
            {
                int pageNo = 1;
                if (page != null)
                {
                    pageNo = (int)page;
                }
                var response = await _service.GetLists(pagePerCount, pageSize, pageNo, systemId);
                var result = Results.Ok(new ApiResponseModel<Pagination<LinkedServer>>()
                {
                    success = true,
                    errorCode = 0,
                    errorMessage = GlobalConstants.API_RESULT_SUCCESS,
                    result = response,
                });
                return result;
            });
        }

    }
}