< Summary

Information
Class: Chronicis.Api.Controllers.QuestUpdatesController
Assembly: Chronicis.Api
File(s): /home/runner/work/chronicis/chronicis/src/Chronicis.Api/Controllers/QuestUpdatesController.cs
Line coverage
100%
Covered lines: 8
Uncovered lines: 0
Coverable lines: 8
Total lines: 109
Line coverage: 100%
Branch coverage
N/A
Covered branches: 0
Total branches: 0
Branch coverage: N/A
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%

File(s)

/home/runner/work/chronicis/chronicis/src/Chronicis.Api/Controllers/QuestUpdatesController.cs

#LineLine coverage
 1using Chronicis.Api.Infrastructure;
 2using Chronicis.Api.Models;
 3using Chronicis.Api.Services;
 4using Chronicis.Shared.DTOs.Quests;
 5using Microsoft.AspNetCore.Authorization;
 6using Microsoft.AspNetCore.Mvc;
 7
 8namespace Chronicis.Api.Controllers;
 9
 10/// <summary>
 11/// API endpoints for QuestUpdate management.
 12/// </summary>
 13[ApiController]
 14[Authorize]
 15public class QuestUpdatesController : ControllerBase
 16{
 17    private readonly IQuestUpdateService _questUpdateService;
 18    private readonly ICurrentUserService _currentUserService;
 19    private readonly ILogger<QuestUpdatesController> _logger;
 20
 121    public QuestUpdatesController(
 122        IQuestUpdateService questUpdateService,
 123        ICurrentUserService currentUserService,
 124        ILogger<QuestUpdatesController> logger)
 25    {
 126        _questUpdateService = questUpdateService;
 127        _currentUserService = currentUserService;
 128        _logger = logger;
 129    }
 30
 31    /// <summary>
 32    /// GET /quests/{questId}/updates - Get paginated quest updates.
 33    /// </summary>
 34    [HttpGet("quests/{questId:guid}/updates")]
 35    public async Task<ActionResult<PagedResult<QuestUpdateEntryDto>>> GetQuestUpdates(
 36        Guid questId,
 37        [FromQuery] int skip = 0,
 38        [FromQuery] int take = 20)
 39    {
 40        var user = await _currentUserService.GetRequiredUserAsync();
 41        _logger.LogTraceSanitized("Getting quest updates for quest {QuestId} (skip: {Skip}, take: {Take}) for user {User
 42            questId, skip, take, user.Id);
 43
 44        var result = await _questUpdateService.GetQuestUpdatesAsync(questId, user.Id, skip, take);
 45
 46        return result.Status switch
 47        {
 48            ServiceStatus.Success => Ok(result.Value),
 49            ServiceStatus.NotFound => NotFound(new { error = result.ErrorMessage }),
 50            ServiceStatus.Forbidden => StatusCode(403, new { error = result.ErrorMessage }),
 51            ServiceStatus.ValidationError => BadRequest(new { error = result.ErrorMessage }),
 52            _ => StatusCode(500, new { error = "An unexpected error occurred" })
 53        };
 54    }
 55
 56    /// <summary>
 57    /// POST /quests/{questId}/updates - Create a new quest update (GM or Player).
 58    /// </summary>
 59    [HttpPost("quests/{questId:guid}/updates")]
 60    public async Task<ActionResult<QuestUpdateEntryDto>> CreateQuestUpdate(
 61        Guid questId,
 62        [FromBody] QuestUpdateCreateDto dto)
 63    {
 64        var user = await _currentUserService.GetRequiredUserAsync();
 65
 66        if (dto == null)
 67        {
 68            return BadRequest(new { error = "Request body is required" });
 69        }
 70
 71        _logger.LogTraceSanitized("Creating quest update for quest {QuestId} by user {UserId}", questId, user.Id);
 72
 73        var result = await _questUpdateService.CreateQuestUpdateAsync(questId, dto, user.Id);
 74
 75        return result.Status switch
 76        {
 77            ServiceStatus.Success => CreatedAtAction(
 78                nameof(GetQuestUpdates),
 79                new { questId = questId, skip = 0, take = 20 },
 80                result.Value),
 81            ServiceStatus.NotFound => NotFound(new { error = result.ErrorMessage }),
 82            ServiceStatus.Forbidden => StatusCode(403, new { error = result.ErrorMessage }),
 83            ServiceStatus.ValidationError => BadRequest(new { error = result.ErrorMessage }),
 84            _ => StatusCode(500, new { error = "An unexpected error occurred" })
 85        };
 86    }
 87
 88    /// <summary>
 89    /// DELETE /quests/{questId}/updates/{updateId} - Delete a quest update.
 90    /// GM can delete any, Player can delete own only.
 91    /// </summary>
 92    [HttpDelete("quests/{questId:guid}/updates/{updateId:guid}")]
 93    public async Task<IActionResult> DeleteQuestUpdate(Guid questId, Guid updateId)
 94    {
 95        var user = await _currentUserService.GetRequiredUserAsync();
 96        _logger.LogTraceSanitized("Deleting quest update {UpdateId} from quest {QuestId} for user {UserId}",
 97            updateId, questId, user.Id);
 98
 99        var result = await _questUpdateService.DeleteQuestUpdateAsync(questId, updateId, user.Id);
 100
 101        return result.Status switch
 102        {
 103            ServiceStatus.Success => NoContent(),
 104            ServiceStatus.NotFound => NotFound(new { error = result.ErrorMessage }),
 105            ServiceStatus.Forbidden => StatusCode(403, new { error = result.ErrorMessage }),
 106            _ => StatusCode(500, new { error = "An unexpected error occurred" })
 107        };
 108    }
 109}
Generated by: ReportGenerator 5.5.4.0
03/14/2026 - 20:01:37
GitHub | reportgenerator.io

Methods/Properties

.ctor(Chronicis.Api.Services.IQuestUpdateService,Chronicis.Api.Infrastructure.ICurrentUserService,Microsoft.Extensions.Logging.ILogger`1<Chronicis.Api.Controllers.QuestUpdatesController>)