293 lines
13 KiB
C#
293 lines
13 KiB
C#
using System;
|
|
using System.Threading.Tasks;
|
|
using System.Collections.Generic;
|
|
using Microsoft.AspNetCore.Http;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Serilog;
|
|
using LCU.Library.Internal.FileOperationsModels.Models;
|
|
using LCU.Library.Internal.Exceptions;
|
|
using LCU.Library.Internal.ApiResponse.Models;
|
|
using LCU.Api.Internal.FileOperations.Services.QueueServices;
|
|
using LCU.Api.Internal.FileOperations.Extensions;
|
|
using LCU.Api.Internal.FileOperations.Services;
|
|
using LCU.Api.Internal.FileOperations.Services.FileActionServices;
|
|
namespace LCU.Api.Internal.FileOperations.Controllers;
|
|
|
|
[Route("api/[controller]")]
|
|
[ApiController]
|
|
public class FileOperationsController : ControllerBase
|
|
{
|
|
private readonly IQueueFileOperationsService _queueFileOperationsService;
|
|
private readonly IActionService<MoveFileRequest> _moveFileService;
|
|
private readonly IActionService<CopyFileRequest> _copyFileService;
|
|
private readonly IActionService<DeleteFileRequest> _deleteFileService;
|
|
private readonly IActionService<ModifyFileRequest> _modifyFileService;
|
|
private readonly IActionService<RenameFileRequest> _renameFileService;
|
|
private readonly IActionService<ZipDirectoryRequest> _zipDirectoryService;
|
|
private readonly IActionService<UnzipFileRequest> _unzipFileService;
|
|
private readonly IActionService<UnzipPasswordProtectedFileRequest> _unzipPasswordProtectedFileService;
|
|
private readonly IActionService<CreateDirectoryRequest> _createDirectoryService;
|
|
private readonly IActionService<RenameDirectoryRequest> _renameDirectoryService;
|
|
private readonly IActionService<BulkOperationRequest<MoveFileRequest>> _bulkMoveFileService;
|
|
private readonly IActionService<EncryptFileDataRequest> _encryptFileDataService;
|
|
private readonly IActionService<DecryptFileDataRequest> _decryptFileDataService;
|
|
private readonly IActionService<WriteFileRequest> _writeFileDataService;
|
|
private readonly IActionService<DeleteDirectoryRequest> _deleteDirectoryService;
|
|
private readonly IActionService<DeleteEmptyDirectoryRequest> _deleteEmptyDirectoryService;
|
|
private readonly IDirectFileService _directFileService;
|
|
|
|
public FileOperationsController(IQueueFileOperationsService fileOperationsService,
|
|
IActionService<MoveFileRequest> moveFileService,
|
|
IActionService<CopyFileRequest> copyFileService,
|
|
IActionService<ModifyFileRequest> modifyFileService,
|
|
IActionService<DeleteFileRequest> deleteFileService,
|
|
IActionService<RenameFileRequest> renameFileService,
|
|
IActionService<ZipDirectoryRequest> zipDirectoryService,
|
|
IActionService<UnzipFileRequest> unzipFileService,
|
|
IActionService<UnzipPasswordProtectedFileRequest> unzipPasswordProtectedFileService,
|
|
IActionService<CreateDirectoryRequest> createDirectoryService,
|
|
IActionService<RenameDirectoryRequest> renameDirectoryService,
|
|
IActionService<BulkOperationRequest<MoveFileRequest>> bulkMoveFileService,
|
|
IActionService<EncryptFileDataRequest> encryptFileDataService,
|
|
IActionService<DecryptFileDataRequest> decryptFileDataService,
|
|
IActionService<WriteFileRequest> writeFileDataService,
|
|
IActionService<DeleteDirectoryRequest> deleteDirectoryService,
|
|
IActionService<DeleteEmptyDirectoryRequest> deleteEmptyDirectoryService,
|
|
IDirectFileService directFileService)
|
|
{
|
|
_queueFileOperationsService = fileOperationsService;
|
|
_moveFileService = moveFileService;
|
|
_copyFileService = copyFileService;
|
|
_modifyFileService = modifyFileService;
|
|
_deleteFileService = deleteFileService;
|
|
_renameFileService = renameFileService;
|
|
_zipDirectoryService = zipDirectoryService;
|
|
_unzipFileService = unzipFileService;
|
|
_unzipPasswordProtectedFileService = unzipPasswordProtectedFileService;
|
|
_createDirectoryService = createDirectoryService;
|
|
_renameDirectoryService = renameDirectoryService;
|
|
_bulkMoveFileService = bulkMoveFileService;
|
|
_encryptFileDataService = encryptFileDataService;
|
|
_decryptFileDataService = decryptFileDataService;
|
|
_directFileService = directFileService;
|
|
_writeFileDataService = writeFileDataService;
|
|
_deleteDirectoryService = deleteDirectoryService;
|
|
_deleteEmptyDirectoryService = deleteEmptyDirectoryService;
|
|
}
|
|
|
|
// Get api/{file}
|
|
[HttpGet("{filename}")]
|
|
[ProducesResponseType(200)]
|
|
[ProducesResponseType(400)]
|
|
public IActionResult GetFile([FromRoute] string filename)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(filename))
|
|
{
|
|
return BadRequest("filename is required");
|
|
}
|
|
|
|
try
|
|
{
|
|
var result = _directFileService.GetFileBytes(filename);
|
|
return new FileContentResult(result, "application/octet-stream");
|
|
}
|
|
catch (ArgumentException ae)
|
|
{
|
|
Log.Error(ae, $"Request for bad file path {filename}");
|
|
return BadRequest("File path not found");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Error(ex, $"Unexpected error retrieving file path {filename}");
|
|
return StatusCode(StatusCodes.Status500InternalServerError);
|
|
}
|
|
}
|
|
|
|
// POST api/MoveFile
|
|
[HttpPost("MoveFile")]
|
|
[ProducesResponseType(201)]
|
|
[ProducesResponseType(typeof(List<string>), 400)]
|
|
[ProducesResponseType(500)]
|
|
public async Task<IActionResult> MoveFile([FromBody] MoveFileRequest request)
|
|
{
|
|
return await HandleRequestResponse(request, FileOperationType.Move, _moveFileService);
|
|
}
|
|
|
|
// POST api/CopyFile
|
|
[HttpPost("CopyFile")]
|
|
[ProducesResponseType(201)]
|
|
[ProducesResponseType(typeof(List<string>), 400)]
|
|
[ProducesResponseType(500)]
|
|
public async Task<IActionResult> CopyFile([FromBody] CopyFileRequest request)
|
|
{
|
|
return await HandleRequestResponse(request, FileOperationType.Copy, _copyFileService);
|
|
}
|
|
|
|
// POST api/ModifyFile
|
|
[HttpPost("ModifyFile")]
|
|
[ProducesResponseType(201)]
|
|
[ProducesResponseType(typeof(List<string>), 400)]
|
|
[ProducesResponseType(500)]
|
|
public async Task<IActionResult> ModifyFile([FromBody] ModifyFileRequest request)
|
|
{
|
|
return await HandleRequestResponse(request, FileOperationType.Modify, _modifyFileService);
|
|
}
|
|
|
|
// POST api/DeleteFile
|
|
[HttpPost("DeleteFile")]
|
|
[ProducesResponseType(201)]
|
|
[ProducesResponseType(typeof(List<string>), 400)]
|
|
[ProducesResponseType(500)]
|
|
public async Task<IActionResult> DeleteFile([FromBody] DeleteFileRequest request)
|
|
{
|
|
return await HandleRequestResponse(request, FileOperationType.Delete, _deleteFileService);
|
|
}
|
|
|
|
// POST api/RenameFile
|
|
[HttpPost("RenameFile")]
|
|
[ProducesResponseType(201)]
|
|
[ProducesResponseType(typeof(List<string>), 400)]
|
|
[ProducesResponseType(500)]
|
|
public async Task<IActionResult> RenameFile([FromBody] RenameFileRequest request)
|
|
{
|
|
return await HandleRequestResponse(request, FileOperationType.Rename, _renameFileService);
|
|
}
|
|
|
|
// POST api/ZipDirectory
|
|
[HttpPost("ZipDirectory")]
|
|
[ProducesResponseType(201)]
|
|
[ProducesResponseType(typeof(List<string>), 400)]
|
|
[ProducesResponseType(500)]
|
|
public async Task<IActionResult> ZipDirectory([FromBody] ZipDirectoryRequest request)
|
|
{
|
|
return await HandleRequestResponse(request, FileOperationType.ZipDirectory, _zipDirectoryService);
|
|
}
|
|
|
|
// POST api/UnzipFile
|
|
[HttpPost("UnzipFile")]
|
|
[ProducesResponseType(201)]
|
|
[ProducesResponseType(typeof(List<string>), 400)]
|
|
[ProducesResponseType(500)]
|
|
public async Task<IActionResult> UnzipFile([FromBody] UnzipFileRequest request)
|
|
{
|
|
return await HandleRequestResponse(request, FileOperationType.UnzipFile, _unzipFileService);
|
|
}
|
|
|
|
// POST api/UnzipPasswordProtectedFile
|
|
[HttpPost("UnzipPasswordProtectedFile")]
|
|
[ProducesResponseType(201)]
|
|
[ProducesResponseType(typeof(List<string>), 400)]
|
|
[ProducesResponseType(500)]
|
|
public async Task<IActionResult> UnzipPasswordProtectedFile([FromBody] UnzipPasswordProtectedFileRequest request)
|
|
{
|
|
return await HandleRequestResponse(request, FileOperationType.UnzipPasswordProtectedFile, _unzipPasswordProtectedFileService);
|
|
}
|
|
|
|
// POST api/CreateDirectory
|
|
[HttpPost("CreateDirectory")]
|
|
[ProducesResponseType(201)]
|
|
[ProducesResponseType(typeof(List<string>), 400)]
|
|
[ProducesResponseType(500)]
|
|
public async Task<IActionResult> CreateDirectory([FromBody] CreateDirectoryRequest request)
|
|
{
|
|
return await HandleRequestResponse(request, FileOperationType.CreateDirectory, _createDirectoryService);
|
|
}
|
|
|
|
// POST api/RenameDirectory
|
|
[HttpPost("RenameDirectory")]
|
|
[ProducesResponseType(201)]
|
|
[ProducesResponseType(typeof(List<string>), 400)]
|
|
[ProducesResponseType(500)]
|
|
public async Task<IActionResult> RenameDirectory([FromBody] RenameDirectoryRequest request)
|
|
{
|
|
return await HandleRequestResponse(request, FileOperationType.RenameDirectory, _renameDirectoryService);
|
|
}
|
|
|
|
// POST api/BulkMoveFile
|
|
[HttpPost("BulkMoveFile")]
|
|
[ProducesResponseType(201)]
|
|
[ProducesResponseType(typeof(List<string>), 400)]
|
|
[ProducesResponseType(500)]
|
|
public async Task<IActionResult> BulkMoveFile([FromBody] BulkOperationRequest<MoveFileRequest> request)
|
|
{
|
|
return await HandleRequestResponse(request, FileOperationType.BulkMoveFile, _bulkMoveFileService);
|
|
}
|
|
|
|
// POST api/EncryptFileData
|
|
[HttpPost("EncryptFileData")]
|
|
[ProducesResponseType(201)]
|
|
[ProducesResponseType(typeof(List<string>), 400)]
|
|
[ProducesResponseType(500)]
|
|
public async Task<IActionResult> EncryptFileData([FromBody] EncryptFileDataRequest request)
|
|
{
|
|
return await HandleRequestResponse(request, FileOperationType.EncryptFileData, _encryptFileDataService);
|
|
}
|
|
|
|
// POST api/DecryptFileData
|
|
[HttpPost("DecryptFileData")]
|
|
[ProducesResponseType(201)]
|
|
[ProducesResponseType(typeof(List<string>), 400)]
|
|
[ProducesResponseType(500)]
|
|
public async Task<IActionResult> DecryptFileData([FromBody] DecryptFileDataRequest request)
|
|
{
|
|
return await HandleRequestResponse(request, FileOperationType.DecryptFileData, _decryptFileDataService);
|
|
}
|
|
|
|
// POST api/WriteFileData
|
|
[HttpPost("WriteFileData")]
|
|
[ProducesResponseType(201)]
|
|
[ProducesResponseType(typeof(List<string>), 400)]
|
|
[ProducesResponseType(500)]
|
|
public async Task<IActionResult> WriteFileData([FromBody] WriteFileRequest request)
|
|
{
|
|
return await HandleRequestResponse(request, FileOperationType.WriteFile, _writeFileDataService);
|
|
}
|
|
|
|
[HttpPost("DeleteDirectory")]
|
|
[ProducesResponseType(201)]
|
|
[ProducesResponseType(typeof(List<string>), 400)]
|
|
[ProducesResponseType(500)]
|
|
public async Task<IActionResult> DeleteDirectory([FromBody] DeleteDirectoryRequest request)
|
|
{
|
|
return await HandleRequestResponse(request, FileOperationType.DeleteDirectory, _deleteDirectoryService);
|
|
}
|
|
|
|
[HttpPost("DeleteEmptyDirectory")]
|
|
[ProducesResponseType(201)]
|
|
[ProducesResponseType(typeof(List<string>), 400)]
|
|
[ProducesResponseType(500)]
|
|
public async Task<IActionResult> DeleteEmptyDirectory([FromBody] DeleteEmptyDirectoryRequest request)
|
|
{
|
|
return await HandleRequestResponse(request, FileOperationType.DeleteEmptyDirectory, _deleteEmptyDirectoryService);
|
|
}
|
|
|
|
public async Task<IActionResult> HandleRequestResponse<TRequest>(TRequest originalRequest, FileOperationType operationType, IActionService<TRequest> service) where TRequest : ReturnResponse
|
|
{
|
|
try
|
|
{
|
|
if (!ModelState.IsValid)
|
|
{
|
|
return BadRequest(ModelState.GetErrorMessages());
|
|
}
|
|
|
|
var validateResponse = service.PreQueueValidation(originalRequest);
|
|
if (!validateResponse.IsSuccessful)
|
|
{
|
|
return BadRequest($"Request is invalid. Response: {String.Join("\n ", validateResponse.MessageStack.ToArray())}");
|
|
}
|
|
|
|
await _queueFileOperationsService.QueueFileOperations(originalRequest, operationType);
|
|
return Ok();
|
|
}
|
|
catch (ServiceException)
|
|
{
|
|
return StatusCode(StatusCodes.Status500InternalServerError);
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
Log.Error(exception, "Unexpected Exception");
|
|
return StatusCode(StatusCodes.Status500InternalServerError);
|
|
}
|
|
}
|
|
}
|