Apply api high quality rules.

Football.Management.Application/Players/Commands/CreatePlayer/CreatePlayerCommandHander.cs

@@ -2,7 +2,7 @@
 using Football.Management.Application.Abstractions;
 using Football.Management.Domain.Entities;
 using Football.Management.Domain.Identities;
-using Football.Management.Domain.Repositories;
+using Football.Management.Domain.Repositories.Players;
 using Football.Management.Domain.ValueObjects;
 
 namespace Football.Management.Application.Players.Commands.CreatePlayer;
@@ -16,41 +16,41 @@ public CreatePlayerCommandHander(IPlayerRepository playerRepository)
         _playerRepository = playerRepository;
     }
 
-    public async Task<Result<PlayerId>> Handle(CreatePlayerCommand request, CancellationToken cancellationToken)
+    public Task<Result<PlayerId>> Handle(CreatePlayerCommand request, CancellationToken cancellationToken)
     {
         var firstName = PlayerFirstName.Create(request.FirstName);
 
         if (firstName.IsFailed)
         {
-            return firstName.ToResult<PlayerId>();
+            return Task.FromResult(firstName.ToResult<PlayerId>());
         }
 
         var lastName = PlayerLastName.Create(request.LastName);
 
         if (lastName.IsFailed)
         {
-            return lastName.ToResult<PlayerId>();
+            return Task.FromResult(lastName.ToResult<PlayerId>());
         }
 
         var attackSkill = PlayerAttackSkill.Create(request.AttackSkill);
 
         if (attackSkill.IsFailed)
         {
-            return attackSkill.ToResult<PlayerId>();
+            return Task.FromResult(attackSkill.ToResult<PlayerId>());
         }
 
         var midfieldSkill = PlayerMidfieldSkill.Create(request.MidfieldSkill);
 
         if (midfieldSkill.IsFailed)
         {
-            return midfieldSkill.ToResult<PlayerId>();
+            return Task.FromResult(midfieldSkill.ToResult<PlayerId>());
         }
 
         var defenseSkill = PlayerDefenseSkill.Create(request.DefenseSkill);
 
         if (defenseSkill.IsFailed)
         {
-            return defenseSkill.ToResult<PlayerId>();
+            return Task.FromResult(defenseSkill.ToResult<PlayerId>());
         }
 
         var player = Player.Create(
@@ -62,11 +62,24 @@ public async Task<Result<PlayerId>> Handle(CreatePlayerCommand request, Cancella
 
         if (player.IsFailed)
         {
-            return player.ToResult<PlayerId>();
+            return Task.FromResult(player.ToResult<PlayerId>());
         }
 
-        await _playerRepository.AddAsync(player.Value, cancellationToken);
+        return _playerRepository
+            .AddAsync(player.Value, cancellationToken)
+            .ContinueWith(t =>
+            {
+                if (t.IsFaulted)
+                {
+                    return Result.Fail<PlayerId>("Task has failed.");
+                }
+
+                if (t.Result.IsFailed)
+                {
+                    return t.Result.ToResult<PlayerId>();
+                }
 
-        return player.Value.Id;
+                return Result.Ok(player.Value.Id);
+            });
     }
 }

Football.Management.Application/Players/Queries/GetPlayerById/GetPlayerByIdQueryHandler.cs

@@ -1,7 +1,7 @@
 using FluentResults;
 using Football.Management.Application.Abstractions;
 using Football.Management.Domain.Entities;
-using Football.Management.Domain.Repositories;
+using Football.Management.Domain.Repositories.Players;
 
 namespace Football.Management.Application.Players.Queries.GetPlayerById;
 
@@ -14,15 +14,8 @@ public GetPlayerByIdQueryHandler(IPlayerRepository playerRepository)
         _playerRepository = playerRepository;
     }
 
-    public async Task<Result<Player>> Handle(GetPlayerByIdQuery request, CancellationToken cancellationToken)
+    public Task<Result<Player>> Handle(GetPlayerByIdQuery request, CancellationToken cancellationToken)
     {
-        var player = await _playerRepository.GetAsync(request.PlayerId, cancellationToken);
-
-        if (player is null)
-        {
-            return Result.Fail("Player was not found.");
-        }
-
-        return player;
+        return _playerRepository.GetAsync(request.PlayerId, cancellationToken);
     }
 }

Football.Management.Domain/Repositories/Players/Errors/PlayerExists.cs

@@ -0,0 +1,9 @@
+using FluentResults;
+using Football.Management.Domain.Entities;
+
+namespace Football.Management.Domain.Repositories.Players.Errors;
+
+public class PlayerExists(Player player) : Error
+{
+    public Player Player { get; } = player;
+}

Football.Management.Domain/Repositories/Players/Errors/PlayerNotFound.cs

@@ -0,0 +1,9 @@
+using FluentResults;
+using Football.Management.Domain.Identities;
+
+namespace Football.Management.Domain.Repositories.Players.Errors;
+
+public class PlayerNotFound(PlayerId PlayerId) : Error
+{
+    public PlayerId PlayerId { get; } = PlayerId;
+}

Football.Management.Domain/Repositories/Players/IPlayerRepository.cs

@@ -0,0 +1,11 @@
+using FluentResults;
+using Football.Management.Domain.Entities;
+using Football.Management.Domain.Identities;
+
+namespace Football.Management.Domain.Repositories.Players;
+
+public interface IPlayerRepository
+{
+    Task<Result> AddAsync(Player player, CancellationToken cancellationToken);
+    Task<Result<Player>> GetAsync(PlayerId playerId, CancellationToken cancellationToken);
+}

