Steven Phung

exercise.pizzashopapi/DTO/CustomerDTO.cs

@@ -0,0 +1,8 @@
+namespace exercise.pizzashopapi.DTO
+{
+    public class CustomerDTO
+    {
+        public string Name { get; set; }
+        public List<CustomerOrderDTO> Orders { get; set; } = new List<CustomerOrderDTO>();
+    }
+}

exercise.pizzashopapi/DTO/CustomerOrderDTO.cs

@@ -0,0 +1,9 @@
+namespace exercise.pizzashopapi.DTO
+{
+    public class CustomerOrderDTO
+    {
+        public int OrderId { get; set; }
+        public PizzaDTO Pizza { get; set; }
+    }
+
+}

exercise.pizzashopapi/DTO/CustomerPut.cs

@@ -0,0 +1,7 @@
+namespace exercise.pizzashopapi.DTO
+{
+    public class CustomerPut
+    {
+        public string Name { get; set; }
+    }
+}

exercise.pizzashopapi/DTO/OrderCustomerDTO.cs

@@ -0,0 +1,7 @@
+namespace exercise.pizzashopapi.DTO
+{
+    public class OrderCustomerDTO
+    {
+        public string Name { get; set; }
+    }
+}

exercise.pizzashopapi/DTO/OrderDTO.cs

@@ -0,0 +1,10 @@
+namespace exercise.pizzashopapi.DTO
+{
+    public class OrderDTO
+    {
+        public int Id { get; set; }
+        public OrderCustomerDTO Customer { get; set; }
+        public PizzaDTO Pizza { get; set; }
+
+    }
+}

exercise.pizzashopapi/DTO/PizzaDTO.cs

@@ -0,0 +1,9 @@
+namespace exercise.pizzashopapi.DTO
+{
+    public class PizzaDTO
+    {
+        public string Name { get; set; }
+        public decimal Price { get; set; }
+        //public List<PizzaOrderDTO> OrderPizza { get; set; } = new List<PizzaOrderDTO>();
+    }
+}

exercise.pizzashopapi/DTO/PizzaListDTO.cs

@@ -0,0 +1,9 @@
+namespace exercise.pizzashopapi.DTO
+{
+    public class PizzaListDTO
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+        public decimal Price { get; set; }
+    }
+}

exercise.pizzashopapi/Data/DataContext.cs

@@ -12,11 +12,12 @@ public DataContext()
             connectionString = configuration.GetValue<string>("ConnectionStrings:DefaultConnectionString");
 
         }
