monorepo/LCU.API.Internal.FileOperations/LCU.Api.Internal.FileOperations/Controllers/FileValidationController.cs

using System;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Serilog;
using LCU.Library.Internal.FileOperationsModels.Models;
using LCU.Api.Internal.FileOperations.Validations;
using LCU.Api.Internal.FileOperations.Services.FileActionServices;
using System.Collections.Generic;
using System.Threading.Tasks;
using LCU.Api.Internal.FileOperations.Extensions;
using LCU.Library.Internal.Exceptions;
using LCU.Api.Internal.FileOperations.Services.QueueServices;
using LCU.Library.Internal.FileOperationsModels.Models.Requests;

namespace LCU.Api.Internal.FileOperations.Controllers;

[ApiController]
[Route("[controller]")]
public class FileValidationController : ControllerBase
{
    private readonly IQueueFileOperationsService _queueFileOperationsService;
    private readonly IActionService<ValidateFileRequest> _validateFileService;
    private readonly IActionService<ValidateFileSizeInRangeRequest> _validateFileSizeInRangeService;

    public FileValidationController(IQueueFileOperationsService fileOperationsService,
                                    IActionService<ValidateFileRequest> validateFileService,
                                    IActionService<ValidateFileSizeInRangeRequest> validateFileSizeInRangeService
        )
    {
        _queueFileOperationsService = fileOperationsService;
        _validateFileService = validateFileService;
        _validateFileSizeInRangeService = validateFileSizeInRangeService;
    }
    // POST ValidateFileExists
    [HttpPost("ValidateFileExists")]
    [ProducesResponseType(200)]
    [ProducesResponseType(typeof(bool), 400)]
    [ProducesResponseType(500)]
    public IActionResult ValidateFileExists([FromBody] string sourceFilePath)
    {
        try
        {
            var requestResponse = new RequestResponse();
            requestResponse = FileValidation.ValidateFileExists(sourceFilePath, requestResponse);
            return Ok(requestResponse.IsSuccessful);
        }
        catch (Exception exception)
        {
            Log.Error(exception, "Unexpected Exception");
            return StatusCode(StatusCodes.Status500InternalServerError);
        }
    }

    // POST api/QueueValidateFile
    [HttpPost("QueueValidateFile")]
    [ProducesResponseType(201)]
    [ProducesResponseType(typeof(List<string>), 400)]
    [ProducesResponseType(500)]
    public async Task<IActionResult> ValidateFile([FromBody] ValidateFileRequest request)
    {
        try
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState.GetErrorMessages());
            }

            var validateResponse = _validateFileService.PreQueueValidation(request);
            if (!validateResponse.IsSuccessful)
            {
                return BadRequest($"Request is invalid. Response: {String.Join("\n ", validateResponse.MessageStack.ToArray())}");
            }

            await _queueFileOperationsService.QueueFileOperations(request, FileOperationType.Validate);
            return Accepted();
        }
        catch (ServiceException)
        {
            return StatusCode(StatusCodes.Status500InternalServerError);
        }
        catch (Exception exception)
        {
            Log.Error(exception, "Unexpected Exception");
            return StatusCode(StatusCodes.Status500InternalServerError);
        }
    }

    [HttpPost("ValidatePdfPageExists/{path}/{pageNumber:int}")]
    [ProducesResponseType(200)]
    [ProducesResponseType(typeof(bool), 400)]
    [ProducesResponseType(500)]
    public IActionResult ValidatePdfPageExists(string path, int pageNumber)
    {
        try
        {
            var requestResponse = new RequestResponse();
            requestResponse = PdfValidations.ValidatePdfPageExists(requestResponse, path, pageNumber);
            return Ok(requestResponse);
        }
        catch (Exception exception)
        {

            Log.Error(exception, "Unexpected Exception");
            return StatusCode(StatusCodes.Status500InternalServerError);
        }
    }

    // POST api/QueueValidateFileSizeInRange
    [HttpPost("QueueValidateFileSizeInRange")]
    [ProducesResponseType(201)]
    [ProducesResponseType(typeof(List<string>), 400)]
    [ProducesResponseType(500)]
    public async Task<IActionResult> ValidateFileSizeInRange([FromBody] ValidateFileSizeInRangeRequest request)
    {
        try
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState.GetErrorMessages());
            }

            var validateResponse = _validateFileSizeInRangeService.PreQueueValidation(request);
            if (!validateResponse.IsSuccessful)
            {
                return BadRequest($"Request is invalid. Response: {string.Join("\n ", validateResponse.MessageStack.ToArray())}");
            }

            await _queueFileOperationsService.QueueFileOperations(request, FileOperationType.ValidateFileSizeInRange);
            return Accepted();
        }
        catch (ServiceException)
        {
            return StatusCode(StatusCodes.Status500InternalServerError);
        }
        catch (Exception exception)
        {
            Log.Error(exception, "Unexpected Exception");
            return StatusCode(StatusCodes.Status500InternalServerError);
        }
    }
}