#105 ✨ Added Heroes & Teams endpoints (#115)

Resolves #105 

- Migrates endpoints from CA to VSA
- Refactors endpoints into VSA format
- Migrates tests for endpoints

Author: sam-s-maher

src/VerticalSliceArchitectureTemplate/Common/Extensions/CustomResult.cs

@@ -0,0 +1,48 @@
+using Microsoft.AspNetCore.Http.HttpResults;
+
+namespace VerticalSliceArchitectureTemplate.Common.Extensions;
+
+public static class CustomResult
+{
+    public static IResult Problem(List<Error> errors)
+    {
+        if (errors.Count is 0)
+        {
+            return TypedResults.Problem();
+        }
+
+        if (errors.All(error => error.Type == ErrorType.Validation))
+        {
+            return ValidationProblem(errors);
+        }
+
+        return Problem(errors[0]);
+    }
+
+    private static ProblemHttpResult Problem(Error error)
+    {
+        var statusCode = error.Type switch
+        {
+            ErrorType.Conflict => StatusCodes.Status409Conflict,
+            ErrorType.Validation => StatusCodes.Status400BadRequest,
+            ErrorType.NotFound => StatusCodes.Status404NotFound,
+            _ => StatusCodes.Status500InternalServerError
+        };
+
+        return TypedResults.Problem(statusCode: statusCode, title: error.Description);
+    }
+
+    private static ValidationProblem ValidationProblem(List<Error> errors)
+    {
+        var validationErrors = new Dictionary<string, string[]>();
+        foreach (var e in errors)
+        {
+            if (validationErrors.Remove(e.Code, out var value))
+                validationErrors.Add(e.Code, [.. value, e.Description]);
+            else
+                validationErrors.Add(e.Code, [e.Description]);
+        }
+
+        return TypedResults.ValidationProblem(validationErrors, title: "One or more validation errors occurred.");
+    }
+}

src/VerticalSliceArchitectureTemplate/Features/Heroes/Commands/CreateHeroCommand.cs

@@ -0,0 +1,60 @@
+using MediatR;
+using VerticalSliceArchitectureTemplate.Common.Domain.Heroes;
+using VerticalSliceArchitectureTemplate.Common.Extensions;
+
+namespace VerticalSliceArchitectureTemplate.Features.Heroes.Commands;
+
+public static class CreateHeroCommand
+{
+    public record CreateHeroPowerDto(string Name, int PowerLevel);
+    
+    public record Request(
+        string Name,
+        string Alias,
+        IEnumerable<CreateHeroPowerDto> Powers) : IRequest<ErrorOr<Guid>>;
+    
+    public class Endpoint : IEndpoint
+    {
+        public static void MapEndpoint(IEndpointRouteBuilder endpoints)
+        {
+            endpoints
+                .MapApiGroup(HeroesFeature.FeatureName)
+                .MapPost("/",
+                    async (ISender sender, Request request, CancellationToken ct) =>
+                    {
+                        var result = await sender.Send(request, ct);
+                        return result.Match(_ => TypedResults.Created(), CustomResult.Problem);
+                    })
+                .WithName("CreateHero")
+                .ProducesPost();
+        }
+    }
+    
+    internal sealed class Validator : AbstractValidator<Request>
+    {
+        public Validator()
+        {
+            RuleFor(v => v.Name)
+                .NotEmpty();
+
+            RuleFor(v => v.Alias)
+                .NotEmpty();
+        }
+    }
+    
+    internal sealed class Handler(AppDbContext dbContext)
+        : IRequestHandler<Request, ErrorOr<Guid>>
+    {
+        public async Task<ErrorOr<Guid>> Handle(Request request, CancellationToken cancellationToken)
+        {
+            var hero = Hero.Create(request.Name, request.Alias);
+            var powers = request.Powers.Select(p => new Power(p.Name, p.PowerLevel));
+            hero.UpdatePowers(powers);
+
+            await dbContext.Heroes.AddAsync(hero, cancellationToken);
+            await dbContext.SaveChangesAsync(cancellationToken);
+
+            return hero.Id.Value;
+        }
+    }
+}

