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

using Api.SeaHavenIndustries.DTOs;
using Api.SeaHavenIndustries.Helper;
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]")]
    public class DropdownOptionsController : Controller
    {
        private readonly IDropdownOptionsService _dropdownOptionsService;
        private readonly ILogger<DropdownOptionsController> _logger;

        public DropdownOptionsController(IDropdownOptionsService dropdownOptionsService, ILogger<DropdownOptionsController> logger)
        {
            _dropdownOptionsService = dropdownOptionsService;
            _logger = logger;
        }

        [HttpGet]
        public async Task<IActionResult> GetAll([FromQuery] string? category = null, CancellationToken cancellationToken = default)
        {
            var data = await _dropdownOptionsService.GetAllAsync(category, cancellationToken);
            return Ok(data);
        }

        [HttpGet("ByCategory/{category}")]
        public async Task<IActionResult> GetByCategory(string category, [FromQuery] string? parent = null, CancellationToken cancellationToken = default)
        {
            var data = await _dropdownOptionsService.GetByCategoryAsync(category, parent, cancellationToken);
            return Ok(data);
        }

        [HttpPost]
        public async Task<IActionResult> Create([FromBody] DropdownOption_DTO model, CancellationToken cancellationToken)
        {
            try
            {
                var created = await _dropdownOptionsService.CreateAsync(MapToService(model), cancellationToken);
                return Ok(created);
            }
            catch (InvalidOperationException ex)
            {
                return BadRequest(new { message = _logger.Sanitize(ex, "The dropdown option could not be saved") });
            }
        }

        [HttpPut("{id}")]
        public async Task<IActionResult> Update(int id, [FromBody] DropdownOption_DTO model, CancellationToken cancellationToken)
        {
            try
            {
                var updated = await _dropdownOptionsService.UpdateAsync(id, MapToService(model), cancellationToken);
                return Ok(updated);
            }
            catch (KeyNotFoundException)
            {
                return NotFound(new { message = "Option not found" });
            }
        }

        [HttpDelete("{id}")]
        public async Task<IActionResult> Delete(int id, CancellationToken cancellationToken)
        {
            try
            {
                await _dropdownOptionsService.DeleteAsync(id, cancellationToken);
                return Ok(new { message = "Deleted" });
            }
            catch (KeyNotFoundException)
            {
                return NotFound(new { message = "Option not found" });
            }
        }

        private static DropdownOptionDTO MapToService(DropdownOption_DTO model)
        {
            return new DropdownOptionDTO
            {
                Id = model.Id,
                Category = model.Category,
                Value = model.Value,
                ParentValue = model.ParentValue,
                SortOrder = model.SortOrder,
                IsActive = model.IsActive
            };
        }
    }
}