AJout des DTO et endpoint sur le nouveau git

PyroFetes/Endpoints/Brand/CreateBrandEndpoint.cs

@@ -0,0 +1,35 @@
+using API.DTO.Brand.Request;
+using API.DTO.Brand.Response;
+using FastEndpoints;
+
+namespace PyroFetes.Endpoints.Brand;
+
+public class CreateBrandEndpoint(PyroFetesDbContext pyrofetesdbcontext) : Endpoint<CreateBrandDto, GetBrandDto>
+{
+    public override void Configure()
+    {
+        Post("/api/brands");
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(CreateBrandDto req, CancellationToken ct)
+    {
+        
+        Models.Brand brand = new ()
+        {
+            Name = req.Name
+        };
+        
+        pyrofetesdbcontext.Brands.Add(brand);
+        await pyrofetesdbcontext.SaveChangesAsync(ct);
+        
+        Console.WriteLine("Marque créé avec succès !");
+
+        GetBrandDto responseDto = new ()
+        {
+            Name = req.Name
+        };
+
+        await Send.OkAsync(responseDto, ct);
+    }
+}

PyroFetes/Endpoints/Brand/DeleteBrandEndpoint.cs

@@ -0,0 +1,38 @@
+using FastEndpoints;
+using Microsoft.EntityFrameworkCore;
+
+namespace PyroFetes.Endpoints.Brand;
+
+public class DeleteBrandRequest
+{
+    public int Id { get; set; }
+}
+
+public class DeleteBrandEndpoint(PyroFetesDbContext pyrofetesdbcontext) : Endpoint<DeleteBrandRequest>
+{
+    public override void Configure()
+    {
+        Delete("/api/brands/{@id}", x => new { x.Id });
+        AllowAnonymous();
+    }
+    
+    public override async Task HandleAsync(DeleteBrandRequest req, CancellationToken ct)
+    {
+        
+        Models.Brand? brandToDelete = await pyrofetesdbcontext
+            .Brands
+            .SingleOrDefaultAsync(a => a.Id == req.Id, cancellationToken: ct);
+
+        if (brandToDelete == null)
+        {
+            Console.WriteLine($"Aucune marque avec l'ID {req.Id} trouvé.");
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+
+        pyrofetesdbcontext.Brands.Remove(brandToDelete);
+        await pyrofetesdbcontext.SaveChangesAsync(ct);
+
+        await Send.NoContentAsync(ct);
+    }
+}

PyroFetes/Endpoints/Brand/GetAllBrandsEndpoint.cs

@@ -0,0 +1,28 @@
+using API.DTO.Brand.Response;
+using FastEndpoints;
+using Microsoft.EntityFrameworkCore;
+
+namespace PyroFetes.Endpoints.Brand;
+
+public class GetAllBrandsEndpoint(PyroFetesDbContext pyrofetesdbcontext) : EndpointWithoutRequest<List<GetBrandDto>>
+{
+    public override void Configure()
+    {
+        Get("/api/brands");
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(CancellationToken ct)
+    {
+        
+        List<GetBrandDto> responseDto = await pyrofetesdbcontext.Brands
+            .Select(a => new GetBrandDto
+                {
+                    Id = a.Id,
+                    Name = a.Name,
+                }
+            ).ToListAsync(ct);
+
+        await Send.OkAsync(responseDto, ct);
+    }
+}

PyroFetes/Endpoints/Brand/GetBrandEndpoint.cs

@@ -0,0 +1,42 @@
+using API.DTO.Brand.Response;
+using FastEndpoints;
+using Microsoft.EntityFrameworkCore;
+
+namespace PyroFetes.Endpoints.Brand;
+
+public class GetBrandRequest
+{
+    public int Id { get; set; }
+}
+
+public class GetBrandEndpoint(PyroFetesDbContext pyrofetesdbcontext) :Endpoint<GetBrandRequest, GetBrandDto>
+{
+    public override void Configure()
+    {
+        Get("/api/brands/{@id}", x => new { x.Id });
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(GetBrandRequest req, CancellationToken ct)
+    {
+        
+        Models.Brand? brand = await pyrofetesdbcontext
+            .Brands
+            .SingleOrDefaultAsync(a => a.Id == req.Id, cancellationToken: ct);
+
+        if (brand == null)
+        {
+            Console.WriteLine($"Aucune marque avec l'ID {req.Id} trouvé.");
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+
+        GetBrandDto responseDto = new()
+        {
+            Id = req.Id, 
+            Name = brand.Name
+        };
+
+        await Send.OkAsync(responseDto, ct);
+    }
+}

PyroFetes/Endpoints/Brand/UpdateBrandEndpoint.cs

@@ -0,0 +1,34 @@
+using API.DTO.Brand.Request;
+using API.DTO.Brand.Response;
+using FastEndpoints;
+
+namespace PyroFetes.Endpoints.Brand;
+
+public class UpdateBrandEndpoint(PyroFetesDbContext pyrofetesdbcontext) : Endpoint<UpdateBrandDto, GetBrandDto>
+{
+    public override void Configure()
+    {
+        Post("/api/brands");
+        AllowAnonymous();
+    }
+    
+    public override async Task HandleAsync(UpdateBrandDto req, CancellationToken ct)
+    {
+        
+        Models.Brand brand = new()
+        {
+            Name = req.Name
+        };
+        pyrofetesdbcontext.Add(brand);
+        await pyrofetesdbcontext.SaveChangesAsync(ct);
+
+        GetBrandDto response = new()
+        {
+            Id = req.Id,
+            Name = req.Name
+        };
+
+        await Send.OkAsync(response, ct);
+
+    }
+}

PyroFetes/Endpoints/Classification/CreateClassificationEndpoint.cs

@@ -0,0 +1,35 @@
+using API.DTO.Classification.Request;
+using API.DTO.Classification.Response;
+using FastEndpoints;
+
+namespace PyroFetes.Endpoints.Classification;
+
+public class CreateClassificationEndpoint(PyroFetesDbContext pyrofetesdbcontext) : Endpoint<CreateClassificationDto, GetClassificationDto>
+{
+    public override void Configure()
+    {
+        Post("/api/classifications");
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(CreateClassificationDto req, CancellationToken ct)
+    {
+        
+        Models.Classification classification = new ()
+        {
+            Label = req.Label
+        };
+        
+        pyrofetesdbcontext.Classifications.Add(classification);
+        await pyrofetesdbcontext.SaveChangesAsync(ct);
+        
+        Console.WriteLine("Classification créée avec succès !");
+
+        GetClassificationDto responseDto = new ()
+        {
+            Label = req.Label
+        };
+
+        await Send.OkAsync(responseDto, ct);
+    }
+}

PyroFetes/Endpoints/Classification/DeleteClassificationEndpoint.cs

@@ -0,0 +1,38 @@
+using FastEndpoints;
+using Microsoft.EntityFrameworkCore;
+
+namespace PyroFetes.Endpoints.Classification;
+
+public class DeleteClassificationRequest
+{
+    public int Id { get; set; }
+}
+
+public class DeleteClassificationEndpoint(PyroFetesDbContext libraryDbContext) : Endpoint<DeleteClassificationRequest>
+{
+    public override void Configure()
+    {
+        Delete("/api/classifications/{@id}", x => new { x.Id });
+        AllowAnonymous();
+    }
+    
+    public override async Task HandleAsync(DeleteClassificationRequest req, CancellationToken ct)
+    {
+        
+        Models.Classification? classificationToDelete = await libraryDbContext
+            .Classifications
+            .SingleOrDefaultAsync(a => a.Id == req.Id, cancellationToken: ct);
+
+        if (classificationToDelete == null)
+        {
+            Console.WriteLine($"Aucune classification avec l'ID {req.Id} trouvé.");
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+
+        libraryDbContext.Classifications.Remove(classificationToDelete);
+        await libraryDbContext.SaveChangesAsync(ct);
+
+        await Send.NoContentAsync(ct);
+    }
+}

PyroFetes/Endpoints/Classification/GetAllClassificationsEndpoint.cs

@@ -0,0 +1,28 @@
+using API.DTO.Classification.Response;
+using FastEndpoints;
+using Microsoft.EntityFrameworkCore;
+
+namespace PyroFetes.Endpoints.Classification;
+
+public class GetAllClassificationsEndpoint(PyroFetesDbContext pyrofetesdbcontext) : EndpointWithoutRequest<List<GetClassificationDto>>
+{
+    public override void Configure()
+    {
+        Get("/api/classifications");
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(CancellationToken ct)
+    {
+        
+        List<GetClassificationDto> responseDto = await pyrofetesdbcontext.Classifications
+            .Select(a => new GetClassificationDto
+                {
+                    Id = a.Id,
+                    Label = a.Label,
+                }
+            ).ToListAsync(ct);
+
+        await Send.OkAsync(responseDto, ct);
+    }
+}

PyroFetes/Endpoints/Classification/GetClassificationEndpoint.cs

@@ -0,0 +1,42 @@
+using API.DTO.Classification.Response;
+using FastEndpoints;
+using Microsoft.EntityFrameworkCore;
+
+namespace PyroFetes.Endpoints.Classification;
+
+public class GetClassificationRequest
+{
+    public int Id { get; set; }
+}
+
+public class GetClassificationEndpoint(PyroFetesDbContext pyrofetesdbcontext) :Endpoint<GetClassificationRequest, GetClassificationDto>
+{
+    public override void Configure()
+    {
+        Get("/api/classifications/{@id}", x => new { x.Id });
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(GetClassificationRequest req, CancellationToken ct)
+    {
+        
+        Models.Classification? classification = await pyrofetesdbcontext
+            .Classifications
+            .SingleOrDefaultAsync(a => a.Id == req.Id, cancellationToken: ct);
+
+        if (classification == null)
+        {
+            Console.WriteLine($"Aucune classification avec l'ID {req.Id} trouvé.");
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+
+        GetClassificationDto responseDto = new()
+        {
+            Id = req.Id, 
+            Label = classification.Label
+        };
+
+        await Send.OkAsync(responseDto, ct);
+    }
+}

PyroFetes/Endpoints/Classification/UpdateClassificationEndpoint.cs

@@ -0,0 +1,34 @@
+using API.DTO.Classification.Request;
+using API.DTO.Classification.Response;
+using FastEndpoints;
+
+namespace PyroFetes.Endpoints.Classification;
+
+public class UpdateClassificationEndpoint(PyroFetesDbContext pyrofetesdbcontext) : Endpoint<UpdateClassificationDto, GetClassificationDto>
+{
+    public override void Configure()
+    {
+        Post("/api/classifications");
+        AllowAnonymous();
+    }
+    
+    public override async Task HandleAsync(UpdateClassificationDto req, CancellationToken ct)
+    {
+        
+        Models.Classification classification = new()
+        {
+            Label = req.Label
+        };
+        pyrofetesdbcontext.Add(classification);
+        await pyrofetesdbcontext.SaveChangesAsync(ct);
+
+        GetClassificationDto response = new()
+        {
+            Id = req.Id,
+            Label = req.Label
+        };
+
+        await Send.OkAsync(response, ct);
+
+    }
+}

PyroFetes/Endpoints/Movement/CreateMovementEndpoint.cs

@@ -0,0 +1,41 @@
+using API.DTO.Movement.Request;
+using API.DTO.Movement.Response;
+using FastEndpoints;
+
+namespace PyroFetes.Endpoints.Movement;
+
+public class CreateMovementEndpoint(PyroFetesDbContext pyrofetesdbcontext) : Endpoint<CreateMovementDto, GetMovementDto>
+{
+    public override void Configure()
+    {
+        Post("/api/movements");
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(CreateMovementDto req, CancellationToken ct)
+    {
+        
+        Models.Movement movement = new ()
+        {
+            Date = req.Date,
+            Start = req.Start,
+            Arrival = req.Arrival,
+            Quantity = req.Quantity
+        };
+        
+        pyrofetesdbcontext.Movements.Add(movement);
+        await pyrofetesdbcontext.SaveChangesAsync(ct);
+        
+        Console.WriteLine("Movement créée avec succès !");
+
+        GetMovementDto responseDto = new ()
+        {
+            Date = req.Date,
+            Start = req.Start,
+            Arrival = req.Arrival,
+            Quantity = req.Quantity
+        };
+
+        await Send.OkAsync(responseDto, ct);
+    }
+}

PyroFetes/Endpoints/Movement/DeleteMovementEndpoint.cs

@@ -0,0 +1,38 @@
+using FastEndpoints;
+using Microsoft.EntityFrameworkCore;
+
+namespace PyroFetes.Endpoints.Movement;
+
+public class DeleteMovementRequest
+{
+    public int  Id  { get; set; }
+}
+
+public class DeleteMovementEndpoint(PyroFetesDbContext pyrofetesdbcontext) : Endpoint<DeleteMovementRequest>
+{
+    public override void Configure()
+    {
+        Delete("/api/Movements/{@id}", x => new { x.Id });
+        AllowAnonymous();
+    }
+    
+    public override async Task HandleAsync(DeleteMovementRequest req, CancellationToken ct)
+    {
+        
+        Models.Movement? movementToDelete = await pyrofetesdbcontext
+            .Movements
+            .SingleOrDefaultAsync(a => a.Id == req.Id, cancellationToken: ct);
+
+        if (movementToDelete == null)
+        {
+            Console.WriteLine($"Aucune mouvement avec l'ID {req.Id} trouvé.");
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+
+        pyrofetesdbcontext.Movements.Remove(movementToDelete);
+        await pyrofetesdbcontext.SaveChangesAsync(ct);
+
+        await Send.NoContentAsync(ct);
+    }
+}

PyroFetes/Endpoints/Movement/GetAllMovementsEndpoint.cs

@@ -0,0 +1,31 @@
+using API.DTO.Movement.Response;
+using FastEndpoints;
+using Microsoft.EntityFrameworkCore;
+
+namespace PyroFetes.Endpoints.Movement;
+
+public class GetAllMovementsEndpoint(PyroFetesDbContext pyrofetesdbcontext) : EndpointWithoutRequest<List<GetMovementDto>>
+{
+    public override void Configure()
+    {
+        Get("/api/movements");
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(CancellationToken ct)
+    {
+        
+        List<GetMovementDto> responseDto = await pyrofetesdbcontext.Movements
+            .Select(a => new GetMovementDto
+                {
+                    Id = a.Id,
+                    Date = a.Date,
+                    Start = a.Start,
+                    Arrival = a.Arrival,
+                    Quantity = a.Quantity
+                }
+            ).ToListAsync(ct);
+
+        await Send.OkAsync(responseDto, ct);
+    }
+}

PyroFetes/Endpoints/Movement/GetMovementEndpoint.cs

@@ -0,0 +1,45 @@
+using API.DTO.Movement.Response;
+using FastEndpoints;
+using Microsoft.EntityFrameworkCore;
+
+namespace PyroFetes.Endpoints.Movement;
+
+public class GetMovementRequest
+{
+    public int Id { get; set; }
+}
+
+public class GetMovementEndpoint(PyroFetesDbContext pyrofetesdbcontext) :Endpoint<GetMovementRequest, GetMovementDto>
+{
+    public override void Configure()
+    {
+        Get("/api/movements/{@id}", x => new { x.Id });
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(GetMovementRequest req, CancellationToken ct)
+    {
+        
+        Models.Movement? movement = await pyrofetesdbcontext
+            .Movements
+            .SingleOrDefaultAsync(a => a.Id == req.Id, cancellationToken: ct);
+
+        if (movement == null)
+        {
+            Console.WriteLine($"Aucun mouvement avec l'ID {req.Id} trouvé.");
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+
+        GetMovementDto responseDto = new()
+        {
+            Id = req.Id, 
+            Date = movement.Date,
+            Start = movement.Start,
+            Arrival = movement.Arrival,
+            Quantity = movement.Quantity
+        };
+
+        await Send.OkAsync(responseDto, ct);
+    }
+}

PyroFetes/Endpoints/Movement/UpdateMovementEndpoint.cs

@@ -0,0 +1,40 @@
+using API.DTO.Movement.Request;
+using API.DTO.Movement.Response;
+using FastEndpoints;
+
+namespace PyroFetes.Endpoints.Movement;
+
+public class UpdateMovementEndpoint(PyroFetesDbContext pyrofetesdbcontext) : Endpoint<UpdateMovementDto, GetMovementDto>
+{
+    public override void Configure()
+    {
+        Post("/api/movements");
+        AllowAnonymous();
+    }
+    
+    public override async Task HandleAsync(UpdateMovementDto req, CancellationToken ct)
+    {
+        
+        Models.Movement movement = new()
+        {
+            Date = req.Date,
+            Start = req.Start,
+            Arrival = req.Arrival,
+            Quantity = req.Quantity
+        };
+        pyrofetesdbcontext.Add(movement);
+        await pyrofetesdbcontext.SaveChangesAsync(ct);
+
+        GetMovementDto response = new()
+        {
+            Id = req.Id,
+            Date = req.Date,
+            Start = req.Start,
+            Arrival = req.Arrival,
+            Quantity = req.Quantity
+        };
+
+        await Send.OkAsync(response, ct);
+
+    }
+}

PyroFetes/Endpoints/Product/CreateProductEndpoint.cs

@@ -0,0 +1,57 @@
+using API.DTO.Product.Request;
+using API.DTO.Product.Response;
+using FastEndpoints;
+
+namespace PyroFetes.Endpoints.Product;
+
+public class CreateProductEndpoint(PyroFetesDbContext pyrofetesdbcontext) : Endpoint<CreateProductDto, GetProductDto>
+{
+    public override void Configure()
+    {
+        Post("/api/products");
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(CreateProductDto req, CancellationToken ct)
+    {
+        Models.Product product = new ()
+        {
+            References = req.References,
+            Name = req.Name!,
+            Duration = req.Duration,
+            Caliber = req.Caliber,
+            ApprovalNumber = req.ApprovalNumber,
+            Weight = req.Weight,
+            Nec = req.Nec,
+            SellingPrice = req.SellingPrice,
+            Image = req.Image!,
+            Link = req.Link!,
+            ProductCategoryId = req.ProductCategoryId,
+            ClassificationId = req.ClassificationId
+        };
+        
+        pyrofetesdbcontext.Products.Add(product);
+        await pyrofetesdbcontext.SaveChangesAsync(ct);
+        
+        Console.WriteLine("Product créé avec succès !");
+
+        GetProductDto responseDto = new ()
+        {
+            Id = product.Id,
+            Reference = req.References,
+            Name = req.Name,
+            Duration = req.Duration,
+            Caliber = req.Caliber,
+            ApprovalNumber = req.ApprovalNumber,
+            Weight = req.Weight,
+            Nec = req.Nec,
+            SellingPrice = req.SellingPrice,
+            Image = req.Image,
+            Link = req.Link,
+            ProductCategoryId = req.ProductCategoryId,
+            ClassificationId = req.ClassificationId
+        };
+
+        await Send.OkAsync(responseDto, ct);
+    }
+}

PyroFetes/Endpoints/Product/DeleteProductEndpoint.cs

@@ -0,0 +1,37 @@
+using FastEndpoints;
+using Microsoft.EntityFrameworkCore;
+
+namespace PyroFetes.Endpoints.Product;
+
+public class DeleteProductRequest
+{
+    public int Id { get; set; }
+}
+
+public class DeleteProductEndpoint(PyroFetesDbContext pyrofetesdbcontext) : Endpoint<DeleteProductRequest>
+{
+    public override void Configure()
+    {
+        Delete("/api/products/{@id}", x => new { x.Id });
+        AllowAnonymous();
+    }
+    
+    public override async Task HandleAsync(DeleteProductRequest req, CancellationToken ct)
+    {
+        Models.Product? productToDelete = await pyrofetesdbcontext
+            .Products
+            .SingleOrDefaultAsync(p => p.Id == req.Id, cancellationToken: ct);
+
+        if (productToDelete == null)
+        {
+            Console.WriteLine($"Aucun produit avec l'ID {req.Id} trouvé.");
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+
+        pyrofetesdbcontext.Products.Remove(productToDelete);
+        await pyrofetesdbcontext.SaveChangesAsync(ct);
+
+        await Send.NoContentAsync(ct);
+    }
+}

PyroFetes/Endpoints/Product/GetAllProductsEndpoint.cs

@@ -0,0 +1,40 @@
+using API.DTO.Product.Response;
+using FastEndpoints;
+using Microsoft.EntityFrameworkCore;
+
+namespace PyroFetes.Endpoints.Product;
+
+public class GetAllProductsEndpoint(PyroFetesDbContext pyrofetesdbcontext) : EndpointWithoutRequest<List<GetProductDto>>
+{
+    public override void Configure()
+    {
+        Get("/api/products");
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(CancellationToken ct)
+    {
+        List<GetProductDto> responseDto = await pyrofetesdbcontext.Products
+            .Select(p => new GetProductDto()
+                {
+                    Id = p.Id,
+                    Reference = p.References,
+                    Name = p.Name,
+                    Duration = p.Duration,
+                    Caliber = p.Caliber,
+                    ApprovalNumber = p.ApprovalNumber,
+                    Weight = p.Weight,
+                    Nec = p.Nec,
+                    SellingPrice = p.SellingPrice,
+                    Image = p.Image,
+                    Link = p.Link,
+                    ClassificationId = p.ClassificationId,
+                    ClassificationLabel = p.Classification!.Label,
+                    ProductCategoryId = p.ProductCategoryId,
+                    ProductCategoryLabel = p.ProductCategory!.Label,
+                }
+            ).ToListAsync(ct);
+
+        await Send.OkAsync(responseDto, ct);
+    }
+}

PyroFetes/Endpoints/Product/GetProductEndpoint.cs

@@ -0,0 +1,55 @@
+using API.DTO.Product.Response;
+using FastEndpoints;
+using Microsoft.EntityFrameworkCore;
+
+namespace PyroFetes.Endpoints.Product;
+
+public class GetProductRequest
+{
+    public int Id { get; set; }
+}
+
+
+public class GetProductEndpoint(PyroFetesDbContext pyrofetesdbcontext) :Endpoint<GetProductRequest, GetProductDto>
+{
+    public override void Configure()
+    {
+        Get("/api/product/{@id}", x => new { x.Id });
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(GetProductRequest req, CancellationToken ct)
+    {
+        Models.Product? product = await pyrofetesdbcontext
+            .Products.Include(product => product.Classification).Include(product => product.ProductCategory)
+            .SingleOrDefaultAsync(p => p.Id == req.Id, cancellationToken: ct);
+
+        if (product == null)
+        {
+            Console.WriteLine($"Aucun produit avec l'ID {req.Id} trouvé.");
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+
+        GetProductDto responseDto = new()
+        {
+            Id = product.Id,
+            Reference = product.References,
+            Name = product.Name,
+            Duration = product.Duration,
+            Caliber = product.Caliber,
+            ApprovalNumber = product.ApprovalNumber,
+            Weight = product.Weight,
+            Nec = product.Nec,
+            SellingPrice = product.SellingPrice,
+            Image = product.Image,
+            Link = product.Link,
+            ClassificationId = product.ClassificationId,
+            ClassificationLabel = product.Classification!.Label, 
+            ProductCategoryId = product.ProductCategoryId, 
+            ProductCategoryLabel = product.ProductCategory!.Label,
+        };
+
+        await Send.OkAsync(responseDto, ct);
+    }
+}

PyroFetes/Endpoints/Product/UpdateProductEndpoint.cs

@@ -0,0 +1,58 @@
+using API.DTO.Product.Request;
+using API.DTO.Product.Response;
+using FastEndpoints;
+using Microsoft.EntityFrameworkCore;
+
+namespace PyroFetes.Endpoints.Product;
+
+public class UpdateProductEndpoint(PyroFetesDbContext pyrofetesdbcontext) :Endpoint<UpdateProductDto, GetProductDto>
+{
+    public override void Configure()
+    {
+        Put("/api/products/{@id}", x => new { x.Id });
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(UpdateProductDto req, CancellationToken ct)
+    {
+        Models.Product? productToEdit = await pyrofetesdbcontext
+            .Products
+            .SingleOrDefaultAsync(p => p.Id == req.Id, cancellationToken: ct);
+
+        if (productToEdit == null)
+        {
+            Console.WriteLine($"Aucun produit avec l'ID {req.Id} trouvé.");
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+
+        productToEdit.References = req.Reference;
+        productToEdit.Name = req.Name;
+        productToEdit.Duration = req.Duration;
+        productToEdit.Caliber = req.Caliber;
+        productToEdit.ApprovalNumber = req.ApprovalNumber; 
+        productToEdit.Weight = req.Weight;
+        productToEdit.Nec = req.Nec;
+        productToEdit.SellingPrice = req.SellingPrice;
+        productToEdit.Image = req.Image;
+        productToEdit.Link = req.Link;
+        await pyrofetesdbcontext.SaveChangesAsync(ct);
+
+        GetProductDto responseDto = new()
+        {
+            Id = req.Id,
+            Reference = req.Reference,
+            Name = req.Name,
+            Duration = req.Duration,
+            Caliber = req.Caliber,
+            ApprovalNumber = req.ApprovalNumber,
+            Weight = req.Weight,
+            Nec = req.Nec,
+            SellingPrice = req.SellingPrice,
+            Image = req.Image,
+            Link = req.Link
+        };
+
+        await Send.OkAsync(responseDto, ct);
+    }
+}

PyroFetes/Endpoints/ProductCategory/CreateProductCategoryEndpoint.cs

@@ -0,0 +1,37 @@
+using API.DTO.ProductCategory.Request;
+using API.DTO.ProductCategory.Response;
+using FastEndpoints;
+
+namespace PyroFetes.Endpoints.ProductCategory;
+
+public class CreateProductCategoryEndpoint(PyroFetesDbContext pyrofetesdbcontext) : Endpoint<CreateProductCategoryDto, GetProductCategoryDto>
+{
+    public override void Configure()
+    {
+        Post("/api/productcategories");
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(CreateProductCategoryDto req, CancellationToken ct)
+    {
+        Models.ProductCategory productCategory = new ()
+        {
+            Label = req.Label,
+            
+        };
+        
+        pyrofetesdbcontext.ProductCategories.Add(productCategory);
+        await pyrofetesdbcontext.SaveChangesAsync(ct);
+        
+        Console.WriteLine("Category créé avec succès !");
+
+        GetProductCategoryDto responseDto = new ()
+        {
+            Id = productCategory.Id,
+            Label = productCategory.Label
+            
+        };
+
+        await Send.OkAsync(responseDto, ct);
+    }
+}

PyroFetes/Endpoints/ProductCategory/DeleteProductCategoryEndpoint.cs

@@ -0,0 +1,36 @@
+using FastEndpoints;
+using Microsoft.EntityFrameworkCore;
+
+namespace PyroFetes.Endpoints.ProductCategory;
+
+public class DeleteProductCategoryRequest
+{
+    public int Id { get; set; }
+}
+
+public class DeleteProductCategoryEndpoint(PyroFetesDbContext pyrofetesdbcontext) : Endpoint<DeleteProductCategoryRequest>
+{
+    public override void Configure()
+    {
+        Delete("/api/productcategories/{@id}", x => new { x.Id });
+        AllowAnonymous();
+    }
+    
+    public override async Task HandleAsync(DeleteProductCategoryRequest req, CancellationToken ct)
+    {
+        Models.ProductCategory? productCategoryToDelete = await pyrofetesdbcontext
+            .ProductCategories
+            .SingleOrDefaultAsync(pc => pc.Id == req.Id, cancellationToken: ct);
+
+        if (productCategoryToDelete == null)
+        {
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+
+        pyrofetesdbcontext.ProductCategories.Remove(productCategoryToDelete);
+        await pyrofetesdbcontext.SaveChangesAsync(ct);
+
+        await Send.NoContentAsync(ct);
+    }
+}

PyroFetes/Endpoints/ProductCategory/GetAllProductCategoriesEndpoint.cs

@@ -0,0 +1,27 @@
+using API.DTO.ProductCategory.Response;
+using FastEndpoints;
+using Microsoft.EntityFrameworkCore;
+
+namespace PyroFetes.Endpoints.ProductCategory;
+
+public class GetAllProductCategoriesEndpoint(PyroFetesDbContext pyrofetesdbcontext) : EndpointWithoutRequest<List<GetProductCategoryDto>>
+{
+    public override void Configure()
+    {
+        Get("/api/productcategories");
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(CancellationToken ct)
+    {
+        List<GetProductCategoryDto> responseDto = await pyrofetesdbcontext.ProductCategories
+            .Select(pc => new GetProductCategoryDto()
+                {
+                    Id = pc.Id,
+                    Label = pc.Label
+                }
+            ).ToListAsync(ct);
+
+        await Send.OkAsync(responseDto, ct);
+    }
+}

PyroFetes/Endpoints/ProductCategory/GetProductCategoryEndpoint.cs

@@ -0,0 +1,42 @@
+using API.DTO.ProductCategory.Response;
+using FastEndpoints;
+using Microsoft.EntityFrameworkCore;
+
+namespace PyroFetes.Endpoints.ProductCategory;
+
+public class GetProductCategoryRequest
+{
+    public int Id { get; set; }
+}
+
+
+public class GetProductCategoryEndpoint(PyroFetesDbContext pyrofetesdbcontext) :Endpoint<GetProductCategoryRequest, GetProductCategoryDto>
+{
+    public override void Configure()
+    {
+        Get("/api/productcategory/{@id}", x => new { x.Id });
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(GetProductCategoryRequest req, CancellationToken ct)
+    {
+        Models.ProductCategory? productCategory = await pyrofetesdbcontext
+            .ProductCategories
+            .SingleOrDefaultAsync(pc => pc.Id == req.Id, cancellationToken: ct);
+
+        if (productCategory == null)
+        {
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+
+        GetProductCategoryDto responseDto = new()
+        {
+            Id = productCategory.Id,
+            Label = productCategory.Label
+            
+        };
+
+        await Send.OkAsync(responseDto, ct);
+    }
+}

PyroFetes/Endpoints/ProductCategory/UpdateProductCategoryEndpoint.cs

@@ -0,0 +1,39 @@
+using API.DTO.ProductCategory.Request;
+using API.DTO.ProductCategory.Response;
+using FastEndpoints;
+using Microsoft.EntityFrameworkCore;
+
+namespace PyroFetes.Endpoints.ProductCategory;
+
+public class UpdateProductCategoryEndpoint(PyroFetesDbContext pyrofetesdbcontext) :Endpoint<UpdateProductCategoryDto, GetProductCategoryDto>
+{
+    public override void Configure()
+    {
+        Put("/api/productcategory/{@id}", x => new { x.Id });
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(UpdateProductCategoryDto req, CancellationToken ct)
+    {
+        Models.ProductCategory? productCategoryToEdit = await pyrofetesdbcontext
+            .ProductCategories
+            .SingleOrDefaultAsync(pc => pc.Id == req.Id, cancellationToken: ct);
+
+        if (productCategoryToEdit == null)
+        {
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+
+        productCategoryToEdit.Label = req.Label;
+        await pyrofetesdbcontext.SaveChangesAsync(ct);
+
+        GetProductCategoryDto responseDto = new()
+        {
+            Id = req.Id,
+            Label = req.Label,
+        };
+
+        await Send.OkAsync(responseDto, ct);
+    }
+}

PyroFetes/Endpoints/Supplier/CreateSupplierEndpoint.cs

@@ -0,0 +1,48 @@
+using API.DTO.Supplier.Request;
+using API.DTO.Supplier.Response;
+using FastEndpoints;
+
+namespace PyroFetes.Endpoints.Supplier;
+
+public class CreateSupplierEndpoint(PyroFetesDbContext pyrofetesdbcontext) : Endpoint<CreateSupplierDto, GetSupplierDto>
+{
+    public override void Configure()
+    {
+        Post("/api/suppliers");
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(CreateSupplierDto req, CancellationToken ct)
+    {
+        // Création d'un nouvel objet Supplier
+        Models.Supplier supplier = new()
+        {
+            Name = req.Name,
+            Email = req.Email,
+            Phone = req.PhoneNumber,
+            Address = req.Adress,
+            ZipCode = req.ZipCode,
+            City = req.City
+        };
+        
+        // Ajout à la base et sauvegarde
+        pyrofetesdbcontext.Suppliers.Add(supplier);
+        await pyrofetesdbcontext.SaveChangesAsync(ct);
+        
+        Console.WriteLine("Fournisseur créé avec succès !");
+
+        // Préparation de la réponse
+        GetSupplierDto responseDto = new()
+        {
+            Id = supplier.Id,
+            Name = supplier.Name,
+            Email = supplier.Email,
+            PhoneNumber = supplier.Phone,
+            Adress = supplier.Address,
+            ZipCode = supplier.ZipCode,
+            City = supplier.City
+        };
+
+        await Send.OkAsync(responseDto, ct);
+    }
+}

PyroFetes/Endpoints/Supplier/DeleteSupplierEndpoint.cs

@@ -0,0 +1,37 @@
+using FastEndpoints;
+using Microsoft.EntityFrameworkCore;
+
+namespace PyroFetes.Endpoints.Supplier;
+
+public class DeleteSupplierRequest
+{
+    public int Id { get; set; }
+}
+
+public class DeleteSupplierEndpoint(PyroFetesDbContext pyrofetesdbcontext) : Endpoint<DeleteSupplierRequest>
+{
+    public override void Configure()
+    {
+        Delete("/api/suppliers/{@id}", x => new { x.Id });
+        AllowAnonymous();
+    }
+    
+    public override async Task HandleAsync(DeleteSupplierRequest req, CancellationToken ct)
+    {
+        Models.Supplier? supplierToDelete = await pyrofetesdbcontext
+            .Suppliers
+            .SingleOrDefaultAsync(s => s.Id == req.Id, cancellationToken: ct);
+
+        if (supplierToDelete == null)
+        {
+            Console.WriteLine($"Aucun fournisseur avec l'ID {req.Id} trouvé.");
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+
+        pyrofetesdbcontext.Suppliers.Remove(supplierToDelete);
+        await pyrofetesdbcontext.SaveChangesAsync(ct);
+
+        await Send.NoContentAsync(ct);
+    }
+}

PyroFetes/Endpoints/Supplier/GetAllSupplierEndpoint.cs

@@ -0,0 +1,32 @@
+using API.DTO.Supplier.Response;
+using FastEndpoints;
+using Microsoft.EntityFrameworkCore;
+
+namespace PyroFetes.Endpoints.Supplier;
+
+public class GetAllSuppliersEndpoint(PyroFetesDbContext pyrofetesdbcontext) : EndpointWithoutRequest<List<GetSupplierDto>>
+{
+    public override void Configure()
+    {
+        Get("/api/suppliers");
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(CancellationToken ct)
+    {
+        List<GetSupplierDto> responseDto = await pyrofetesdbcontext.Suppliers
+            .Select(s => new GetSupplierDto
+            {
+                Id = s.Id,
+                Name = s.Name!,
+                Email = s.Email!,
+                PhoneNumber = s.Phone!,
+                Adress = s.Address!,
+                ZipCode = s.ZipCode,
+                City = s.City!
+            })
+            .ToListAsync(ct);
+
+        await Send.OkAsync(responseDto, ct);
+    }
+}

PyroFetes/Endpoints/Supplier/GetSupplierEndpoint.cs

@@ -0,0 +1,46 @@
+using API.DTO.Supplier.Response;
+using FastEndpoints;
+using Microsoft.EntityFrameworkCore;
+
+namespace PyroFetes.Endpoints.Supplier;
+
+public class GetSupplierRequest
+{
+    public int Id { get; set; }
+}
+
+public class GetSupplierEndpoint(PyroFetesDbContext pyrofetesdbcontext) : Endpoint<GetSupplierRequest, GetSupplierDto>
+{
+    public override void Configure()
+    {
+        Get("/api/suppliers/{@id}", x => new { x.Id });
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(GetSupplierRequest req, CancellationToken ct)
+    {
+        Models.Supplier? supplier = await pyrofetesdbcontext
+            .Suppliers
+            .SingleOrDefaultAsync(s => s.Id == req.Id, cancellationToken: ct);
+
+        if (supplier == null)
+        {
+            Console.WriteLine($"Aucun fournisseur avec l'ID {req.Id} trouvé.");
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+
+        GetSupplierDto responseDto = new()
+        {
+            Id = supplier.Id,
+            Name = supplier.Name!,
+            Email = supplier.Email!,
+            PhoneNumber = supplier.Phone!,
+            Adress = supplier.Address!,
+            ZipCode = supplier.ZipCode,
+            City = supplier.City!
+        };
+
+        await Send.OkAsync(responseDto, ct);
+    }
+}

PyroFetes/Endpoints/Supplier/UpdateSupplierEndpoint.cs

@@ -0,0 +1,52 @@
+using API.DTO.Supplier.Request;
+using API.DTO.Supplier.Response;
+using FastEndpoints;
+using Microsoft.EntityFrameworkCore;
+
+namespace PyroFetes.Endpoints.Supplier;
+
+public class UpdateSupplierEndpoint(PyroFetesDbContext pyrofetesdbcontext) : Endpoint<UpdateSupplierDto, GetSupplierDto>
+{
+    public override void Configure()
+    {
+        Put("/api/suppliers/{@id}", x => new { x.Id });
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(UpdateSupplierDto req, CancellationToken ct)
+    {
+        Models.Supplier? supplierToEdit = await pyrofetesdbcontext
+            .Suppliers
+            .SingleOrDefaultAsync(s => s.Id == req.Id, cancellationToken: ct);
+
+        if (supplierToEdit == null)
+        {
+            Console.WriteLine($"Aucun fournisseur avec l'ID {req.Id} trouvé.");
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+
+        // Mise à jour des propriétés
+        supplierToEdit.Name = req.Name;
+        supplierToEdit.Email = req.Email;
+        supplierToEdit.Phone = req.PhoneNumber;
+        supplierToEdit.Address = req.Adress;
+        supplierToEdit.ZipCode = req.ZipCode;
+        supplierToEdit.City = req.City;
+
+        await pyrofetesdbcontext.SaveChangesAsync(ct);
+
+        GetSupplierDto responseDto = new()
+        {
+            Id = supplierToEdit.Id,
+            Name = supplierToEdit.Name,
+            Email = supplierToEdit.Email,
+            PhoneNumber = supplierToEdit.Phone,
+            Adress = supplierToEdit.Address,
+            ZipCode = supplierToEdit.ZipCode,
+            City = supplierToEdit.City
+        };
+
+        await Send.OkAsync(responseDto, ct);
+    }
+}

PyroFetes/Endpoints/Warehouse/CreateWarehouseEndpoint.cs

@@ -0,0 +1,47 @@
+using API.DTO.Warehouse.Request;
+using API.DTO.Warehouse.Response;
+using FastEndpoints;
+
+namespace PyroFetes.Endpoints.Warehouse;
+
+public class CreateWarehouseEndpoint(PyroFetesDbContext pyrofetesdbcontext) : Endpoint<CreateWarehouseDto, GetWarehouseDto>
+{
+    public override void Configure()
+    {
+        Post("/api/warehouse");
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(CreateWarehouseDto req, CancellationToken ct)
+    {
+        Models.Warehouse warehouse = new()
+        {
+            Name = req.Name,
+            MaxWeight = req.MaxWeight,
+            Current = req.Current,
+            MinWeight = req.MinWeight,
+            Address = req.Adress,
+            ZipCode = req.ZipCode,
+            City = req.City
+        };
+        
+        pyrofetesdbcontext.Warehouses.Add(warehouse);
+        await pyrofetesdbcontext.SaveChangesAsync(ct);
+        
+        Console.WriteLine("Entrepôt créé avec succès !");
+
+        GetWarehouseDto responseDto = new()
+        {
+            Id = warehouse.Id,
+            Name = warehouse.Name,
+            MaxWeight = warehouse.MaxWeight,
+            Current = warehouse.Current,
+            MinWeight = warehouse.MinWeight,
+            Adress = warehouse.Address,
+            ZipCode = warehouse.ZipCode,
+            City = warehouse.City
+        };
+
+        await Send.OkAsync(responseDto, ct);
+    }
+}

PyroFetes/Endpoints/Warehouse/DeleteWarehouseEndpoint.cs

@@ -0,0 +1,37 @@
+using FastEndpoints;
+using Microsoft.EntityFrameworkCore;
+
+namespace PyroFetes.Endpoints.Warehouse;
+
+public class DeleteWarehouseRequest
+{
+    public int Id { get; set; }
+}
+
+public class DeleteWarehouseEndpoint(PyroFetesDbContext pyrofetesdbcontext) : Endpoint<DeleteWarehouseRequest>
+{
+    public override void Configure()
+    {
+        Delete("/api/warehouse/{@id}", x => new { x.Id });
+        AllowAnonymous();
+    }
+    
+    public override async Task HandleAsync(DeleteWarehouseRequest req, CancellationToken ct)
+    {
+        Models.Warehouse? warehouseToDelete = await pyrofetesdbcontext
+            .Warehouses
+            .SingleOrDefaultAsync(w => w.Id == req.Id, cancellationToken: ct);
+
+        if (warehouseToDelete == null)
+        {
+            Console.WriteLine($"Aucun entrepôt avec l'ID {req.Id} trouvé.");
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+
+        pyrofetesdbcontext.Warehouses.Remove(warehouseToDelete);
+        await pyrofetesdbcontext.SaveChangesAsync(ct);
+
+        await Send.NoContentAsync(ct);
+    }
+}

PyroFetes/Endpoints/Warehouse/GetAllWarehouseEndpoint.cs

@@ -0,0 +1,33 @@
+using API.DTO.Warehouse.Response;
+using FastEndpoints;
+using Microsoft.EntityFrameworkCore;
+
+namespace PyroFetes.Endpoints.Warehouse;
+
+public class GetAllWarehouseEndpoint(PyroFetesDbContext pyrofetesdbcontext) : EndpointWithoutRequest<List<GetWarehouseDto>>
+{
+    public override void Configure()
+    {
+        Get("/api/warehouses");
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(CancellationToken ct)
+    {
+        List<GetWarehouseDto> responseDto = await pyrofetesdbcontext.Warehouses
+            .Select(w => new GetWarehouseDto
+            {
+                Id = w.Id,
+                Name = w.Name,
+                MaxWeight = w.MaxWeight,
+                Current = w.Current,
+                MinWeight = w.MinWeight,
+                Adress = w.Address,
+                ZipCode = w.ZipCode,
+                City = w.City
+            })
+            .ToListAsync(ct);
+
+        await Send.OkAsync(responseDto, ct);
+    }
+}

PyroFetes/Endpoints/Warehouse/GetWarehouseEndpoint.cs

@@ -0,0 +1,47 @@
+using API.DTO.Warehouse.Response;
+using FastEndpoints;
+using Microsoft.EntityFrameworkCore;
+
+namespace PyroFetes.Endpoints.Warehouse;
+
+public class GetWarehouseRequest
+{
+    public int Id { get; set; }
+}
+
+public class GetWarehouseEndpoint(PyroFetesDbContext pyrofetesdbcontext) : Endpoint<GetWarehouseRequest, GetWarehouseDto>
+{
+    public override void Configure()
+    {
+        Get("/api/warehouses/{@id}", x => new { x.Id });
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(GetWarehouseRequest req, CancellationToken ct)
+    {
+        Models.Warehouse? warehouse = await pyrofetesdbcontext
+            .Warehouses
+            .SingleOrDefaultAsync(w => w.Id == req.Id, cancellationToken: ct);
+
+        if (warehouse == null)
+        {
+            Console.WriteLine($"Aucun entrepôt avec l'ID {req.Id} trouvé.");
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+
+        GetWarehouseDto responseDto = new()
+        {
+            Id = warehouse.Id,
+            Name = warehouse.Name!,
+            MaxWeight = warehouse.MaxWeight,
+            Current = warehouse.Current,
+            MinWeight = warehouse.MinWeight,
+            Adress = warehouse.Address!,
+            ZipCode = warehouse.ZipCode,
+            City = warehouse.City!
+        };
+
+        await Send.OkAsync(responseDto, ct);
+    }
+}

PyroFetes/Endpoints/Warehouse/UpdateWarehouseEndpoint.cs

@@ -0,0 +1,54 @@
+using API.DTO.Warehouse.Request;
+using API.DTO.Warehouse.Response;
+using FastEndpoints;
+using Microsoft.EntityFrameworkCore;
+
+namespace PyroFetes.Endpoints.Warehouse;
+
+public class UpdateWarehouseEndpoint(PyroFetesDbContext pyrofetesdbcontext) : Endpoint<UpdateWarehouseDto, GetWarehouseDto>
+{
+    public override void Configure()
+    {
+        Put("/api/warehouses/{@id}", x => new { x.Id });
+        AllowAnonymous();
+    }
+
+    public override async Task HandleAsync(UpdateWarehouseDto req, CancellationToken ct)
+    {
+        Models.Warehouse? warehouseToEdit = await pyrofetesdbcontext
+            .Warehouses
+            .SingleOrDefaultAsync(w => w.Id == req.Id, cancellationToken: ct);
+
+        if (warehouseToEdit == null)
+        {
+            Console.WriteLine($"Aucun entrepôt avec l'ID {req.Id} trouvé.");
+            await Send.NotFoundAsync(ct);
+            return;
+        }
+
+        // Mise à jour des champs
+        warehouseToEdit.Name = req.Name;
+        warehouseToEdit.MaxWeight = req.MaxWeight;
+        warehouseToEdit.Current = req.Current;
+        warehouseToEdit.MinWeight = req.MinWeight;
+        warehouseToEdit.Address = req.Adress;
+        warehouseToEdit.ZipCode = req.ZipCode;
+        warehouseToEdit.City = req.City;
+
+        await pyrofetesdbcontext.SaveChangesAsync(ct);
+
+        GetWarehouseDto responseDto = new()
+        {
+            Id = warehouseToEdit.Id,
+            Name = warehouseToEdit.Name,
+            MaxWeight = warehouseToEdit.MaxWeight,
+            Current = warehouseToEdit.Current,
+            MinWeight = warehouseToEdit.MinWeight,
+            Adress = warehouseToEdit.Address,
+            ZipCode = warehouseToEdit.ZipCode,
+            City = warehouseToEdit.City
+        };
+
+        await Send.OkAsync(responseDto, ct);
+    }
+}