# Baserow.Net.Blazor

[![Version](https://img.shields.io/badge/Version-0.1.14-blue)](https://github.com/your-username/baserow-net)
[![License](https://img.shields.io/badge/License-MIT-green)](LICENSE)
[![.NET](https://img.shields.io/badge/.NET-10.0-purple)](https://dotnet.microsoft.com/)
[![Blazor](https://img.shields.io/badge/Blazor-WebAssembly-orange)](https://blazor.net/)

Blazor WebAssembly Erweiterung für Baserow.Net mit Authentifizierung, Navigation und UI-Komponenten.

## 📋 Voraussetzungen

- **.NET 10.0 oder höher**
- **Blazor WebAssembly**
- **NuGet-Pakete** (werden automatisch installiert):
  - `Baserow.Net` (>= 0.1.14)
  - `Microsoft.AspNetCore.Components.Web` (>= 10.0.0)
  - `Microsoft.Extensions.DependencyInjection.Abstractions` (>= 10.0.0)
  - `Microsoft.Extensions.Http` (>= 10.0.0)
  - `Microsoft.JSInterop` (>= 10.0.0)
  - `Radzen.Blazor` (>= 8.3.2)

## 🚀 Features

- 🔐 **Authentication** - Baserow-Authentication für Blazor mit StateProvider
- ⚠️ **Error Handling** - Globale Fehlerbehandlung mit UI-Komponenten
- 🗄️ **Token Storage** - Sichere Token-Verwaltung im Browser
- 🧭 **Navigation** - Baserow-integrierte Navigation-Helpers
- 🎨 **UI Components** - Vorgefertigte Error-Handling Komponenten

## 📦 Installation

```bash
dotnet add package Baserow.Net.Blazor
```

**Abhängigkeiten:** Dieses Paket benötigt `Baserow.Net` als Grundlage.

## ⚡ Quick Start

### 1. Service Registration (NEU - Vereinfacht!)

```csharp
// Program.cs
using Baserow.Net.Extension;
using Baserow.Net.Blazor.Extensions;
using Baserow.Net.Models;

var builder = WebAssemblyHostBuilder.CreateDefault(args);

var baseUrl = builder.Configuration["Baserow:BaseUrl"] ?? "https://api.baserow.io/";

// Alle Baserow Core Services mit einem Aufruf registrieren
builder.Services.AddBaserow(baseUrl);

// Authentifizierung konfigurieren
builder.Services.AddBaserowAuthentication(options =>
{
    options.BaseUrl = baseUrl;
    options.ApiToken = builder.Configuration["Baserow:ApiToken"];
});

// Alle Blazor-spezifischen Services mit einem Aufruf registrieren
builder.Services.AddBaserowBlazor();

var app = builder.Build();
await app.RunAsync();
```

**Was wird automatisch registriert?**

Mit `AddBaserow()`:
- `IBaserowService` - Hauptservice
- `AdminBaserowService` - Admin-Funktionen
- `IBaserowFieldMapper` - Field-Mapping

Mit `AddBaserowBlazor()`:
- Navigation-Helper
- Logging-Services
- Table-Routing
- Theme-Service
- Version-Service

### 1b. Alternative: Granulare Kontrolle

```csharp
// Wenn Sie nur bestimmte Services benötigen
builder.Services.AddBaserow(baseUrl);
builder.Services.AddBaserowAuthentication(options => { ... });

// Einzelne Services registrieren
builder.Services.AddNavigationServices();
builder.Services.AddBaserowLogging();
builder.Services.AddThemeService();
// etc.
```

### 2. Authentication Setup

```csharp
// App.razor
<Router AppAssembly="@typeof(App).Assembly">
    <Found Context="routeData">
        <AuthorizeView>
            <Authorized>
                <ErrorHandler>
                    <RouteView RouteData="@routeData" DefaultLayout="@typeof(MainLayout)" />
                </ErrorHandler>
            </Authorized>
            <NotAuthorized>
                <RedirectToLogin />
            </NotAuthorized>
        </AuthorizeView>
    </Found>
    <NotFound>
        <PageTitle>Not found</PageTitle>
        <LayoutView Layout="@typeof(MainLayout)">
            <p role="alert">Sorry, there's nothing at this address.</p>
        </LayoutView>
    </NotFound>
</Router>
```

### 3. Login Component

```csharp
@page "/login"
@using Baserow.Net.Blazor.Auth
@inject AuthenticationStateProvider AuthProvider
@inject NavigationManager Navigation

<h3>Login</h3>

<EditForm Model="@loginModel" OnValidSubmit="@HandleLogin">
    <InputText @bind-Value="loginModel.Email" placeholder="Email" />
    <InputText @bind-Value="loginModel.Password" type="password" placeholder="Password" />
    <button type="submit" disabled="@isLoading">
    </button>
</EditForm>

@if (!string.IsNullOrEmpty(errorMessage))
{
    <div class="alert alert-danger">@errorMessage</div>
}

@code {
    private LoginModel loginModel = new();
    private bool isLoading = false;
    private string? errorMessage;

    private async Task HandleLogin()
    {
        isLoading = true;
        errorMessage = null;

        try
        {
            var success = await ((BaserowAuthenticationStateProvider)AuthProvider)
                .LoginAsync(loginModel.Email, loginModel.Password);

            if (success)
            {
                Navigation.NavigateTo("/");
            }
            else
            {
                errorMessage = "Invalid credentials";
            }
        }
        catch (Exception ex)
        {
            errorMessage = $"Login failed: {ex.Message}";
        }
        finally
        {
            isLoading = false;
        }
    }

    public class LoginModel
    {
        public string Email { get; set; } = "";
        public string Password { get; set; } = "";
    }
}
```

## 🔧 Konfiguration

### appsettings.json

```json
{
  "Baserow": {
    "BaseUrl": "https://your-baserow-instance.com",
    "DatabaseId": 123,
    "WorkspaceId": 456
  },
    "MaxBrowserLogEntries": 1000,
      "Enabled": true,
      "MinimumLevel": "Warning",
      "LogTableId": 789,
      "MaxRetries": 3,
      "RetryDelaySeconds": 5
    }
  },
  "ErrorHandling": {
    "ShowToastNotifications": true,
    "ErrorIconVisibilityMinutes": 5,
    "AutoClearErrorsAfterMinutes": 30
  }
}
```

## 📚 Hauptkomponenten

### 🔐 Authentication

#### BaserowAuthenticationStateProvider
```csharp
public class MyComponent : ComponentBase
{
    [Inject] private AuthenticationStateProvider AuthProvider { get; set; }
    
    private async Task Login()
    {
        var provider = (BaserowAuthenticationStateProvider)AuthProvider;
        var success = await provider.LoginAsync(email, password);
    }
    
    private async Task Logout()
    {
        var provider = (BaserowAuthenticationStateProvider)AuthProvider;
        await provider.LogoutAsync();
    }
}
```

#### TokenStorage
```csharp
public class TokenService
{
    private readonly ITokenStorage _tokenStorage;
    
    public TokenService(ITokenStorage tokenStorage)
    {
        _tokenStorage = tokenStorage;
    }
    
    public async Task<string?> GetTokenAsync()
    {
        return await _tokenStorage.GetTokenAsync();
    }
    
    public async Task SetTokenAsync(string token)
    {
        await _tokenStorage.SetTokenAsync(token);
    }
}
```


```csharp

@code {
    protected override async Task OnInitializedAsync()
    {
        // Diese Logs werden automatisch an Baserow gesendet (ab Warning Level)
        Logger.LogInformation("Component initialized"); // Nur lokal
        Logger.LogWarning("Something suspicious happened"); // → Baserow
        Logger.LogError("An error occurred"); // → Baserow
    }
}
```

- **Lokal:** Alle Logs werden im Browser SessionStorage gespeichert
- **Baserow:** Logs ab konfigurierbarem Level werden an Baserow-Tabelle gesendet
- **Download:** Logs können als .txt-Datei heruntergeladen werden

### ⚠️ Error Handling

#### ErrorHandler Component
```csharp
<!-- Wrapp um deine gesamte App -->
<ErrorHandler>
    <Router>
        <!-- Deine App-Inhalte -->
    </Router>
</ErrorHandler>
```

#### ErrorBoundary für spezifische Bereiche
```csharp
<ErrorBoundary>
    <ChildContent>
        <!-- Komponenten die Fehler werfen könnten -->
        <RiskyComponent />
    </ChildContent>
    <ErrorContent Context="exception">
        <p>Oops! Something went wrong: @exception.Message</p>
    </ErrorContent>
</ErrorBoundary>
```

### 🧭 Navigation

#### BaserowNavigationHelper
```csharp
@inject IBaserowNavigationHelper NavigationHelper

@code {
    private async Task NavigateToTable(int tableId)
    {
        await NavigationHelper.NavigateToTableAsync(tableId);
    }
    
    private async Task NavigateToRecord(int tableId, int recordId)
    {
        await NavigationHelper.NavigateToRecordAsync(tableId, recordId);
    }
}
```


### 1. Log-Tabelle in Baserow erstellen

Erstelle eine Tabelle mit folgenden Feldern:
- **Timestamp** (Text)
- **Level** (Single Select: Information, Warning, Error, Critical)
- **Category** (Text) 
- **Message** (Long Text)
- **Exception** (Long Text)
- **UserAgent** (Text)
- **Url** (Text)

### 2. Konfiguration

```json
{
      "Enabled": true,
      "LogTableId": 789,  // Deine Log-Tabellen-ID
      "MinimumLevel": "Warning"
    }
  }
}
```

### 3. Features

- ✅ **Automatisch** - Alle Logs ab Warning-Level werden gesendet
- ✅ **Browser-Info** - UserAgent und URL werden automatisch erfasst
- ✅ **Retry-Logic** - Bei Fehlern wird automatisch wiederholt
- ✅ **Fallback** - Bei Baserow-Ausfällen wird lokal gespeichert

## 🎨 UI Components

### Error Components

```csharp
<!-- Globaler Error Handler -->
<ErrorHandler />

<!-- Lokaler Error Boundary -->
<ErrorBoundary>
    <ChildContent>@ChildContent</ChildContent>
    <ErrorContent Context="ex">
        <div class="alert alert-danger">
            <h4>Fehler aufgetreten</h4>
            <p>@ex.Message</p>
        </div>
    </ErrorContent>
</ErrorBoundary>

<!-- Error Catcher für unerwartete Fehler -->
<ErrorCatcher />
```

## 🔒 Security Features

- **Token Encryption** - Tokens werden verschlüsselt im Browser gespeichert
- **Automatic Logout** - Bei Token-Ablauf automatischer Logout
- **CSRF Protection** - Schutz vor Cross-Site Request Forgery
- **Secure Headers** - Sicherheits-Header für API-Requests

## 📱 Browser Kompatibilität

- ✅ Chrome 90+
- ✅ Firefox 88+
- ✅ Safari 14+
- ✅ Edge 90+

## 🚀 Performance

- **Lazy Loading** - Komponenten werden nur bei Bedarf geladen
- **Caching** - Intelligentes Caching von API-Responses
- **Virtualization** - Große Listen werden virtualisiert
- **Compression** - Automatische Response-Komprimierung

## 🧪 Testing

```csharp
// Beispiel Unit Test
public class AuthenticationTests
{
    [Fact]
    public async Task LoginAsync_WithValidCredentials_ReturnsTrue()
    {
        // Arrange
        var tokenStorage = new Mock<ITokenStorage>();
        var httpClient = new Mock<HttpClient>();
        var authProvider = new BaserowAuthenticationStateProvider(
            tokenStorage.Object, httpClient.Object);
        
        // Act
        var result = await authProvider.LoginAsync("test@example.com", "password");
        
        // Assert
        Assert.True(result);
    }
}
```

## 🤝 Contributing

1. Forke das Repository
2. Erstelle einen Feature-Branch: `git checkout -b feature/awesome-feature`
3. Committe deine Änderungen: `git commit -m 'Add awesome feature'`
4. Push den Branch: `git push origin feature/awesome-feature`
5. Erstelle eine Pull Request

## 📄 License

Dieses Projekt steht unter der [MIT License](../LICENSE).

## 🔗 Related Packages

- [`Baserow.Net`](../Baserow.Net/) - Core Baserow SDK
- [`Radzen.Blazor`](https://www.radzen.com/blazor-components/) - Empfohlene UI-Komponenten

## 📞 Support

- 📖 [Dokumentation](docs/)
- 🐛 [Issues](https://github.com/your-username/baserow-net/issues)
- 💬 [Discussions](https://github.com/your-username/baserow-net/discussions)

---

