@chill-sharp/ui-core 1.1.12

package/doc/it/HowTo/01-simple-blog-sqlite.md

@@ -0,0 +1,152 @@
+# HOW-TO: API Blog Semplice Su SQLite
+
+Versione originale in inglese: [English](../../HowTo/01-simple-blog-sqlite.md)
+
+Questo esempio mostra la configurazione ChillSharp minima ma utile: una entita `Blog`, un contesto EF Core SQLite e una API ChillSharp senza testi label di schema negli attributi `ChillEntity` o `ChillProperty`.
+
+## Obiettivo
+
+Costruire una API minima che possa creare e leggere entita `Blog` tramite ChillSharp.
+
+## 1. Definire L'Entita
+
+Usa le versioni senza parametri di `ChillEntity` e `ChillProperty` quando non vuoi ancora fornire testi di schema.
+
+```csharp
+using ChillSharp.Annotations;
+using ChillSharp.EF;
+using System.ComponentModel.DataAnnotations;
+
+namespace MyBlogApp.Model;
+
+[ChillEntity]
+public class Blog : ChillEntity
+{
+    [Key]
+    public override Guid Guid { get; set; }
+
+    [ChillProperty]
+    public string Name { get; set; } = string.Empty;
+
+    [ChillProperty]
+    public string? Url { get; set; }
+
+    public override string GetLabel(IChillContext context) => Name;
+}
+```
+
+## 2. Definire Una Query
+
+`Find` basta per caricare una sola entita tramite `Guid`, ma un tipo query resta utile quando vuoi filtri e proiezioni normali.
+
+```csharp
+using ChillSharp.Annotations;
+using ChillSharp.EF;
+
+namespace MyBlogApp.Query;
+
+[ChillEntity]
+public class BlogQuery : ChillQuery
+{
+    [ChillProperty]
+    public string? Name { get; set; }
+
+    public override IQueryable<IChillEntity> OnQuery(IChillContext context)
+    {
+        var db = (BloggingContext)context;
+        var query = db.Blogs.AsQueryable();
+
+        if (Guid.HasValue)
+            query = query.Where(x => x.Guid == Guid.Value);
+
+        if (!string.IsNullOrWhiteSpace(Name))
+            query = query.Where(x => x.Name.Contains(Name));
+
+        return query;
+    }
+}
+```
+
+## 3. Creare Il Contesto SQLite
+
+Il contesto deve implementare `IChillContext` e restituire il prefisso namespace usato dai tipi model e query.
+
+```csharp
+using Microsoft.EntityFrameworkCore;
+using MyBlogApp.Model;
+
+namespace MyBlogApp;
+
+public class BloggingContext : DbContext, IChillContext
+{
+    public DbSet<Blog> Blogs => Set<Blog>();
+
+    public BloggingContext(DbContextOptions<BloggingContext> options) : base(options)
+    {
+    }
+
+    public string GetChillTypePrefix() => "MyBlogApp";
+}
+```
+
+## 4. Registrare ChillSharp
+
+```csharp
+using ChillSharp.Api;
+using Microsoft.EntityFrameworkCore;
+
+var builder = WebApplication.CreateBuilder(args);
+
+builder.Services.AddDbContext<BloggingContext>(options =>
+    options.UseSqlite("Data Source=blogging.db"));
+
+builder.Services.AddChillApi<BloggingContext>();
+
+var app = builder.Build();
+
+using (var scope = app.Services.CreateScope())
+{
+    var db = scope.ServiceProvider.GetRequiredService<BloggingContext>();
+    db.Database.EnsureCreated();
+}
+
+app.MapChillApi();
+app.Run();
+```
+
+## 5. Creare E Leggere Un Blog Con `ChillSharpClient`
+
+```csharp
+using ChillSharp.Client;
+using ChillSharp.Client.Dto;
+
+var client = new ChillSharpClient("http://localhost:5000/api/chill");
+
+var blog = new ChillDtoEntity
+{
+    ChillType = "Model.Blog",
+    Guid = Guid.NewGuid()
+};
+blog.Properties["Name"] = "SQLite Notes";
+blog.Properties["Url"] = "https://example.local/sqlite-notes";
+
+var created = client.Create(blog);
+
+var query = new ChillDtoQuery
+{
+    ChillType = "Query.BlogQuery"
+};
+query.Properties["Guid"] = created.Guid;
+query.ResultProperties = ChillDtoProperty.Build("Guid", "Name", "Url");
+
+var result = client.Query(query);
+var loadedBlog = result.Results.Single();
+Console.WriteLine($"{loadedBlog.GetString("Name")} -> {loadedBlog.GetString("Url")}");
+```
+
+## Note
+
+- `Model.Blog` e `Query.BlogQuery` sono nomi tipo brevi. ChillSharp li espande usando `GetChillTypePrefix()`.
+- Con attributi senza parametri, i metadati schema fanno fallback ai nomi CLR di tipo e proprieta.
+
+Esempio successivo: [Aggiungere label di schema e leggerle tramite ChillSharp](02-blog-schema-labels.md)

