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

using Api.SeaHavenIndustries.Helper;
using Data.SeaHavenIndustries;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using SeaHaven.Services.DTOs;
using SeaHaven.Services.Interfaces;

namespace Api.SeaHavenIndustries.Controllers
{
    [Authorize]
    [ApiController]
    [Route("api/[controller]")]
    [Route("api/uplifts")]
    public class UpliftController : Controller
    {
        private readonly IUpliftService _upliftService;
        private readonly ILogger<UpliftController> _logger;

        public UpliftController(IUpliftService upliftService, ILogger<UpliftController> logger)
        {
            _upliftService = upliftService;
            _logger = logger;
        }

        [HttpGet]
        public async Task<IActionResult> List([FromQuery] string? status = "Pending", [FromQuery] int? tier = null, [FromQuery] int page = 1, [FromQuery] int pageSize = 25, CancellationToken cancellationToken = default)
        {
            var result = await _upliftService.ListAsync(User, status, tier, page, pageSize, cancellationToken);
            return Ok(new DataResponse { Status = "Success", Data = result });
        }

        [HttpGet("dispatch/{dispatchId:int}")]
        public async Task<IActionResult> ListForDispatch(int dispatchId, CancellationToken cancellationToken = default)
        {
            var items = await _upliftService.ListForDispatchAsync(User, dispatchId, cancellationToken);
            return Ok(new DataResponse { Status = "Success", Data = items });
        }

        [HttpPost("{id:int}/approve")]
        public async Task<IActionResult> Approve(int id, [FromBody] DecisionRequest? body, CancellationToken cancellationToken = default)
        {
            try
            {
                var result = await _upliftService.ApproveAsync(User, id, body?.Note, cancellationToken);
                return Ok(new DataResponse { Status = "Success", Data = result });
            }
            catch (KeyNotFoundException ex)
            {
                return NotFound(new Response { Status = "Error", Message = _logger.Sanitize(ex, "Uplift request not found") });
            }
            catch (UpliftForbiddenException ex)
            {
                return StatusCode(403, new Response { Status = "Error", Message = _logger.Sanitize(ex, "You are not authorized to perform this action on this uplift request") });
            }
            catch (InvalidOperationException ex)
            {
                return BadRequest(new Response { Status = "Error", Message = _logger.Sanitize(ex, "This uplift request cannot be modified in its current state") });
            }
        }

        [HttpPost("{id:int}/deny")]
        public async Task<IActionResult> Deny(int id, [FromBody] DecisionRequest? body, CancellationToken cancellationToken = default)
        {
            try
            {
                var result = await _upliftService.DenyAsync(User, id, body?.Note, cancellationToken);
                return Ok(new DataResponse { Status = "Success", Data = result });
            }
            catch (KeyNotFoundException ex)
            {
                return NotFound(new Response { Status = "Error", Message = _logger.Sanitize(ex, "Uplift request not found") });
            }
            catch (UpliftForbiddenException ex)
            {
                return StatusCode(403, new Response { Status = "Error", Message = _logger.Sanitize(ex, "You are not authorized to perform this action on this uplift request") });
            }
            catch (InvalidOperationException ex)
            {
                return BadRequest(new Response { Status = "Error", Message = _logger.Sanitize(ex, "This uplift request cannot be modified in its current state") });
            }
        }

        [HttpGet("can-approve")]
        public IActionResult CanApprove([FromQuery] int tier)
        {
            return Ok(new DataResponse { Status = "Success", Data = new { canApprove = _upliftService.CanApprove(User, tier) } });
        }

        public class DecisionRequest
        {
            public string? Note { get; set; }
        }
    }
}