src/VerticalSliceArchitectureTemplate/Features/Heroes/Commands/UpdateHeroCommand.cs

@@ -0,0 +1,77 @@
+using MediatR;
+using System.Text.Json.Serialization;
+using VerticalSliceArchitectureTemplate.Common.Domain.Heroes;
+using VerticalSliceArchitectureTemplate.Common.Extensions;
+
+namespace VerticalSliceArchitectureTemplate.Features.Heroes.Commands;
+
+public static class UpdateHeroCommand
+{
+    public record UpdateHeroPowerDto(string Name, int PowerLevel);
+    
+    public record Request(
+        string Name,
+        string Alias,
+        IEnumerable<UpdateHeroPowerDto> Powers) : IRequest<ErrorOr<Guid>>
+    {
+        [JsonIgnore]
+        public Guid HeroId { get; set; }
+    }
+    
+    public class Endpoint : IEndpoint
+    {
+        public static void MapEndpoint(IEndpointRouteBuilder endpoints)
+        {
+            endpoints
+                .MapApiGroup(HeroesFeature.FeatureName)
+                .MapPut("/{heroId:guid}",
+                    async (ISender sender, Guid heroId, Request request, CancellationToken cancellationToken) =>
+                    {
+                        request.HeroId = heroId;
+                        var result = await sender.Send(request, cancellationToken);
+                        return result.Match(_ => TypedResults.NoContent(), CustomResult.Problem);
+                    })
+                .WithName("UpdateHero")
+                .ProducesPut();
+        }
+    }
+    
+    internal sealed class Validator : AbstractValidator<Request>
+    {
+        public Validator()
+        {
+            RuleFor(v => v.HeroId)
+                .NotEmpty();
+
+            RuleFor(v => v.Name)
+                .NotEmpty();
+
+            RuleFor(v => v.Alias)
+                .NotEmpty();
+        }
+    }
+    
+    internal sealed class Handler(AppDbContext dbContext)
+        : IRequestHandler<Request, ErrorOr<Guid>>
+    {
+        public async Task<ErrorOr<Guid>> Handle(Request request, CancellationToken cancellationToken)
+        {
+            var heroId = HeroId.From(request.HeroId);
+            var hero = await dbContext.Heroes
+                .Include(h => h.Powers)
+                .FirstOrDefaultAsync(h => h.Id == heroId, cancellationToken);
+
+            if (hero is null)
+                return HeroErrors.NotFound;
+
+            hero.Name = request.Name;
+            hero.Alias = request.Alias;
+            var powers = request.Powers.Select(p => new Power(p.Name, p.PowerLevel));
+            hero.UpdatePowers(powers);
+
+            await dbContext.SaveChangesAsync(cancellationToken);
+
+            return hero.Id.Value;
+        }
+    }
+}

src/VerticalSliceArchitectureTemplate/Features/Heroes/HeroesFeature.cs

@@ -0,0 +1,11 @@
+namespace VerticalSliceArchitectureTemplate.Features.Heroes;
+
+public sealed class HeroesFeature : IFeature
+{
+    public static string FeatureName => "Heroes";
+
+    public static void ConfigureServices(IServiceCollection services, IConfiguration config)
+    {
+
+    }
+}

src/VerticalSliceArchitectureTemplate/Features/Heroes/Queries/GetAllHeroesQuery.cs

