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

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

namespace Api.SeaHavenIndustries.Controllers
{
    [Authorize]
    [ApiController]
    [Route("api/WorkOrder")]
    [Route("api/workorders")]
    public class WorkOrderDetailController : Controller
    {
        private readonly IWorkOrderDetailService _workOrderDetailService;
        private readonly IWorkOrderCommentService _workOrderCommentService;

        public WorkOrderDetailController(
            IWorkOrderDetailService workOrderDetailService,
            IWorkOrderCommentService workOrderCommentService)
        {
            _workOrderDetailService = workOrderDetailService;
            _workOrderCommentService = workOrderCommentService;
        }

        [HttpGet("{id:int}/detail")]
        public async Task<IActionResult> GetDetail(int id)
        {
            try
            {
                var detail = await _workOrderDetailService.GetDetailAsync(id, User);
                if (detail == null)
                    return NotFound(new Response { Status = "Error", Message = "Work order not found." });
                return Ok(detail);
            }
            catch (WorkOrderBoardValidationException ex) when (ex.Code == "Forbidden")
            {
                return StatusCode(StatusCodes.Status403Forbidden, new Response { Status = "Error", Message = ex.Message });
            }
        }

        [HttpGet("{id:int}/audit")]
        public async Task<IActionResult> GetAudit(int id, [FromQuery] int limit = 50)
        {
            try
            {
                var audit = await _workOrderDetailService.GetAuditAsync(id, User, limit);
                if (audit == null)
                    return NotFound(new Response { Status = "Error", Message = "Work order not found." });
                return Ok(audit);
            }
            catch (WorkOrderBoardValidationException ex) when (ex.Code == "Forbidden")
            {
                return StatusCode(StatusCodes.Status403Forbidden, new Response { Status = "Error", Message = ex.Message });
            }
        }

        [HttpGet("{id:int}/comments")]
        public async Task<IActionResult> GetBoardComments(int id)
        {
            try
            {
                var comments = await _workOrderCommentService.GetCommentsAsync(id, User);
                if (comments == null)
                    return NotFound(new Response { Status = "Error", Message = "Work order not found." });
                return Ok(comments);
            }
            catch (WorkOrderBoardValidationException ex) when (ex.Code == "Forbidden")
            {
                return StatusCode(StatusCodes.Status403Forbidden,
                    new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
            }
        }

        [HttpPost("{id:int}/comments")]
        public async Task<IActionResult> AddBoardComment(int id, [FromBody] WorkOrderCommentCreateDto request)
        {
            try
            {
                var actorId = User.FindFirstValue(ClaimTypes.NameIdentifier);
                var comment = await _workOrderCommentService.AddCommentAsync(id, request, User, actorId);
                return Ok(comment);
            }
            catch (WorkOrderBoardValidationException ex) when (ex.Code == "NotFound")
            {
                return NotFound(new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
            }
            catch (WorkOrderBoardValidationException ex) when (ex.Code == "Forbidden")
            {
                return StatusCode(StatusCodes.Status403Forbidden,
                    new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
            }
            catch (WorkOrderBoardValidationException ex)
            {
                return UnprocessableEntity(new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
            }
        }

        [HttpPatch("{id:int}/comments/{commentId:int}")]
        public async Task<IActionResult> UpdateBoardComment(
            int id,
            int commentId,
            [FromBody] WorkOrderCommentCreateDto request)
        {
            try
            {
                var actorId = User.FindFirstValue(ClaimTypes.NameIdentifier);
                var comment = await _workOrderCommentService.UpdateCommentAsync(
                    id, commentId, request, User, actorId);
                return Ok(comment);
            }
            catch (WorkOrderBoardValidationException ex) when (ex.Code == "NotFound")
            {
                return NotFound(new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
            }
            catch (WorkOrderBoardValidationException ex) when (ex.Code == "Forbidden")
            {
                return StatusCode(StatusCodes.Status403Forbidden,
                    new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
            }
            catch (WorkOrderBoardValidationException ex)
            {
                return UnprocessableEntity(new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
            }
        }
    }
}