Workshop10-API/Controllers/WorkshopsController.cs

using CampusWorkshops.Api.Dtos;
using CampusWorkshops.Api.Models;
using CampusWorkshops.Api.Repositories;
using FluentValidation;
using Microsoft.AspNetCore.Mvc;
using Workshop10_API.Validation;

namespace CampusWorkshops.Api.Controllers;

[ApiController]
[Route("api/[controller]")]
public class WorkshopsController : ControllerBase
{
    private readonly IWorkshopRepository _repo;
    public WorkshopsController(IWorkshopRepository repo) => _repo = repo;

    /// <summary>Lista workshops com filtros opcionais.</summary>
    [HttpGet]
    public async Task<IActionResult> GetAll([FromQuery] DateTimeOffset? from, [FromQuery] DateTimeOffset? to, [FromQuery] string? q, CancellationToken ct)
    {
        var workshops = await _repo.GetAllAsync(from, to, q, ct);
        if (!workshops.Any())
            return NoContent();
        
        var workshopDTOs = workshops.Select(w => ConvertToWorkshopResponseDTO(w)).ToList();
        return Ok(workshopDTOs);
    }

    [HttpGet("{id:guid}")]
    public async Task<IActionResult> GetById(Guid id, CancellationToken ct)
    {
        var workshop = await _repo.GetByIdAsync(id, ct);

        if (workshop == null)
            return NoContent();

        return Ok(ConvertToWorkshopResponseDTO(workshop));
    }

    [HttpPost]
    public async Task<IActionResult> Create([FromBody] CreateWorkshopRequestDTO workshopDTO, CancellationToken ct)
    {
        var dtoValidator = new WorkshopRequestDTOValidator();
        var validationResult = await dtoValidator.ValidateAsync(workshopDTO);
        if (!validationResult.IsValid)
        {
            var erros = validationResult.Errors.Select(e => new { e.PropertyName, e.ErrorMessage });
            return BadRequest(erros);
        }
        
        Workshop workshop = new Workshop
        {
            Capacity = workshopDTO.Capacity,
            Description = workshopDTO.Description,
            EndAt = workshopDTO.EndAt,
            IsOnline = workshopDTO.IsOnline,
            Location = workshopDTO.Location,
            StartAt = workshopDTO.StartAt,
            Title = workshopDTO.Title
        };

        var result = await _repo.AddAsync(workshop, ct);

        if (result != null)
            return CreatedAtAction(nameof(GetById), new { workshopDTO });

        return BadRequest();
    }

    [HttpDelete]
    public async Task<IActionResult> Delete(Guid id, CancellationToken ct)
    {
        var result = await _repo.DeleteAsync(id, ct);
        if(result)
            return NoContent();
        
        return NotFound();
    }

    private WorkshopResponseDTO ConvertToWorkshopResponseDTO(Workshop workshop)
    {
        return new WorkshopResponseDTO(
                   workshop.Id,
                   workshop.Title,
                   workshop.Description,
                   workshop.StartAt,
                   workshop.EndAt,
                   workshop.Location,
                   workshop.Capacity,
                   workshop.IsOnline
               );
    }
}