< 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: 230
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    public async Task<SlugUpdateResponseDto?> UpdateSlugAsync(Guid worldId, string slug)
 55    {
 56        return await _http.PutEntityAsync<SlugUpdateResponseDto>(
 57            $"worlds/{worldId}/slug",
 58            new SlugUpdateRequestDto { Slug = slug },
 59            _logger,
 60            $"slug for world {worldId}");
 61    }
 62
 63    // ===== World Links =====
 64
 65    public async Task<List<WorldLinkDto>> GetWorldLinksAsync(Guid worldId)
 66    {
 67        return await _http.GetListAsync<WorldLinkDto>(
 68            $"worlds/{worldId}/links",
 69            _logger,
 70            $"links for world {worldId}");
 71    }
 72
 73    public async Task<WorldLinkDto?> CreateWorldLinkAsync(Guid worldId, WorldLinkCreateDto dto)
 74    {
 75        return await _http.PostEntityAsync<WorldLinkDto>(
 76            $"worlds/{worldId}/links",
 77            dto,
 78            _logger,
 79            $"link for world {worldId}");
 80    }
 81
 82    public async Task<WorldLinkDto?> UpdateWorldLinkAsync(Guid worldId, Guid linkId, WorldLinkUpdateDto dto)
 83    {
 84        return await _http.PutEntityAsync<WorldLinkDto>(
 85            $"worlds/{worldId}/links/{linkId}",
 86            dto,
 87            _logger,
 88            $"link {linkId} for world {worldId}");
 89    }
 90
 91    public async Task<bool> DeleteWorldLinkAsync(Guid worldId, Guid linkId)
 92    {
 93        return await _http.DeleteEntityAsync(
 94            $"worlds/{worldId}/links/{linkId}",
 95            _logger,
 96            $"link {linkId} from world {worldId}");
 97    }
 98
 99    // ===== Member Management =====
 100
 101    public async Task<List<WorldMemberDto>> GetMembersAsync(Guid worldId)
 102    {
 103        return await _http.GetListAsync<WorldMemberDto>(
 104            $"worlds/{worldId}/members",
 105            _logger,
 106            $"members for world {worldId}");
 107    }
 108
 109    public async Task<WorldMemberDto?> UpdateMemberRoleAsync(Guid worldId, Guid memberId, WorldMemberUpdateDto dto)
 110    {
 111        return await _http.PutEntityAsync<WorldMemberDto>(
 112            $"worlds/{worldId}/members/{memberId}",
 113            dto,
 114            _logger,
 115            $"member {memberId} in world {worldId}");
 116    }
 117
 118    public async Task<bool> RemoveMemberAsync(Guid worldId, Guid memberId)
 119    {
 120        return await _http.DeleteEntityAsync(
 121            $"worlds/{worldId}/members/{memberId}",
 122            _logger,
 123            $"member {memberId} from world {worldId}");
 124    }
 125
 126    // ===== Invitation Management =====
 127
 128    public async Task<List<WorldInvitationDto>> GetInvitationsAsync(Guid worldId)
 129    {
 130        return await _http.GetListAsync<WorldInvitationDto>(
 131            $"worlds/{worldId}/invitations",
 132            _logger,
 133            $"invitations for world {worldId}");
 134    }
 135
 136    public async Task<WorldInvitationDto?> CreateInvitationAsync(Guid worldId, WorldInvitationCreateDto dto)
 137    {
 138        return await _http.PostEntityAsync<WorldInvitationDto>(
 139            $"worlds/{worldId}/invitations",
 140            dto,
 141            _logger,
 142            $"invitation for world {worldId}");
 143    }
 144
 145    public async Task<bool> RevokeInvitationAsync(Guid worldId, Guid invitationId)
 146    {
 147        return await _http.DeleteEntityAsync(
 148            $"worlds/{worldId}/invitations/{invitationId}",
 149            _logger,
 150            $"invitation {invitationId} from world {worldId}");
 151    }
 152
 153    public async Task<WorldJoinResultDto?> JoinWorldAsync(string code)
 154    {
 155        var dto = new WorldJoinDto { Code = code };
 156        return await _http.PostEntityAsync<WorldJoinResultDto>(
 157            "worlds/join",
 158            dto,
 159            _logger,
 160            "join world");
 161    }
 162
 163    // ===== World Documents =====
 164
 165    public async Task<WorldDocumentUploadResponseDto?> RequestDocumentUploadAsync(
 166        Guid worldId,
 167        WorldDocumentUploadRequestDto dto)
 168    {
 169        return await _http.PostEntityAsync<WorldDocumentUploadResponseDto>(
 170            $"worlds/{worldId}/documents/request-upload",
 171            dto,
 172            _logger,
 173            $"document upload request for world {worldId}");
 174    }
 175
 176    public async Task<WorldDocumentDto?> ConfirmDocumentUploadAsync(Guid worldId, Guid documentId)
 177    {
 178        var dto = new WorldDocumentConfirmUploadDto { DocumentId = documentId };
 179        return await _http.PostEntityAsync<WorldDocumentDto>(
 180            $"worlds/{worldId}/documents/{documentId}/confirm",
 181            dto,
 182            _logger,
 183            $"document upload confirmation for {documentId}");
 184    }
 185
 186    public async Task<List<WorldDocumentDto>> GetWorldDocumentsAsync(Guid worldId)
 187    {
 188        return await _http.GetListAsync<WorldDocumentDto>(
 189            $"worlds/{worldId}/documents",
 190            _logger,
 191            $"documents for world {worldId}");
 192    }
 193
 194    public async Task<DocumentDownloadResult?> DownloadDocumentAsync(Guid documentId)
 195    {
 196        var downloadInfo = await _http.GetEntityAsync<WorldDocumentDownloadDto>(
 197            $"/documents/{documentId}/content",
 198            _logger,
 199            $"download URL for document {documentId}");
 200
 201        if (downloadInfo == null)
 202            return null;
 203
 204        return new DocumentDownloadResult(
 205            downloadInfo.DownloadUrl,
 206            downloadInfo.FileName,
 207            downloadInfo.ContentType,
 208            downloadInfo.FileSizeBytes);
 209    }
 210
 211    public async Task<WorldDocumentDto?> UpdateDocumentAsync(
 212        Guid worldId,
 213        Guid documentId,
 214        WorldDocumentUpdateDto dto)
 215    {
 216        return await _http.PutEntityAsync<WorldDocumentDto>(
 217            $"worlds/{worldId}/documents/{documentId}",
 218            dto,
 219            _logger,
 220            $"document {documentId} for world {worldId}");
 221    }
 222
 223    public async Task<bool> DeleteDocumentAsync(Guid worldId, Guid documentId)
 224    {
 225        return await _http.DeleteEntityAsync(
 226            $"worlds/{worldId}/documents/{documentId}",
 227            _logger,
 228            $"document {documentId} from world {worldId}");
 229    }
 230}
Generated by: ReportGenerator 5.5.10.0
06/11/2026 - 03:52:19
GitHub | reportgenerator.io

Methods/Properties

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