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

using Api.SeaHavenIndustries.DTOs;
using Data.SeaHavenIndustries;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;

namespace Api.SeaHavenIndustries.Controllers
{
    [Authorize]
    [ApiController]
    [Route("api/[controller]")]
    [Route("api/tasklisttemplates")]
    public class TaskListTemplateController : Controller
    {
        private readonly ApplicationDbContext _db;

        public TaskListTemplateController(ApplicationDbContext db)
        {
            _db = db;
        }

        [HttpGet]
        public async Task<IActionResult> GetAll()
        {
            var data = await _db.TaskListTemplates
                .Where(t => t.IsActive)
                .Include(t => t.Items.OrderBy(i => i.SortOrder))
                .OrderBy(t => t.Name)
                .Select(t => new
                {
                    t.Id,
                    t.Name,
                    t.Description,
                    t.IsActive,
                    items = t.Items.OrderBy(i => i.SortOrder).Select(i => new
                    {
                        i.Id,
                        i.ItemText,
                        i.SortOrder
                    }).ToList()
                })
                .ToListAsync();
            return Ok(data);
        }

        [HttpGet("{id}")]
        public async Task<IActionResult> GetById(int id)
        {
            var template = await _db.TaskListTemplates
                .Include(t => t.Items.OrderBy(i => i.SortOrder))
                .Where(t => t.Id == id)
                .Select(t => new
                {
                    t.Id,
                    t.Name,
                    t.Description,
                    t.IsActive,
                    items = t.Items.OrderBy(i => i.SortOrder).Select(i => new
                    {
                        i.Id,
                        i.ItemText,
                        i.SortOrder
                    }).ToList()
                })
                .FirstOrDefaultAsync();

            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)
        {
            try
            {
                var template = new TaskListTemplate
                {
                    Name = model.Name,
                    Description = model.Description,
                    IsActive = model.IsActive,
                    Items = model.Items.Select((item, idx) => new TaskListTemplateItem
                    {
                        ItemText = item.ItemText,
                        SortOrder = item.SortOrder > 0 ? item.SortOrder : idx
                    }).ToList()
                };

                _db.TaskListTemplates.Add(template);
                await _db.SaveChangesAsync();
                return Ok(new { message = "Template created", id = template.Id });
            }
            catch (Exception ex)
            {
                return BadRequest(new Response { Status = "Error", Message = ex.Message });
            }
        }

        [HttpPut("{id}")]
        public async Task<IActionResult> Update(int id, [FromBody] TaskListTemplate_DTO model)
        {
            try
            {
                var template = await _db.TaskListTemplates
                    .Include(t => t.Items)
                    .FirstOrDefaultAsync(t => t.Id == id);

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

                template.Name = model.Name;
                template.Description = model.Description;
                template.IsActive = model.IsActive;

                _db.TaskListTemplateItems.RemoveRange(template.Items);

                template.Items = model.Items.Select((item, idx) => new TaskListTemplateItem
                {
                    TaskListTemplateId = id,
                    ItemText = item.ItemText,
                    SortOrder = item.SortOrder > 0 ? item.SortOrder : idx
                }).ToList();

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

        [HttpDelete("{id}")]
        public async Task<IActionResult> Delete(int id)
        {
            var template = await _db.TaskListTemplates.FindAsync(id);
            if (template == null)
                return NotFound(new Response { Status = "Error", Message = "Template not found" });

            template.IsActive = false;
            await _db.SaveChangesAsync();
            return Ok(new { message = "Template deleted" });
        }
    }
}