Admin notes/tournament endpoints

API/Configurations/MapperProfile.cs

@@ -11,6 +11,10 @@ public class MapperProfile : Profile
 {
  public MapperProfile()
  {
+ CreateMap<AdminNoteEntityBase, AdminNoteDTO>()
+ .ForMember(x => x.AdminUsername,
+ opt => opt.MapFrom(x => x.AdminUser.Player == null ? null : x.AdminUser.Player.Username));
+
  CreateMap<Beatmap, BeatmapDTO>();
  CreateMap<Game, GameDTO>();
  CreateMap<GameWinRecord, GameWinRecordDTO>();

API/Controllers/TournamentsController.Admin.cs

@@ -0,0 +1,162 @@
+using API.DTOs;
+using API.Utilities;
+using API.Utilities.Extensions;
+using Database.Entities;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace API.Controllers;
+
+public partial class TournamentsController
+{
+ /// <summary>
+ /// Creates an admin note for a tournament
+ /// </summary>
+ /// <param name="id">Tournament id</param>
+ /// <response code="401">If the requester is not properly authorized</response>
+ /// <response code="404">If a tournament matching the given id does not exist</response>
+ /// <response code="400">If the authorized user does not exist</response>
+ /// <response code="200">Returns the created admin note</response>
+ [HttpPost("{id:int}/notes")]
+ [Authorize(Roles = $"{OtrClaims.Admin}")]
+ [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+ [ProducesResponseType(StatusCodes.Status404NotFound)]
+ [ProducesResponseType(StatusCodes.Status400BadRequest)]
+ [ProducesResponseType<AdminNoteDTO>(StatusCodes.Status200OK)]
+ public async Task<IActionResult> CreateAdminNoteAsync(int id, [FromBody] string note)
+ {
+ var adminUserId = User.AuthorizedIdentity();
+ if (!adminUserId.HasValue)
+ {
+ return Unauthorized();
+ }
+
+ if (!await tournamentsService.ExistsAsync(id))
+ {
+ return NotFound();
+ }
+
+ AdminNoteDTO? result = await adminNoteService.CreateAsync<TournamentAdminNote>(id, adminUserId.Value, note);
+ return result is not null
+ ? Ok(result)
+ : BadRequest();
+ }
+
+ /// <summary>
+ /// List all admin notes from a tournament
+ /// </summary>
+ /// <param name="id">Tournament id</param>
+ /// <response code="404">If a tournament matching the given id does not exist</response>
+ /// <response code="200">Returns all admin notes from a tournament</response>
+ [HttpGet("{id:int}/notes")]
+ [Authorize(Roles = $"{OtrClaims.Admin}")]
+ [ProducesResponseType(StatusCodes.Status404NotFound)]
+ [ProducesResponseType<IEnumerable<AdminNoteDTO>>(StatusCodes.Status200OK)]
+ public async Task<IActionResult> ListAdminNotesAsync(int id)
+ {
+ if (!await tournamentsService.ExistsAsync(id))
+ {
+ return NotFound();
+ }
+
+ return Ok(await adminNoteService.GetAsync<TournamentAdminNote>(id));
+ }
+
+ /// <summary>
+ /// Updates an admin note for a tournament
+ /// </summary>
+ /// <param name="id">Tournament id</param>
+ /// <param name="noteId">Admin note id</param>
+ /// <response code="401">If the requester is not properly authorized</response>
+ /// <response code="404">
+ /// If a tournament matching the given id does not exist.
+ /// If an admin note matching the given noteId does not exist
+ /// </response>
+ /// <response code="403">If the requester did not create the admin note</response>
+ /// <response code="200">Returns the updated admin note</response>
+ [HttpPatch("{id:int}/notes/{noteId:int}")]
+ [Authorize(Roles = $"{OtrClaims.Admin}")]
+ [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+ [ProducesResponseType(StatusCodes.Status404NotFound)]
+ [ProducesResponseType(StatusCodes.Status403Forbidden)]
+ [ProducesResponseType<AdminNoteDTO>(StatusCodes.Status200OK)]
+ public async Task<IActionResult> UpdateAdminNoteAsync(int id, int noteId, [FromBody] string note)
+ {
+ var adminUserId = User.AuthorizedIdentity();
+ if (!adminUserId.HasValue)
+ {
+ return Unauthorized();
+ }
+
+ if (!await tournamentsService.ExistsAsync(id))
+ {
+ return NotFound();
+ }
+
+ AdminNoteDTO? existingNote = await adminNoteService.GetAsync<TournamentAdminNote>(noteId);
+ if (existingNote is null)
+ {
+ return NotFound();
+ }
+
+ if (adminUserId != existingNote.AdminUserId)
+ {
+ return Forbid();
+ }
+
+ existingNote.Note = note;
+ AdminNoteDTO? result = await adminNoteService.UpdateAsync<TournamentAdminNote>(existingNote);
+
+ return result is not null
+ ? Ok(result)
+ : NotFound();
+ }
+
+ /// <summary>
+ /// Deletes an admin note for a tournament
+ /// </summary>
+ /// <param name="id">Tournament id</param>
+ /// <param name="noteId">Admin note id</param>
+ /// <response code="401">If the requester is not properly authorized</response>
+ /// <response code="404">
+ /// If a tournament matching the given id does not exist.
+ /// If an admin note matching the given noteId does not exist
+ /// </response>
+ /// <response code="403">If the requester did not create the admin note</response>
+ /// <response code="200">Returns the updated admin note</response>
+ [HttpDelete("{id:int}/notes/{noteId:int}")]
+ [Authorize(Roles = $"{OtrClaims.Admin}")]
+ [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+ [ProducesResponseType(StatusCodes.Status404NotFound)]
+ [ProducesResponseType(StatusCodes.Status403Forbidden)]
+ [ProducesResponseType<AdminNoteDTO>(StatusCodes.Status200OK)]
+ public async Task<IActionResult> DeleteAdminNoteAsync(int id, int noteId)
+ {
+ var adminUserId = User.AuthorizedIdentity();
+ if (!adminUserId.HasValue)
+ {
+ return Unauthorized();
+ }
+
+ if (!await tournamentsService.ExistsAsync(id))
+ {
+ return NotFound();
+ }
+
+ AdminNoteDTO? existingNote = await adminNoteService.GetAsync<TournamentAdminNote>(noteId);
+ if (existingNote is null)
+ {
+ return NotFound();
+ }
+
+ if (adminUserId != existingNote.AdminUserId)
+ {
+ return Forbid();
+ }
+
+ var result = await adminNoteService.DeleteAsync<TournamentAdminNote>(noteId);
+ return result
+ ? Ok()
+ : NotFound();
+ }
+}

API/Controllers/TournamentsController.cs

@@ -12,7 +12,10 @@ namespace API.Controllers;
 [ApiController]
 [ApiVersion(1)]
 [Route("api/v{version:apiVersion}/[controller]")]
-public class TournamentsController(ITournamentsService tournamentsService) : Controller
+public partial class TournamentsController(
+ ITournamentsService tournamentsService,
+ IAdminNoteService adminNoteService
+) : Controller
 {
  /// <summary>
  /// List all tournaments

API/DTOs/AdminNoteDTO.cs

@@ -0,0 +1,42 @@
+namespace API.DTOs;
+
+/// <summary>
+/// Represents a note for an entity created by an admin
+/// </summary>
+public class AdminNoteDTO
+{
+ /// <summary>
+ /// Id
+ /// </summary>
+ public int Id { get; init; }
+
+ /// <summary>
+ /// Timestamp of creation
+ /// </summary>
+ public DateTime Created { get; init; }
+
+ /// <summary>
+ /// Timestamp of the last update if available
+ /// </summary>
+ public DateTime? Updated { get; init; }
+
+ /// <summary>
+ /// Id of the parent entity
+ /// </summary>
+ public int ReferenceId { get; init; }
+
+ /// <summary>
+ /// Id of the admin user that created the note
+ /// </summary>
+ public int AdminUserId { get; set; }
+
+ /// <summary>
+ /// Username of the admin user that created the note
+ /// </summary>
+ public string? AdminUsername { get; init; }
+
+ /// <summary>
+ /// Content of the note
+ /// </summary>
+ public string Note { get; set; } = string.Empty;
+}

API/Program.cs

@@ -427,6 +427,7 @@ await context.HttpContext.Response.WriteAsync(
 builder.Services.AddScoped<IApiPlayerMatchStatsRepository, ApiPlayerMatchStatsRepository>();
 builder.Services.AddScoped<IApiTournamentsRepository, ApiTournamentsRepository>();
 
+builder.Services.AddScoped<IAdminNoteRepository, AdminNoteRepository>();
 builder.Services.AddScoped<IBaseStatsRepository, BaseStatsRepository>();
 builder.Services.AddScoped<IBeatmapsRepository, BeatmapsRepository>();
 builder.Services.AddScoped<IGamesRepository, GamesRepository>();
@@ -446,6 +447,7 @@ await context.HttpContext.Response.WriteAsync(
 
 #region Services
 
+builder.Services.AddScoped<IAdminNoteService, AdminNoteService>();
 builder.Services.AddScoped<IBaseStatsService, BaseStatsService>();
 builder.Services.AddScoped<IBeatmapService, BeatmapService>();
 builder.Services.AddScoped<IGamesService, GamesService>();

API/Services/Implementations/AdminNoteService.cs

@@ -0,0 +1,67 @@
+using API.DTOs;
+using API.Services.Interfaces;
+using AutoMapper;
+using Database.Entities;
+using Database.Repositories.Interfaces;
+
+namespace API.Services.Implementations;
+
+public class AdminNoteService(
+ IAdminNoteRepository adminNoteRepository,
+ IUserRepository userRepository,
+ IMapper mapper
+) : IAdminNoteService
+{
+ public async Task<AdminNoteDTO?> CreateAsync<TAdminNote>(int referenceId, int adminUserId, string note)
+ where TAdminNote : AdminNoteEntityBase, new()
+ {
+ if (!await userRepository.ExistsAsync(adminUserId))
+ {
+ return null;
+ }
+
+ var entity = new TAdminNote
+ {
+ ReferenceId = referenceId,
+ AdminUserId = adminUserId,
+ Note = note
+ };
+
+ await adminNoteRepository.CreateAsync(entity);
+ return mapper.Map<AdminNoteDTO>(entity);
+ }
+
+ public async Task<AdminNoteDTO?> GetAsync<TAdminNote>(int id) where TAdminNote : AdminNoteEntityBase =>
+ mapper.Map<AdminNoteDTO>(await adminNoteRepository.GetAsync<TAdminNote>(id));
+
+ public async Task<IEnumerable<AdminNoteDTO>> ListAsync<TAdminNote>(int referenceId) where TAdminNote : AdminNoteEntityBase =>
+ mapper.Map<IEnumerable<AdminNoteDTO>>(await adminNoteRepository.ListAsync<TAdminNote>(referenceId));
+
+ public async Task<AdminNoteDTO?> UpdateAsync<TAdminNote>(AdminNoteDTO updatedNote) where TAdminNote : AdminNoteEntityBase
+ {
+ TAdminNote? adminNote = await adminNoteRepository.GetAsync<TAdminNote>(updatedNote.Id);
+
+ if (adminNote is null)
+ {
+ return null;
+ }
+
+ adminNote.Note = updatedNote.Note;
+ await adminNoteRepository.UpdateAsync(adminNote);
+
+ return mapper.Map<AdminNoteDTO>(adminNote);
+ }
+
+ public async Task<bool> DeleteAsync<TAdminNote>(int id) where TAdminNote : AdminNoteEntityBase
+ {
+ TAdminNote? adminNote = await adminNoteRepository.GetAsync<TAdminNote>(id);
+
+ if (adminNote is null)
+ {
+ return false;
+ }
+
+ await adminNoteRepository.DeleteAsync(adminNote);
+ return true;
+ }
+}

API/Services/Implementations/TournamentsService.cs

@@ -43,6 +43,9 @@ bool preApprove
  return mapper.Map<TournamentCreatedResultDTO>(tournament);
  }
 
+ public async Task<bool> ExistsAsync(int id) =>
+ await tournamentsRepository.ExistsAsync(id);
+
  public async Task<bool> ExistsAsync(string name, Ruleset ruleset)
  => await tournamentsRepository.ExistsAsync(name, ruleset);
 

API/Services/Interfaces/IAdminNoteService.cs

@@ -0,0 +1,59 @@
+using API.DTOs;
+using Database.Entities;
+
+namespace API.Services.Interfaces;
+
+public interface IAdminNoteService
+{
+ /// <summary>
+ /// Creates a <typeparamref name="TAdminNote"/>
+ /// </summary>
+ /// <param name="referenceId">Id of the parent entity</param>
+ /// <param name="adminUserId">Id of the admin <see cref="User"/> creating the <typeparamref name="TAdminNote"/></param>
+ /// <param name="note">Content of the <typeparamref name="TAdminNote"/></param>
+ /// <typeparam name="TAdminNote">The type of admin note being created</typeparam>
+ /// <returns>
+ /// The created <see cref="AdminNoteDTO"/> if successful, or null if a <see cref="User"/> for the
+ /// given <paramref name="adminUserId"/> does not exist
+ /// </returns>
+ /// <remarks>
+ /// This method checks for existence of the admin <see cref="User"/>, but checking for existence of the parent
+ /// entity should be handled by the caller
+ /// </remarks>
+ Task<AdminNoteDTO?> CreateAsync<TAdminNote>(int referenceId, int adminUserId, string note)
+ where TAdminNote : AdminNoteEntityBase, new();
+
+ /// <summary>
+ /// Gets an <see cref="AdminNoteDTO"/>
+ /// </summary>
+ /// <param name="id">Id of the <typeparamref name="TAdminNote"/></param>
+ /// <typeparam name="TAdminNote">The type of admin note being retrieved</typeparam>
+ /// <returns>The <see cref="AdminNoteDTO"/>, or null if not found</returns>
+ Task<AdminNoteDTO?> GetAsync<TAdminNote>(int id) where TAdminNote : AdminNoteEntityBase;
+
+ /// <summary>
+ /// Gets a collection of <see cref="AdminNoteDTO"/>s by their parent reference Id.
+ /// </summary>
+ /// <param name="referenceId">Id of the parent entity</param>
+ /// <typeparam name="TAdminNote">The type of admin note being retrieved</typeparam>
+ /// <returns>A collection of <see cref="AdminNoteDTO"/>s for the given referenceId</returns>
+ Task<IEnumerable<AdminNoteDTO>> ListAsync<TAdminNote>(int referenceId) where TAdminNote : AdminNoteEntityBase;
+
+ /// <summary>
+ /// Updates the <see cref="AdminNoteEntityBase.Note"/> of a <typeparamref name="TAdminNote"/>
+ /// </summary>
+ /// <param name="updatedNote">The updated admin note</param>
+ /// <typeparam name="TAdminNote">The type of admin note being updated</typeparam>
+ /// <returns>The updated <see cref="AdminNoteDTO"/>, or null if not found</returns>
+ Task<AdminNoteDTO?> UpdateAsync<TAdminNote>(AdminNoteDTO updatedNote) where TAdminNote : AdminNoteEntityBase;
+
+ /// <summary>
+ /// Deletes a <typeparamref name="TAdminNote"/>
+ /// </summary>
+ /// <param name="id">Id of the <typeparamref name="TAdminNote"/></param>
+ /// <typeparam name="TAdminNote">The type of admin note being deleted</typeparam>
+ /// <returns>
+ /// True if successful, false if a <see cref="AdminNoteDTO"/> for the given id does not exist
+ /// </returns>
+ Task<bool> DeleteAsync<TAdminNote>(int id) where TAdminNote : AdminNoteEntityBase;
+}

API/Services/Interfaces/ITournamentsService.cs

@@ -18,6 +18,12 @@ Task<TournamentCreatedResultDTO> CreateAsync(
  bool preApprove
  );
 
+ /// <summary>
+ /// Denotes a tournament exists for the given id
+ /// </summary>
+ /// <param name="id">Tournament id</param>
+ Task<bool> ExistsAsync(int id);
+
  /// <summary>
  /// Denotes a tournament with matching name and ruleset exists
  /// </summary>