+
         protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
         {            
             optionsBuilder.UseNpgsql(connectionString);
 
-            //set primary of order?
+            //set primary of order
 
             //seed data?
 

exercise.pizzashopapi/Data/Seeder.cs

@@ -12,15 +12,26 @@ public async static void SeedPizzaShopApi(this WebApplication app)
                 {
                     db.Add(new Customer() { Name="Nigel" });
                     db.Add(new Customer() { Name = "Dave" });
+                    db.Add(new Customer() { Name = "Steven" });
+
                     await db.SaveChangesAsync();
                 }
                 if(!db.Pizzas.Any())
                 {
-                    db.Add(new Pizza() { Name = "Cheese & Pineapple" });
-                    db.Add(new Pizza() { Name = "Vegan Cheese Tastic" });
+                    db.Add(new Pizza() { Name = "Cheese & Pineapple", Price = 139.99M });
+                    db.Add(new Pizza() { Name = "Vegan Cheese Tastic" , Price = 119.99M});
+                    db.Add(new Pizza() { Name = "Marshmellow", Price = 89.99M });
+
                     await db.SaveChangesAsync();
 
                 }
+                if (!db.Orders.Any())
+                {
+                    db.Add(new Order() { CustomerId = 1, PizzaId = 2 });
+                    db.Add(new Order() { CustomerId = 2, PizzaId = 1 });
+                    db.Add(new Order() { CustomerId = 3, PizzaId = 3 });
+                    await db.SaveChangesAsync();
+                }
 
                 //order data
                 if(1==1)

exercise.pizzashopapi/EndPoints/PizzaShopApi.cs

@@ -1,15 +1,235 @@
-using exercise.pizzashopapi.Repository;
+using AutoMapper;
+using exercise.pizzashopapi.DTO;
+using exercise.pizzashopapi.Models;
+using exercise.pizzashopapi.Repository;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Infrastructure;
+using Microsoft.EntityFrameworkCore;
 
 namespace exercise.pizzashopapi.EndPoints
 {
     public static class PizzaShopApi
     {
         public static void ConfigurePizzaShopApi(this WebApplication app)
         {
-
+
+            var PizzaGroup = app.MapGroup("/pizza");
+
+            PizzaGroup.MapGet("/", GetPizzas);
+            PizzaGroup.MapGet("/{id}", GetPizza);
+            PizzaGroup.MapPost("/", AddPizza);
+            PizzaGroup.MapPut("/{id}", UpdatePizza);
+            PizzaGroup.MapDelete("/{id}", DeletePizza);
+
+            var CustomerGroup = app.MapGroup("/customer");
+            CustomerGroup.MapGet("/", GetCustomers);
+            CustomerGroup.MapGet("/{id}", GetCustomer);
+            CustomerGroup.MapPost("/", AddCustomer);
+            CustomerGroup.MapPut("/{id}", UpdateCustomer);
+
+            var OrderGroup = app.MapGroup("/order");
+            OrderGroup.MapGet("/", GetOrders);
+            OrderGroup.MapGet("/{id}", GetOrder);
+            OrderGroup.MapPost("/{customerId}/{pizzaId}", AddOrder);
+
+        }
+
+        #region Pizza
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public static async Task<IResult> GetPizzas(IRepository<Pizza> repo, IMapper mapper )
+        {
+            var pizzas = await repo.Get();
+            var pizzaDTOs = mapper.Map<List<PizzaListDTO>>(pizzas);
+            return Results.Ok(pizzaDTOs);
+
+        }
+
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        public static async Task<IResult> GetPizza(IRepository<Pizza> repo, int id, IMapper mapper)
+        {
+            var pizza = await repo.GetById(id);
+            if (pizza == null)
+            {
+                return Results.NotFound();
+            }
+
+            return Results.Ok(mapper.Map<PizzaDTO>(pizza));
+        }
+
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public static async Task<IResult> AddPizza(IRepository<Pizza> repo, PizzaDTO pizza, IMapper mapper)
+        {
+            Pizza newPizza = new Pizza
+            {
+                Name = pizza.Name,
+                Price = pizza.Price
+            };
+
+            var result = await repo.Add(newPizza);
+            return Results.Ok(mapper.Map<PizzaDTO>(result));
+        }
+
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        public static async Task<IResult> UpdatePizza(IRepository<Pizza> repo, int id, PizzaDTO pizza, IMapper mapper)
+        {
+            var existingPizza = await repo.GetById(id);
+            if (existingPizza == null)
+            {
+                return Results.NotFound();
+            }
+            existingPizza.Name = pizza.Name;
+            existingPizza.Price = pizza.Price;
+            var result = await repo.Update(existingPizza);
+            return TypedResults.Ok(mapper.Map<PizzaDTO>(result));
+        }
+
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        public static async Task<IResult> DeletePizza(IRepository<Pizza> repo, int id)
+        {
+            var existingPizza = await repo.GetById(id);
+            if (existingPizza == null)
+            {
+                return Results.NotFound();
+            }
+            var result = await repo.Delete(id);
+            return TypedResults.Ok(result);
+        }
+
+        #endregion
+
+        #region Customer
+
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public static async Task<IResult> GetCustomers(IRepository<Customer> repo, IMapper mapper)
+        {
+            var customers = await repo
+                .GetWithNestedIncludes( query => query.Include(c => c.Orders)
+                .ThenInclude(o => o.Pizza));
+
+            return Results.Ok(mapper.Map<List<CustomerDTO>>(customers));
+
         }
 
-
+
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        public static async Task<IResult> GetCustomer(IRepository<Customer> repo, int id, IMapper mapper)
+        {
+            var customer = await repo.GetQuery()
+                .Include(c => c.Orders)
+                .ThenInclude(o => o.Pizza)
+                .FirstOrDefaultAsync(c => c.Id == id);
+            if (customer == null)
+            {
+                return Results.NotFound();
+            }
+            return Results.Ok(mapper.Map<CustomerDTO>(customer));
+        }
+
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public static async Task<IResult> AddCustomer(IRepository<Customer> repo, CustomerPut customer, IMapper mapper)
+        {
+            Customer newCustomer = new Customer
+            {
+                Name = customer.Name
+            };
+            var result = await repo.Add(newCustomer);
+            return Results.Ok(mapper.Map<CustomerDTO>(result));
+        }
+
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        public static async Task<IResult> UpdateCustomer(IRepository<Customer> repo, int id, CustomerPut customer, IMapper mapper)
+        {
+            var existingCustomer = await repo.GetById(id);
+            if (existingCustomer == null)
+            {
+                return Results.NotFound();
+            }
+            existingCustomer.Name = customer.Name;
+            var result = await repo.Update(existingCustomer);
+            return TypedResults.Ok(mapper.Map<CustomerDTO>(result));
+        }
+
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        public static async Task<IResult> DeleteCustomer(IRepository<Customer> repo, int id)
+        {
+            var existingCustomer = await repo.GetById(id);
+            if (existingCustomer == null)
+            {
+                return Results.NotFound();
+            }
+            var result = await repo.Delete(id);
+            return TypedResults.Ok(result);
+        }
+
+        #endregion
+
+        #region Orders
+
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public static async Task<IResult> GetOrders(IRepository<Order> repo, IMapper mapper)
+        {
+            var orders = await repo.GetQuery()
+                .Include(o => o.Customer)
+                .Include(o => o.Pizza)
+                .ToListAsync();
+            return Results.Ok(mapper.Map<List<OrderDTO>>(orders));
+        }
+
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        public static async Task<IResult> GetOrder(IRepository<Order> repo, int id, IMapper mapper)
+        {
+            var order = await repo.GetQuery()
+                .Include(o => o.Customer)
+                .Include(o => o.Pizza)
+                .FirstOrDefaultAsync(o => o.Id == id);
+            if (order == null)
+            {
+                return Results.NotFound();
+            }
+            return Results.Ok(mapper.Map<OrderDTO>(order));
+        }
+
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        public static async Task<IResult> AddOrder(IRepository<Order> orderRepo, IRepository<Pizza> pizzaRepo, IRepository<Customer> customerRepo, int customerId, int pizzaId, IMapper mapper)
+        {
+            //var customer = await repo.GetById(customerId);
+            var customer = await customerRepo.GetQuery()
+                .FirstOrDefaultAsync(c => c.Id == customerId);
+
+            if (customer == null)
+            {
+                return Results.NotFound();
+            }
+            //var pizza = await repo.GetById(pizzaId);
+            var pizza = await pizzaRepo.GetQuery()
+                .FirstOrDefaultAsync(c => c.Id == pizzaId);
+
+            if (pizza == null)
+            {
+                return Results.NotFound();
+            }
+
+            Order newOrder = new Order
+            {
+                CustomerId = customerId,
+                PizzaId = pizzaId,
+                Pizza = pizza,
+                Customer = customer,
+
+            };
+            var result = await orderRepo.Add(newOrder);
+            return Results.Ok(mapper.Map<OrderDTO>(result));
+        }
+
+
+        #endregion
     }
 }

exercise.pizzashopapi/Mapper/Mapping.cs

@@ -0,0 +1,42 @@
+using AutoMapper;
+using exercise.pizzashopapi.DTO;
+using exercise.pizzashopapi.Models;
+namespace exercise.pizzashopapi.Mapper
+{
+    public class Mapping : Profile
+    {
+
+        public Mapping()
+        {
+            CreateMap<Pizza, PizzaDTO>();
+            CreateMap<Pizza, PizzaListDTO>();
+            CreateMap<Order, OrderDTO>();
+            CreateMap<Customer, CustomerDTO>();
+
+            CreateMap<Customer, CustomerDTO>()
+            .ForMember(dest => dest.Orders, opt => opt.MapFrom(src => src.Orders));
+
+            CreateMap<Order, CustomerOrderDTO>()
+                .ForMember(dest => dest.Pizza, opt => opt.MapFrom(src => src.Pizza))
+                .ForMember(dest => dest.OrderId, opt => opt.MapFrom(src => src.Id));
+
+            CreateMap<Order, OrderCustomerDTO>()
+                .ForMember(dest => dest.Name, opt => opt.MapFrom(src => src.Customer.Name));
+
+            CreateMap<Order, PizzaDTO>()
+                .ForMember(dest => dest.Name, opt => opt.MapFrom(src => src.Pizza));
+
+            CreateMap<Order, OrderDTO>()
+                .ForMember(dest => dest.Customer, opt => opt.MapFrom(src => src.Customer))
+                .ForMember(dest => dest.Pizza, opt => opt.MapFrom(src => src.Pizza));
+
+            CreateMap<Customer, OrderCustomerDTO>()
+                .ForMember(dest => dest.Name, opt => opt.MapFrom(src => src.Name));
+
+            CreateMap<Pizza, PizzaDTO>()
+                .ForMember(dest => dest.Name, opt => opt.MapFrom(src => src.Name))
+                .ForMember(dest => dest.Price, opt => opt.MapFrom(src => src.Price));
+
+        }
+    }
+}