< 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
0%
Covered lines: 0
Uncovered lines: 50
Coverable lines: 50
Total lines: 109
Line coverage: 0%
Branch coverage
0%
Covered branches: 0
Total branches: 18
Branch coverage: 0%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%210%
GetQuestUpdates()0%4260%
CreateQuestUpdate()0%7280%
DeleteQuestUpdate()0%2040%

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
 021    public QuestUpdatesController(
 022        IQuestUpdateService questUpdateService,
 023        ICurrentUserService currentUserService,
 024        ILogger<QuestUpdatesController> logger)
 25    {
 026        _questUpdateService = questUpdateService;
 027        _currentUserService = currentUserService;
 028        _logger = logger;
 029    }
 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    {
 040        var user = await _currentUserService.GetRequiredUserAsync();
 041        _logger.LogDebug("Getting quest updates for quest {QuestId} (skip: {Skip}, take: {Take}) for user {UserId}",
 042            questId, skip, take, user.Id);
 43
 044        var result = await _questUpdateService.GetQuestUpdatesAsync(questId, user.Id, skip, take);
 45
 046        return result.Status switch
 047        {
 048            ServiceStatus.Success => Ok(result.Value),
 049            ServiceStatus.NotFound => NotFound(new { error = result.ErrorMessage }),
 050            ServiceStatus.Forbidden => StatusCode(403, new { error = result.ErrorMessage }),
 051            ServiceStatus.ValidationError => BadRequest(new { error = result.ErrorMessage }),
 052            _ => StatusCode(500, new { error = "An unexpected error occurred" })
 053        };
 054    }
 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    {
 064        var user = await _currentUserService.GetRequiredUserAsync();
 65
 066        if (dto == null)
 67        {
 068            return BadRequest(new { error = "Request body is required" });
 69        }
 70
 071        _logger.LogDebug("Creating quest update for quest {QuestId} by user {UserId}", questId, user.Id);
 72
 073        var result = await _questUpdateService.CreateQuestUpdateAsync(questId, dto, user.Id);
 74
 075        return result.Status switch
 076        {
 077            ServiceStatus.Success => CreatedAtAction(
 078                nameof(GetQuestUpdates),
 079                new { questId = questId, skip = 0, take = 20 },
 080                result.Value),
 081            ServiceStatus.NotFound => NotFound(new { error = result.ErrorMessage }),
 082            ServiceStatus.Forbidden => StatusCode(403, new { error = result.ErrorMessage }),
 083            ServiceStatus.ValidationError => BadRequest(new { error = result.ErrorMessage }),
 084            _ => StatusCode(500, new { error = "An unexpected error occurred" })
 085        };
 086    }
 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    {
 095        var user = await _currentUserService.GetRequiredUserAsync();
 096        _logger.LogDebug("Deleting quest update {UpdateId} from quest {QuestId} for user {UserId}",
 097            updateId, questId, user.Id);
 98
 099        var result = await _questUpdateService.DeleteQuestUpdateAsync(questId, updateId, user.Id);
 100
 0101        return result.Status switch
 0102        {
 0103            ServiceStatus.Success => NoContent(),
 0104            ServiceStatus.NotFound => NotFound(new { error = result.ErrorMessage }),
 0105            ServiceStatus.Forbidden => StatusCode(403, new { error = result.ErrorMessage }),
 0106            _ => StatusCode(500, new { error = "An unexpected error occurred" })
 0107        };
 0108    }
 109}
Generated by: ReportGenerator 5.5.1.0
02/17/2026 - 23:26:51
GitHub | reportgenerator.io

Methods/Properties

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