add: ef core

Controllers/WorkshopsController.cs

@@ -1,9 +1,8 @@
+
 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;
 
@@ -12,6 +11,7 @@ namespace CampusWorkshops.Api.Controllers;
 public class WorkshopsController : ControllerBase
 {
     private readonly IWorkshopRepository _repo;
+
     public WorkshopsController(IWorkshopRepository repo) => _repo = repo;
 
     /// <summary>Lista workshops com filtros opcionais.</summary>
@@ -19,75 +19,195 @@ public class WorkshopsController : ControllerBase
     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);
+        var response = workshops.Select(w => new WorkshopResponse(
+            w.Id,
+            w.Title,
+            w.Description,
+            w.StartAt,
+            w.EndAt,
+            w.Location,
+            w.Capacity,
+            w.IsOnline
+        )).ToList();
+
+        return Ok(response);
     }
 
+    /// <summary>Obtém um workshop por Id.</summary>
     [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 NotFound();
+        }
 
-        return Ok(ConvertToWorkshopResponseDTO(workshop));
+        var response = new WorkshopResponse(
+            workshop.Id,
+            workshop.Title,
+            workshop.Description,
+            workshop.StartAt,
+            workshop.EndAt,
+            workshop.Location,
+            workshop.Capacity,
+            workshop.IsOnline
+        );
+
+        return Ok(response);
     }
 
+    /// <summary>Cria um novo workshop.</summary>
     [HttpPost]
-    public async Task<IActionResult> Create([FromBody] CreateWorkshopRequestDTO workshopDTO, CancellationToken ct)
+    public async Task<IActionResult> Create([FromBody] CreateWorkshopRequest body, CancellationToken ct)
     {
-        var dtoValidator = new WorkshopRequestDTOValidator();
-        var validationResult = await dtoValidator.ValidateAsync(workshopDTO);
-        if (!validationResult.IsValid)
+        if (!ModelState.IsValid)
         {
-            var erros = validationResult.Errors.Select(e => new { e.PropertyName, e.ErrorMessage });
-            return BadRequest(erros);
+            return BadRequest(ModelState);
         }
-        
-        Workshop workshop = new Workshop
+
+        // Validações de negócio
+        if (body.StartAt >= body.EndAt)
         {
-            Capacity = workshopDTO.Capacity,
-            Description = workshopDTO.Description,
-            EndAt = workshopDTO.EndAt,
-            IsOnline = workshopDTO.IsOnline,
-            Location = workshopDTO.Location,
-            StartAt = workshopDTO.StartAt,
-            Title = workshopDTO.Title
+            return BadRequest("Data de início deve ser anterior à data de fim.");
+        }
+
+        if (body.StartAt < DateTimeOffset.UtcNow)
+        {
+            return BadRequest("Data de início deve ser no futuro.");
+        }
+
+        if (!body.IsOnline && string.IsNullOrWhiteSpace(body.Location))
+        {
+            return BadRequest("Location é obrigatório para workshops presenciais.");
+        }
+
+        if (body.Capacity < 1)
+        {
+            return BadRequest("Capacidade deve ser pelo menos 1.");
+        }
+
+        var workshop = new Workshop
+        {
+            Id = Guid.NewGuid(),
+            Title = body.Title,
+            Description = body.Description,
+            StartAt = body.StartAt,
+            EndAt = body.EndAt,
+            Location = body.Location,
+            Capacity = body.Capacity,
+            IsOnline = body.IsOnline
         };
 
-        var result = await _repo.AddAsync(workshop, ct);
+        var createdWorkshop = await _repo.AddAsync(workshop, ct);
 
-        if (result != null)
-            return CreatedAtAction(nameof(GetById), new { workshopDTO });
+        var response = new WorkshopResponse(
+            createdWorkshop.Id,
+            createdWorkshop.Title,
+            createdWorkshop.Description,
+            createdWorkshop.StartAt,
+            createdWorkshop.EndAt,
+            createdWorkshop.Location,
+            createdWorkshop.Capacity,
+            createdWorkshop.IsOnline
+        );
 
-        return BadRequest();
+        return CreatedAtAction(nameof(GetById), new { id = createdWorkshop.Id }, response);
     }
 
