@chill-sharp/ui-core 1.1.12 → 1.1.15

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

@@ -1,152 +0,0 @@
-# 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

@@ -1,139 +0,0 @@
-# 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

@@ -1,221 +0,0 @@
-# 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

@@ -1,193 +0,0 @@
-# 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)