Implement available opponent controller

planetarium · Dec 26, 2024 · 97832d3 · 97832d3
1 parent b550292
commit 97832d3
Show file tree

Hide file tree

Showing 11 changed files with 288 additions and 10 deletions.
diff --git a/ArenaService.Tests/Controllers/AvailableOpponentControllerTests.cs b/ArenaService.Tests/Controllers/AvailableOpponentControllerTests.cs
@@ -0,0 +1,103 @@
+using System.Security.Claims;
+using ArenaService.Controllers;
+using ArenaService.Dtos;
+using ArenaService.Models;
+using ArenaService.Repositories;
+using ArenaService.Services;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http.HttpResults;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+
+namespace ArenaService.Tests.Controllers;
+
+public class AvailableOpponentControllerTests
+{
+    private readonly AvailableOpponentController _controller;
+    private Mock<IAvailableOpponentRepository> _availableOpponentRepositoryMock;
+    private AvailableOpponentService _availableOpponentService;
+    private Mock<IParticipantRepository> _participantRepositoryMock;
+    private ParticipantService _participantService;
+
+    public AvailableOpponentControllerTests()
+    {
+        var availableOpponentRepositoryMock = new Mock<IAvailableOpponentRepository>();
+        _availableOpponentRepositoryMock = availableOpponentRepositoryMock;
+        _availableOpponentService = new AvailableOpponentService(
+            _availableOpponentRepositoryMock.Object
+        );
+        var participantRepositoryMock = new Mock<IParticipantRepository>();
+        _participantRepositoryMock = participantRepositoryMock;
+        _participantService = new ParticipantService(_participantRepositoryMock.Object);
+        _controller = new AvailableOpponentController(
+            _availableOpponentService,
+            _participantService
+        );
+    }
+
+    [Fact]
+    public async Task GetAvailableOpponents_WithValidHeader_ReturnsOk()
+    {
+        var avatarAddress = "DDF1472fD5a79B8F46C28e7643eDEF045e36BD3d";
+
+        _participantRepositoryMock
+            .Setup(repo => repo.GetParticipantByAvatarAddressAsync(1, avatarAddress))
+            .ReturnsAsync(
+                new Participant
+                {
+                    Id = 1,
+                    AvatarAddress = avatarAddress,
+                    NameWithHash = "test",
+                    PortraitId = 1
+                }
+            );
+
+        _availableOpponentRepositoryMock
+            .Setup(repo => repo.GetAvailableOpponents(1))
+            .ReturnsAsync(
+                [
+                    new AvailableOpponent
+                    {
+                        Id = 1,
+                        ParticipantId = 1,
+                        OpponentId = 2,
+                        Opponent = new Participant
+                        {
+                            Id = 2,
+                            AvatarAddress = "test",
+                            NameWithHash = "opponent1",
+                            PortraitId = 1
+                        },
+                        RefillBlockIndex = 1
+                    },
+                    new AvailableOpponent
+                    {
+                        Id = 2,
+                        ParticipantId = 1,
+                        OpponentId = 3,
+                        Opponent = new Participant
+                        {
+                            Id = 3,
+                            AvatarAddress = "test",
+                            NameWithHash = "opponent2",
+                            PortraitId = 1
+                        },
+                        RefillBlockIndex = 1
+                    }
+                ]
+            );
+
+        _controller.ControllerContext = new ControllerContext
+        {
+            HttpContext = new DefaultHttpContext()
+        };
+        _controller.ControllerContext.HttpContext.User = new ClaimsPrincipal(
+            new ClaimsIdentity([new Claim("avatar", avatarAddress)])
+        );
+
+        var result = await _controller.GetAvailableOpponents(1);
+
+        var okResult = Assert.IsType<Ok<AvailableOpponentsResponse>>(result.Result);
+        Assert.Equal(2, okResult.Value?.AvailableOpponents.Count);
+    }
+}
diff --git a/ArenaService.Tests/Controllers/ParticipantControllerTests.cs b/ArenaService.Tests/Controllers/ParticipantControllerTests.cs
@@ -52,7 +52,7 @@ public async Task Join_ActivatedSeasonsExist_ReturnsOk()
         _seasonRepositoryMock.Setup(repo => repo.GetSeasonAsync(season.Id)).ReturnsAsync(season);
         _participantRepositoryMock
             .Setup(repo =>
-                repo.InsertParticipantToSpecificSeason(
+                repo.InsertParticipantToSpecificSeasonAsync(
                     season.Id,
                     participant.AvatarAddress,
                     participant.NameWithHash,
@@ -99,7 +99,7 @@ public async Task Join_ActivatedSeasonsNotExist_ReturnsNotFound()
         _seasonRepositoryMock.Setup(repo => repo.GetActivatedSeasonsAsync()).ReturnsAsync([season]);
         _participantRepositoryMock
             .Setup(repo =>
-                repo.InsertParticipantToSpecificSeason(
+                repo.InsertParticipantToSpecificSeasonAsync(
                     season.Id,
                     participant.AvatarAddress,
                     participant.NameWithHash,
@@ -146,7 +146,7 @@ public async Task Join_SeasonsNotExist_ReturnsNotFound()
         _seasonRepositoryMock.Setup(repo => repo.GetActivatedSeasonsAsync()).ReturnsAsync([season]);
         _participantRepositoryMock
             .Setup(repo =>
-                repo.InsertParticipantToSpecificSeason(
+                repo.InsertParticipantToSpecificSeasonAsync(
                     season.Id,
                     participant.AvatarAddress,
                     participant.NameWithHash,

diff --git a/ArenaService/Controllers/AvailableOpponentController.cs b/ArenaService/Controllers/AvailableOpponentController.cs
@@ -0,0 +1,80 @@
+namespace ArenaService.Controllers;
+
+using System.Security.Claims;
+using ArenaService.Dtos;
+using ArenaService.Extensions;
+using ArenaService.Services;
+using Microsoft.AspNetCore.Http.HttpResults;
+using Microsoft.AspNetCore.Mvc;
+
+[Route("seasons/{seasonId}/available-opponents")]
+[ApiController]
+public class AvailableOpponentController : ControllerBase
+{
+    private readonly AvailableOpponentService _availableOpponentService;
+    private readonly ParticipantService _participantService;
+
+    public AvailableOpponentController(
+        AvailableOpponentService availableOpponentService,
+        ParticipantService participantService
+    )
+    {
+        _availableOpponentService = availableOpponentService;
+        _participantService = participantService;
+    }
+
+    private string? ExtractAvatarAddress()
+    {
+        if (HttpContext.User.Identity is ClaimsIdentity identity)
+        {
+            var claim = identity.FindFirst("avatar");
+            return claim?.Value;
+        }
+        return null;
+    }
+
+    [HttpGet]
+    public async Task<
+        Results<UnauthorizedHttpResult, NotFound<string>, Ok<AvailableOpponentsResponse>>
+    > GetAvailableOpponents(int seasonId)
+    {
+        var avatarAddress = ExtractAvatarAddress();
+
+        if (avatarAddress is null)
+        {
+            return TypedResults.Unauthorized();
+        }
+
+        var participant = await _participantService.GetParticipantByAvatarAddressAsync(
+            seasonId,
+            avatarAddress
+        );
+
+        if (participant is null)
+        {
+            return TypedResults.NotFound("Not participant user.");
+        }
+
+        var opponents = await _availableOpponentService.GetAvailableOpponents(participant.Id);
+
+        return TypedResults.Ok(
+            new AvailableOpponentsResponse { AvailableOpponents = opponents.ToResponse() }
+        );
+    }
+
+    [HttpGet]
+    public async Task<Results<UnauthorizedHttpResult, NotFound<string>, Created>> ResetOpponents(
+        int seasonId
+    )
+    {
+        var avatarAddress = ExtractAvatarAddress();
+
+        if (avatarAddress is null)
+        {
+            return TypedResults.Unauthorized();
+        }
+
+        // Dummy implementation
+        return TypedResults.Created();
+    }
+}
diff --git a/ArenaService/Controllers/ParticipantController.cs b/ArenaService/Controllers/ParticipantController.cs
@@ -6,7 +6,7 @@ namespace ArenaService.Controllers;
 using Microsoft.AspNetCore.Http.HttpResults;
 using Microsoft.AspNetCore.Mvc;
 
-[Route("api/seasons/{seasonId}/participants")]
+[Route("seasons/{seasonId}/participants")]
 [ApiController]
 public class ParticipantController : ControllerBase
 {

diff --git a/ArenaService/Dtos/AvailableOpponentsResponse.cs b/ArenaService/Dtos/AvailableOpponentsResponse.cs
@@ -0,0 +1,6 @@
+namespace ArenaService.Dtos;
+
+public class AvailableOpponentsResponse
+{
+    public required List<ParticipantResponse> AvailableOpponents { get; set; }
+}
diff --git a/ArenaService/Extensions/ParticipantExtensions.cs b/ArenaService/Extensions/ParticipantExtensions.cs
@@ -14,4 +14,16 @@ public static ParticipantResponse ToResponse(this Participant participant)
             PortraitId = participant.PortraitId,
         };
     }
+
+    public static List<ParticipantResponse> ToResponse(this List<Participant> participants)
+    {
+        return participants
+            .Select(p => new ParticipantResponse
+            {
+                AvatarAddress = p.AvatarAddress,
+                NameWithHash = p.NameWithHash,
+                PortraitId = p.PortraitId,
+            })
+            .ToList();
+    }
 }
diff --git a/ArenaService/Models/AvailableOpponent.cs b/ArenaService/Models/AvailableOpponent.cs
@@ -10,14 +10,14 @@ public class AvailableOpponent
 
     [Required]
     public int ParticipantId { get; set; }
-    public required Participant Participant { get; set; }
+    public Participant Participant { get; set; } = null!;
 
     [Required]
     public int OpponentId { get; set; }
-    public required Participant Opponent { get; set; }
+    public Participant Opponent { get; set; } = null!;
 
     [Required]
     public long RefillBlockIndex { get; set; }
 
-    public bool IsBattled { get; set; }
+    public bool IsBattled { get; set; } = false;
 }
diff --git a/ArenaService/SeasonRepositories/AvailableOpponentRepository.cs b/ArenaService/SeasonRepositories/AvailableOpponentRepository.cs
@@ -0,0 +1,27 @@
+namespace ArenaService.Repositories;
+
+using ArenaService.Data;
+using ArenaService.Models;
+using Microsoft.EntityFrameworkCore;
+
+public interface IAvailableOpponentRepository
+{
+    Task<List<AvailableOpponent>> GetAvailableOpponents(int participantId);
+}
+
+public class AvailableOpponentRepository : IAvailableOpponentRepository
+{
+    private readonly ArenaDbContext _context;
+
+    public AvailableOpponentRepository(ArenaDbContext context)
+    {
+        _context = context;
+    }
+
+    public async Task<List<AvailableOpponent>> GetAvailableOpponents(int participantId)
+    {
+        return await _context
+            .AvailableOpponents.Where(ao => ao.ParticipantId == participantId)
+            .ToListAsync();
+    }
+}
diff --git a/ArenaService/SeasonRepositories/ParticipantRepository.cs b/ArenaService/SeasonRepositories/ParticipantRepository.cs
@@ -2,15 +2,17 @@ namespace ArenaService.Repositories;
 
 using ArenaService.Data;
 using ArenaService.Models;
+using Microsoft.EntityFrameworkCore;
 
 public interface IParticipantRepository
 {
-    Task<Participant> InsertParticipantToSpecificSeason(
+    Task<Participant> InsertParticipantToSpecificSeasonAsync(
         int seasonId,
         string avatarAddress,
         string nameWithHash,
         int portraitId
     );
+    Task<Participant?> GetParticipantByAvatarAddressAsync(int seasonId, string avatarAddress);
 }
 
 public class ParticipantRepository : IParticipantRepository
@@ -22,7 +24,7 @@ public ParticipantRepository(ArenaDbContext context)
         _context = context;
     }
 
-    public async Task<Participant> InsertParticipantToSpecificSeason(
+    public async Task<Participant> InsertParticipantToSpecificSeasonAsync(
         int seasonId,
         string avatarAddress,
         string nameWithHash,
@@ -41,4 +43,14 @@ int portraitId
         _context.SaveChanges();
         return participant.Entity;
     }
+
+    public async Task<Participant?> GetParticipantByAvatarAddressAsync(
+        int seasonId,
+        string avatarAddress
+    )
+    {
+        return await _context.Participants.FirstOrDefaultAsync(p =>
+            p.SeasonId == seasonId && p.AvatarAddress == avatarAddress
+        );
+    }
 }
diff --git a/ArenaService/Services/AvailableOpponentService.cs b/ArenaService/Services/AvailableOpponentService.cs
@@ -0,0 +1,25 @@
+namespace ArenaService.Services;
+
+using ArenaService.Dtos;
+using ArenaService.Extensions;
+using ArenaService.Models;
+using ArenaService.Repositories;
+
+public class AvailableOpponentService
+{
+    private readonly IAvailableOpponentRepository _availableOpponentRepository;
+
+    public AvailableOpponentService(IAvailableOpponentRepository availableOpponentRepository)
+    {
+        _availableOpponentRepository = availableOpponentRepository;
+    }
+
+    public async Task<List<Participant>> GetAvailableOpponents(int participantId)
+    {
+        var availableOpponents = await _availableOpponentRepository.GetAvailableOpponents(
+            participantId
+        );
+        var opponents = availableOpponents.Select(ao => ao.Opponent).ToList();
+        return opponents;
+    }
+}
diff --git a/ArenaService/Services/ParticipaintService.cs b/ArenaService/Services/ParticipaintService.cs
@@ -2,6 +2,7 @@ namespace ArenaService.Services;
 
 using ArenaService.Dtos;
 using ArenaService.Extensions;
+using ArenaService.Models;
 using ArenaService.Repositories;
 
 public class ParticipantService
@@ -18,12 +19,24 @@ public async Task<ParticipantResponse> AddParticipantAsync(
         JoinRequest joinRequest
     )
     {
-        var participant = await _participantRepository.InsertParticipantToSpecificSeason(
+        var participant = await _participantRepository.InsertParticipantToSpecificSeasonAsync(
             seasonId,
             joinRequest.AvatarAddress,
             joinRequest.NameWithHash,
             joinRequest.PortraitId
         );
         return participant.ToResponse();
     }
+
+    public async Task<Participant?> GetParticipantByAvatarAddressAsync(
+        int seasonId,
+        string avatarAddress
+    )
+    {
+        var participant = await _participantRepository.GetParticipantByAvatarAddressAsync(
+            seasonId,
+            avatarAddress
+        );
+        return participant;
+    }
 }