package/doc/it/HowTo/02-blog-schema-labels.md

@@ -0,0 +1,139 @@
+# HOW-TO: Aggiungere Label Di Schema Al Blog E Leggerle
+
+Versione originale in inglese: [English](../../HowTo/02-blog-schema-labels.md)
+
+Questo esempio aggiorna il modello `Blog` precedente aggiungendo testi di schema a `ChillEntity` e `ChillProperty`, poi mostra come leggere quelle label.
+
+## Obiettivo
+
+Decorare il modello con metadati di schema e recuperarli tramite i servizi schema di ChillSharp.
+
+## 1. Aggiungere Label A Entita E Proprieta
+
+```csharp
+using ChillSharp.Annotations;
+using ChillSharp.EF;
+using System.ComponentModel.DataAnnotations;
+
+namespace MyBlogApp.Model;
+
+[ChillEntity(
+    UniquePropertyKeyString: "4E16F6C0-6B95-4D67-98BC-9F4D0D63EAF1",
+    PrimaryLanguageLabel: "Blog",
+    SecondaryLanguageLabel: "Blog")]
+public class Blog : ChillEntity
+{
+    [Key]
+    public override Guid Guid { get; set; }
+
+    [ChillProperty(
+        UniquePropertyKeyString: "50B1BB6C-D794-41E4-A85C-D4F9D7A6FA7E",
+        PrimaryLanguageLabel: "Blog name",
+        SecondaryLanguageLabel: "Nome blog")]
+    public string Name { get; set; } = string.Empty;
+
+    [ChillProperty(
+        UniquePropertyKeyString: "A18E7754-D8F7-45FE-B8A8-EA762A4EC9E6",
+        PrimaryLanguageLabel: "Blog url",
+        SecondaryLanguageLabel: "Url blog")]
+    public string? Url { get; set; }
+
+    public override string GetLabel(IChillContext context) => Name;
+}
+```
+
+## 2. Abilitare La Persistenza Dello Schema
+
+Per esporre metadati schema tramite `get-schema`, il contesto EF Core deve anche implementare `IChillSchemaDbContext`, aggiungere il modello schema e registrare `AddChillSchema<TContext>()`.
+
+```csharp
+using ChillSharp.Schema;
+using ChillSharp.Schema.Model;
+using Microsoft.EntityFrameworkCore;
+using MyBlogApp.Model;
+
+namespace MyBlogApp;
+
+public class BloggingContext : DbContext, IChillContext, IChillSchemaDbContext
+{
+    public DbSet<Blog> Blogs => Set<Blog>();
+    public DbSet<ChillSchemaEntry> SchemaEntries => Set<ChillSchemaEntry>();
+
+    public BloggingContext(DbContextOptions<BloggingContext> options) : base(options)
+    {
+    }
+
+    public string GetChillTypePrefix() => "MyBlogApp";
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        base.OnModelCreating(modelBuilder);
+        modelBuilder.AddChillSchemaModel();
+    }
+}
+```
+
+Registra il servizio schema insieme all'API:
+
+```csharp
+using ChillSharp.Api;
+using ChillSharp.Schema;
+using Microsoft.EntityFrameworkCore;
+
+var builder = WebApplication.CreateBuilder(args);
+
+builder.Services.AddDbContext<BloggingContext>(options =>
+    options.UseSqlite("Data Source=blogging.db"));
+
+builder.Services.AddChillApi<BloggingContext>();
+builder.Services.AddChillSchema<BloggingContext>();
+```
+
+## 3. Leggere I Metadati Di Schema Da Un Client
+
+`ChillSharpClient.GetSchema(...)` restituisce metadati proprieta generati dal modello decorato.
+
+```csharp
+using ChillSharp.Client;
+
+var client = new ChillSharpClient("http://localhost:5000/api/chill");
+var schema = client.GetSchema("Model.Blog", "default");
+
+var nameProperty = schema?.Properties.Single(x => x.Name == "Name");
+var urlProperty = schema?.Properties.Single(x => x.Name == "Url");
+
+Console.WriteLine(nameProperty?.DisplayName); // Blog name
+Console.WriteLine(urlProperty?.DisplayName);  // Blog url
+```
+
+## 4. Leggere Il Nome Visualizzato Dell'Entita Sul Server
+
+La `ChillSharp.Dto.ChillDtoSchema` lato server contiene anche il `DisplayName` dell'entita, popolato da `ChillEntityAttribute.PrimaryLanguageLabel`.
+
+```csharp
+using ChillSharp;
+
+public class SchemaDebugService
+{
+    private readonly IChillDtoEngine _dtoEngine;
+
+    public SchemaDebugService(IChillDtoEngine dtoEngine)
+    {
+        _dtoEngine = dtoEngine;
+    }
+
+    public string? GetBlogSchemaDisplayName()
+    {
+        var schema = _dtoEngine.GetSchema("Model.Blog", "default");
+        return schema?.DisplayName;
+    }
+}
+```
+
+## Note
+
+- `DisplayName` della proprieta viene da `ChillPropertyAttribute.PrimaryLanguageLabel`.
+- `DisplayName` dell'entita viene da `ChillEntityAttribute.PrimaryLanguageLabel`.
+- Se poi chiami `SetSchema(...)`, i valori schema persistiti possono sovrascrivere i default generati per un dato `ChillType` e `ChillViewCode`.
+
+Esempio successivo: [Usare l'autenticazione con ChillSharp](03-authentication.md)

package/doc/it/HowTo/03-authentication.md

@@ -0,0 +1,221 @@
+# HOW-TO: Usare L'Autenticazione Con ChillSharp
+
+Versione originale in inglese: [English](../../HowTo/03-authentication.md)
+
+Questo esempio mostra la configurazione di autenticazione minima ma utile per una API ChillSharp: proteggere l'API, abilitare il modulo auth, registrare un account, fare login e lasciare che `ChillSharpClient` riusi e rinnovi i token automaticamente.
+
+## Obiettivo
+
+Esporre una API ChillSharp protetta basata su ASP.NET Core Identity e autenticarsi con `ChillSharpClient`.
+
+## 1. Usare Un Contesto Che Supporti Identity E ChillSharp Auth
+
+Il contesto deve supportare il normale modello ChillSharp e le tabelle auth.
+
+```csharp
+using ChillSharp;
+using ChillSharp.Auth;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore;
+
+namespace MyBlogApp;
+
+public class BloggingContext : IdentityDbContext<IdentityUser>, IChillContext, IChillAuthDbContext
+{
+    public BloggingContext(DbContextOptions<BloggingContext> options) : base(options)
+    {
+    }
+
+    public string GetChillTypePrefix() => "MyBlogApp";
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        base.OnModelCreating(modelBuilder);
+        modelBuilder.AddChillAuthModel();
+    }
+}
+```
+
+## 2. Registrare Identity, Authentication E I Servizi Auth ChillSharp
+
+Proteggi la normale ChillSharp API e aggiungi sopra gli endpoint auth.
+
+```csharp
+using ChillSharp.Api;
+using ChillSharp.Auth;
+using ChillSharp.Auth.Api;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.EntityFrameworkCore;
+
+var builder = WebApplication.CreateBuilder(args);
+
+builder.Services.AddDbContext<BloggingContext>(options =>
+    options.UseSqlite("Data Source=blogging-auth.db"));
+
+builder.Services.AddIdentityCore<IdentityUser>()
+    .AddEntityFrameworkStores<BloggingContext>()
+    .AddSignInManager()
+    .AddDefaultTokenProviders();
+
+builder.Services.AddAuthentication(ChillAuthIdentityDefaults.AuthenticationScheme)
+    .AddChillAuthBearer();
+
+builder.Services.AddAuthorization();
+
+builder.Services.AddChillApi<BloggingContext>(options =>
+{
+    options.ProtectedApi = true;
+});
+
+builder.Services.AddChillAuthIdentityApi<BloggingContext, IdentityUser>(options =>
+{
+    options.ReturnPasswordResetTokensInResponse = true;
+    options.InitializeRootUserOnStartup = true;
+    options.CreateChillAuthUserForRoot = true;
+    options.RootUserName = "root";
+    options.RootPassword = "Pass123$";
+    options.RootEmail = "root@example.com";
+    options.RootDisplayName = "Root Administrator";
+});
+```
+
+Quando `CreateChillAuthUserForRoot = true`, all'avvio viene creato anche il relativo `AuthUser` ChillSharp e `CanManagePermissions = true` viene impostato per quell'utente root.
+
+Puoi fornire gli stessi valori di bootstrap anche tramite variabili d'ambiente invece di hardcodarli:
+
+```text
+CHILLSHARP_AUTH_ROOT_USERNAME=root
+CHILLSHARP_AUTH_ROOT_PASSWORD=Pass123$
+CHILLSHARP_AUTH_ROOT_EMAIL=root@example.com
+CHILLSHARP_AUTH_ROOT_DISPLAY_NAME=Root Administrator
+```
+
+## 3. Abilitare Il Middleware E Mappare L'API
+
+`MapChillApi()` espone sia gli endpoint normali ChillSharp sia quelli auth una volta registrati i servizi auth.
+
+```csharp
+var app = builder.Build();
+
+app.UseAuthentication();
+app.UseAuthorization();
+
+using (var scope = app.Services.CreateScope())
+{
+    var db = scope.ServiceProvider.GetRequiredService<BloggingContext>();
+    db.Database.EnsureCreated();
+}
+
+app.MapChillApi();
+app.Run();
+```
+
+## 4. Usare L'Utente Root Per Gestire I Permessi
+
+L'inizializzatore root-user e la via piu semplice di bootstrap per un sistema protetto nuovo, perche l'utente auth ChillSharp collegato viene creato con la gestione permessi abilitata.
+
+```csharp
+var rootClient = new ChillSharpClient("http://localhost:5000/api/chill");
+
+var rootLogin = rootClient.LoginAuthAccount(new LoginAuthIdentityRequest
+{
+    UserNameOrEmail = "root",
+    Password = "Pass123$"
+});
+
+var authUsers = rootClient.GetAuthUsers();
+Console.WriteLine(authUsers.Count);
+```
+
+Quel login puo chiamare endpoint di gestione auth come utenti, ruoli e regole di permesso perche l'`AuthUser` root generato ha `CanManagePermissions = true`.
+
+## 5. Registrare Il Primo Account Normale
+
+Crea il client con il normale Chill base URL. Le chiamate auth passano automaticamente da `/api/chill` a `/api/chill-auth`.
+
+```csharp
+using ChillSharp.Auth.Contracts;
+using ChillSharp.Client;
+
+var client = new ChillSharpClient("http://localhost:5000/api/chill");
+
+var registerResponse = client.RegisterAuthAccount(new RegisterAuthIdentityRequest
+{
+    UserName = "admin",
+    Email = "admin@example.com",
+    Password = "Pass123$",
+    DisplayName = "Administrator",
+    DisplayCultureName = "it-IT",
+    CreateChillAuthUser = true
+});
+```
+
+Dopo una registrazione riuscita, il client salva internamente access token e refresh token restituiti.
+
+Se `DisplayCultureName` viene fornito e `CreateChillAuthUser = true`, il relativo `AuthUser` viene inizializzato con valori derivati dalla cultura per:
+
+- `DisplayTimeZone`
+- `DisplayDateFormat`
+- `DisplayNumberFormat`
+
+Per esempio, `it-IT` tipicamente produce preset come:
+
+- `DisplayTimeZone = "W. Europe Standard Time"`
+- `DisplayDateFormat = "DD/MM/YYYY"`
+- `DisplayNumberFormat = "1.000,00"`
+
+Questi sono preset server-side e possono essere modificati in seguito tramite la gestione utenti auth.
+
+## 6. Fare Login Esplicito
+
+Se l'account esiste gia, fai login con lo stesso `ChillSharpClient`.
+
+```csharp
+var loginResponse = client.LoginAuthAccount(new LoginAuthIdentityRequest
+{
+    UserNameOrEmail = "admin",
+    Password = "Pass123$"
+});
+```
+
+## 7. Chiamare Endpoint Protetti
+
+Una volta autenticato, lo stesso client puo chiamare gli endpoint ChillSharp protetti.
+
+```csharp
+using ChillSharp.Client.Dto;
+
+var query = new ChillDtoQuery
+{
+    ChillType = "Query.BlogQuery"
+};
+query.ResultProperties = ChillDtoProperty.Build("Guid", "Name");
+
+var result = client.Query(query);
+Console.WriteLine(result.Results.Count);
+```
+
+## 8. Lasciare Che Il Client Rinnovi I Token Automaticamente
+
+Non devi allegare manualmente il bearer token a ogni richiesta. Se il client ha gia un refresh token, le chiamate autenticate rinnovano l'access token quando serve.
+
+```csharp
+var roles = client.GetAuthRoles();
+```
+
+Puoi anche fare refresh esplicito:
+
+```csharp
+var refreshed = client.RefreshAuthAccount();
+```
+
+## Note
+
+- Usa `options.ProtectedApi = true` su `AddChillApi<TContext>(...)` se gli endpoint ChillSharp devono richiedere autenticazione.
+- L'utente root creato da `AddChillAuthIdentityApi(...)` e il percorso bootstrap amministrativo. Quando `CreateChillAuthUserForRoot = true`, il relativo `AuthUser` ChillSharp viene creato con `CanManagePermissions = true`.
+- `CreateChillAuthUser = true` crea l'`AuthUser` ChillSharp collegato, ma non concede automaticamente permessi amministrativi.
+- `DisplayCultureName` in registrazione preimposta `DisplayTimeZone`, `DisplayDateFormat` e `DisplayNumberFormat` per il relativo `AuthUser`.
+- In produzione, inizializza il primo amministratore in modo deliberato, ad esempio con root-user initialization o un flusso trusted in fase di installazione.
+
+Esempio successivo: [Creare un'immagine Docker e configurarla con variabili d'ambiente](05-docker-env-variables.md)

package/doc/it/HowTo/04-blog-posts-one-to-many.md

@@ -0,0 +1,193 @@
+# HOW-TO: Gestire Una Relazione Blog-Posts Uno-a-Molti
+
+Versione originale in inglese: [English](../../HowTo/04-blog-posts-one-to-many.md)
+
+Questo esempio estende il modello blog con i post e mostra come caricare un blog insieme ai suoi post in una singola chiamata `ChillSharpClient.Query(...)`.
+
+## Obiettivo
+
+Modellare una relazione uno-a-molti `Blog` -> `Posts` e proiettare la collezione annidata dal client ChillSharp.
+
+## 1. Definire Le Entita
+
+```csharp
+using ChillSharp.Annotations;
+using ChillSharp.EF;
+using System.ComponentModel.DataAnnotations;
+
+namespace MyBlogApp.Model;
+
+[ChillEntity]
+public class Blog : ChillEntity
+{
+    [Key]
+    public override Guid Guid { get; set; }
+
+    [ChillProperty]
+    public string Name { get; set; } = string.Empty;
+
+    [ChillProperty]
+    public string? Url { get; set; }
+
+    [ChillProperty]
+    public ICollection<Post>? Posts { get; set; }
+
+    public override string GetLabel(IChillContext context) => Name;
+}
+
+[ChillEntity]
+public class Post : ChillEntity
+{
+    [Key]
+    public override Guid Guid { get; set; }
+
+    [ChillProperty]
+    public Blog? Blog { get; set; }
+
+    [ChillProperty]
+    public DateTime? CreatedAt { get; set; }
+
+    [ChillProperty]
+    public string Title { get; set; } = string.Empty;
+
+    [ChillProperty]
+    public string Content { get; set; } = string.Empty;
+
+    public override void OnCreate(IChillContext context)
+    {
+        base.OnCreate(context);
+        CreatedAt = DateTime.UtcNow;
+    }
+
+    public override string GetLabel(IChillContext context) => Title;
+}
+```
+
+## 2. Aggiungere Entrambi I Set Al Contesto
+
+```csharp
+using Microsoft.EntityFrameworkCore;
+using MyBlogApp.Model;
+
+namespace MyBlogApp;
+
+public class BloggingContext : DbContext, IChillContext
+{
+    public DbSet<Blog> Blogs => Set<Blog>();
+    public DbSet<Post> Posts => Set<Post>();
+
+    public BloggingContext(DbContextOptions<BloggingContext> options) : base(options)
+    {
+    }
+
+    public string GetChillTypePrefix() => "MyBlogApp";
+}
+```
+
+## 3. Definire Una Query Per I Blog
+
+```csharp
+using ChillSharp.Annotations;
+using ChillSharp.EF;
+
+namespace MyBlogApp.Query;
+
+[ChillEntity]
+public class BlogQuery : ChillQuery
+{
+    [ChillProperty]
+    public string? Name { get; set; }
+
+    public override IQueryable<IChillEntity> OnQuery(IChillContext context)
+    {
+        var db = (BloggingContext)context;
+        var query = db.Blogs.AsQueryable();
+
+        if (Guid.HasValue)
+            query = query.Where(x => x.Guid == Guid.Value);
+
+        if (!string.IsNullOrWhiteSpace(Name))
+            query = query.Where(x => x.Name.Contains(Name));
+
+        return query;
+    }
+}
+```
+
+## 4. Creare Un Blog E Due Post
+
+La relazione viene creata inviando il DTO padre `Blog` come proprieta `Blog` di ogni `Post`.
+
+```csharp
+using ChillSharp.Client;
+using ChillSharp.Client.Dto;
+
+var client = new ChillSharpClient("http://localhost:5000/api/chill");
+
+var blog = new ChillDtoEntity
+{
+    ChillType = "Model.Blog",
+    Guid = Guid.NewGuid()
+};
+blog.Properties["Name"] = "ChillSharp Blog";
+blog.Properties["Url"] = "https://example.local/chillsharp-blog";
+
+var createdBlog = client.Create(blog);
+
+var firstPost = new ChillDtoEntity
+{
+    ChillType = "Model.Post",
+    Guid = Guid.NewGuid()
+};
+firstPost.Properties["Title"] = "First post";
+firstPost.Properties["Content"] = "Hello from ChillSharp";
+firstPost.Properties["Blog"] = createdBlog.Mock();
+client.Create(firstPost);
+
+var secondPost = new ChillDtoEntity
+{
+    ChillType = "Model.Post",
+    Guid = Guid.NewGuid()
+};
+secondPost.Properties["Title"] = "Second post";
+secondPost.Properties["Content"] = "Nested queries are handy";
+secondPost.Properties["Blog"] = createdBlog.Mock();
+client.Create(secondPost);
+```
+
+## 5. Caricare Un Blog Con I Suoi Post In Una Chiamata
+
+Questa e la parte piu importante per una relazione uno-a-molti: la proiezione annidata viene descritta tramite `ChillDtoProperty.With(...)`, e la collezione restituita viene letta con `GetCollection(...)`.
+
+```csharp
+using ChillSharp.Client.Dto;
+
+var query = new ChillDtoQuery
+{
+    ChillType = "Query.BlogQuery"
+};
+query.Properties["Guid"] = createdBlog.Guid;
+query.ResultProperties = ChillDtoProperty.Build(
+    "Guid",
+    "Name",
+    "Url",
+    ChillDtoProperty.With("Posts", "Guid", "Title", "CreatedAt"));
+
+var queryResult = client.Query(query);
+var loadedBlog = queryResult.Results.Single();
+
+Console.WriteLine(loadedBlog.GetString("Name"));
+
+foreach (var post in loadedBlog.GetCollection("Posts"))
+{
+    Console.WriteLine(post.GetString("Title"));
+}
+```
+
+## Cosa Ti Da Questo
+
+- una chiamata HTTP per caricare l'entita padre e la collezione figlia
+- un builder di proiezione fortemente tipizzato lato client
+- gestione della relazione tramite DTO senza scrivere un controller dedicato per `Blog` o `Post`
+
+Prossimo: [Torna all'indice della documentazione](../README.md)