DD.WellWorkover.Cloud/AsbCloudWebApi/Controllers/FileController.cs

using AsbCloudApp.Data;
using AsbCloudApp.Requests;
using AsbCloudApp.Services;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using AsbCloudApp.Repositories;

namespace AsbCloudWebApi.Controllers
{

    /// <summary>
    /// Хранение файлов
    /// </summary>
    [Route("api/well/{idWell}/files")]
    [ApiController]
    [Authorize]
    public class FileController : ControllerBase
    {
        private readonly FileService fileService;
        private readonly IWellService wellService;

        public FileController(FileService fileService, IWellService wellService)
        {
            this.fileService = fileService;
            this.wellService = wellService;
        }

        /// <summary>
        /// Сохраняет переданные файлы и информацию о них
        /// </summary>
        /// <param name="idWell">id скважины</param>
        /// <param name="idCategory">id категории файла</param>
        /// <param name="files">Коллекция файлов</param>
        /// <param name="userRepository">dependency</param>
        /// <param name="token"> Токен отмены задачи </param>
        /// <returns></returns>
        [HttpPost]
        [Permission]
        [ProducesResponseType(typeof(int), (int)System.Net.HttpStatusCode.OK)]
        public async Task<IActionResult> SaveFilesAsync(int idWell, int idCategory,
            [FromForm] IFormFileCollection files, [FromServices] IUserRepository userRepository, CancellationToken token)
        {
            int? idCompany = User.GetCompanyId();
            int? idUser = User.GetUserId();

            if (idCompany is null || idUser is null)
                return Forbid();

            if (!await wellService.IsCompanyInvolvedInWellAsync((int)idCompany,
                idWell, token).ConfigureAwait(false))
                return Forbid();

            if (!userRepository.HasPermission((int)idUser, $"File.edit{idCategory}"))
                return Forbid();

            foreach (var file in files)
            {
                var fileStream = file.OpenReadStream();
                await fileService.SaveAsync(idWell, idUser ?? 0, idCategory, file.FileName,
                     fileStream, token).ConfigureAwait(false);
            }

            return Ok();
        }

        /// <summary>
        /// Возвращает информацию о файлах для скважины в выбраной категории
        /// </summary>
        /// <param name="request"> </param>
        /// <param name="token"> Токен отмены задачи </param>
        /// <returns>Список информации о файлах в этой категории</returns>
        [HttpGet("/api/files")]
        [Permission]
        [ProducesResponseType(typeof(PaginationContainer<FileInfoDto>), (int)System.Net.HttpStatusCode.OK)]
        public async Task<IActionResult> GetFilesInfoAsync(
            [FromQuery] FileRequest request,
            CancellationToken token)
        {
            int? idCompany = User.GetCompanyId();

            if (request.IdCategory is null || idCompany is null)
                return Forbid();

            if (!await wellService.IsCompanyInvolvedInWellAsync(idCompany.Value,
                request.IdWell, token).ConfigureAwait(false))
                return Forbid();

            var filesInfo = await fileService.GetInfosPaginatedAsync(request, token).ConfigureAwait(false);

            return Ok(filesInfo);
        }

        /// <summary>
        /// Возвращает файл с диска на сервере
        /// </summary>
        /// <param name="idFile">id запрашиваемого файла</param>
        /// <param name="token"> Токен отмены задачи </param>
        /// <returns>Запрашиваемый файл</returns>
        [HttpGet("{idFile}")]
        [Permission]
        [ProducesResponseType(typeof(PhysicalFileResult), (int)System.Net.HttpStatusCode.OK)]
        public async Task<IActionResult> GetFileAsync(
            int idFile, CancellationToken token)
        {
            int? idCompany = User.GetCompanyId();

            if (idCompany is null)
                return Forbid();

            var fileInfo = await fileService.GetOrDefaultAsync(idFile, token);

            if (fileInfo is null)
                return NotFound(idFile);

            if (!await wellService.IsCompanyInvolvedInWellAsync((int)idCompany,
            fileInfo.IdWell, token).ConfigureAwait(false))
                return Forbid();

            var fileStream = fileService.GetFileStream(fileInfo);

            return File(fileStream, "application/octet-stream", fileInfo.Name);
        }

