@chill-sharp/ui-core 1.1.12 → 1.1.15

package/doc/it/AuthenticationModel/README.md

@@ -1,171 +0,0 @@
-# Autenticazione E Autorizzazione ChillSharp
-
-Versione originale in inglese: [English](../../AuthenticationModel/README.md)
-
-Questo documento copre il modulo auth a livello di riferimento. Per una configurazione guidata, continua a usare [doc/HowTo/03-authentication.md](../HowTo/03-authentication.md).
-
-## Separazione Del Modulo
-
-`ChillSharp.Auth` espone due aree correlate ma distinte:
-
-- autenticazione account
-  Flussi di register, login, refresh, cambio password e reset password basati su ASP.NET Core Identity
-
-- gestione autorizzazione
-  utenti auth, ruoli, assegnazioni ruolo, regole di permesso e valutazione dei permessi
-
-## Endpoint Account
-
-Registrati tramite:
-
-```csharp
-builder.Services.AddChillAuthIdentityApi<AppDbContext, IdentityUser>();
-```
-
-Route tipiche:
-
-- `/api/chill-auth/account/register`
-- `/api/chill-auth/account/login`
-- `/api/chill-auth/account/refresh`
-- `/api/chill-auth/account/change-password`
-- `/api/chill-auth/account/request-password-reset`
-- `/api/chill-auth/account/reset-password`
-
-Queste sono le route usate internamente da `ChillSharpClient`.
-
-`RegisterAuthIdentityRequest` supporta anche:
-
-- `DisplayName`
-- `DisplayCultureName`
-- `CreateChillAuthUser`
-
-Quando `CreateChillAuthUser` e abilitato e viene fornito `DisplayCultureName`, il relativo `AuthUser` viene preimpostato automaticamente con:
-
-- `DisplayCultureName`
-- `DisplayTimeZone`
-- `DisplayDateFormat`
-- `DisplayNumberFormat`
-
-Il server ricava questi valori dalla cultura selezionata usando una mappatura best effort del fuso orario piu i separatori di data e numeri della cultura.
-
-## Endpoint Di Gestione Autorizzazione
-
-Registrati tramite:
-
-```csharp
-builder.Services.AddChillAuthApi<AppDbContext>();
-```
-
-Gruppi di route tipici:
-
-- `/api/chill-auth/users`
-- `/api/chill-auth/roles`
-- `/api/chill-auth/permissions`
-
-Questi endpoint gestiscono:
-
-- `AuthUser`
-- `AuthRole`
-- `AuthUserRole`
-- `AuthPermissionRule`
-- risultati di valutazione dei permessi
-
-`AuthUser` ora include anche preferenze di visualizzazione opzionali per la UI:
-
-- `DisplayCultureName`
-- `DisplayTimeZone`
-- `DisplayDateFormat`
-- `DisplayNumberFormat`
-
-## Requisiti Del Contesto
-
-Il contesto host deve:
-
-- implementare `IChillAuthDbContext`
-- includere `modelBuilder.AddChillAuthModel()`
-
-Per account basati su Identity, il contesto deve anche essere uno store EF valido per ASP.NET Core Identity, tipicamente:
-
-```csharp
-public class AppDbContext : IdentityDbContext<IdentityUser>, IChillContext, IChillAuthDbContext
-{
-}
-```
-
-## Bootstrap Dell'Utente Root
-
-`AddChillAuthIdentityApi(...)` puo inizializzare un account root all'avvio.
-
-Configurazioni supportate:
-
-- opzioni dirette nel codice
-- variabili d'ambiente
-
-Variabili d'ambiente predefinite:
-
-- `CHILLSHARP_AUTH_ROOT_USERNAME`
-- `CHILLSHARP_AUTH_ROOT_PASSWORD`
-- `CHILLSHARP_AUTH_ROOT_EMAIL`
-- `CHILLSHARP_AUTH_ROOT_DISPLAY_NAME`
-
-Quando abilitato, il flusso di bootstrap puo creare anche il collegato `AuthUser` ChillSharp con accesso alla gestione permessi.
-
-## Accesso Alla Gestione Permessi
-
-Essere autenticati non basta per gestire il modulo auth.
-
-Gli endpoint di gestione auth richiedono un utente auth ChillSharp con diritti di gestione permessi, tipicamente:
-
-- `CanManagePermissions = true`
-
-Questo e il problema critico di bootstrap in un database pulito:
-
-- il primo utente Identity registrato puo esistere
-- il relativo `AuthUser` puo esistere
-- ma nessuno puo ancora avere i diritti per gestire ruoli e permessi
-
-Per questo il bootstrap root o un altro percorso di setup trusted e importante.
-
-## Uso Del Client
-
-Usa il normale Chill base URL:
-
-```csharp
-var client = new ChillSharpClient("http://localhost:5000/api/chill");
-```
-
-`ChillSharpClient` passa automaticamente a `/api/chill-auth/...` per i metodi auth.
-
-Esempi:
-
-- `RegisterAuthAccount`
-- `LoginAuthAccount`
-- `RefreshAuthAccount`
-- `ChangeAuthPassword`
-- `CreateAuthRole`
-- `CreateAuthPermissionRule`
-- `EvaluateAuthEntityPermission`
-
-I payload di lista utente e dettaglio utente espongono anche:
-
-- `DisplayCultureName`
-- `DisplayTimeZone`
-- `DisplayDateFormat`
-- `DisplayNumberFormat`
-
-## Gestione Dei Token
-
-`ChillSharpClient` conserva:
-
-- access token
-- refresh token
-
-Se e presente un refresh token, il client puo rinnovare automaticamente l'access token durante chiamate autenticate successive.
-
-## Relazione Con Il Modello Permessi
-
-Le regole esatte di risoluzione permessi sono documentate separatamente in:
-
-- [PermissionModel/README.md](../PermissionModel/README.md)
-
-Usa quel documento per il modello di precedenza e scope. Usa questo per registrazione e flusso auth runtime.