@@ -0,0 +1,59 @@
+using MediatR;
+using VerticalSliceArchitectureTemplate.Common.Extensions;
+
+namespace VerticalSliceArchitectureTemplate.Features.Heroes.Queries;
+
+public static class GetAllHeroesQuery
+{
+    public record HeroDto(Guid Id, string Name, string Alias, int PowerLevel, IEnumerable<HeroPowerDto> Powers);
+    public record HeroPowerDto(string Name, int PowerLevel);
+    
+    public record Request : IRequest<ErrorOr<IReadOnlyList<HeroDto>>>;
+    
+    public class Endpoint : IEndpoint
+    {
+        public static void MapEndpoint(IEndpointRouteBuilder endpoints)
+        {
+            endpoints
+                .MapApiGroup(HeroesFeature.FeatureName)
+                .MapGet("/",
+                    async (ISender sender, CancellationToken cancellationToken) =>
+                    {
+                        var request = new Request();
+                        var result = await sender.Send(request, cancellationToken);
+                        return TypedResults.Ok(result);
+                    })
+                .WithName("GetAllHeroes")
+                .ProducesGet<IReadOnlyList<HeroDto>>();
+        }
+    }
+    
+    public class Validator : AbstractValidator<Request>
+    {
+        public Validator() {}
+    }
+    
+    internal sealed class Handler : IRequestHandler<Request, ErrorOr<IReadOnlyList<HeroDto>>>
+    {
+        private readonly AppDbContext _dbContext;
+
+        public Handler(AppDbContext dbContext)
+        {
+            _dbContext = dbContext;
+        }
+
+        public async Task<ErrorOr<IReadOnlyList<HeroDto>>> Handle(
+            Request request,
+            CancellationToken cancellationToken)
+        {
+            return await _dbContext.Heroes
+                .Select(h => new HeroDto(
+                    h.Id.Value,
+                    h.Name,
+                    h.Alias,
+                    h.PowerLevel,
+                    h.Powers.Select(p => new HeroPowerDto(p.Name, p.PowerLevel))))
+                .ToListAsync(cancellationToken);
+        }
+    }
+}

src/VerticalSliceArchitectureTemplate/Features/Teams/Commands/AddHeroToTeamCommand.cs

@@ -0,0 +1,84 @@
+using Ardalis.Specification.EntityFrameworkCore;
+using MediatR;
+using System.Text.Json.Serialization;
+using VerticalSliceArchitectureTemplate.Common.Domain.Heroes;
+using VerticalSliceArchitectureTemplate.Common.Domain.Teams;
+using VerticalSliceArchitectureTemplate.Common.Extensions;
+
+namespace VerticalSliceArchitectureTemplate.Features.Teams.Commands;
+
+public static class AddHeroToTeamCommand
+{
+    public record Request : IRequest<ErrorOr<Success>>
+    {
+        [JsonIgnore]
+        public Guid TeamId { get; set; }
+        [JsonIgnore]
+        public Guid HeroId { get; set; }
+    }
+    
+    public class Endpoint : IEndpoint
+    {
+        public static void MapEndpoint(IEndpointRouteBuilder endpoints)
+        {
+            endpoints
+                .MapApiGroup(TeamsFeature.FeatureName)
+                .MapPost("/{teamId:guid}/heroes/{heroId:guid}",
+                    async (
+                        ISender sender,
+                        Guid teamId,
+                        Guid heroId,
+                        Request request,
+                        CancellationToken ct) =>
+                    {
+                        request.TeamId = teamId;
+                        request.HeroId = heroId;
+                        var result = await sender.Send(request, ct);
+                        return result.Match(_ => TypedResults.Created(), CustomResult.Problem);
+                    })
+                .WithName("AddHeroToTeam")
+                .ProducesPost();
+        }
+    }
+    
+    internal sealed class Validator : AbstractValidator<Request>
+    {
+        public Validator()
+        {
+            RuleFor(v => v.HeroId)
+                .NotEmpty();
+
+            RuleFor(v => v.TeamId)
+                .NotEmpty();
+        }
+    }
+    
+    internal sealed class Handler(AppDbContext dbContext)
+        : IRequestHandler<Request, ErrorOr<Success>>
+    {
+        public async Task<ErrorOr<Success>> Handle(Request request, CancellationToken cancellationToken)
+        {
+            var teamId = TeamId.From(request.TeamId);
+            var heroId = HeroId.From(request.HeroId);
+
+            var team = dbContext.Teams
+                .WithSpecification(new TeamByIdSpec(teamId))
+                .FirstOrDefault();
+
+            if (team is null)
+                return TeamErrors.NotFound;
+
+            var hero = dbContext.Heroes
+                .WithSpecification(new HeroByIdSpec(heroId))
+                .FirstOrDefault();
+
+            if (hero is null)
+                return HeroErrors.NotFound;
+
+            team.AddHero(hero);
+            await dbContext.SaveChangesAsync(cancellationToken);
+
+            return new Success();
+        }
+    }
+}