-    [HttpDelete]
+    /// <summary>Atualiza parcialmente um workshop existente.</summary>
+    [HttpPatch("{id:guid}")]
+    public async Task<IActionResult> Patch(Guid id, [FromBody] PatchWorkshopRequest body, CancellationToken ct)
+    {
+        if (!ModelState.IsValid)
+        {
+            return BadRequest(ModelState);
+        }
+
+        var existingWorkshop = await _repo.GetByIdAsync(id, ct);
+        if (existingWorkshop == null)
+        {
+            return NotFound();
+        }
+
+        // Aplicar apenas os campos fornecidos
+        if (body.Title != null)
+            existingWorkshop.Title = body.Title;
+        
+        if (body.Description != null)
+            existingWorkshop.Description = body.Description;
+        
+        if (body.StartAt.HasValue)
+        {
+            if (body.StartAt.Value < DateTimeOffset.UtcNow)
+            {
+                return BadRequest("Data de início deve ser no futuro.");
+            }
+            existingWorkshop.StartAt = body.StartAt.Value;
+        }
+        
+        if (body.EndAt.HasValue)
+            existingWorkshop.EndAt = body.EndAt.Value;
+        
+        if (body.Location != null)
+            existingWorkshop.Location = body.Location;
+        
+        if (body.Capacity.HasValue)
+        {
+            if (body.Capacity.Value < 1)
+            {
+                return BadRequest("Capacidade deve ser pelo menos 1.");
+            }
+            existingWorkshop.Capacity = body.Capacity.Value;
+        }
+        
+        if (body.IsOnline.HasValue)
+            existingWorkshop.IsOnline = body.IsOnline.Value;
+
+        // Validações de negócio após aplicar mudanças
+        if (existingWorkshop.StartAt >= existingWorkshop.EndAt)
+        {
+            return BadRequest("Data de início deve ser anterior à data de fim.");
+        }
+
+        if (!existingWorkshop.IsOnline && string.IsNullOrWhiteSpace(existingWorkshop.Location))
+        {
+            return BadRequest("Location é obrigatório para workshops presenciais.");
+        }
+
+        var updatedWorkshop = await _repo.UpdateAsync(existingWorkshop, ct);
+        if (updatedWorkshop == null)
+        {
+            return NotFound();
+        }
+
+        var response = new WorkshopResponse(
+            updatedWorkshop.Id,
+            updatedWorkshop.Title,
+            updatedWorkshop.Description,
+            updatedWorkshop.StartAt,
+            updatedWorkshop.EndAt,
+            updatedWorkshop.Location,
+            updatedWorkshop.Capacity,
+            updatedWorkshop.IsOnline
+        );
+
+        return Ok(response);
+    }
+
+    /// <summary>Remove um workshop.</summary>
+    [HttpDelete("{id:guid}")]
     public async Task<IActionResult> Delete(Guid id, CancellationToken ct)
     {
-        var result = await _repo.DeleteAsync(id, ct);
-        if(result)
-            return NoContent();
-        
-        return NotFound();
-    }
+        var workshop = await _repo.GetByIdAsync(id, ct);
+        if (workshop == null)
+        {
+            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
-               );
+        await _repo.DeleteAsync(id, ct);
+        return NoContent();
     }
 }

Dtos/CreateWorkshopRequest.cs

@@ -0,0 +1,28 @@
+
+using System.ComponentModel.DataAnnotations;
+
+namespace CampusWorkshops.Api.Dtos;
+
+// DTO para criação de Workshop com validações
+public record CreateWorkshopRequest(
+    [Required(ErrorMessage = "Título é obrigatório")]
+    [StringLength(120, MinimumLength = 3, ErrorMessage = "Título deve ter entre 3 e 120 caracteres")]
+    string Title,
+    
+    [StringLength(2000, ErrorMessage = "Descrição não pode exceder 2000 caracteres")]
+    string? Description,
+    
+    [Required(ErrorMessage = "Data de início é obrigatória")]
+    DateTimeOffset StartAt,
+    
+    [Required(ErrorMessage = "Data de fim é obrigatória")]
+    DateTimeOffset EndAt,
+    
+    [StringLength(200, ErrorMessage = "Localização não pode exceder 200 caracteres")]
+    string? Location,
+    
+    [Range(1, 1000, ErrorMessage = "Capacidade deve estar entre 1 e 1000")]
+    int Capacity,
+    
+    bool IsOnline
+);