package/doc/it/AuthenticationModel/how-to-integreate-auth-minimal-api.md

@@ -1,292 +0,0 @@
-Versione originale in inglese: [English](../../AuthenticationModel/how-to-integreate-auth-minimal-api.md)
-
-Certo. Qui trovi la versione aggiornata, corretta e moderna della configurazione con **Microsoft.IdentityModel.JsonWebTokens**, perche Microsoft ha deciso che la vecchia libreria JWT dovesse diventare "legacy".
-
-Questo e il modo pulito per avere:
-
-✅ store utenti Identity
-✅ login/register Minimal API
-✅ token JWT Bearer
-✅ niente cookie
-✅ niente UI
-✅ niente `JwtSecurityTokenHandler` obsoleto
-
----
-
-# ✅ Minimal Identity API ASP.NET Core + JWT (JsonWebTokenHandler moderno)
-
----
-
-# ✅ 1. Installare I Pacchetti
-
-Esegui:
-
-```bash
-dotnet add package Microsoft.AspNetCore.Identity.EntityFrameworkCore
-dotnet add package Microsoft.AspNetCore.Authentication.JwtBearer
-dotnet add package Microsoft.EntityFrameworkCore.SqlServer
-dotnet add package Microsoft.IdentityModel.JsonWebTokens
-```
-
-Niente `System.IdentityModel.Tokens.Jwt`.
-
----
-
-# ✅ 2. Creare L'Identity DbContext
-
-```csharp
-using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore;
-
-public class AppDbContext : IdentityDbContext
-{
-    public AppDbContext(DbContextOptions<AppDbContext> options)
-        : base(options) { }
-}
-```
-
----
-
-# ✅ 3. Configurare Database + IdentityCore
-
-In `Program.cs`:
-
-```csharp
-builder.Services.AddDbContext<AppDbContext>(options =>
-    options.UseSqlServer(builder.Configuration.GetConnectionString("Default")));
-```
-
-Poi aggiungi Identity:
-
-```csharp
-builder.Services.AddIdentityCore<IdentityUser>()
-    .AddEntityFrameworkStores<AppDbContext>()
-    .AddDefaultTokenProviders();
-```
-
-✅ Niente UI  
-✅ Niente Razor  
-✅ Niente circo dei cookie
-
----
-
-# ✅ 4. Configurare L'Autenticazione JWT (Bearer)
-
-Aggiungi gli import:
-
-```csharp
-using Microsoft.AspNetCore.Authentication.JwtBearer;
-using Microsoft.IdentityModel.Tokens;
-using System.Text;
-```
-
-Poi:
-
-```csharp
-var jwtKey = builder.Configuration["Jwt:Key"]!;
-var jwtIssuer = builder.Configuration["Jwt:Issuer"]!;
-```
-
-Ora configura:
-
-```csharp
-builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
-    .AddJwtBearer(options =>
-    {
-        options.TokenValidationParameters = new TokenValidationParameters
-        {
-            ValidateIssuer = true,
-            ValidIssuer = jwtIssuer,
-
-            ValidateAudience = false,
-
-            ValidateIssuerSigningKey = true,
-            IssuerSigningKey = new SymmetricSecurityKey(
-                Encoding.UTF8.GetBytes(jwtKey)),
-
-            ValidateLifetime = true
-        };
-    });
-```
-
----
-
-# ✅ 5. Abilitare L'Autorizzazione
-
-```csharp
-builder.Services.AddAuthorization();
-```
-
----
-
-# ✅ 6. Aggiungere Il Middleware
-
-Dopo `var app = builder.Build();`
-
-```csharp
-app.UseAuthentication();
-app.UseAuthorization();
-```
-
-Se salti questo passaggio, non funziona niente.
-
----
-
-# ✅ 7. Generare Un Token JWT (JsonWebTokenHandler moderno)
-
-Aggiungi gli import:
-
-```csharp
-using Microsoft.IdentityModel.JsonWebTokens;
-using System.Security.Claims;
-```
-
-Poi definisci:
-
-```csharp
-string GenerateJwtToken(IdentityUser user)
-{
-    var claims = new List<Claim>
-    {
-        new Claim(JwtRegisteredClaimNames.Sub, user.Id),
-        new Claim(JwtRegisteredClaimNames.Email, user.Email!)
-    };
-
-    var key = new SymmetricSecurityKey(
-        Encoding.UTF8.GetBytes(jwtKey));
-
-    var creds = new SigningCredentials(
-        key,
-        SecurityAlgorithms.HmacSha256);
-
-    var tokenDescriptor = new SecurityTokenDescriptor
-    {
-        Subject = new ClaimsIdentity(claims),
-        Expires = DateTime.UtcNow.AddHours(2),
-        Issuer = jwtIssuer,
-        SigningCredentials = creds
-    };
-
-    var handler = new JsonWebTokenHandler();
-
-    return handler.CreateToken(tokenDescriptor);
-}
-```
-
-✅ Questo sostituisce il vecchio `JwtSecurityTokenHandler`.
-
----
-
-# ✅ 8. Endpoint Di Registrazione (Minimal API)
-
-```csharp
-app.MapPost("/register", async (
-    UserManager<IdentityUser> userManager,
-    RegisterRequest request) =>
-{
-    var user = new IdentityUser
-    {
-        UserName = request.Email,
-        Email = request.Email
-    };
-
-    var result = await userManager.CreateAsync(user, request.Password);
-
-    if (!result.Succeeded)
-        return Results.BadRequest(result.Errors);
-
-    return Results.Ok("User registered");
-});
-```
-
----
-
-# ✅ 9. Endpoint Di Login (ritorna JWT)
-
-```csharp
-app.MapPost("/login", async (
-    UserManager<IdentityUser> userManager,
-    LoginRequest request) =>
-{
-    var user = await userManager.FindByEmailAsync(request.Email);
-
-    if (user == null)
-        return Results.Unauthorized();
-
-    var valid = await userManager.CheckPasswordAsync(user, request.Password);
-
-    if (!valid)
-        return Results.Unauthorized();
-
-    var token = GenerateJwtToken(user);
-
-    return Results.Ok(new { token });
-});
-```
-
----
-
-# ✅ 10. Proteggere Un Endpoint
-
-```csharp
-app.MapGet("/me", (ClaimsPrincipal user) =>
-{
-    var email = user.FindFirst(ClaimTypes.Email)?.Value;
-
-    return Results.Ok(new { email });
-})
-.RequireAuthorization();
-```
-
----
-
-# ✅ 11. Aggiungere I Modelli Request
-
-```csharp
-public record RegisterRequest(string Email, string Password);
-
-public record LoginRequest(string Email, string Password);
-```
-
----
-
-# ✅ 12. Configurare `appsettings.json`
-
-```json
-"Jwt": {
-  "Key": "REPLACE_WITH_A_REAL_SECRET_32+_CHARS",
-  "Issuer": "MyApiAuthServer"
-}
-```
-
-Usa una chiave lunga e casuale.
-
----
-
-# ✅ Risultato
-
-Ora hai:
-
-✅ `/register`  
-✅ `/login` -> ritorna JWT  
-✅ endpoint protetti con Bearer token  
-✅ store utenti Identity in SQL  
-✅ niente cookie  
-✅ niente UI  
-✅ niente handler JWT legacy
-
----
-
-# Se Vuoi Gli Step Successivi
-
-Quando vorrai:
-
-* refresh token
-* ruoli + claim
-* endpoint per reset password
-* conferma email
-* `/logout` con invalidazione JWT
-
-allora l'autenticazione diventa un sistema vero, non una demo.
-
-Resta comunque una base pulita e moderna.