shoc-backend/Api.SeaHavenIndustries/Controllers/WorkOrderMediaController.cs

using Api.SeaHavenIndustries.DTOs;
using Data.SeaHavenIndustries;
using Data.SeaHavenIndustries.Enums;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using SeaHaven.Services.DTOs;
using SeaHaven.Services.Exceptions;
using SeaHaven.Services.Helpers;
using SeaHaven.Services.Interfaces;
using System.Security.Claims;

namespace Api.SeaHavenIndustries.Controllers
{
    [Authorize]
    [ApiController]
    [Route("api/WorkOrder")]
    [Route("api/workorders")]
    public class WorkOrderMediaController : Controller
    {
        private readonly IWorkOrderMediaService _workOrderMediaService;
        private readonly IFileStoragePort _fileStorage;

        public WorkOrderMediaController(
            IWorkOrderMediaService workOrderMediaService,
            IFileStoragePort fileStorage)
        {
            _workOrderMediaService = workOrderMediaService;
            _fileStorage = fileStorage;
        }

        [HttpGet("{id:int}/media")]
        public async Task<IActionResult> GetMedia(int id)
        {
            var media = await _workOrderMediaService.GetMediaAsync(id);
            if (media == null)
                return NotFound(new Response { Status = "Error", Message = "Work order not found." });
            return Ok(media);
        }

        [HttpPost("{id:int}/media")]
        [RequestSizeLimit(30_000_000)]
        public async Task<IActionResult> AddMedia(
            int id,
            [FromForm] WorkOrderMediaCategory? category,
            [FromForm] IFormFile file)
        {
            if (file == null || file.Length == 0)
                return BadRequest(new Response { Status = "Error", Message = "file is required." });

            try
            {
                WorkOrderMediaFileRules.EnsureAllowed(file);
                var actorId = User.FindFirstValue(ClaimTypes.NameIdentifier);
                var fileUrl = await _fileStorage.SaveFileAsync(file);
                var media = await _workOrderMediaService.AddMediaAsync(id, category, fileUrl, actorId);
                return Ok(media);
            }
            catch (WorkOrderBoardValidationException ex) when (ex.Code == "NotFound")
            {
                return NotFound(new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
            }
            catch (WorkOrderBoardValidationException ex)
            {
                return UnprocessableEntity(new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
            }
        }

        [HttpPatch("{id:int}/media/{mediaId:int}")]
        public async Task<IActionResult> UpdateMediaCategory(
            int id,
            int mediaId,
            [FromForm] WorkOrderMediaCategory category)
        {
            try
            {
                var actorId = User.FindFirstValue(ClaimTypes.NameIdentifier);
                var media = await _workOrderMediaService.UpdateMediaCategoryAsync(id, mediaId, category, actorId);
                return Ok(media);
            }
            catch (WorkOrderBoardValidationException ex) when (ex.Code == "NotFound")
            {
                return NotFound(new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
            }
            catch (WorkOrderBoardValidationException ex)
            {
                return UnprocessableEntity(new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
            }
        }

        [HttpDelete("{id:int}/media/{mediaId:int}")]
        public async Task<IActionResult> DeleteMedia(int id, int mediaId)
        {
            try
            {
                var actorId = User.FindFirstValue(ClaimTypes.NameIdentifier);
                await _workOrderMediaService.DeleteMediaAsync(id, mediaId, actorId);
                return NoContent();
            }
            catch (WorkOrderBoardValidationException ex) when (ex.Code == "NotFound")
            {
                return NotFound(new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
            }
            catch (WorkOrderBoardValidationException ex)
            {
                return UnprocessableEntity(new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
            }
        }
    }
}