AppStd/EnvelopeGenerator
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

First successfull build

Browse Source
This commit is contained in:
OlgunR
2026-03-19 12:35:23 +01:00
parent 7271a92d32
commit 4f3c66b4f7
30 changed files with 767 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
EnvelopeGenerator.ReceiverUI/EnvelopeGenerator.ReceiverUI.Client/Services/AuthService.cs
View File

@@ -1,6 +1,54 @@
namespace EnvelopeGenerator.ReceiverUI.Client.Services
using EnvelopeGenerator.ReceiverUI.Client.Services.Base;
namespace EnvelopeGenerator.ReceiverUI.Client.Services;
/// <summary>
/// Spricht mit dem bestehenden AuthController der API.
/// Die API erkennt den Nutzer über das Cookie "AuthToken" automatisch.
/// </summary>
public class AuthService : ApiServiceBase, IAuthService
{
public class AuthService
public AuthService(HttpClient http, ILogger<AuthService> logger) : base(http, logger) { }
public async Task<ApiResponse> CheckAuthAsync(string? role = null, CancellationToken ct = default)
{
var endpoint = role is not null ? $"api/auth/check?role={role}" : "api/auth/check";
try
{
var response = await Http.GetAsync(endpoint, ct);
return response.IsSuccessStatusCode
? ApiResponse.Success((int)response.StatusCode)
: ApiResponse.Failure((int)response.StatusCode);
}
catch (HttpRequestException ex)
{
Logger.LogError(ex, "HTTP error calling GET {Endpoint}", endpoint);
return ApiResponse.Failure(0, "Verbindung zum Server fehlgeschlagen.");
}
catch (TaskCanceledException)
{
return ApiResponse.Failure(0, "Anfrage abgebrochen.");
}
}
}
public async Task<ApiResponse> LogoutAsync(CancellationToken ct = default)
{
const string endpoint = "api/auth/logout";
try
{
var response = await Http.PostAsync(endpoint, null, ct);
return response.IsSuccessStatusCode
? ApiResponse.Success((int)response.StatusCode)
: ApiResponse.Failure((int)response.StatusCode);
}
catch (HttpRequestException ex)
{
Logger.LogError(ex, "HTTP error calling POST {Endpoint}", endpoint);
return ApiResponse.Failure(0, "Verbindung zum Server fehlgeschlagen.");
}
catch (TaskCanceledException)
{
return ApiResponse.Failure(0, "Anfrage abgebrochen.");
}
}
}

40
EnvelopeGenerator.ReceiverUI/EnvelopeGenerator.ReceiverUI.Client/Services/Base/ApiResponse.cs
View File

@@ -1,6 +1,38 @@
namespace EnvelopeGenerator.ReceiverUI.Client.Services.Base
namespace EnvelopeGenerator.ReceiverUI.Client.Services.Base;
/// <summary>
/// Einheitliches Response-Objekt für ALLE API-Aufrufe.
///
/// WARUM: Jeder API-Aufruf kann fehlschlagen (Netzwerk, 401, 500...).
/// Statt überall try-catch zu haben, kapselt dieses Objekt Erfolg/Fehler einheitlich.
/// So kann jede Blazor-Komponente einheitlich darauf reagieren.
/// </summary>
public record ApiResponse<T>
{
public class ApiResponse
{
}
public bool IsSuccess { get; init; }
public T? Data { get; init; }
public int StatusCode { get; init; }
public string? ErrorMessage { get; init; }
public static ApiResponse<T> Success(T data, int statusCode = 200)
=> new() { IsSuccess = true, Data = data, StatusCode = statusCode };
public static ApiResponse<T> Failure(int statusCode, string? error = null)
=> new() { IsSuccess = false, StatusCode = statusCode, ErrorMessage = error };
}
/// <summary>
/// Response ohne Daten (für POST/PUT/DELETE die nur Status zurückgeben).
/// </summary>
public record ApiResponse
{
public bool IsSuccess { get; init; }
public int StatusCode { get; init; }
public string? ErrorMessage { get; init; }
public static ApiResponse Success(int statusCode = 200)
=> new() { IsSuccess = true, StatusCode = statusCode };
public static ApiResponse Failure(int statusCode, string? error = null)
=> new() { IsSuccess = false, StatusCode = statusCode, ErrorMessage = error };
}

