< Summary

Information
Class: Chronicis.Api.Controllers.ResourceProvidersController
Assembly: Chronicis.Api
File(s): /home/runner/work/chronicis/chronicis/src/Chronicis.Api/Controllers/ResourceProvidersController.cs
Line coverage
0%
Covered lines: 0
Uncovered lines: 40
Coverable lines: 40
Total lines: 112
Line coverage: 0%
Branch coverage
0%
Covered branches: 0
Total branches: 2
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%
GetWorldProviders()100%210%
ToggleProvider()0%620%

File(s)

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

#LineLine coverage
 1using Chronicis.Api.Infrastructure;
 2using Chronicis.Api.Services;
 3using Chronicis.Shared.DTOs;
 4using Chronicis.Shared.Extensions;
 5using Microsoft.AspNetCore.Authorization;
 6using Microsoft.AspNetCore.Mvc;
 7
 8namespace Chronicis.Api.Controllers;
 9
 10/// <summary>
 11/// Controller for managing resource providers and their world associations.
 12/// </summary>
 13[ApiController]
 14[Route("api/worlds/{worldId}/resource-providers")]
 15[Authorize]
 16public class ResourceProvidersController : ControllerBase
 17{
 18    private readonly IResourceProviderService _service;
 19    private readonly ICurrentUserService _currentUserService;
 20    private readonly ILogger<ResourceProvidersController> _logger;
 21
 022    public ResourceProvidersController(
 023        IResourceProviderService service,
 024        ICurrentUserService currentUserService,
 025        ILogger<ResourceProvidersController> logger)
 26    {
 027        _service = service;
 028        _currentUserService = currentUserService;
 029        _logger = logger;
 030    }
 31
 32    /// <summary>
 33    /// Gets all resource providers with their enabled status for a world.
 34    /// </summary>
 35    /// <param name="worldId">The world ID</param>
 36    /// <returns>List of providers with enabled status</returns>
 37    [HttpGet]
 38    [ProducesResponseType(typeof(List<WorldResourceProviderDto>), StatusCodes.Status200OK)]
 39    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
 40    [ProducesResponseType(StatusCodes.Status403Forbidden)]
 41    [ProducesResponseType(StatusCodes.Status404NotFound)]
 42    public async Task<IActionResult> GetWorldProviders(Guid worldId)
 43    {
 44        try
 45        {
 046            var user = await _currentUserService.GetRequiredUserAsync();
 047            var providers = await _service.GetWorldProvidersAsync(worldId, user.Id);
 48
 049            var dtos = providers.Select(p => new WorldResourceProviderDto
 050            {
 051                Provider = new ResourceProviderDto
 052                {
 053                    Code = p.Provider.Code,
 054                    Name = p.Provider.Name,
 055                    Description = p.Provider.Description,
 056                    DocumentationLink = p.Provider.DocumentationLink,
 057                    License = p.Provider.License
 058                },
 059                IsEnabled = p.IsEnabled
 060            }).ToList();
 61
 062            return Ok(dtos);
 63        }
 064        catch (KeyNotFoundException ex)
 65        {
 066            _logger.LogWarning(ex, "World {WorldId} not found", worldId);
 067            return NotFound(new { message = ex.Message });
 68        }
 069        catch (UnauthorizedAccessException ex)
 70        {
 071            _logger.LogWarning(ex, "Unauthorized access to world {WorldId}", worldId);
 072            return Forbid();
 73        }
 074    }
 75
 76    /// <summary>
 77    /// Enables or disables a resource provider for a world.
 78    /// Only the world owner can modify provider settings.
 79    /// </summary>
 80    /// <param name="worldId">The world ID</param>
 81    /// <param name="providerCode">The provider code</param>
 82    /// <param name="request">Toggle request</param>
 83    /// <returns>Success result</returns>
 84    [HttpPost("{providerCode}/toggle")]
 85    [ProducesResponseType(StatusCodes.Status200OK)]
 86    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
 87    [ProducesResponseType(StatusCodes.Status403Forbidden)]
 88    [ProducesResponseType(StatusCodes.Status404NotFound)]
 89    public async Task<IActionResult> ToggleProvider(
 90        Guid worldId,
 91        string providerCode,
 92        [FromBody] ToggleResourceProviderRequestDto request)
 93    {
 94        try
 95        {
 096            var user = await _currentUserService.GetRequiredUserAsync();
 097            await _service.SetProviderEnabledAsync(worldId, providerCode, request.Enabled, user.Id);
 98
 099            return Ok(new { message = $"Provider {providerCode} {(request.Enabled ? "enabled" : "disabled")} successfull
 100        }
 0101        catch (KeyNotFoundException ex)
 102        {
 0103            _logger.LogErrorSanitized(ex, "World {WorldId} or provider {ProviderCode} not found", worldId, providerCode)
 0104            return NotFound(new { message = ex.Message });
 105        }
 0106        catch (UnauthorizedAccessException ex)
 107        {
 0108            _logger.LogWarning(ex, "Unauthorized attempt to modify world {WorldId}", worldId);
 0109            return Forbid();
 110        }
 0111    }
 112}
Generated by: ReportGenerator 5.5.1.0
02/17/2026 - 23:26:51
GitHub | reportgenerator.io

Methods/Properties

.ctor(Chronicis.Api.Services.IResourceProviderService,Chronicis.Api.Infrastructure.ICurrentUserService,Microsoft.Extensions.Logging.ILogger`1<Chronicis.Api.Controllers.ResourceProvidersController>)
GetWorldProviders()
ToggleProvider()