        /// <summary>
        /// Помечает файл как удаленный
        /// </summary>
        /// <param name="idWell">id скважины</param>
        /// <param name="idFile">id запрашиваемого файла</param>
        /// <param name="userRepository">dependency</param>
        /// <param name="token">Токен отмены задачи </param>
        /// <returns></returns>
        [HttpDelete("{idFile}")]
        [Permission]
        [ProducesResponseType(typeof(int), (int)System.Net.HttpStatusCode.OK)]
        public async Task<IActionResult> DeleteAsync(int idWell, int idFile,
             [FromServices] IUserRepository userRepository,
            CancellationToken token)
        {
            int? idUser = User.GetUserId();

            int? idCompany = User.GetCompanyId();

            if (idUser is null || idCompany is null || !await wellService.IsCompanyInvolvedInWellAsync((int)idCompany,
                idWell, token).ConfigureAwait(false))
                return Forbid();

            var fileInfo = await fileService.GetOrDefaultAsync(idFile, token);

            if (fileInfo is null)
                return NotFound(idFile);

            if (!userRepository.HasPermission((int)idUser, $"File.edit{fileInfo?.IdCategory}"))
                return Forbid();

            var result = await fileService.MarkAsDeletedAsync(idFile, token);

            return Ok(result);
        }

        /// <summary>
        /// Создает метку для файла
        /// </summary>
        /// <param name="idWell">id скважины </param>
        /// <param name="markDto">метка файла</param>
        /// <param name="token">Токен отмены задачи </param>
        /// <returns></returns>
        [HttpPost("fileMark")]
        [Permission]
        public async Task<IActionResult> CreateFileMarkAsync(int idWell, FileMarkDto markDto, CancellationToken token)
        {
            var idCompany = User.GetCompanyId();

            var idUser = User.GetUserId();

            if (idCompany is null || idUser is null ||
                !await wellService.IsCompanyInvolvedInWellAsync((int)idCompany,
                    idWell, token).ConfigureAwait(false))
                return Forbid();

            var result = await fileService.CreateFileMarkAsync(markDto, (int)idUser, token)
                .ConfigureAwait(false);

            return Ok(result);
        }

        /// <summary>
        /// Помечает метку у файла как удаленную
        /// </summary>
        /// <param name="idWell">id скважины </param>
        /// <param name="idMark">id метки </param>
        /// <param name="token">Токен отмены задачи </param>
        /// <returns></returns>
        [HttpDelete("fileMark")]
        [Permission]
        [ProducesResponseType(typeof(int), (int)System.Net.HttpStatusCode.OK)]
        public async Task<IActionResult> DeleteFileMarkAsync(int idWell, int idMark,
            CancellationToken token)
        {
            var idCompany = User.GetCompanyId();

            if (idCompany is null || !await wellService.IsCompanyInvolvedInWellAsync((int)idCompany,
                idWell, token).ConfigureAwait(false))
                return Forbid();

            var result = await fileService.MarkFileMarkAsDeletedAsync(idMark, token)
                .ConfigureAwait(false);

            return Ok(result);
        }

        /// <summary>
        /// Возвращает информацию о файле
        /// </summary>
        /// <param name="idFile">id запрашиваемого файла</param>
        /// <param name="token"> Токен отмены задачи </param>
        /// <returns>Запрашиваемый файл</returns>
        [HttpGet("/api/files/{idFile}")]
        [Permission]
        [ProducesResponseType(typeof(FileInfoDto), (int)System.Net.HttpStatusCode.OK)]
        public async Task<IActionResult> GetFileInfoAsync([FromRoute] int idFile, CancellationToken token)
        {
            int? idCompany = User.GetCompanyId();

            if (idCompany is null)
                return Forbid();

            try
            {
                var fileInfo = await fileService.GetOrDefaultAsync(idFile, token).ConfigureAwait(false);
                return Ok(fileInfo);
            }
            catch (FileNotFoundException ex)
            {
                return NotFound(ex.FileName);
            }
        }
    }

}