Dtos/CreateWorkshopRequestDTO.cs

@@ -1,12 +0,0 @@
-
-namespace CampusWorkshops.Api.Dtos;
-
-public record CreateWorkshopRequestDTO(
-    string? Title,
-    string? Description,
-    DateTimeOffset StartAt,
-    DateTimeOffset EndAt,
-    string? Location,
-    int Capacity,
-    bool IsOnline
-);

Dtos/PatchWorkshopRequest.cs

@@ -0,0 +1,23 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace CampusWorkshops.Api.Dtos;
+
+// DTO para atualização parcial de Workshop.
+public record PatchWorkshopRequest(
+    [StringLength(120, MinimumLength = 3, ErrorMessage = "Título deve ter entre 3 e 120 caracteres")]
+    string? Title,
+    
+    [StringLength(2000, ErrorMessage = "Descrição não pode exceder 2000 caracteres")]
+    string? Description,
+    
+    DateTimeOffset? StartAt,
+    DateTimeOffset? EndAt,
+    
+    [StringLength(200, ErrorMessage = "Localização não pode exceder 200 caracteres")]
+    string? Location,
+    
+    [Range(1, 1000, ErrorMessage = "Capacidade deve estar entre 1 e 1000")]
+    int? Capacity,
+    
+    bool? IsOnline
+);

Dtos/WorkshopResponse.cs

@@ -1,7 +1,8 @@
 
 namespace CampusWorkshops.Api.Dtos;
 
-public record WorkshopResponseDTO(
+// DTO de resposta para Workshop
+public record WorkshopResponse(
 	Guid Id,
 	string? Title,
 	string? Description,

Infraestructure/Data/WorkshopDBContext.cs

@@ -0,0 +1,25 @@
+using Microsoft.EntityFrameworkCore;
+using CampusWorkshops.Api.Models;
+
+namespace CampusWorkshops.Api.Infrastructure.Data;
+
+public class WorkshopsDbContext : DbContext
+{
+    public WorkshopsDbContext(DbContextOptions<WorkshopsDbContext> options) : base(options) {}
+
+    public DbSet<Workshop> Workshops => Set<Workshop>();
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        modelBuilder.Entity<Workshop>(e =>
+        {
+            e.ToTable("Workshops");
+            e.HasKey(w => w.Id);
+            e.Property(w => w.Title).IsRequired().HasMaxLength(120);
+            e.Property(w => w.Description).HasMaxLength(2000);
+            e.Property(w => w.Location).HasMaxLength(200);
+            e.Property(w => w.Capacity).HasDefaultValue(1);
+            e.HasIndex(w => w.StartAt);
+        });
+    }
+}

Migrations/20250903175616_InitialCreate.Designer.cs

@@ -0,0 +1,65 @@
+// <auto-generated />
+using System;
+using CampusWorkshops.Api.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace Workshop10_API.Migrations
+{
+    [DbContext(typeof(WorkshopsDbContext))]
+    [Migration("20250903175616_InitialCreate")]
+    partial class InitialCreate
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "9.0.8");
+
+            modelBuilder.Entity("CampusWorkshops.Api.Models.Workshop", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Capacity")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(1);
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(2000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("EndAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsOnline")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Location")
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("StartAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(120)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StartAt");
+
+                    b.ToTable("Workshops", (string)null);
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Migrations/20250903175616_InitialCreate.cs

@@ -0,0 +1,45 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Workshop10_API.Migrations
+{
+    /// <inheritdoc />
+    public partial class InitialCreate : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "Workshops",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "TEXT", nullable: false),
+                    Title = table.Column<string>(type: "TEXT", maxLength: 120, nullable: false),
+                    Description = table.Column<string>(type: "TEXT", maxLength: 2000, nullable: true),
+                    StartAt = table.Column<DateTimeOffset>(type: "TEXT", nullable: false),
+                    EndAt = table.Column<DateTimeOffset>(type: "TEXT", nullable: false),
+                    Location = table.Column<string>(type: "TEXT", maxLength: 200, nullable: true),
+                    Capacity = table.Column<int>(type: "INTEGER", nullable: false, defaultValue: 1),
+                    IsOnline = table.Column<bool>(type: "INTEGER", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Workshops", x => x.Id);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Workshops_StartAt",
+                table: "Workshops",
+                column: "StartAt");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "Workshops");
+        }
+    }
+}