Football.Management.Persistence/Football.Management.Persistence.csproj

@@ -10,4 +10,8 @@
     <Nullable>enable</Nullable>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="FluentResults" Version="3.15.2" />
+  </ItemGroup>
+
 </Project>

Football.Management.Persistence/Repositories/Players/PlayerRepositoryInMemory.cs

@@ -0,0 +1,51 @@
+using FluentResults;
+using Football.Management.Domain.Entities;
+using Football.Management.Domain.Identities;
+using Football.Management.Domain.Repositories.Players;
+using Football.Management.Domain.Repositories.Players.Errors;
+using Football.Management.Domain.ValueObjects;
+
+namespace Football.Management.Persistence.Repositories.Players;
+
+public sealed class PlayerRepositoryInMemory : IPlayerRepository
+{
+    private List<Player> _players = new();
+
+    public PlayerRepositoryInMemory()
+    {
+        var player = Player.Create(
+            PlayerFirstName.Create("Kamil").ValueOrDefault,
+            PlayerLastName.Create("Grabara").ValueOrDefault,
+            PlayerAttackSkill.Create(0).ValueOrDefault,
+            PlayerMidfieldSkill.Create(5).ValueOrDefault,
+            PlayerDefenseSkill.Create(10).ValueOrDefault);
+
+        _players.Add(player.Value);
+    }
+
+    public async Task<Result> AddAsync(Player player, CancellationToken cancellationToken)
+    {
+        var playerResult = await GetAsync(player.Id, cancellationToken);
+
+        if (playerResult.IsSuccess)
+        {
+            return Result.Fail(new PlayerExists(player));
+        }
+
+        _players.Add(player);
+
+        return Result.Ok();
+    }
+
+    public Task<Result<Player>> GetAsync(PlayerId playerId, CancellationToken cancellationToken)
+    {
+        var player = _players.FirstOrDefault(i => i.Id.Id == playerId.Id);
+
+        if (player is null)
+        {
+            return Task.FromResult(Result.Fail<Player>(new PlayerNotFound(playerId)));
+        }
+
+        return Task.FromResult(Result.Ok(player));
+    }
+}

Football.Management.Presentation/Players/Controllers/PlayersController.cs

@@ -5,11 +5,12 @@
 using Football.Management.Domain.Identities;
 using Football.Management.Application.Players.Queries.GetPlayerById;
 using Football.Management.Presentation.Players.Responses;
+using Football.Management.Domain.Repositories.Players.Errors;
 
 namespace Football.Management.Presentation.Players.Controllers;
 
 [ApiController]
-[Route("api/players")]
+[Route("api/player")]
 public sealed class PlayersController : ControllerBase
 {
     private readonly ISender _sender;
@@ -20,11 +21,11 @@ public PlayersController(ISender sender)
     }
 
     [HttpPost]
-    public async Task<IActionResult> CreatePlayer(CreatePlayerRequest request, CancellationToken cancellationToken)
+    public async Task<IActionResult> CreatePlayer(PlayerPostRequest request, CancellationToken cancellationToken)
     {
         var command = new CreatePlayerCommand(request.FirstName, request.LastName, request.AttackSkill, request.MidfieldSkill, request.DefenseSkill);
         var result = await _sender.Send(command, cancellationToken);
-        return result.IsSuccess ? Ok(result.Value) : BadRequest(result.Errors);
+        return result.IsSuccess ? Ok(result.Value) : BadRequest(new { result.Errors });
     }
 
     [HttpGet("{playerId}")]
@@ -44,6 +45,10 @@ public async Task<IActionResult> GetPlayerById(Guid playerId, CancellationToken
                 player.DefenseSkill.Value);
             return Ok(response);
         }
-        return NotFound(result.Errors);
+        if (result.Errors.Select(e => e.GetType()).Contains(typeof(PlayerNotFound)))
+        {
+            return NoContent();
+        }
+        return Ok(result.Errors);
     }
 }

Football.Management.Presentation/Players/Requests/PlayerPostRequest.cs

@@ -0,0 +1,3 @@
+namespace Football.Management.Presentation.Players.Requests;
+
+public sealed record PlayerPostRequest(string FirstName, string LastName, int AttackSkill, int MidfieldSkill, int DefenseSkill);

Football.Management.Web/Program.cs

@@ -1,4 +1,4 @@
-using Football.Management.Domain.Repositories;
+using Football.Management.Domain.Repositories.Players;
 
 var builder = WebApplication.CreateBuilder(args);
 
@@ -15,7 +15,7 @@
 //             .AddClasses(false)
 //             .AsImplementedInterfaces()
 //             .WithScopedLifetime());
-builder.Services.AddSingleton<IPlayerRepository, Football.Management.Persistence.Repositories.PlayerRepositoryInMemory>();
+builder.Services.AddSingleton<IPlayerRepository, Football.Management.Persistence.Repositories.Players.PlayerRepositoryInMemory>();
 builder.Services.AddMediatR(conf => conf.RegisterServicesFromAssembly(Football.Management.Application.AssemblyReference.Assembly));
 builder.Services.AddControllers().AddApplicationPart(Football.Management.Presentation.AssemblyReference.Assembly);
 builder.Services.AddSwaggerGen();