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

using Api.SeaHavenIndustries.DTOs;
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/tasklisttemplates")]
    public class TaskListTemplateController : Controller
    {
        private readonly ITaskListTemplateService _taskListTemplateService;
        private readonly ILogger<TaskListTemplateController> _logger;

        public TaskListTemplateController(ITaskListTemplateService taskListTemplateService, ILogger<TaskListTemplateController> logger)
        {
            _taskListTemplateService = taskListTemplateService;
            _logger = logger;
        }

        [HttpGet]
        public async Task<IActionResult> GetAll(CancellationToken cancellationToken)
        {
            var data = await _taskListTemplateService.GetAllAsync(cancellationToken);
            return Ok(data);
        }

        [HttpGet("{id}")]
        public async Task<IActionResult> GetById(int id, CancellationToken cancellationToken)
        {
            var template = await _taskListTemplateService.GetByIdAsync(id, cancellationToken);

            if (template == null)
                return NotFound(new Response { Status = "Error", Message = "Template not found" });

            return Ok(template);
        }

        [HttpPost]
        public async Task<IActionResult> Create([FromBody] TaskListTemplate_DTO model, CancellationToken cancellationToken)
        {
            try
            {
                var input = MapToInput(model);
                var id = await _taskListTemplateService.CreateAsync(input, cancellationToken);
                return Ok(new { message = "Template created", id });
            }
            catch (Exception ex)
            {
                return BadRequest(new Response { Status = "Error", Message = _logger.Sanitize(ex) });
            }
        }

        [HttpPut("{id}")]
        public async Task<IActionResult> Update(int id, [FromBody] TaskListTemplate_DTO model, CancellationToken cancellationToken)
        {
            try
            {
                var input = MapToInput(model);
                var updated = await _taskListTemplateService.UpdateAsync(id, input, cancellationToken);
                if (!updated)
                    return NotFound(new Response { Status = "Error", Message = "Template not found" });

                return Ok(new { message = "Template updated" });
            }
            catch (Exception ex)
            {
                return BadRequest(new Response { Status = "Error", Message = _logger.Sanitize(ex) });
            }
        }

        [HttpDelete("{id}")]
        public async Task<IActionResult> Delete(int id, CancellationToken cancellationToken)
        {
            var deleted = await _taskListTemplateService.DeleteAsync(id, cancellationToken);
            if (!deleted)
                return NotFound(new Response { Status = "Error", Message = "Template not found" });

            return Ok(new { message = "Template deleted" });
        }

        private static TaskListTemplateInput MapToInput(TaskListTemplate_DTO model)
        {
            return new TaskListTemplateInput
            {
                Name = model.Name,
                Description = model.Description,
                IsActive = model.IsActive,
                Items = model.Items.Select(item => new TaskListTemplateInputItem
                {
                    ItemText = item.ItemText,
                    SortOrder = item.SortOrder
                }).ToList()
            };
        }
    }
}