Creación de multiple registros en ASP.Net con Minimal API

Supongamos que necesitamos generar múltiples clientes en nuestra base de datos. Por lo general, se crearán individualmente, pero ¿Cómo podríamos generar varios y verificar el estado de creación de cada uno? Esto es lo que explicaremos en este post.

Una pregunta que surge es, si no puedo crear uno de los recursos ¿Debe fallar todo el proceso? no necesariamente, podemos devolver el estado de cada una de las entidades o recursos estamos creando.

Demo

Para esta demostración, emplearemos .Net 6 y Visual Studio 2022. Abriremos Visual Studio y crearemos un proyecto de Web API con soporte para Minimal API. Implementaremos un escenario de uso que no permitirá la creación de varios clientes en nuestra base de datos, además de posibilitar el procesamiento individual de un cliente.

En la pantalla siguiente, debemos desactivar la opción “Usar controladores…” y seleccionar “Habilitar compatibilidad con OpenAPI”.

A continuación, procederemos a eliminar todo lo asociado a la plantilla, en particular lo vinculado a WheatherForecast, dejándolo de la siguiente forma:

Para lograr una implementación simple, incorporaremos el paquete Microsoft.EntityFrameworkCore.InMemory. La información se guardará en la memoria.

Ahora procederemos a crear un contexto para nuestra base de datos que contendrá la implementación de nuestra entidad Customers. Crearemos una carpeta en el proyecto denominada Data y en su interior, crearemos la siguiente clase ProyectoDBContext. A continuación, la completamos con el siguiente código.

using Microsoft.EntityFrameworkCore;

namespace WebApplication1.Data
{
    public class ProyectoDBContext : DbContext
    {
        public DbSet<Customer> Customer { get; set; }

        public ProyectoDBContext(DbContextOptions<ProyectoDBContext> options)
            : base(options)
        { }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Customer>(entity =>
                entity.Property(p => p.Surname).IsRequired()
            );
        }
    }
}

Luego, procedemos a registrar el contexto en memoria dentro de nuestro Program.cs.

builder.Services.AddDbContext<ProyectoDBContext>(opt => opt.UseInMemoryDatabase("proyecto"));

Ahora toca crear nuestros modelos. Los situaremos en la carpeta Data. Incluiremos: Customer Request, responsable de recibir el post, Customer que será nuestra entidad almacenada, para cada estado de la solicitud tendremos MultipleCustomerBase, y por último, MultipleCustomers y MultipleCustomerError que heredarán del anterior.

public record CustomerRequest(string Name, string Surname);

public record Cutomer(int Id, string Name, string Surname);

public record(string Status);

public record MultipleCustomersErrorl(string Status, string Message): MultipleBooksBase(Status);

public record MultipleCustomers(string Status, Cutomer Message) : MultipleBooksBase(Status);

Ahora, iniciaremos la implementación de nuestro servicio; primero, declaramos la interfaz:

public interface ICustomerService
{
    IEnumerable<MultipleCustomersBase> CreateCustomers(IEnumerable<CustomerRequest> customerRequest);
}

Ahora implementaremos nuestra interface:

public class CustomerService : ICustomerService
{
    private readonly ProyectoDBContext_context;

    public ProyectoDBContext (ProyectoDBContext  context)
    {
        _context = context;
    }
    public IEnumerable<MultipleCustomersBase> CreateBooks(IEnumerable<CustomerRequest> customerRequests)
    {
        var customers = new List<customerRequest>();

        foreach (var customerRequest in customerRequests)
        {
            try
            {
                var customer = _context.Add(new Cutomer(0, customerRequest .Name,  string Surname));
                _context.SaveChanges();
                customers .Add(new MultipleCustomers("201", customer.Entity));
            }
            catch (Exception)
            {
                books.Add(new MultipleCustomersError("500", "Error al crear el recurso"));
                _context.ChangeTracker.Clear();
            }
        }
        return customers;
    }
}

En la implementación del método CreateCustomers, creamos el registro MultipleCustomers con el estado 201 en caso de éxito, y si hay algún error, creamos el registro MultipleCustomersError, que siempre contendrá el estado 500 con un mensaje de error al crear un recurso sobre todos los errores.

A continuación, vamos a nuestro program.cs y añadimos nuestro servicio:

builder.Services.AddScoped<ICustomerService, CustomerService>();

Para correr el servicio, podemos usar PostMan enviando el siguiente mensaje:

[
    {
        "name":"Homero",
        "surname":"Simpsons"
    },
    {
        "name":"Bart"
    },
    {
        "name":"Lisa",
        "surname":"Simpsons"
    }
]

En la configuración de nuestra base de datos, establecimos que el apellido o surname es necesario. Esto significa que el segundo devolverá un error. El resultado de la llamada será el siguiente:

[
    {
        "message": {
            "id": 1,
            "name":"Homero",
            "surname":"Simpsons"
        },
        "status": "201"
    },
    {
        "message": "Error al crear el recurso",
        "status": "500"
    },
    {
        "message": {
            "id": 3,
            "  "name":"Lisa",
            "surname":"Simpsons"
        },
        "status": "201"
    }
]

Conclusiones

En este ejemplo, se evidencia que un post tiene la capacidad de almacenar más de una entidad y proporcionar mensajes de estado para cada una de ellas. En publicaciones futuras, profundizaremos en algunos temas de Minimal API.