shoc-backend/Api.SeaHavenIndustries/Controllers/WorkOrderCompletionController.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 WorkOrderCompletionController : Controller
    {
        private readonly IWorkOrderCompletionService _workOrderCompletionService;
        private readonly ICompletionDocTemplateService _completionDocTemplateService;
        private readonly IFileStoragePort _fileStorage;

        public WorkOrderCompletionController(
            IWorkOrderCompletionService workOrderCompletionService,
            ICompletionDocTemplateService completionDocTemplateService,
            IFileStoragePort fileStorage)
        {
            _workOrderCompletionService = workOrderCompletionService;
            _completionDocTemplateService = completionDocTemplateService;
            _fileStorage = fileStorage;
        }

        [HttpGet("completion-templates")]
        public async Task<IActionResult> GetCompletionTemplates(
            [FromQuery] string? search = null,
            [FromQuery] string? serviceKey = null,
            [FromQuery] WorkOrderType? workOrderType = null,
            CancellationToken cancellationToken = default)
        {
            var templates = await _completionDocTemplateService.ListAsync(search, serviceKey, workOrderType, cancellationToken);
            return Ok(templates);
        }

        [HttpGet("completion-templates/{id:int}")]
        public async Task<IActionResult> GetCompletionTemplate(int id, CancellationToken cancellationToken)
        {
            var template = await _completionDocTemplateService.GetAsync(id, cancellationToken);
            if (template == null)
                return NotFound(new Response { Status = "Error", Message = "Template not found." });
            return Ok(template);
        }

        [HttpGet("completion-templates/{id:int}/linked-work-orders")]
        public async Task<IActionResult> GetCompletionTemplateLinkedWorkOrders(int id, CancellationToken cancellationToken)
        {
            try
            {
                var linked = await _completionDocTemplateService.GetLinkedWorkOrdersAsync(User, id, cancellationToken);
                return Ok(linked);
            }
            catch (WorkOrderBoardValidationException ex)
            {
                return MapTemplateError(ex);
            }
        }

        [HttpPost("completion-templates")]
        public async Task<IActionResult> CreateCompletionTemplate(
            [FromBody] CompletionDocTemplateCreateDto request,
            CancellationToken cancellationToken)
        {
            try
            {
                var created = await _completionDocTemplateService.CreateAsync(User, request, cancellationToken);
                return Ok(created);
            }
            catch (WorkOrderBoardValidationException ex)
            {
                return MapTemplateError(ex);
            }
        }

        [HttpPut("completion-templates/{id:int}")]
        public async Task<IActionResult> UpdateCompletionTemplate(
            int id,
            [FromBody] CompletionDocTemplateCreateDto request,
            CancellationToken cancellationToken)
        {
            try
            {
                var updated = await _completionDocTemplateService.UpdateAsync(User, id, request, cancellationToken);
                return Ok(updated);
            }
            catch (WorkOrderBoardValidationException ex)
            {
                return MapTemplateError(ex);
            }
        }

        [HttpDelete("completion-templates/{id:int}")]
        public async Task<IActionResult> DeleteCompletionTemplate(int id, CancellationToken cancellationToken)
        {
            try
            {
                await _completionDocTemplateService.DeleteAsync(User, id, cancellationToken);
                return NoContent();
            }
            catch (WorkOrderBoardValidationException ex)
            {
                return MapTemplateError(ex);
            }
        }

        private IActionResult MapTemplateError(WorkOrderBoardValidationException ex)
        {
            var body = new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message };
            return ex.Code switch
            {
                "Forbidden" => StatusCode(StatusCodes.Status403Forbidden, body),
                "NotFound" => NotFound(body),
                _ => UnprocessableEntity(body)
            };
        }

        [HttpPost("{id:int}/completion-doc")]
        [RequestSizeLimit(50_000_000)]
        public async Task<IActionResult> UploadCompletionDoc(
            int id,
            [FromForm] IFormFile file,
            [FromForm] string? signOffName = null,
            [FromForm] string? signOffSignature = null,
            [FromForm] string? workOrderVersion = null)
        {
            if (file == null || file.Length == 0)
                return BadRequest(new Response { Status = "Error", Message = "file is required." });

            string? fileUrl = null;
            try
            {
                WorkOrderCompletionDocFileRules.EnsureAllowed(file);
                var actorId = User.FindFirstValue(ClaimTypes.NameIdentifier);
                await _workOrderCompletionService.EnsureCanUploadCompletionDocAsync(id, User, actorId);

                fileUrl = await _fileStorage.SaveFileAsync(file);
                var result = await _workOrderCompletionService.UploadCompletionDocAsync(
                    id,
                    new WorkOrderCompletionDocUploadDto
                    {
                        SignOffName = signOffName,
                        SignOffSignature = signOffSignature,
                        WorkOrderVersion = workOrderVersion
                    },
                    fileUrl,
                    User,
                    actorId);
                return Ok(result);
            }
            catch (WorkOrderBoardValidationException ex) when (ex.Code is "NotFound")
            {
                TryCompensateUpload(fileUrl);
                return NotFound(new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
            }
            catch (WorkOrderBoardValidationException ex) when (ex.Code is "Forbidden")
            {
                TryCompensateUpload(fileUrl);
                return StatusCode(StatusCodes.Status403Forbidden,
                    new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
            }
            catch (WorkOrderBoardValidationException ex) when (ex.Code is "ConcurrencyConflict")
            {
                TryCompensateUpload(fileUrl);
                return Conflict(new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
            }
            catch (WorkOrderBoardValidationException ex)
            {
                TryCompensateUpload(fileUrl);
                return UnprocessableEntity(new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
            }
        }

        private void TryCompensateUpload(string? fileUrl)
        {
            if (!string.IsNullOrWhiteSpace(fileUrl))
                _fileStorage.TryDelete(fileUrl);
        }
    }
}