110
EnvelopeGenerator.ReceiverUI/EnvelopeGenerator.ReceiverUI.Client/Services/Base/ApiServiceBase.cs
View File

@@ -1,6 +1,110 @@
namespace EnvelopeGenerator.ReceiverUI.Client.Services.Base
using System.Net.Http.Json;
using Microsoft.Extensions.Logging;
namespace EnvelopeGenerator.ReceiverUI.Client.Services.Base;
/// <summary>
/// Basisklasse für ALLE API-Services.
///
/// WARUM eine Basisklasse?
/// - Einheitliches Error-Handling: Jeder API-Aufruf wird gleich behandelt
/// - DRY (Don't Repeat Yourself): Logging, Fehlerbehandlung, Serialisierung nur einmal
/// - Einfache Erweiterung: Retry-Logik, Token-Refresh etc. nur hier ändern
/// </summary>
public abstract class ApiServiceBase
{
public class ApiServiceBase
protected readonly HttpClient Http;
protected readonly ILogger Logger;
protected ApiServiceBase(HttpClient http, ILogger logger)
{
Http = http;
Logger = logger;
}
}
/// <summary>
/// GET-Request mit Deserialisierung.
/// Alle API GET-Aufrufe gehen durch diese Methode.
/// </summary>
protected async Task<ApiResponse<T>> GetAsync<T>(string endpoint, CancellationToken ct = default)
{
try
{
var response = await Http.GetAsync(endpoint, ct);
if (!response.IsSuccessStatusCode)
{
var errorBody = await response.Content.ReadAsStringAsync(ct);
Logger.LogWarning("GET {Endpoint} failed: {Status} - {Body}",
endpoint, (int)response.StatusCode, errorBody);
return ApiResponse<T>.Failure((int)response.StatusCode, errorBody);
}
var data = await response.Content.ReadFromJsonAsync<T>(cancellationToken: ct);
return ApiResponse<T>.Success(data!, (int)response.StatusCode);
}
catch (HttpRequestException ex)
{
Logger.LogError(ex, "HTTP error calling GET {Endpoint}", endpoint);
return ApiResponse<T>.Failure(0, "Verbindung zum Server fehlgeschlagen.");
}
catch (TaskCanceledException)
{
Logger.LogWarning("GET {Endpoint} was cancelled", endpoint);
return ApiResponse<T>.Failure(0, "Anfrage abgebrochen.");
}
}
/// <summary>
/// POST-Request mit Body und Response-Deserialisierung.
/// </summary>
protected async Task<ApiResponse<TResponse>> PostAsync<TRequest, TResponse>(
string endpoint, TRequest body, CancellationToken ct = default)
{
try
{
var response = await Http.PostAsJsonAsync(endpoint, body, ct);
if (!response.IsSuccessStatusCode)
{
var errorBody = await response.Content.ReadAsStringAsync(ct);
Logger.LogWarning("POST {Endpoint} failed: {Status} - {Body}",
endpoint, (int)response.StatusCode, errorBody);
return ApiResponse<TResponse>.Failure((int)response.StatusCode, errorBody);
}
var data = await response.Content.ReadFromJsonAsync<TResponse>(cancellationToken: ct);
return ApiResponse<TResponse>.Success(data!, (int)response.StatusCode);
}
catch (HttpRequestException ex)
{
Logger.LogError(ex, "HTTP error calling POST {Endpoint}", endpoint);
return ApiResponse<TResponse>.Failure(0, "Verbindung zum Server fehlgeschlagen.");
}
}
/// <summary>
/// POST-Request ohne Response-Body (z.B. Logout).
/// </summary>
protected async Task<ApiResponse> PostAsync<TRequest>(
string endpoint, TRequest body, CancellationToken ct = default)
{
try
{
var response = await Http.PostAsJsonAsync(endpoint, body, ct);
if (!response.IsSuccessStatusCode)
{
var errorBody = await response.Content.ReadAsStringAsync(ct);
return ApiResponse.Failure((int)response.StatusCode, errorBody);
}
return ApiResponse.Success((int)response.StatusCode);
}
catch (HttpRequestException ex)
{
Logger.LogError(ex, "HTTP error calling POST {Endpoint}", endpoint);
return ApiResponse.Failure(0, "Verbindung zum Server fehlgeschlagen.");
}
}
}

