< Summary

Information
Class: Chronicis.Client.Services.WorldApiService
Assembly: Chronicis.Client
File(s): /home/runner/work/chronicis/chronicis/src/Chronicis.Client/Services/WorldApiService.cs
Line coverage
100%
Covered lines: 3
Uncovered lines: 0
Coverable lines: 3
Total lines: 233
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.Client/Services/WorldApiService.cs

#LineLine coverage
 1using Chronicis.Shared.DTOs;
 2
 3namespace Chronicis.Client.Services;
 4
 5/// <summary>
 6/// Service for World API operations.
 7/// Uses HttpClientExtensions for consistent error handling and logging.
 8/// </summary>
 9public class WorldApiService : IWorldApiService
 10{
 11    private readonly HttpClient _http;
 12    private readonly ILogger<WorldApiService> _logger;
 13
 14    public WorldApiService(HttpClient http, ILogger<WorldApiService> logger)
 15    {
 316        _http = http;
 317        _logger = logger;
 318    }
 19
 20    public async Task<List<WorldDto>> GetWorldsAsync()
 21    {
 22        return await _http.GetListAsync<WorldDto>(
 23            "worlds",
 24            _logger,
 25            "worlds");
 26    }
 27
 28    public async Task<WorldDetailDto?> GetWorldAsync(Guid worldId)
 29    {
 30        return await _http.GetEntityAsync<WorldDetailDto>(
 31            $"worlds/{worldId}",
 32            _logger,
 33            $"world {worldId}");
 34    }
 35
 36    public async Task<WorldDto?> CreateWorldAsync(WorldCreateDto dto)
 37    {
 38        return await _http.PostEntityAsync<WorldDto>(
 39            "worlds",
 40            dto,
 41            _logger,
 42            "world");
 43    }
 44
 45    public async Task<WorldDto?> UpdateWorldAsync(Guid worldId, WorldUpdateDto dto)
 46    {
 47        return await _http.PutEntityAsync<WorldDto>(
 48            $"worlds/{worldId}",
 49            dto,
 50            _logger,
 51            $"world {worldId}");
 52    }
 53
 54    // ===== World Links =====
 55
 56    public async Task<List<WorldLinkDto>> GetWorldLinksAsync(Guid worldId)
 57    {
 58        return await _http.GetListAsync<WorldLinkDto>(
 59            $"worlds/{worldId}/links",
 60            _logger,
 61            $"links for world {worldId}");
 62    }
 63
 64    public async Task<WorldLinkDto?> CreateWorldLinkAsync(Guid worldId, WorldLinkCreateDto dto)
 65    {
 66        return await _http.PostEntityAsync<WorldLinkDto>(
 67            $"worlds/{worldId}/links",
 68            dto,
 69            _logger,
 70            $"link for world {worldId}");
 71    }
 72
 73    public async Task<WorldLinkDto?> UpdateWorldLinkAsync(Guid worldId, Guid linkId, WorldLinkUpdateDto dto)
 74    {
 75        return await _http.PutEntityAsync<WorldLinkDto>(
 76            $"worlds/{worldId}/links/{linkId}",
 77            dto,
 78            _logger,
 79            $"link {linkId} for world {worldId}");
 80    }
 81
 82    public async Task<bool> DeleteWorldLinkAsync(Guid worldId, Guid linkId)
 83    {
 84        return await _http.DeleteEntityAsync(
 85            $"worlds/{worldId}/links/{linkId}",
 86            _logger,
 87            $"link {linkId} from world {worldId}");
 88    }
 89
 90    // ===== Public Sharing =====
 91
 92    public async Task<PublicSlugCheckResultDto?> CheckPublicSlugAsync(Guid worldId, string slug)
 93    {
 94        var dto = new PublicSlugCheckDto { Slug = slug };
 95        return await _http.PostEntityAsync<PublicSlugCheckResultDto>(
 96            $"worlds/{worldId}/check-public-slug",
 97            dto,
 98            _logger,
 99            $"public slug check for world {worldId}");
 100    }
 101
 102    // ===== Member Management =====
 103
 104    public async Task<List<WorldMemberDto>> GetMembersAsync(Guid worldId)
 105    {
 106        return await _http.GetListAsync<WorldMemberDto>(
 107            $"worlds/{worldId}/members",
 108            _logger,
 109            $"members for world {worldId}");
 110    }
 111
 112    public async Task<WorldMemberDto?> UpdateMemberRoleAsync(Guid worldId, Guid memberId, WorldMemberUpdateDto dto)
 113    {
 114        return await _http.PutEntityAsync<WorldMemberDto>(
 115            $"worlds/{worldId}/members/{memberId}",
 116            dto,
 117            _logger,
 118            $"member {memberId} in world {worldId}");
 119    }
 120
 121    public async Task<bool> RemoveMemberAsync(Guid worldId, Guid memberId)
 122    {
 123        return await _http.DeleteEntityAsync(
 124            $"worlds/{worldId}/members/{memberId}",
 125            _logger,
 126            $"member {memberId} from world {worldId}");
 127    }
 128
 129    // ===== Invitation Management =====
 130
 131    public async Task<List<WorldInvitationDto>> GetInvitationsAsync(Guid worldId)
 132    {
 133        return await _http.GetListAsync<WorldInvitationDto>(
 134            $"worlds/{worldId}/invitations",
 135            _logger,
 136            $"invitations for world {worldId}");
 137    }
 138
 139    public async Task<WorldInvitationDto?> CreateInvitationAsync(Guid worldId, WorldInvitationCreateDto dto)
 140    {
 141        return await _http.PostEntityAsync<WorldInvitationDto>(
 142            $"worlds/{worldId}/invitations",
 143            dto,
 144            _logger,
 145            $"invitation for world {worldId}");
 146    }
 147
 148    public async Task<bool> RevokeInvitationAsync(Guid worldId, Guid invitationId)
 149    {
 150        return await _http.DeleteEntityAsync(
 151            $"worlds/{worldId}/invitations/{invitationId}",
 152            _logger,
 153            $"invitation {invitationId} from world {worldId}");
 154    }
 155
 156    public async Task<WorldJoinResultDto?> JoinWorldAsync(string code)
 157    {
 158        var dto = new WorldJoinDto { Code = code };
 159        return await _http.PostEntityAsync<WorldJoinResultDto>(
 160            "worlds/join",
 161            dto,
 162            _logger,
 163            "join world");
 164    }
 165
 166    // ===== World Documents =====
 167
 168    public async Task<WorldDocumentUploadResponseDto?> RequestDocumentUploadAsync(
 169        Guid worldId,
 170        WorldDocumentUploadRequestDto dto)
 171    {
 172        return await _http.PostEntityAsync<WorldDocumentUploadResponseDto>(
 173            $"worlds/{worldId}/documents/request-upload",
 174            dto,
 175            _logger,
 176            $"document upload request for world {worldId}");
 177    }
 178
 179    public async Task<WorldDocumentDto?> ConfirmDocumentUploadAsync(Guid worldId, Guid documentId)
 180    {
 181        var dto = new WorldDocumentConfirmUploadDto { DocumentId = documentId };
 182        return await _http.PostEntityAsync<WorldDocumentDto>(
 183            $"worlds/{worldId}/documents/{documentId}/confirm",
 184            dto,
 185            _logger,
 186            $"document upload confirmation for {documentId}");
 187    }
 188
 189    public async Task<List<WorldDocumentDto>> GetWorldDocumentsAsync(Guid worldId)
 190    {
 191        return await _http.GetListAsync<WorldDocumentDto>(
 192            $"worlds/{worldId}/documents",
 193            _logger,
 194            $"documents for world {worldId}");
 195    }
 196
 197    public async Task<DocumentDownloadResult?> DownloadDocumentAsync(Guid documentId)
 198    {
 199        var downloadInfo = await _http.GetEntityAsync<WorldDocumentDownloadDto>(
 200            $"/documents/{documentId}/content",
 201            _logger,
 202            $"download URL for document {documentId}");
 203
 204        if (downloadInfo == null)
 205            return null;
 206
 207        return new DocumentDownloadResult(
 208            downloadInfo.DownloadUrl,
 209            downloadInfo.FileName,
 210            downloadInfo.ContentType,
 211            downloadInfo.FileSizeBytes);
 212    }
 213
 214    public async Task<WorldDocumentDto?> UpdateDocumentAsync(
 215        Guid worldId,
 216        Guid documentId,
 217        WorldDocumentUpdateDto dto)
 218    {
 219        return await _http.PutEntityAsync<WorldDocumentDto>(
 220            $"worlds/{worldId}/documents/{documentId}",
 221            dto,
 222            _logger,
 223            $"document {documentId} for world {worldId}");
 224    }
 225
 226    public async Task<bool> DeleteDocumentAsync(Guid worldId, Guid documentId)
 227    {
 228        return await _http.DeleteEntityAsync(
 229            $"worlds/{worldId}/documents/{documentId}",
 230            _logger,
 231            $"document {documentId} from world {worldId}");
 232    }
 233}
Generated by: ReportGenerator 5.5.4.0
03/14/2026 - 20:01:37
GitHub | reportgenerator.io

Methods/Properties

.ctor(System.Net.Http.HttpClient,Microsoft.Extensions.Logging.ILogger`1<Chronicis.Client.Services.WorldApiService>)