Migrations/WorkshopsDbContextModelSnapshot.cs

@@ -0,0 +1,62 @@
+// <auto-generated />
+using System;
+using CampusWorkshops.Api.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace Workshop10_API.Migrations
+{
+    [DbContext(typeof(WorkshopsDbContext))]
+    partial class WorkshopsDbContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "9.0.8");
+
+            modelBuilder.Entity("CampusWorkshops.Api.Models.Workshop", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Capacity")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(1);
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(2000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("EndAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsOnline")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Location")
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("StartAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(120)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StartAt");
+
+                    b.ToTable("Workshops", (string)null);
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Models/Workshop.cs

@@ -1,19 +1,32 @@
+
+using System.ComponentModel.DataAnnotations;
+
 namespace CampusWorkshops.Api.Models;
 
+// Modelo mínimo para Workshop com validações
 public class Workshop
 {
+    // Identificador único
     public Guid Id { get; set; } = Guid.NewGuid();
 
+    [Required(ErrorMessage = "Título é obrigatório")]
+    [StringLength(120, MinimumLength = 3, ErrorMessage = "Título deve ter entre 3 e 120 caracteres")]
     public string? Title { get; set; }
 
+    [StringLength(2000, ErrorMessage = "Descrição não pode exceder 2000 caracteres")]
     public string? Description { get; set; }
 
+    [Required(ErrorMessage = "Data de início é obrigatória")]
     public DateTimeOffset StartAt { get; set; }
-    
+
+    [Required(ErrorMessage = "Data de fim é obrigatória")]
     public DateTimeOffset EndAt { get; set; }
 
+    // Location deve ser obrigatório se IsOnline == false (validado no controller)
+    [StringLength(200, ErrorMessage = "Localização não pode exceder 200 caracteres")]
     public string? Location { get; set; }
 
+    [Range(1, 1000, ErrorMessage = "Capacidade deve estar entre 1 e 1000")]
     public int Capacity { get; set; } = 1;
 
     public bool IsOnline { get; set; }

Program.cs

@@ -1,26 +1,30 @@
 // Note: repository implementation removed for workshop exercise (TODOs in project files)
-using CampusWorkshops.Api.Repositories;
 using Microsoft.AspNetCore.Diagnostics;
 using Microsoft.AspNetCore.Mvc;
-using SharpGrip.FluentValidation.AutoValidation.Mvc.Extensions;
+using CampusWorkshops.Api.Repositories;
+using Microsoft.EntityFrameworkCore;
+using CampusWorkshops.Api.Infrastructure.Data;
 
 var builder = WebApplication.CreateBuilder(args);
 
-builder.Services.AddControllers();
+// Add services
+builder.Services.AddDbContext<WorkshopsDbContext>(options =>
+    options.UseSqlite(builder.Configuration.GetConnectionString("WorkshopsDb")));
 
-builder.Services.AddTransient<IWorkshopRepository, InMemoryWorkshopRepository>();
-builder.Services.AddFluentValidationAutoValidation();
+builder.Services.AddScoped<IWorkshopRepository, EfWorkshopRepository>();
+builder.Services.AddControllers();
 builder.Services.AddEndpointsApiExplorer();
 builder.Services.AddSwaggerGen(o =>
 {
     o.SwaggerDoc("v1", new Microsoft.OpenApi.Models.OpenApiInfo
     {
-        Title = "Workshop 10 - API's RESTFul",
+        Title = "CampusWorkshops API",
         Version = "v1",
         Description = "API para gestão de workshops do campus (MVP in-memory)."
     });
 });
 
+// DI
 
 var app = builder.Build();
 

Properties/launchSettings.json

@@ -5,7 +5,7 @@
       "commandName": "Project",
       "dotnetRunMessages": true,
       "launchBrowser": false,
-      "applicationUrl": "http://localhost:5001",
+      "applicationUrl": "http://localhost:5298",
       "environmentVariables": {
         "ASPNETCORE_ENVIRONMENT": "Development"
       }
@@ -14,7 +14,7 @@
       "commandName": "Project",
       "dotnetRunMessages": true,
       "launchBrowser": false,
-      "applicationUrl": "https://localhost:7006;http://localhost:5001",
+      "applicationUrl": "https://localhost:7006;http://localhost:5298",
       "environmentVariables": {
         "ASPNETCORE_ENVIRONMENT": "Development"
       }

Repositories/EfWorkshopRepository.cs

@@ -0,0 +1,71 @@
+using CampusWorkshops.Api.Models;
+using Microsoft.EntityFrameworkCore;
+using CampusWorkshops.Api.Infrastructure.Data;
+
+namespace CampusWorkshops.Api.Repositories;
+
+public class EfWorkshopRepository : IWorkshopRepository
+{
+    private readonly WorkshopsDbContext _db;
+    public EfWorkshopRepository(WorkshopsDbContext db) => _db = db;
+
+    public async Task<IReadOnlyList<Workshop>> GetAllAsync(DateTimeOffset? from, DateTimeOffset? to, string? q, CancellationToken ct)
+    {
+        var query = _db.Workshops.AsNoTracking().AsQueryable();
+        if (from.HasValue)
+        {
+            query = query.Where(w => w.StartAt >= from.Value);
+        }
+        if (to.HasValue)
+        {
+            query = query.Where(w => w.EndAt >= to.Value);
+        }
+        if (!string.IsNullOrWhiteSpace(q))
+        {
+            var termo = q.ToLowerInvariant();
+            query = query.Where(w => w.Title.Contains(termo)|| w.Description.Contains(termo));
+        }
+        Console.WriteLine(query.ToQueryString());
+        return await query.ToListAsync(ct);
+        
+    }
+
+    public async Task<Workshop?> GetByIdAsync(Guid id, CancellationToken ct)
+        => await _db.Workshops.AsNoTracking().FirstOrDefaultAsync(w => w.Id == id, ct);
+
+    public async Task<Workshop> AddAsync(Workshop workshop, CancellationToken ct)
+    {
+        _db.Workshops.Add(workshop);
+        await _db.SaveChangesAsync();
+        return workshop;
+    }
+
+    public async Task<Workshop?> UpdateAsync(Workshop workshop, CancellationToken ct)
+    {
+        _db.Workshops.Update(workshop);
+        await _db.SaveChangesAsync(ct);
+        return workshop;
+    }
+
+    public async Task<bool> DeleteAsync(Guid id, CancellationToken ct)
+    {
+        var encontrado = await _db.Workshops.FindAsync([id]);
+        if (encontrado == null)
+        {
+            return false;
+        }
+        _db.Workshops.Remove(encontrado);
+        await _db.SaveChangesAsync();
+        return true;
+    }
+
+    public Task<bool> ExistsAsync(Guid id, CancellationToken ct)
+        => _db.Workshops.AnyAsync(w => w.Id == id, ct);
+
+    public async Task<Workshop?> UpdatePartialAsync(Guid id, Action<Workshop> updateAction, CancellationToken ct)
+    {
+        var w = await _db.Workshops.FirstOrDefaultAsync(x => x.Id == id, ct);
+        // TODO: implementar o UpdatePartial
+        return w;
+    }
+}

Repositories/IWorkshopRepository.cs

@@ -9,5 +9,8 @@ public interface IWorkshopRepository
     Task<IReadOnlyList<Workshop>> GetAllAsync(DateTimeOffset? from, DateTimeOffset? to, string? q, CancellationToken ct);
     Task<Workshop?> GetByIdAsync(Guid id, CancellationToken ct);
     Task<Workshop> AddAsync(Workshop workshop, CancellationToken ct);
+    Task<Workshop?> UpdateAsync(Workshop workshop, CancellationToken ct);
     Task<bool> DeleteAsync(Guid id, CancellationToken ct);
+    Task<bool> ExistsAsync(Guid id, CancellationToken ct);
+    Task<Workshop?> UpdatePartialAsync(Guid id, Action<Workshop> updateAction, CancellationToken ct);
 }

Repositories/InMemoryWorkshopRepository.cs

@@ -6,73 +6,20 @@ namespace CampusWorkshops.Api.Repositories;
 // In-memory repository stub
 public class InMemoryWorkshopRepository : IWorkshopRepository
 {
-    private readonly List<Workshop> workshops = new List<Workshop>();
+    List<Workshop> _workshops = new();
 
-    public InMemoryWorkshopRepository()
-    {
-        workshops.AddRange(Seed());
-    }
-
-    public async Task<Workshop?> GetByIdAsync(Guid id, CancellationToken ct)
-    {
-        ct.ThrowIfCancellationRequested();
-
-        Workshop workshop = workshops.FirstOrDefault(w => w.Id == id);
-        if(workshop == null) return await Task.FromResult<Workshop?>(null);
-        return await Task.FromResult<Workshop?>(workshop);
-    }
-
-    public async Task<Workshop> AddAsync(Workshop workshop, CancellationToken ct)
-    {
-        ct.ThrowIfCancellationRequested();
-        ArgumentNullException.ThrowIfNull(workshop);
-
-        workshops.Add(workshop);
-
-        return await Task.FromResult<Workshop?>(workshop);
-
-    }
-
-    public async Task<IReadOnlyList<Workshop>> GetAllAsync(DateTimeOffset? from, DateTimeOffset? to, string? q, CancellationToken ct)
-    {
-        ct.ThrowIfCancellationRequested();
-
-        IEnumerable<Workshop> retorno = workshops;
-        if (from.HasValue)
-            retorno = retorno.Where(w => w.StartAt >= from.Value);
-        if (to.HasValue)
-            retorno = retorno.Where(w => w.StartAt <= to.Value);
-        if (!string.IsNullOrWhiteSpace(q))
-            retorno = retorno.Where(w => (!string.IsNullOrWhiteSpace(w.Title) && w.Title.Contains(q)));
-        IReadOnlyList<Workshop> orderedWorkshops = retorno.OrderBy(r => r.StartAt).ToList();
-
-        return await Task.FromResult<IReadOnlyList<Workshop>>(orderedWorkshops);
-    }
-    public async Task<bool> DeleteAsync(Guid id, CancellationToken ct)
-    {
-        bool retorno = false;
-        Workshop workshop = await GetByIdAsync(id, ct);
-        if(workshop != null)
-            retorno = workshops.Remove(workshop);
-
-        return retorno;
-    }
-
-    /// <summary>
-    /// Método auxiliar para popular o repositório in memory com alguns workshops de exemplo
-    /// </summary>
-    private static List<Workshop> Seed()
+    private void Seed()
     {
         // Base de datas: sempre a partir da próxima semana, para não “envelhecer” o seed
         var baseDate = DateTimeOffset.UtcNow.Date.AddDays(7);
-        List<Workshop> workShops = new();
+
         var w1 = new Workshop
         {
             Id = Guid.Parse("8a0b9f1b-6c9b-4a2a-9d5e-1c2f3a4b5c6d"),
             Title = "APIs RESTful — visão geral",
             Description = "Modelagem de recursos, status codes e boas práticas.",
             StartAt = baseDate.AddHours(12),   // daqui a 7 dias, 12:00 UTC
-            EndAt = baseDate.AddHours(15),   // 15:00 UTC
+            EndAt   = baseDate.AddHours(15),   // 15:00 UTC
             Location = "Lab 101",
             Capacity = 25,
             IsOnline = false
@@ -84,7 +31,7 @@ public class InMemoryWorkshopRepository : IWorkshopRepository
             Title = "Entity Framework — mapeamentos e LINQ",
             Description = "Relações, consultas eficientes e boas práticas.",
             StartAt = baseDate.AddDays(2).AddHours(12), // +2 dias, 12:00 UTC
-            EndAt = baseDate.AddDays(2).AddHours(14), // 14:00 UTC
+            EndAt   = baseDate.AddDays(2).AddHours(14), // 14:00 UTC
             Location = null,   // online
             Capacity = 40,
             IsOnline = true
@@ -96,17 +43,178 @@ public class InMemoryWorkshopRepository : IWorkshopRepository
             Title = "Construindo contratos com Swagger/OpenAPI",
             Description = "Documentação viva, exemplos e testes via Swagger UI.",
             StartAt = baseDate.AddDays(5).AddHours(13), // +5 dias, 13:00 UTC
-            EndAt = baseDate.AddDays(5).AddHours(16), // 16:00 UTC
+            EndAt   = baseDate.AddDays(5).AddHours(16), // 16:00 UTC
             Location = "Auditório Central",
             Capacity = 80,
             IsOnline = false
         };
 
-        workShops.Add(w1);
-        workShops.Add(w2);
-        workShops.Add(w3);
-        return workShops;
+        _workshops.Add(w1);
+        _workshops.Add(w2);
+        _workshops.Add(w3);
     }
 
 
+    public InMemoryWorkshopRepository()
+    {
+        Seed();
+    }
+
+    public Task<IReadOnlyList<Workshop>> GetAllAsync(DateTimeOffset? from, DateTimeOffset? to, string? q, CancellationToken ct)
+    {
+        var query = _workshops.AsQueryable();
+
+        // Filtro por data início (from)
+        if (from.HasValue)
+        {
+            query = query.Where(w => w.StartAt >= from.Value);
+        }
+
+        // Filtro por data fim (to)  
+        if (to.HasValue)
+        {
+            query = query.Where(w => w.StartAt <= to.Value);
+        }
+
+        // Filtro por texto (q) - busca no título e descrição
+        if (!string.IsNullOrWhiteSpace(q))
+        {
+            var searchTerm = q.Trim().ToLowerInvariant();
+            query = query.Where(w => 
+                (w.Title != null && w.Title.ToLowerInvariant().Contains(searchTerm)) ||
+                (w.Description != null && w.Description.ToLowerInvariant().Contains(searchTerm))
+            );
+        }
+
+        // Ordenar por data de início
+        var result = query.OrderBy(w => w.StartAt).ToList();
+        
+        return Task.FromResult<IReadOnlyList<Workshop>>(result);
+    }
+
+    public Task<Workshop?> GetByIdAsync(Guid id, CancellationToken ct)
+    {
+        var workshop = _workshops.FirstOrDefault(w => w.Id == id);
+        return Task.FromResult(workshop);
+    }
+
+    public Task<Workshop> AddAsync(Workshop workshop, CancellationToken ct)
+    {
+        // Gerar novo ID se não foi fornecido ou se já existe
+        if (workshop.Id == Guid.Empty || _workshops.Any(w => w.Id == workshop.Id))
+        {
+            workshop.Id = Guid.NewGuid();
+        }
+
+        // Validações de negócio que serão úteis quando migrar para banco
+        ValidateWorkshop(workshop);
+
+        _workshops.Add(workshop);
+        return Task.FromResult(workshop);
+    }
+
+    public Task<Workshop?> UpdateAsync(Workshop workshop, CancellationToken ct)
+    {
+        var existingIndex = _workshops.FindIndex(w => w.Id == workshop.Id);
+        if (existingIndex < 0)
+        {
+            return Task.FromResult<Workshop?>(null);
+        }
+
+        // Validações de negócio
+        ValidateWorkshop(workshop);
+
+        _workshops[existingIndex] = workshop;
+        return Task.FromResult<Workshop?>(workshop);
+    }
+
+    public Task<bool> DeleteAsync(Guid id, CancellationToken ct)
+    {
+        var workshop = _workshops.FirstOrDefault(w => w.Id == id);
+        if (workshop == null)
+        {
+            return Task.FromResult(false);
+        }
+
+        _workshops.Remove(workshop);
+        return Task.FromResult(true);
+    }
+
+    public Task<bool> ExistsAsync(Guid id, CancellationToken ct)
+    {
+        var exists = _workshops.Any(w => w.Id == id);
+        return Task.FromResult(exists);
+    }
+
+    public Task<Workshop?> UpdatePartialAsync(Guid id, Action<Workshop> updateAction, CancellationToken ct)
+    {
+        var workshop = _workshops.FirstOrDefault(w => w.Id == id);
+        if (workshop == null)
+        {
+            return Task.FromResult<Workshop?>(null);
+        }
+
+        // Aplicar as modificações
+        updateAction(workshop);
+
+        // Validar após modificações
+        ValidateWorkshop(workshop);
+
+        return Task.FromResult<Workshop?>(workshop);
+    }
+
+    private void ValidateWorkshop(Workshop workshop)
+    {
+        var errors = new List<string>();
+
+        // Validação de título
+        if (string.IsNullOrWhiteSpace(workshop.Title))
+        {
+            errors.Add("Title is required");
+        }
+        else if (workshop.Title.Length < 3 || workshop.Title.Length > 120)
+        {
+            errors.Add("Title must be between 3 and 120 characters");
+        }
+
+        // Validação de descrição
+        if (!string.IsNullOrWhiteSpace(workshop.Description) && workshop.Description.Length > 2000)
+        {
+            errors.Add("Description cannot exceed 2000 characters");
+        }
+
+        // Validação de datas
+        if (workshop.EndAt <= workshop.StartAt)
+        {
+            errors.Add("End date must be after start date");
+        }
+
+        if (workshop.StartAt <= DateTimeOffset.UtcNow)
+        {
+            errors.Add("Start date must be in the future");
+        }
+
+        // Validação de capacidade
+        if (workshop.Capacity < 1)
+        {
+            errors.Add("Capacity must be at least 1");
+        }
+
+        // Validação de localização para workshops presenciais
+        if (!workshop.IsOnline && string.IsNullOrWhiteSpace(workshop.Location))
+        {
+            errors.Add("Location is required for in-person workshops");
+        }
+
+        // Validação de localização para workshops online
+        if (workshop.IsOnline && !string.IsNullOrWhiteSpace(workshop.Location))
+        {
+            errors.Add("Location should not be specified for online workshops");
+        }
+
+        if (errors.Any())
+        {
+            throw new ArgumentException($"Workshop validation failed: {string.Join(", ", errors)}");
+        }
+    }
 }

Validation/WorkshopRequestDTOValidator.cs

@@ -1,33 +0,0 @@
-using CampusWorkshops.Api.Dtos;
-using FluentValidation;
-
-namespace Workshop10_API.Validation
-{
-    public class WorkshopRequestDTOValidator : AbstractValidator<CreateWorkshopRequestDTO>
-    {
-        public WorkshopRequestDTOValidator()
-        {
-            RuleFor(x => x.Title)
-                .NotEmpty().WithMessage("O título é obrigatório.")
-                .Length(3, 120).WithMessage("O título deve ter entre 3 e 120 caracteres.");
-
-            RuleFor(x => x.Capacity)
-                .GreaterThan(0).WithMessage("Capacidade deve ser no mínimo 1.");
-
-            RuleFor(x => x.StartAt)
-                .LessThan(x => x.EndAt).WithMessage("A data de início deve ser menor que a data de término.");
-
-            RuleFor(x => x.Location)
-                .NotEmpty().When(x => !x.IsOnline)
-                .WithMessage("Local é obrigatório quando o evento não é online.");
-
-            RuleFor(x => x.StartAt)
-                .Must(date => DateTime.TryParse(date.ToString("yyyy/MM/dd HH:mm:ss"), out DateTime x))
-                .WithMessage("A data de início deve estar em formato ISO 8601 (YYYY-MM-DDTHH:mm:ssZ).");
-
-            RuleFor(x => x.EndAt)
-                .Must(date => DateTime.TryParse(date.ToString("yyyy/MM/dd HH:mm:ss"), out DateTime x))
-                .WithMessage("A data fim deve estar em formato ISO 8601 (YYYY-MM-DDTHH:mm:ssZ).");
-        }
-    }
-}

Workshop10-API.csproj

@@ -8,15 +8,18 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="FluentValidation" Version="12.0.0" />
     <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="9.0.2" />
     <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.8" />
-    <PackageReference Include="SharpGrip.FluentValidation.AutoValidation.Mvc" Version="1.5.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="9.0.8">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="9.0.8" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="9.0.8">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
     <PackageReference Include="Swashbuckle.AspNetCore" Version="9.0.3" />
   </ItemGroup>
 
-  <ItemGroup>
-    <Folder Include="Controllers\" />
-  </ItemGroup>
-
 </Project>

Workshop10-API.http

@@ -1,6 +1,6 @@
-@Workshop10_API_HostAddress = http://localhost:5001
+@Workshop10_API_HostAddress = http://localhost:5298
 
-GET {{Workshop10_API_HostAddress}}/
+GET {{Workshop10_API_HostAddress}}/weatherforecast/
 Accept: application/json
 
 ###

appsettings.Development.json

@@ -1,4 +1,7 @@
 {
+  "ConnectionStrings": {
+    "WorkshopsDb": "Data Source=workshops.db"
+  },
   "Logging": {
     "LogLevel": {
       "Default": "Information",