20
EnvelopeGenerator.ReceiverUI/EnvelopeGenerator.ReceiverUI.Client/Services/EnvelopeService.cs
View File

@@ -1,6 +1,16 @@
namespace EnvelopeGenerator.ReceiverUI.Client.Services
using EnvelopeGenerator.ReceiverUI.Client.Models;
using EnvelopeGenerator.ReceiverUI.Client.Services.Base;
namespace EnvelopeGenerator.ReceiverUI.Client.Services;
public class EnvelopeService : ApiServiceBase, IEnvelopeService
{
public class EnvelopeService
{
}
}
public EnvelopeService(HttpClient http, ILogger<EnvelopeService> logger) : base(http, logger) { }
public Task<ApiResponse<IEnumerable<EnvelopeModel>>> GetEnvelopesAsync(CancellationToken ct = default)
=> GetAsync<IEnumerable<EnvelopeModel>>("api/envelope", ct);
public Task<ApiResponse<IEnumerable<EnvelopeReceiverModel>>> GetEnvelopeReceiversAsync(
CancellationToken ct = default)
=> GetAsync<IEnumerable<EnvelopeReceiverModel>>("api/envelopereceiver", ct);
}

24
EnvelopeGenerator.ReceiverUI/EnvelopeGenerator.ReceiverUI.Client/Services/IAuthService.cs
View File

@@ -1,6 +1,20 @@
namespace EnvelopeGenerator.ReceiverUI.Client.Services
using EnvelopeGenerator.ReceiverUI.Client.Services.Base;
namespace EnvelopeGenerator.ReceiverUI.Client.Services;
/// <summary>
/// Kommuniziert mit dem AuthController der API.
///
/// WARUM Interface + Implementierung?
/// - Testbarkeit: In Unit-Tests kann man einen Mock verwenden
/// - Austauschbarkeit: Wenn sich die API ändert, ändert sich nur die Implementierung
/// - Blazor-Konvention: Services werden über Interfaces per DI registriert
/// </summary>
public interface IAuthService
{
public interface IAuthService
{
}
}
/// <summary>Prüft ob der Nutzer eingeloggt ist → GET /api/auth/check</summary>
Task<ApiResponse> CheckAuthAsync(string? role = null, CancellationToken ct = default);
/// <summary>Logout → POST /api/auth/logout</summary>
Task<ApiResponse> LogoutAsync(CancellationToken ct = default);
}

22
EnvelopeGenerator.ReceiverUI/EnvelopeGenerator.ReceiverUI.Client/Services/IEnvelopeService.cs
View File

@@ -1,6 +1,18 @@
namespace EnvelopeGenerator.ReceiverUI.Client.Services
using EnvelopeGenerator.ReceiverUI.Client.Models;
using EnvelopeGenerator.ReceiverUI.Client.Services.Base;
namespace EnvelopeGenerator.ReceiverUI.Client.Services;
/// <summary>
/// Kommuniziert mit EnvelopeController und EnvelopeReceiverController.
/// Verwendet Client-eigene Models statt der Server-DTOs.
/// </summary>
public interface IEnvelopeService
{
public interface IEnvelopeService
{
}
}
/// <summary>Lädt Umschläge → GET /api/envelope</summary>
Task<ApiResponse<IEnumerable<EnvelopeModel>>> GetEnvelopesAsync(CancellationToken ct = default);
/// <summary>Lädt EnvelopeReceiver → GET /api/envelopereceiver</summary>
Task<ApiResponse<IEnumerable<EnvelopeReceiverModel>>> GetEnvelopeReceiversAsync(
CancellationToken ct = default);
}