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

Supongamos que necesitamos crear varios clientes en nuestra base de datos. Habitualmente se crearán de a uno, pero ¿Cómo podríamos crear varias y ver si el estado de creación de cada uno? Esto es lo que veremos 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 este demo vamos a utilizar .Net 6 y Visual Studio 2022. Abriremos Visual Studio y creamos un proyecto Web Api con soporte Minimal API. Implementaremos un caso de uso el cual no permitirá crear varios clientes en nuestra base de datos, además, de poder procesar de a un cliente.

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

Lo siguiente es limpiar todo lo que tenga que ver con la plantilla, lo que está relacionado con WheatherForecast quedando así:

Para poder hacer una implementación simple vamos a agregar el paquete Microsoft.EntityFrameworkCore.InMemory. Guardaremos los datos en memoria.

Ahora vamos a crear un contexto para nuestra base de datos que tendrá la implementación de nuestra entidad Customers. Crearemos una carpeta en el proyecto que llamaremos Data y dentro crearemos la siguiente clase ProyectoDBContext. Dentro 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()
            );
        }
    }
}

Lo siguiente, registramos el contexto en memoria dentro de nuestros Program.cs.

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

Es momento de crear nuestros modelos. Los crearemos dentro de nuestra carpeta Data. Tendremos: Customer Request, que será el encargado de recibir el post, Customer que será nuestra entidad almacenada, para cada estado de la solicitud tendremos MultipleCustomerBase, por último, MultipleCustomers y MultipleCustomerError heredadas 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 vamos a implementar nuestro servicio, primero declaremos la interface:

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 creado en caso de éxito, y si hay algún error, creamos el registro MultipleCustomersError, siempre contendrá el estado 500 con error al crear un mensaje de recurso sobre todos los errores.

Lo siguiente es ir al nuestr program.cs y agregar 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 nuestra configuración de la base de datos, pusimos como requerido el apellido o surname. Esto quiere decir que el segundo devolver un error. El Resultado de la llamada será la 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

Con este ejemplo podemos ver que un post puede guardar más de una entidad y devolver a su vez los mensajes de estado para cada una de las entidades. En próximos posts veremos más en detalle algunos temas de Minimal API.