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

using System;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Serilog;
using LCU.Api.Internal.FileOperations.Services;
using LCU.Api.Internal.FileOperations.Services.FileActionServices;
using LCU.Library.Internal.FileOperationsModels.Models;
using LCU.Library.Internal.Exceptions;
using LCU.Library.Internal.ApiResponse.Models;
namespace LCU.Api.Internal.FileOperations.Controllers;

[ApiController]
[Route("api/[controller]")]
public class DirectFileOperationsController : ControllerBase
{
    private readonly IDirectFileOperationsService _directFileOperationsService;
    private readonly IActionService<MoveFileRequest> _moveFileService;
    private readonly IActionService<WriteFileRequest> _writeFileService;
    private readonly IActionService<CreateDirectoryRequest> _createDirectoryRequestService;
    private readonly IActionService<UnzipFileRequest> _unzipFileRequestService;
    private readonly IActionService<ZipDirectoryRequest> _zipDirectoryRequestService;
    private readonly IActionService<DeleteDirectoryRequest> _deleteDirectoryRequestService;
    private readonly IActionService<DeleteFileRequest> _deleteFileRequestService;
    private readonly IActionService<AppendFileRequest> _appendFileService;

    public DirectFileOperationsController(IDirectFileOperationsService directFileOperationsService,
                                          IActionService<MoveFileRequest> moveFileService,
                                          IActionService<WriteFileRequest> writeFileRequest,
                                          IActionService<CreateDirectoryRequest> createDirectoryRequestService,
                                          IActionService<UnzipFileRequest> unzipFileRequestService,
                                          IActionService<ZipDirectoryRequest> zipDirectoryRequestService,
                                          IActionService<DeleteDirectoryRequest> deleteDirectoryRequestService,
                                          IActionService<DeleteFileRequest> deleteFileRequestService,
                                          IActionService<AppendFileRequest> appendFileService)
    {
        _directFileOperationsService = directFileOperationsService;
        _moveFileService = moveFileService;
        _writeFileService = writeFileRequest;
        _createDirectoryRequestService = createDirectoryRequestService;
        _unzipFileRequestService = unzipFileRequestService;
        _zipDirectoryRequestService = zipDirectoryRequestService;
        _deleteDirectoryRequestService = deleteDirectoryRequestService;
        _deleteFileRequestService = deleteFileRequestService;
        _appendFileService = appendFileService;
    }

    [HttpPost("MoveFile")]
    [ProducesResponseType(200)]
    [ProducesResponseType(typeof(ReturnResponse), 400)]
    [ProducesResponseType(500)]
    public async Task<IActionResult> MoveFile([FromBody] MoveFileRequest request)
    {
        return await HandleRequestResponse(request, FileOperationType.Move, _moveFileService);
    }

    [HttpPost("WriteFile")]
    [ProducesResponseType(200)]
    [ProducesResponseType(typeof(ReturnResponse), 400)]
    [ProducesResponseType(500)]
    public async Task<IActionResult> WriteFile([FromBody] WriteFileRequest request)
    {
        return await HandleRequestResponse(request, FileOperationType.WriteFile, _writeFileService);
    }

    [HttpPost("CreateDirectory")]
    [ProducesResponseType(200)]
    [ProducesResponseType(typeof(ReturnResponse), 400)]
    [ProducesResponseType(500)]
    public async Task<IActionResult> CreateDirectory([FromBody] CreateDirectoryRequest request)
    {
        return await HandleRequestResponse(request, FileOperationType.CreateDirectory, _createDirectoryRequestService);
    }

    [HttpPost("UnzipFile")]
    [ProducesResponseType(200)]
    [ProducesResponseType(typeof(ReturnResponse), 400)]
    [ProducesResponseType(500)]
    public async Task<IActionResult> UnzipFile([FromBody] UnzipFileRequest request)
    {
        return await HandleRequestResponse(request, FileOperationType.UnzipFile, _unzipFileRequestService);
    }

    [HttpPost("ZipDirectory")]
    [ProducesResponseType(200)]
    [ProducesResponseType(typeof(ReturnResponse), 400)]
    [ProducesResponseType(500)]
    public async Task<IActionResult> ZipDirectory([FromBody] ZipDirectoryRequest request)
    {
        return await HandleRequestResponse(request, FileOperationType.ZipDirectory, _zipDirectoryRequestService);
    }

    [HttpPost("DeleteDirectory")]
    [ProducesResponseType(200)]
    [ProducesResponseType(typeof(ReturnResponse), 400)]
    [ProducesResponseType(500)]
    public async Task<IActionResult> DeleteDirectory([FromBody] DeleteDirectoryRequest request)
    {
        return await HandleRequestResponse(request, FileOperationType.DeleteDirectory, _deleteDirectoryRequestService);
    }


    [HttpPost("DeleteFile")]
    [ProducesResponseType(200)]
    [ProducesResponseType(typeof(ReturnResponse), 400)]
    [ProducesResponseType(500)]
    public async Task<IActionResult> DeleteFile([FromBody] DeleteFileRequest request)
    {
        return await HandleRequestResponse(request, FileOperationType.Delete, _deleteFileRequestService);
    }

    [HttpPost("AppendFile")]
    [ProducesResponseType(200)]
    [ProducesResponseType(typeof(ReturnResponse), 400)]
    [ProducesResponseType(500)]
    public async Task<IActionResult> AppendFile([FromBody] AppendFileRequest request)
    {
        return await HandleRequestResponse(request, FileOperationType.AppendFile, _appendFileService);
    }

    public async Task<IActionResult> HandleRequestResponse<TRequest>(TRequest originalRequest, 
                                                                     FileOperationType operationType, 
                                                                     IActionService<TRequest> service) where TRequest : ReturnResponse
    {
        try
        {
            var validateResponse = service.PreQueueValidation(originalRequest);
            if (!validateResponse.IsSuccessful)
            {
                return BadRequest($"Request is invalid. Response: {String.Join("\n ", validateResponse.MessageStack.ToArray())}");
            }

            var result = await _directFileOperationsService.HandleDirectFileOperationsRequest(originalRequest, operationType);
            return Ok(result);
        }
        catch (ServiceException serviceException)
        {
            return StatusCode(StatusCodes.Status500InternalServerError, serviceException.Message);
        }
        catch (Exception exception)
        {
            Log.Error(exception, "Unexpected Exception");
            return StatusCode(StatusCodes.Status500InternalServerError);
        }
    }
}