From e2842558e8eb598d21520a857d001b4382781074 Mon Sep 17 00:00:00 2001 From: jc-programs Date: Tue, 29 Oct 2024 13:45:55 +0100 Subject: [PATCH 01/28] Creando primer test para comprobar OrderMenyQty --- .../model/EatInOrderRestaurant.java | 3 +- .../model/MenuRestaurant.java | 15 +- .../restaurantManager/model/OrderMenuQty.java | 30 ++++ .../model/OrderRestaurant.java | 32 ++--- .../model/ShippingOrderRestaurant.java | 5 +- .../model/TakeAwayOrder.java | 3 +- .../repository/ShippingOrderRepository.java | 6 + .../restaurantManager/OrderMenuQtyTest.java | 128 ++++++++++++++++++ .../RelationshipsOrderRestaurantTest.java | 17 ++- 9 files changed, 209 insertions(+), 30 deletions(-) create mode 100644 src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java create mode 100644 src/main/java/dev/example/restaurantManager/repository/ShippingOrderRepository.java create mode 100644 src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java diff --git a/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java index 1e2dd12..47b8a51 100644 --- a/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java @@ -6,6 +6,7 @@ import lombok.NoArgsConstructor; import java.util.ArrayList; import java.util.Date; +import java.util.List; import java.util.stream.Collectors; @Data @@ -19,7 +20,7 @@ public class EatInOrderRestaurant extends OrderRestaurant { public EatInOrderRestaurant(String id, Date date, String waiter, int peopleQty, - double totalPayment, boolean paid, ArrayList menus, + double totalPayment, boolean paid, List menus, ArrayList tableRestaurants) { super(id, date, waiter, peopleQty, totalPayment, paid, menus); this.tableRestaurants = tableRestaurants; diff --git a/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java index e916706..51de20f 100644 --- a/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java @@ -11,7 +11,7 @@ import java.util.Objects; @Data -@AllArgsConstructor +// @AllArgsConstructor @NoArgsConstructor @Entity public class MenuRestaurant { @@ -24,9 +24,16 @@ public class MenuRestaurant { private boolean active; private boolean water; - @JsonIgnore - @ManyToMany(mappedBy = "menus", fetch = FetchType.LAZY) - private List orders = new ArrayList<>(); +// @JsonIgnore +// @ManyToMany(mappedBy = "menus", fetch = FetchType.LAZY) +// private List orders = new ArrayList<>(); + + + // to execute old tests + public MenuRestaurant(String id, String name, Double price, String content, boolean active, boolean water,ArrayList orders){ + this(id, name, price, content, active, water); + } + public MenuRestaurant(String id, String name, Double price, String content, boolean active, boolean water) { this.id = id; diff --git a/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java new file mode 100644 index 0000000..ace8edd --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java @@ -0,0 +1,30 @@ +package dev.example.restaurantManager.model; + +import jakarta.persistence.*; +import lombok.Data; +import org.hibernate.annotations.GenericGenerator; + +@Data +@Entity +public class OrderMenuQty { + @Id + @GeneratedValue(generator = "UUID") + @GenericGenerator(name = "UUID", strategy = "org.hibernate.id.UUIDGenerator") + private String id; + + @ManyToOne + @JoinColumn(name = "order_id") + private OrderRestaurant order; + + private int quantity; + + @ManyToOne + @JoinColumn(name = "menu_id") + private MenuRestaurant menu; + + @Override + public String toString(){ + return menu.getId() + " qty: " + this.quantity; + } + +} diff --git a/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java index 994b5a4..ad31e3e 100644 --- a/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java @@ -28,23 +28,23 @@ public class OrderRestaurant { @ManyToMany(fetch = FetchType.LAZY , cascade = {CascadeType.PERSIST, CascadeType.MERGE}) @JoinTable( - name = "ORDER_RESTAURANT_MENU", - joinColumns = @JoinColumn(name = "ORDER_RESTAURANT_FK_ID"), - inverseJoinColumns = @JoinColumn(name = "MENU_RESTAURANT_FK_ID") + name = "ORDER_MENU_QUANTITY", + joinColumns = @JoinColumn(name = "ORDER_ID_FK"), + inverseJoinColumns = @JoinColumn(name = "MENU_ID_FK") ) - private List menus = new ArrayList<>(); - - public List addMenu(MenuRestaurant menu) { - this.menus.add(menu); - menu.getOrders().add(this); - return this.menus; - } - - public List removeMenu(MenuRestaurant menu) { - this.menus.remove(menu); - menu.getOrders().remove(this); - return this.menus; - } + private List menus; + +// public List addMenu(MenuRestaurant menu) { +// this.menus.add(menu); +// menu.getOrders().add(this); +// return this.menus; +// } +// +// public List removeMenu(MenuRestaurant menu) { +// this.menus.remove(menu); +// menu.getOrders().remove(this); +// return this.menus; +// } @Override public String toString() { diff --git a/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java index 6375dc2..8216b79 100644 --- a/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java @@ -1,11 +1,14 @@ package dev.example.restaurantManager.model; +import jakarta.persistence.Entity; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; import java.util.ArrayList; import java.util.Date; +import java.util.List; +@Entity @Data @AllArgsConstructor @NoArgsConstructor @@ -16,7 +19,7 @@ public class ShippingOrderRestaurant extends OrderRestaurant { private String riderName; public ShippingOrderRestaurant(String id, Date date, String waiter, int peopleQty, - double totalPayment, boolean paid, ArrayList menus, + double totalPayment, boolean paid, List menus, String address, String city, String riderName) { super(id, date, waiter, peopleQty, totalPayment, paid, menus); this.address = address; diff --git a/src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java b/src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java index e285789..e21156f 100644 --- a/src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java +++ b/src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java @@ -6,6 +6,7 @@ import lombok.NoArgsConstructor; import java.util.ArrayList; import java.util.Date; +import java.util.List; @Entity @Data @@ -19,7 +20,7 @@ public class TakeAwayOrder extends OrderRestaurant { // Constructor for TakeAwayOrder with the WHOLE DATA fields public TakeAwayOrder(String id, Date date, String waiter, int peopleQty, - double totalPayment, boolean paid, ArrayList menus, + double totalPayment, boolean paid, List menus, Customer customerTakeAway) { // THIS PART is SUPERCLASS diff --git a/src/main/java/dev/example/restaurantManager/repository/ShippingOrderRepository.java b/src/main/java/dev/example/restaurantManager/repository/ShippingOrderRepository.java new file mode 100644 index 0000000..83121f1 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/repository/ShippingOrderRepository.java @@ -0,0 +1,6 @@ +package dev.example.restaurantManager.repository; + +import dev.example.restaurantManager.model.ShippingOrderRestaurant; +import org.springframework.data.jpa.repository.JpaRepository; + +public interface ShippingOrderRepository extends JpaRepository {} diff --git a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java new file mode 100644 index 0000000..2d29281 --- /dev/null +++ b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java @@ -0,0 +1,128 @@ +package dev.example.restaurantManager; + +import com.github.javafaker.Faker; +import dev.example.restaurantManager.model.*; +import dev.example.restaurantManager.repository.CustomerRepository; +import dev.example.restaurantManager.repository.MenuRestaurantRepository; +import dev.example.restaurantManager.repository.ShippingOrderRepository; +import dev.example.restaurantManager.repository.TableRestaurantRepository; +import dev.example.restaurantManager.service.CustomerService; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; + +import java.util.*; + +import static org.assertj.core.api.Assertions.assertThat; + + +@SpringBootTest +public class OrderMenuQtyTest { + + @Autowired + MenuRestaurantRepository menuRepository; + @Autowired + ShippingOrderRepository shippingOrderRepository; + @Autowired + CustomerRepository customerRepository; + @Autowired + TableRestaurantRepository tableRepository; + + + List menus; + List orders; + + Faker faker; + + @BeforeEach + public void createDataAndSave2DB() { + faker = new Faker(); + + // Create sample customers + Customer customer1 = new Customer("C1", "John", "john@email.com", "123-456-7890", 30, false, false); + Customer customer3 = new Customer("C3", "Emily", "emily@email.com", "345-678-9012", 35, false, false); + Customer customer5 = new Customer("C5", "Anna", "anna@email.com", "567-890-1234", 28, false, false); + customerRepository.save(customer1); + customerRepository.save(customer3); + customerRepository.save(customer5); + + // Create sample tables + TableRestaurant table1 = new TableRestaurant("T1", "Window Table", 4, false); + TableRestaurant table2 = new TableRestaurant("T2", "Corner Table", 2, true); + table1.setId("T01"); + table2.setId("T02"); + tableRepository.save(table1); + tableRepository.save(table2); + + + // Create sample menus + MenuRestaurant menu1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true); + MenuRestaurant menu2 = new MenuRestaurant("M02","Pizza Menu", 12.99, "Pizza and salad", true, false); + MenuRestaurant menu3 = new MenuRestaurant("M03","Salad Menu", 8.99, "Mixed salad and dressing", true, true); + menus = new ArrayList<>(Arrays.asList(menu1,menu2,menu3)); + menuRepository.save(menu1); + menuRepository.save(menu2); + menuRepository.save(menu3); + + // Create 3 ShippingOrder objects + ShippingOrderRestaurant so1 = new ShippingOrderRestaurant("SO1", new Date(), "John", 2, 0.0, false, null, "123 Main St", "New York", "Mike"); + ShippingOrderRestaurant so2 = new ShippingOrderRestaurant("SO2", new Date(), "Sarah", 1, 0.0, true, null, "456 Elm St", "Los Angeles", "Tom"); + ShippingOrderRestaurant so3 = new ShippingOrderRestaurant("SO3", new Date(), "Emily", 3, 0.0, false, null, "789 Oak St", "Chicago", "Lisa"); + orders = new ArrayList<>(Arrays.asList(so1,so2,so3)); + shippingOrderRepository.save(so1); + shippingOrderRepository.save(so2); + shippingOrderRepository.save(so3); + +// // Create 3 EatInOrder objects +// EatInOrderRestaurant eo1 = new EatInOrderRestaurant("EO1", new Date(), "David", 4, 0.0, true, null, new ArrayList<>(Arrays.asList(table1))); +// EatInOrderRestaurant eo2 = new EatInOrderRestaurant("EO2", new Date(), "Anna", 2, 0.0, false, null, new ArrayList<>(Arrays.asList(table2))); +// EatInOrderRestaurant eo3 = new EatInOrderRestaurant("EO3", new Date(), "Mark", 6, 0.0, true, null, new ArrayList<>(Arrays.asList(table1, table2))); +// orders.addAll(Arrays.asList(eo1,eo2,eo3)); +// +// // Create 3 TakeAwayOrder objects +// TakeAwayOrder to1 = new TakeAwayOrder("TO1", new Date(), "Alice", 1, 0.0, true, null, customer1 ); +// TakeAwayOrder to2 = new TakeAwayOrder("TO2", new Date(), "Bob", 2, 0.0, false, null, customer3 ); +// TakeAwayOrder to3 = new TakeAwayOrder("TO3", new Date(), "Charlie", 3, 0.0, true, null, customer5); +// orders.addAll(Arrays.asList(to1,to2,to3)); + } + + + + + + + @Test + public void createOrderMenuQtyDB() { + ShippingOrderRestaurant so1 = (ShippingOrderRestaurant)orders.get(0); + List menusQty = new ArrayList<>(); + for(MenuRestaurant m:menus){ + if (faker.random().nextInt(0,3) == 0){ + continue; + } + OrderMenuQty omq = new OrderMenuQty(); + omq.setOrder(so1); + omq.setMenu(m); + omq.setQuantity(faker.random().nextInt(1,5)); + menusQty.add(omq); + } + so1.setMenus(menusQty); + shippingOrderRepository.save(so1); + + Optional found = shippingOrderRepository.findById(so1.getId()); + assertThat(found).isPresent(); + ShippingOrderRestaurant so1DB = found.get(); + int nMenus = so1DB.getMenus().size(); + for(int i=0;i Date: Tue, 29 Oct 2024 13:54:22 +0100 Subject: [PATCH 02/28] Creando primer test para comprobar OrderMenyQty --- .../java/dev/example/restaurantManager/OrderMenuQtyTest.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java index 2d29281..222633b 100644 --- a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java +++ b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java @@ -7,6 +7,7 @@ import dev.example.restaurantManager.repository.ShippingOrderRepository; import dev.example.restaurantManager.repository.TableRestaurantRepository; import dev.example.restaurantManager.service.CustomerService; +import org.hibernate.Hibernate; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; @@ -112,6 +113,9 @@ public void createOrderMenuQtyDB() { Optional found = shippingOrderRepository.findById(so1.getId()); assertThat(found).isPresent(); ShippingOrderRestaurant so1DB = found.get(); + + // https://stackoverflow.com/questions/11746499/how-to-solve-the-failed-to-lazily-initialize-a-collection-of-role-hibernate-ex + Hibernate.initialize(so1DB.getMenus()); int nMenus = so1DB.getMenus().size(); for(int i=0;i Date: Tue, 29 Oct 2024 19:43:55 +0100 Subject: [PATCH 03/28] arreglado para poder utilizar objetos lazy loading --- .../java/dev/example/restaurantManager/OrderMenuQtyTest.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java index 222633b..e34c885 100644 --- a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java +++ b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java @@ -7,11 +7,13 @@ import dev.example.restaurantManager.repository.ShippingOrderRepository; import dev.example.restaurantManager.repository.TableRestaurantRepository; import dev.example.restaurantManager.service.CustomerService; +import jakarta.transaction.Transactional; import org.hibernate.Hibernate; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.transaction.annotation.Propagation; import java.util.*; @@ -94,6 +96,7 @@ public void createDataAndSave2DB() { @Test + @Transactional // (propagation= Propagation.REQUIRED) public void createOrderMenuQtyDB() { ShippingOrderRestaurant so1 = (ShippingOrderRestaurant)orders.get(0); List menusQty = new ArrayList<>(); From c7d9710df46269d155aa2ca133addd3c8ee0c1a8 Mon Sep 17 00:00:00 2001 From: jc-programs Date: Wed, 30 Oct 2024 10:57:39 +0100 Subject: [PATCH 04/28] OrderMenyQty funcionando --- .../restaurantManager/OrderMenuQtyTest.java | 29 +++++++++---------- 1 file changed, 14 insertions(+), 15 deletions(-) diff --git a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java index e34c885..92dca59 100644 --- a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java +++ b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java @@ -6,14 +6,11 @@ import dev.example.restaurantManager.repository.MenuRestaurantRepository; import dev.example.restaurantManager.repository.ShippingOrderRepository; import dev.example.restaurantManager.repository.TableRestaurantRepository; -import dev.example.restaurantManager.service.CustomerService; import jakarta.transaction.Transactional; -import org.hibernate.Hibernate; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; -import org.springframework.transaction.annotation.Propagation; import java.util.*; @@ -40,7 +37,7 @@ public class OrderMenuQtyTest { @BeforeEach public void createDataAndSave2DB() { - faker = new Faker(); + faker = new Faker(new Random(42)); // Create sample customers Customer customer1 = new Customer("C1", "John", "john@email.com", "123-456-7890", 30, false, false); @@ -91,25 +88,29 @@ public void createDataAndSave2DB() { } - - - - - @Test - @Transactional // (propagation= Propagation.REQUIRED) - public void createOrderMenuQtyDB() { - ShippingOrderRestaurant so1 = (ShippingOrderRestaurant)orders.get(0); + private List getRandomMenuQty(OrderRestaurant orderRestaurant){ List menusQty = new ArrayList<>(); for(MenuRestaurant m:menus){ if (faker.random().nextInt(0,3) == 0){ continue; } OrderMenuQty omq = new OrderMenuQty(); - omq.setOrder(so1); + omq.setOrder(orderRestaurant); omq.setMenu(m); omq.setQuantity(faker.random().nextInt(1,5)); menusQty.add(omq); } + return menusQty; + } + + + + @Test + // https://stackoverflow.com/questions/11746499/how-to-solve-the-failed-to-lazily-initialize-a-collection-of-role-hibernate-ex + @Transactional // (propagation= Propagation.REQUIRED) + public void createOrderMenuQtyDB() { + ShippingOrderRestaurant so1 = (ShippingOrderRestaurant)orders.get(0); + List menusQty = getRandomMenuQty(so1); so1.setMenus(menusQty); shippingOrderRepository.save(so1); @@ -117,8 +118,6 @@ public void createOrderMenuQtyDB() { assertThat(found).isPresent(); ShippingOrderRestaurant so1DB = found.get(); - // https://stackoverflow.com/questions/11746499/how-to-solve-the-failed-to-lazily-initialize-a-collection-of-role-hibernate-ex - Hibernate.initialize(so1DB.getMenus()); int nMenus = so1DB.getMenus().size(); for(int i=0;i Date: Wed, 30 Oct 2024 12:00:08 +0100 Subject: [PATCH 05/28] trying to fix old tests --- .../model/EatInOrderRestaurant.java | 7 +++ .../model/OrderRestaurant.java | 61 ++++++++++++++++++- .../model/ShippingOrderRestaurant.java | 10 +++ .../model/TakeAwayOrder.java | 10 +++ .../utilities/Converter.java | 37 +++++++++++ .../restaurantManager/OrderMenuQtyTest.java | 6 +- .../RelationshipsOrderRestaurantTest.java | 54 ++++++++-------- 7 files changed, 155 insertions(+), 30 deletions(-) create mode 100644 src/main/java/dev/example/restaurantManager/utilities/Converter.java diff --git a/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java index 47b8a51..8c90c97 100644 --- a/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java @@ -26,6 +26,13 @@ public EatInOrderRestaurant(String id, Date date, String waiter, int peopleQty, this.tableRestaurants = tableRestaurants; } + public EatInOrderRestaurant(String id, Date date, String waiter, int peopleQty, + double totalPayment, boolean paid, ArrayList menus, + ArrayList tableRestaurants) { + super(id, date, waiter, peopleQty, totalPayment, paid, menus); + this.tableRestaurants = tableRestaurants; + } + @Override public String toString() { return super.toString() + "\n" + diff --git a/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java index ad31e3e..2326372 100644 --- a/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java @@ -1,12 +1,13 @@ package dev.example.restaurantManager.model; -import java.util.ArrayList; -import java.util.Date; -import java.util.List; +import java.util.*; + import com.fasterxml.jackson.annotation.JsonIgnore; import jakarta.persistence.*; import lombok.*; +import dev.example.restaurantManager.utilities.Converter; + @Getter @Setter @AllArgsConstructor @@ -34,6 +35,60 @@ public class OrderRestaurant { ) private List menus; + public OrderRestaurant(String id, Date date, String waiter, int peopleQty, + double totalPayment, boolean paid, ArrayList menus){ + this.id=id; + this.date=date; + this.waiter=waiter; + this.peopleQty=peopleQty; + this.totalPayment=totalPayment; + this.paid=paid; + this.menus = Converter.convertMenus2QtyMenus(this,menus); + } + + + public List addMenu(MenuRestaurant menu) { + if(this.getMenus()==null){ + this.setMenus(new ArrayList()); + } + boolean found = false; + for(OrderMenuQty omq: this.getMenus()){ + if(omq.getMenu().equals(menu)){ + omq.setQuantity(omq.getQuantity()+1); + found = true; + break; + } + } + if(!found){ + OrderMenuQty omq = new OrderMenuQty(); + omq.setMenu(menu); + omq.setQuantity(1); + omq.setOrder(this); + this.getMenus().add(omq); + } + return this.getMenus(); + } + + public List removeMenu(MenuRestaurant menu) { + if(this.getMenus()==null){ + return null; + } + for(OrderMenuQty omq: this.getMenus()){ + if(omq.getMenu().equals(menu)){ + int qty = omq.getQuantity(); + if (qty > 1) { + omq.setQuantity(omq.getQuantity() - 1); + } else{ + this.getMenus().remove(omq); + } + break; + } + } + return this.getMenus(); + } + + + // public List addMenu(MenuRestaurant menu) { // this.menus.add(menu); // menu.getOrders().add(this); diff --git a/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java index 8216b79..cd63231 100644 --- a/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java @@ -27,6 +27,16 @@ public ShippingOrderRestaurant(String id, Date date, String waiter, int peopleQt this.riderName = riderName; } + public ShippingOrderRestaurant(String id, Date date, String waiter, int peopleQty, + double totalPayment, boolean paid, ArrayList menus, + String address, String city, String riderName) { + super(id, date, waiter, peopleQty, totalPayment, paid, menus); + this.address = address; + this.city = city; + this.riderName = riderName; + } + + @Override public String toString() { return super.toString() + "\n" + diff --git a/src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java b/src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java index e21156f..7385640 100644 --- a/src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java +++ b/src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java @@ -29,6 +29,16 @@ public TakeAwayOrder(String id, Date date, String waiter, int peopleQty, this.customerTakeAway = customerTakeAway; } + public TakeAwayOrder(String id, Date date, String waiter, int peopleQty, + double totalPayment, boolean paid, ArrayList menus, + Customer customerTakeAway) { + + // THIS PART is SUPERCLASS + super(id, date, waiter, peopleQty, totalPayment, paid, menus); + // THIS PART is SUBCLASS + this.customerTakeAway = customerTakeAway; + } + @Override public String toString() { return super.toString() + "\n" + diff --git a/src/main/java/dev/example/restaurantManager/utilities/Converter.java b/src/main/java/dev/example/restaurantManager/utilities/Converter.java new file mode 100644 index 0000000..f5b5150 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/utilities/Converter.java @@ -0,0 +1,37 @@ +package dev.example.restaurantManager.utilities; + +import dev.example.restaurantManager.model.MenuRestaurant; +import dev.example.restaurantManager.model.OrderMenuQty; +import dev.example.restaurantManager.model.OrderRestaurant; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +public class Converter { + public static List convertMenus2QtyMenus(OrderRestaurant order, List menus){ + HashMap hashmapMenus = new HashMap<>(); + for(MenuRestaurant m:menus){ + hashmapMenus.put(m,hashmapMenus.getOrDefault(m,0) + 1); + } + List menusNew = new ArrayList<>(); + for(Map.Entry m:hashmapMenus.entrySet()){ + OrderMenuQty omq = new OrderMenuQty(); + omq.setMenu(m.getKey()); + omq.setQuantity(m.getValue()); + omq.setOrder(order); + } + return menusNew; + } + + public static List convertQtyMenus2Menus(List menus){ + List menusNew = new ArrayList<>(); + for(OrderMenuQty omq:menus){ + for(int i=0;i(Arrays.asList(so1,so2,so3)); shippingOrderRepository.save(so1); shippingOrderRepository.save(so2); diff --git a/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java b/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java index 068e620..55f49bd 100644 --- a/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java +++ b/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java @@ -2,6 +2,7 @@ import dev.example.restaurantManager.model.*; import dev.example.restaurantManager.repository.*; +import dev.example.restaurantManager.utilities.Converter; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; @@ -24,7 +25,6 @@ public class RelationshipsOrderRestaurantTest { @Autowired private EatInOrderRestaurantRepository eatInOrderRestaurantRepository; -/* @Test public void TestCreateOrder() { // Create sample menus @@ -139,7 +139,7 @@ public void TestCreateOrderMenu () { System.out.println(found.get()); // then assertThat(found).isPresent(); - assertThat(found.get().getMenus().get(0).getName().equals(menuRestaurant1.getName())); + // assertThat(found.get().getMenus().get(0).getName().equals(menuRestaurant1.getName())); } // java.lang.StackOverflowError toString @@ -170,8 +170,8 @@ public void TestCreateOrderMenu_stackOverflow () { //orderRestaurantRepository.save(orderRestaurant3); // set menus to orders and save - menuRestaurant1.getOrders().add(orderRestaurant1); - menuRestaurantRepository.save(menuRestaurant1); +// menuRestaurant1.getOrders().add(orderRestaurant1); +// menuRestaurantRepository.save(menuRestaurant1); // when Optional found = orderRestaurantRepository.findById("O01"); @@ -188,7 +188,7 @@ public void TestCreateOrderMenu_stackOverflow () { // then assertThat(found).isPresent(); - assertThat(found.get().getMenus().get(0).getName().equals(menuRestaurant1.getName())); +// assertThat(found.get().getMenus().get(0).getName().equals(menuRestaurant1.getName())); } // Adding Menus to an Order: Verifies that menus can be added to an order @@ -206,7 +206,7 @@ public void testAddingMenusToOrder() { // Create an order and add menus OrderRestaurant order = new OrderRestaurant("O01", new Date(), "John", 4, - 43.96, true, new ArrayList<>()); + 43.96, true, (List)null); order.addMenu(menuRestaurant1); order.addMenu(menuRestaurant2); order.addMenu(menuRestaurant3); @@ -219,13 +219,19 @@ public void testAddingMenusToOrder() { // Since we've implemented equals() and hashCode() methods based on // the compilation of all fields except for orders. // This avoids potential circular reference issues while still providing a comprehensive comparison of the menu items. + + // we can now use contains() to check if the retrieved menus match the original ones - assertThat(foundOrder.get().getMenus()).contains(menuRestaurant1, menuRestaurant2, menuRestaurant3); +// assertThat(foundOrder.get().getMenus()).contains(menuRestaurant1, menuRestaurant2, menuRestaurant3); + assertThat(Converter.convertQtyMenus2Menus(foundOrder.get().getMenus())).contains(menuRestaurant1, menuRestaurant2, menuRestaurant3); + + + // Retrieve the menus and assert the order assertThat(foundOrder.get().getMenus()) .extracting("id") .containsExactlyInAnyOrder("M01", "M02", "M03"); - assertThat(foundOrder.get().getMenus()) + assertThat(Converter.convertQtyMenus2Menus(foundOrder.get().getMenus())) .usingElementComparator(Comparator.comparing(MenuRestaurant::getId)) .containsExactlyInAnyOrder(menuRestaurant1, menuRestaurant2, menuRestaurant3); } @@ -244,7 +250,7 @@ public void testAddingRepeatedMenusToOrder() { // Create an order and add menus OrderRestaurant order = new OrderRestaurant("O01", new Date(), "John", 4, - 43.96, true, new ArrayList<>()); + 43.96, true, (List)null); order.addMenu(menuRestaurant1); order.addMenu(menuRestaurant2); order.addMenu(menuRestaurant2); @@ -261,12 +267,12 @@ public void testAddingRepeatedMenusToOrder() { // the compilation of all fields except for orders. // This avoids potential circular reference issues while still providing a comprehensive comparison of the menu items. // we can now use contains() to check if the retrieved menus match the original ones - assertThat(foundOrder.get().getMenus()).contains(menuRestaurant1, menuRestaurant2, menuRestaurant2, menuRestaurant3, menuRestaurant3, menuRestaurant3); + assertThat(Converter.convertQtyMenus2Menus(foundOrder.get().getMenus())).contains(menuRestaurant1, menuRestaurant2, menuRestaurant2, menuRestaurant3, menuRestaurant3, menuRestaurant3); // Retrieve the menus and assert the order assertThat(foundOrder.get().getMenus()) .extracting("id") .containsExactlyInAnyOrder("M01", "M02", "M02","M03, M03, M03"); - assertThat(foundOrder.get().getMenus()) + assertThat(Converter.convertQtyMenus2Menus(foundOrder.get().getMenus())) .usingElementComparator(Comparator.comparing(MenuRestaurant::getId)) .containsExactlyInAnyOrder(menuRestaurant1, menuRestaurant2, menuRestaurant2, menuRestaurant3, menuRestaurant3, menuRestaurant3 ); } @@ -298,7 +304,7 @@ public void testRemovingMenusFromOrder() { OrderRestaurant updatedOrder = foundOrder.get(); // Let's remove the second menu //updatedOrder.removeMenu(menuRestaurant2); - updatedOrder.removeMenu(updatedOrder.getMenus().get(1)); + updatedOrder.removeMenu(Converter.convertQtyMenus2Menus(updatedOrder.getMenus()).get(1)); orderRestaurantRepository.save(updatedOrder); // Retrieve the updated order and assert the menus @@ -308,8 +314,8 @@ public void testRemovingMenusFromOrder() { // assert the menus have been removed assertThat(updatedOrderOptional).isPresent(); assertThat(updatedOrderOptional.get().getMenus()).hasSize(2); - assertThat(updatedOrderOptional.get().getMenus()).contains(menuRestaurant1, menuRestaurant3); - assertThat(updatedOrderOptional.get().getMenus()).doesNotContain(menuRestaurant2); + assertThat(Converter.convertQtyMenus2Menus(updatedOrderOptional.get().getMenus())).contains(menuRestaurant1, menuRestaurant3); + assertThat(Converter.convertQtyMenus2Menus(updatedOrderOptional.get().getMenus())).doesNotContain(menuRestaurant2); // Retrieve the updated order after deleting the menu System.out.println("List of menus AFTER DELETION:"); @@ -413,8 +419,8 @@ public void testCascadingDeletionOfMenusAndOrders() { Optional updatedOrderOptional = orderRestaurantRepository.findById("O01"); assertThat(updatedOrderOptional).isPresent(); assertThat(updatedOrderOptional.get().getMenus()).hasSize(2); - assertThat(updatedOrderOptional.get().getMenus()).contains(menuRestaurant1, menuRestaurant3); - assertThat(updatedOrderOptional.get().getMenus()).doesNotContain(menuRestaurant2); + assertThat(Converter.convertQtyMenus2Menus(updatedOrderOptional.get().getMenus())).contains(menuRestaurant1, menuRestaurant3); + assertThat(Converter.convertQtyMenus2Menus(updatedOrderOptional.get().getMenus())).doesNotContain(menuRestaurant2); // Delete the order and verify the cascade deletion of the order-menu association orderRestaurantRepository.delete(order); @@ -424,9 +430,9 @@ public void testCascadingDeletionOfMenusAndOrders() { assertThat(menuRestaurant1Optional).isPresent(); assertThat(menuRestaurant2Optional).isPresent(); assertThat(menuRestaurant3Optional).isPresent(); - assertThat(menuRestaurant1Optional.get().getOrders()).isEmpty(); - assertThat(menuRestaurant2Optional.get().getOrders()).isEmpty(); - assertThat(menuRestaurant3Optional.get().getOrders()).isEmpty(); +// assertThat(menuRestaurant1Optional.get().getOrders()).isEmpty(); +// assertThat(menuRestaurant2Optional.get().getOrders()).isEmpty(); +// assertThat(menuRestaurant3Optional.get().getOrders()).isEmpty(); } // Adding Menus to an EatInOrder: Verifies that menus can be added @@ -448,7 +454,7 @@ public void testAddingMenusToEatInOrder() { tableRestaurantRepository.save(table2); // Create an EatInOrder and add menus - EatInOrderRestaurant eatInOrder = new EatInOrderRestaurant("EO1", new Date(), "John", 4, 43.96, true, new ArrayList<>(), new ArrayList<>(Arrays.asList(table1, table2))); + EatInOrderRestaurant eatInOrder = new EatInOrderRestaurant("EO1", new Date(), "John", 4, 43.96, true, (List)null, new ArrayList<>(Arrays.asList(table1, table2))); eatInOrder.addMenu(menuRestaurant1); eatInOrder.addMenu(menuRestaurant2); eatInOrder.addMenu(menuRestaurant3); @@ -458,7 +464,7 @@ public void testAddingMenusToEatInOrder() { Optional foundOrder = (Optional) eatInOrderRestaurantRepository.findById("EO1"); assertThat(foundOrder).isPresent(); assertThat(foundOrder.get().getMenus()).hasSize(3); - assertThat(foundOrder.get().getMenus()).contains(menuRestaurant1, menuRestaurant2, menuRestaurant3); + assertThat(Converter.convertQtyMenus2Menus(foundOrder.get().getMenus())).contains(menuRestaurant1, menuRestaurant2, menuRestaurant3); } // Removing Menus from an EatInOrder: Checks that menus can be removed from an EatInOrder @@ -494,11 +500,11 @@ public void testRemovingMenusFromEatInOrder() { Optional updatedOrderOptional = (Optional) eatInOrderRestaurantRepository.findById("EO1"); assertThat(updatedOrderOptional).isPresent(); assertThat(updatedOrderOptional.get().getMenus()).hasSize(2); - assertThat(updatedOrderOptional.get().getMenus()).contains(menuRestaurant1, menuRestaurant3); - assertThat(updatedOrderOptional.get().getMenus()).doesNotContain(menuRestaurant2); + assertThat(Converter.convertQtyMenus2Menus(updatedOrderOptional.get().getMenus())).contains(menuRestaurant1, menuRestaurant3); + assertThat(Converter.convertQtyMenus2Menus(updatedOrderOptional.get().getMenus())).doesNotContain(menuRestaurant2); } -*/ + } From 7dc7464a43a130dfea88df2d3f838036b9c7b89a Mon Sep 17 00:00:00 2001 From: jc-programs Date: Wed, 30 Oct 2024 12:19:36 +0100 Subject: [PATCH 06/28] almost all test fixed --- .../restaurantManager/model/OrderRestaurant.java | 2 +- .../restaurantManager/model/TableRestaurant.java | 1 + .../restaurantManager/utilities/Converter.java | 1 + .../RelationshipsOrderRestaurantTest.java | 11 ++++++----- 4 files changed, 9 insertions(+), 6 deletions(-) diff --git a/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java index 2326372..c52973e 100644 --- a/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java @@ -26,7 +26,7 @@ public class OrderRestaurant { private boolean paid; @JsonIgnore - @ManyToMany(fetch = FetchType.LAZY + @ManyToMany(fetch = FetchType.EAGER , cascade = {CascadeType.PERSIST, CascadeType.MERGE}) @JoinTable( name = "ORDER_MENU_QUANTITY", diff --git a/src/main/java/dev/example/restaurantManager/model/TableRestaurant.java b/src/main/java/dev/example/restaurantManager/model/TableRestaurant.java index 2ce3946..580b4a2 100644 --- a/src/main/java/dev/example/restaurantManager/model/TableRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/TableRestaurant.java @@ -25,6 +25,7 @@ public class TableRestaurant { // we must create a VERY CONCRETE constructor to RUN the OLD tests public TableRestaurant(String name, String description, int qty, boolean busy) { + this.id = name; this.name = name; this.description = description; this.qty = qty; diff --git a/src/main/java/dev/example/restaurantManager/utilities/Converter.java b/src/main/java/dev/example/restaurantManager/utilities/Converter.java index f5b5150..4f7423d 100644 --- a/src/main/java/dev/example/restaurantManager/utilities/Converter.java +++ b/src/main/java/dev/example/restaurantManager/utilities/Converter.java @@ -21,6 +21,7 @@ public static List convertMenus2QtyMenus(OrderRestaurant order, Li omq.setMenu(m.getKey()); omq.setQuantity(m.getValue()); omq.setOrder(order); + menusNew.add(omq); } return menusNew; } diff --git a/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java b/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java index 55f49bd..d8a4e7f 100644 --- a/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java +++ b/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java @@ -228,7 +228,7 @@ public void testAddingMenusToOrder() { // Retrieve the menus and assert the order - assertThat(foundOrder.get().getMenus()) + assertThat(Converter.convertQtyMenus2Menus(foundOrder.get().getMenus())) .extracting("id") .containsExactlyInAnyOrder("M01", "M02", "M03"); assertThat(Converter.convertQtyMenus2Menus(foundOrder.get().getMenus())) @@ -262,16 +262,16 @@ public void testAddingRepeatedMenusToOrder() { // Retrieve the order and assert the menus Optional foundOrder = orderRestaurantRepository.findById("O01"); assertThat(foundOrder).isPresent(); - assertThat(foundOrder.get().getMenus()).hasSize(6); + assertThat(foundOrder.get().getMenus()).hasSize(3); // Since we've implemented equals() and hashCode() methods based on // the compilation of all fields except for orders. // This avoids potential circular reference issues while still providing a comprehensive comparison of the menu items. // we can now use contains() to check if the retrieved menus match the original ones assertThat(Converter.convertQtyMenus2Menus(foundOrder.get().getMenus())).contains(menuRestaurant1, menuRestaurant2, menuRestaurant2, menuRestaurant3, menuRestaurant3, menuRestaurant3); // Retrieve the menus and assert the order - assertThat(foundOrder.get().getMenus()) + assertThat(Converter.convertQtyMenus2Menus(foundOrder.get().getMenus())) .extracting("id") - .containsExactlyInAnyOrder("M01", "M02", "M02","M03, M03, M03"); + .containsExactlyInAnyOrder("M01", "M02", "M02","M03", "M03", "M03"); assertThat(Converter.convertQtyMenus2Menus(foundOrder.get().getMenus())) .usingElementComparator(Comparator.comparing(MenuRestaurant::getId)) .containsExactlyInAnyOrder(menuRestaurant1, menuRestaurant2, menuRestaurant2, menuRestaurant3, menuRestaurant3, menuRestaurant3 ); @@ -304,7 +304,8 @@ public void testRemovingMenusFromOrder() { OrderRestaurant updatedOrder = foundOrder.get(); // Let's remove the second menu //updatedOrder.removeMenu(menuRestaurant2); - updatedOrder.removeMenu(Converter.convertQtyMenus2Menus(updatedOrder.getMenus()).get(1)); +// updatedOrder.removeMenu(Converter.convertQtyMenus2Menus(updatedOrder.getMenus()).get(1)); + updatedOrder.removeMenu(menuRestaurant2); orderRestaurantRepository.save(updatedOrder); // Retrieve the updated order and assert the menus From 41f625b11dd350c6d26ebdd098128e9e94477fb0 Mon Sep 17 00:00:00 2001 From: jc-programs Date: Wed, 30 Oct 2024 13:07:16 +0100 Subject: [PATCH 07/28] all tests ok --- .../example/restaurantManager/model/EatInOrderRestaurant.java | 2 ++ .../dev/example/restaurantManager/model/OrderMenuQty.java | 4 ++-- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java index 8c90c97..e39bb04 100644 --- a/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java @@ -1,6 +1,7 @@ package dev.example.restaurantManager.model; import jakarta.persistence.Entity; +import jakarta.persistence.Transient; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; @@ -15,6 +16,7 @@ @Entity public class EatInOrderRestaurant extends OrderRestaurant { + @Transient private ArrayList tableRestaurants = new ArrayList<>(); //private TableRestaurant orderedTableRestaurant; diff --git a/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java index ace8edd..f8e20a9 100644 --- a/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java +++ b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java @@ -12,13 +12,13 @@ public class OrderMenuQty { @GenericGenerator(name = "UUID", strategy = "org.hibernate.id.UUIDGenerator") private String id; - @ManyToOne + @ManyToOne(cascade = CascadeType.ALL) @JoinColumn(name = "order_id") private OrderRestaurant order; private int quantity; - @ManyToOne + @ManyToOne(cascade = CascadeType.ALL) @JoinColumn(name = "menu_id") private MenuRestaurant menu; From 05690e27bed74c940e394513a3bcbcf0173e6d50 Mon Sep 17 00:00:00 2001 From: jc-programs Date: Wed, 30 Oct 2024 13:16:57 +0100 Subject: [PATCH 08/28] OrderMenuQtyRepository --- .../repository/OrderMenuQtyRepository.java | 6 ++++++ .../restaurantManager/OrderMenuQtyRepositoryTest.java | 3 +++ 2 files changed, 9 insertions(+) create mode 100644 src/main/java/dev/example/restaurantManager/repository/OrderMenuQtyRepository.java create mode 100644 src/test/java/dev/example/restaurantManager/OrderMenuQtyRepositoryTest.java diff --git a/src/main/java/dev/example/restaurantManager/repository/OrderMenuQtyRepository.java b/src/main/java/dev/example/restaurantManager/repository/OrderMenuQtyRepository.java new file mode 100644 index 0000000..ca18861 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/repository/OrderMenuQtyRepository.java @@ -0,0 +1,6 @@ +package dev.example.restaurantManager.repository; + +import dev.example.restaurantManager.model.OrderMenuQty; +import org.springframework.data.jpa.repository.JpaRepository; + +public interface OrderMenuQtyRepository extends JpaRepository {} diff --git a/src/test/java/dev/example/restaurantManager/OrderMenuQtyRepositoryTest.java b/src/test/java/dev/example/restaurantManager/OrderMenuQtyRepositoryTest.java new file mode 100644 index 0000000..d0fb4d6 --- /dev/null +++ b/src/test/java/dev/example/restaurantManager/OrderMenuQtyRepositoryTest.java @@ -0,0 +1,3 @@ +package dev.example.restaurantManager; + +class OrderMenuQtyRepositoryTest {} From b82ba645c5f1fb3c4207da62f2c429c47121d18f Mon Sep 17 00:00:00 2001 From: jc-programs Date: Wed, 30 Oct 2024 13:44:08 +0100 Subject: [PATCH 09/28] add some test. Not finished jet --- .../restaurantManager/model/OrderMenuQty.java | 10 ++++ .../model/OrderRestaurant.java | 40 ++++++++++++++ .../OrderMenuQtyRepositoryTest.java | 3 -- .../restaurantManager/OrderMenuQtyTest.java | 53 +++++++++++++++++-- 4 files changed, 99 insertions(+), 7 deletions(-) delete mode 100644 src/test/java/dev/example/restaurantManager/OrderMenuQtyRepositoryTest.java diff --git a/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java index f8e20a9..827a246 100644 --- a/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java +++ b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java @@ -4,6 +4,8 @@ import lombok.Data; import org.hibernate.annotations.GenericGenerator; +import java.util.Objects; + @Data @Entity public class OrderMenuQty { @@ -27,4 +29,12 @@ public String toString(){ return menu.getId() + " qty: " + this.quantity; } + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (!(o instanceof OrderMenuQty that)) return false; + return quantity == that.quantity && Objects.equals(id, that.id) && Objects.equals(order, that.order) && Objects.equals(menu, that.menu); + } + + } diff --git a/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java index c52973e..bceca64 100644 --- a/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java @@ -47,6 +47,28 @@ public OrderRestaurant(String id, Date date, String waiter, int peopleQty, } + public List addMenuQty(MenuRestaurant menu, int qty) { + if(this.getMenus()==null){ + this.setMenus(new ArrayList()); + } + boolean found = false; + for(OrderMenuQty omq: this.getMenus()){ + if(omq.getMenu().equals(menu)){ + omq.setQuantity(omq.getQuantity()+qty); + found = true; + break; + } + } + if(!found){ + OrderMenuQty omq = new OrderMenuQty(); + omq.setMenu(menu); + omq.setQuantity(qty); + omq.setOrder(this); + this.getMenus().add(omq); + } + return this.getMenus(); + } + public List addMenu(MenuRestaurant menu) { if(this.getMenus()==null){ this.setMenus(new ArrayList()); @@ -69,6 +91,24 @@ public List addMenu(MenuRestaurant menu) { return this.getMenus(); } + public List removeMenuQty(MenuRestaurant menu, int qty) { + if(this.getMenus()==null){ + return null; + } + for(OrderMenuQty omq: this.getMenus()){ + if(omq.getMenu().equals(menu)){ + int oldQty = omq.getQuantity(); + if (oldQty > qty) { + omq.setQuantity(omq.getQuantity() - qty); + } else{ + this.getMenus().remove(omq); + } + break; + } + } + return this.getMenus(); + } + public List removeMenu(MenuRestaurant menu) { if(this.getMenus()==null){ return null; diff --git a/src/test/java/dev/example/restaurantManager/OrderMenuQtyRepositoryTest.java b/src/test/java/dev/example/restaurantManager/OrderMenuQtyRepositoryTest.java deleted file mode 100644 index d0fb4d6..0000000 --- a/src/test/java/dev/example/restaurantManager/OrderMenuQtyRepositoryTest.java +++ /dev/null @@ -1,3 +0,0 @@ -package dev.example.restaurantManager; - -class OrderMenuQtyRepositoryTest {} diff --git a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java index 2bce799..7b7f483 100644 --- a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java +++ b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java @@ -2,10 +2,7 @@ import com.github.javafaker.Faker; import dev.example.restaurantManager.model.*; -import dev.example.restaurantManager.repository.CustomerRepository; -import dev.example.restaurantManager.repository.MenuRestaurantRepository; -import dev.example.restaurantManager.repository.ShippingOrderRepository; -import dev.example.restaurantManager.repository.TableRestaurantRepository; +import dev.example.restaurantManager.repository.*; import jakarta.transaction.Transactional; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -28,6 +25,8 @@ public class OrderMenuQtyTest { CustomerRepository customerRepository; @Autowired TableRestaurantRepository tableRepository; + @Autowired + OrderMenuQtyRepository orderMenuQtyRepository; List menus; @@ -129,6 +128,52 @@ public void createOrderMenuQtyDB() { } + @Test + public void createOrderManyMenus() { + ShippingOrderRestaurant so1 = (ShippingOrderRestaurant)orders.get(1); + List menusQty = getRandomMenuQty(so1); + int nMenus = 0; + int totalQtyMenus = 0; + // for every menu qty will be greater than 1 + for(OrderMenuQty q:menusQty){ + if(q.getQuantity()<2){ + q.setQuantity(faker.random().nextInt(2,8)); + } + totalQtyMenus += q.getQuantity(); + nMenus += 1; + } + so1.setMenus(menusQty); + System.out.println("total menus: " + nMenus); + System.out.println("total qty menus: " + totalQtyMenus); + shippingOrderRepository.save(so1); + + Optional found = shippingOrderRepository.findById(so1.getId()); + assertThat(found).isPresent(); + assertThat(found.get().getId()).isEqualTo(so1.getId()); + assertThat(found.get().getMenus().stream() + .count() + ).isEqualTo(nMenus); + assertThat(found.get().getMenus().stream() + .mapToInt(omq -> omq.getQuantity()) + .sum() + ).isEqualTo(totalQtyMenus); + + + } + + @Test + public void checkOrderMenuQtyRepository() { + ShippingOrderRestaurant so1 = (ShippingOrderRestaurant) orders.get(2); + List menusQty = getRandomMenuQty(so1); + so1.setMenus(menusQty); + shippingOrderRepository.save(so1); + + List menusQtyDB = orderMenuQtyRepository.findAll(); + + assertThat(menusQtyDB).containsAll(menusQty); + + } + } From e30a79679cc84bbce5036ebdc127292d9d2c3d54 Mon Sep 17 00:00:00 2001 From: jc-programs Date: Wed, 30 Oct 2024 13:53:48 +0100 Subject: [PATCH 10/28] some new test still not working --- .../dev/example/restaurantManager/model/OrderMenuQty.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java index 827a246..81e0bf3 100644 --- a/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java +++ b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java @@ -33,7 +33,9 @@ public String toString(){ public boolean equals(Object o) { if (this == o) return true; if (!(o instanceof OrderMenuQty that)) return false; - return quantity == that.quantity && Objects.equals(id, that.id) && Objects.equals(order, that.order) && Objects.equals(menu, that.menu); + // don't check because id it's set in db + // Objects.equals(id, that.id) + return quantity == that.quantity && Objects.equals(order, that.order) && Objects.equals(menu, that.menu); } From ff54b773bd3d3ac382c6e7ca1c2996a7ad6527ff Mon Sep 17 00:00:00 2001 From: jc-programs Date: Wed, 30 Oct 2024 20:25:27 +0100 Subject: [PATCH 11/28] all my test OK --- .../java/dev/example/restaurantManager/model/Booking.java | 4 ++-- .../dev/example/restaurantManager/model/Customer.java | 2 +- .../example/restaurantManager/model/MenuRestaurant.java | 6 +----- .../example/restaurantManager/model/TableRestaurant.java | 5 +++-- .../dev/example/restaurantManager/OrderMenuQtyTest.java | 8 ++++++++ 5 files changed, 15 insertions(+), 10 deletions(-) diff --git a/src/main/java/dev/example/restaurantManager/model/Booking.java b/src/main/java/dev/example/restaurantManager/model/Booking.java index d40aecd..c38a480 100644 --- a/src/main/java/dev/example/restaurantManager/model/Booking.java +++ b/src/main/java/dev/example/restaurantManager/model/Booking.java @@ -22,11 +22,11 @@ public class Booking { //private boolean confirmed; @JsonIgnore - @ManyToOne(fetch = FetchType.LAZY) + @ManyToOne(fetch = FetchType.EAGER) @JoinColumn(name = "TABLE_RESTAURANT_FK_ID") private TableRestaurant tableRestaurantMapped; @JsonIgnore - @ManyToOne(fetch = FetchType.LAZY) + @ManyToOne(fetch = FetchType.EAGER) @JoinColumn(name = "CUSTOMER_FK_ID") private Customer customerMapped; diff --git a/src/main/java/dev/example/restaurantManager/model/Customer.java b/src/main/java/dev/example/restaurantManager/model/Customer.java index 5dcac47..5626217 100644 --- a/src/main/java/dev/example/restaurantManager/model/Customer.java +++ b/src/main/java/dev/example/restaurantManager/model/Customer.java @@ -24,7 +24,7 @@ public class Customer { private boolean deleted; @OneToMany(mappedBy = "customerMapped", cascade = CascadeType.ALL, - fetch = FetchType.EAGER) + fetch = FetchType.LAZY) private List bookings; public Customer(String id, String name, String email, String phoneNumber, diff --git a/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java index 51de20f..b1fb2a9 100644 --- a/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java @@ -1,10 +1,7 @@ package dev.example.restaurantManager.model; import com.fasterxml.jackson.annotation.JsonIgnore; -import jakarta.persistence.Entity; -import jakarta.persistence.FetchType; -import jakarta.persistence.Id; -import jakarta.persistence.ManyToMany; +import jakarta.persistence.*; import lombok.*; import java.util.ArrayList; import java.util.List; @@ -28,7 +25,6 @@ public class MenuRestaurant { // @ManyToMany(mappedBy = "menus", fetch = FetchType.LAZY) // private List orders = new ArrayList<>(); - // to execute old tests public MenuRestaurant(String id, String name, Double price, String content, boolean active, boolean water,ArrayList orders){ this(id, name, price, content, active, water); diff --git a/src/main/java/dev/example/restaurantManager/model/TableRestaurant.java b/src/main/java/dev/example/restaurantManager/model/TableRestaurant.java index 580b4a2..2695436 100644 --- a/src/main/java/dev/example/restaurantManager/model/TableRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/TableRestaurant.java @@ -5,6 +5,7 @@ import lombok.Data; import lombok.NoArgsConstructor; import java.util.ArrayList; +import java.util.List; @Data @AllArgsConstructor @@ -20,8 +21,8 @@ public class TableRestaurant { private boolean busy; @OneToMany(mappedBy = "tableRestaurantMapped", cascade = CascadeType.ALL, - fetch = FetchType.EAGER) - private ArrayList bookings ; + fetch = FetchType.LAZY) + private List bookings ; // we must create a VERY CONCRETE constructor to RUN the OLD tests public TableRestaurant(String name, String description, int qty, boolean busy) { diff --git a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java index 7b7f483..9d75a03 100644 --- a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java +++ b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java @@ -34,8 +34,16 @@ public class OrderMenuQtyTest { Faker faker; + @BeforeEach public void createDataAndSave2DB() { + shippingOrderRepository.deleteAll(); + customerRepository.deleteAll(); + orderMenuQtyRepository.deleteAll(); + menuRepository.deleteAll(); + tableRepository.deleteAll(); + + faker = new Faker(new Random(42)); // Create sample customers From 785bd7f4aaf18f7d6a6367b22994b80a57f21647 Mon Sep 17 00:00:00 2001 From: jc-programs Date: Thu, 31 Oct 2024 09:00:54 +0100 Subject: [PATCH 12/28] sync con home --- .../java/dev/example/restaurantManager/model/Booking.java | 4 ++-- .../dev/example/restaurantManager/model/Customer.java | 2 +- .../example/restaurantManager/model/MenuRestaurant.java | 6 +++++- .../example/restaurantManager/model/TableRestaurant.java | 2 +- .../dev/example/restaurantManager/OrderMenuQtyTest.java | 8 -------- 5 files changed, 9 insertions(+), 13 deletions(-) diff --git a/src/main/java/dev/example/restaurantManager/model/Booking.java b/src/main/java/dev/example/restaurantManager/model/Booking.java index c38a480..d40aecd 100644 --- a/src/main/java/dev/example/restaurantManager/model/Booking.java +++ b/src/main/java/dev/example/restaurantManager/model/Booking.java @@ -22,11 +22,11 @@ public class Booking { //private boolean confirmed; @JsonIgnore - @ManyToOne(fetch = FetchType.EAGER) + @ManyToOne(fetch = FetchType.LAZY) @JoinColumn(name = "TABLE_RESTAURANT_FK_ID") private TableRestaurant tableRestaurantMapped; @JsonIgnore - @ManyToOne(fetch = FetchType.EAGER) + @ManyToOne(fetch = FetchType.LAZY) @JoinColumn(name = "CUSTOMER_FK_ID") private Customer customerMapped; diff --git a/src/main/java/dev/example/restaurantManager/model/Customer.java b/src/main/java/dev/example/restaurantManager/model/Customer.java index 5626217..5dcac47 100644 --- a/src/main/java/dev/example/restaurantManager/model/Customer.java +++ b/src/main/java/dev/example/restaurantManager/model/Customer.java @@ -24,7 +24,7 @@ public class Customer { private boolean deleted; @OneToMany(mappedBy = "customerMapped", cascade = CascadeType.ALL, - fetch = FetchType.LAZY) + fetch = FetchType.EAGER) private List bookings; public Customer(String id, String name, String email, String phoneNumber, diff --git a/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java index b1fb2a9..51de20f 100644 --- a/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java @@ -1,7 +1,10 @@ package dev.example.restaurantManager.model; import com.fasterxml.jackson.annotation.JsonIgnore; -import jakarta.persistence.*; +import jakarta.persistence.Entity; +import jakarta.persistence.FetchType; +import jakarta.persistence.Id; +import jakarta.persistence.ManyToMany; import lombok.*; import java.util.ArrayList; import java.util.List; @@ -25,6 +28,7 @@ public class MenuRestaurant { // @ManyToMany(mappedBy = "menus", fetch = FetchType.LAZY) // private List orders = new ArrayList<>(); + // to execute old tests public MenuRestaurant(String id, String name, Double price, String content, boolean active, boolean water,ArrayList orders){ this(id, name, price, content, active, water); diff --git a/src/main/java/dev/example/restaurantManager/model/TableRestaurant.java b/src/main/java/dev/example/restaurantManager/model/TableRestaurant.java index 2695436..41a4757 100644 --- a/src/main/java/dev/example/restaurantManager/model/TableRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/TableRestaurant.java @@ -21,7 +21,7 @@ public class TableRestaurant { private boolean busy; @OneToMany(mappedBy = "tableRestaurantMapped", cascade = CascadeType.ALL, - fetch = FetchType.LAZY) + fetch = FetchType.EAGER) private List bookings ; // we must create a VERY CONCRETE constructor to RUN the OLD tests diff --git a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java index 9d75a03..7b7f483 100644 --- a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java +++ b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java @@ -34,16 +34,8 @@ public class OrderMenuQtyTest { Faker faker; - @BeforeEach public void createDataAndSave2DB() { - shippingOrderRepository.deleteAll(); - customerRepository.deleteAll(); - orderMenuQtyRepository.deleteAll(); - menuRepository.deleteAll(); - tableRepository.deleteAll(); - - faker = new Faker(new Random(42)); // Create sample customers From 395a60b5f4760175de8e10ece1bc4b99109d0b94 Mon Sep 17 00:00:00 2001 From: jc-programs Date: Thu, 31 Oct 2024 13:45:22 +0100 Subject: [PATCH 13/28] nuevo test para comprobar borrado de OrderMenuQty. Solo funciona desde Order --- .../controller/OrderController.java | 87 +++++++++++++++++++ .../restaurantManager/model/OrderMenuQty.java | 2 +- .../service/OrderService.java | 15 ++++ .../service/OrderServiceImpl.java | 47 ++++++++++ .../restaurantManager/OrderMenuQtyTest.java | 43 +++++++++ 5 files changed, 193 insertions(+), 1 deletion(-) create mode 100644 src/main/java/dev/example/restaurantManager/controller/OrderController.java create mode 100644 src/main/java/dev/example/restaurantManager/service/OrderService.java create mode 100644 src/main/java/dev/example/restaurantManager/service/OrderServiceImpl.java diff --git a/src/main/java/dev/example/restaurantManager/controller/OrderController.java b/src/main/java/dev/example/restaurantManager/controller/OrderController.java new file mode 100644 index 0000000..ea49b63 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/controller/OrderController.java @@ -0,0 +1,87 @@ +package dev.example.restaurantManager.controller; + +import dev.example.restaurantManager.model.OrderRestaurant; +import dev.example.restaurantManager.service.OrderService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; + +import java.util.Date; +import java.util.List; + +@RequestMapping("/api/v1/order") +@RestController +public class OrderController { + + @Autowired + private OrderService orderService; + + // manage request by ResponseEntity with all orders + @GetMapping("/allOrders") + public ResponseEntity> getAllOrders( ) { + List orders = orderService.getAllOrders(); + HttpHeaders headers = getCommonHeaders("Get all orders"); + + return orders != null && !orders.isEmpty() + ? new ResponseEntity<>(orders, headers, HttpStatus.OK) + : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + } + + @PostMapping + public ResponseEntity createOrder(@RequestBody OrderRestaurant order) { + OrderRestaurant createdOrder = orderService.createOrder(order); + HttpHeaders headers = getCommonHeaders("Create a new order"); + + return createdOrder != null + ? new ResponseEntity<>(createdOrder, headers, HttpStatus.CREATED) + : new ResponseEntity<>(headers, HttpStatus.BAD_REQUEST); + } + + @PutMapping("/{id}") + public ResponseEntity updateOrder(@PathVariable String id, @RequestBody OrderRestaurant orderDetails) { + OrderRestaurant updatedOrder = orderService.updateOrder(id, orderDetails); + HttpHeaders headers = getCommonHeaders("Update an order"); + + return updatedOrder != null + ? new ResponseEntity<>(updatedOrder, headers, HttpStatus.OK) + : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + } + + @DeleteMapping("/{id}") + public ResponseEntity deleteOrder(@PathVariable String id) { + boolean deleted = orderService.deleteOrder(id); + HttpHeaders headers = getCommonHeaders("Delete an order"); + headers.add("deleted", String.valueOf(deleted)); + + + return deleted + ? new ResponseEntity<>(headers, HttpStatus.NO_CONTENT) + : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + } + + @GetMapping("/{id}") + public ResponseEntity getOrderById(@PathVariable String id) { + OrderRestaurant order = orderService.getOrderById(id); + HttpHeaders headers = getCommonHeaders("Get an order by Id"); + + return order != null + ? new ResponseEntity<>(order, headers, HttpStatus.OK) + : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + } + + private HttpHeaders getCommonHeaders(String description) { + HttpHeaders headers = new HttpHeaders(); + headers.add("desc", description); + headers.add("content-type", "application/json"); + headers.add("date", new Date().toString()); + headers.add("server", "H2 Database"); + headers.add("version", "1.0.0"); + headers.add("order-count", String.valueOf(orderService.countOrders())); + headers.add("object", "orders"); + return headers; + } + + +} diff --git a/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java index 81e0bf3..c01a558 100644 --- a/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java +++ b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java @@ -26,7 +26,7 @@ public class OrderMenuQty { @Override public String toString(){ - return menu.getId() + " qty: " + this.quantity; + return "id=" + id + ", menú: " + menu.getId() + ", qty: " + this.quantity; } @Override diff --git a/src/main/java/dev/example/restaurantManager/service/OrderService.java b/src/main/java/dev/example/restaurantManager/service/OrderService.java new file mode 100644 index 0000000..8553e10 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/OrderService.java @@ -0,0 +1,15 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.OrderRestaurant; + +import java.util.List; + +public interface OrderService { + List getAllOrders(); + OrderRestaurant createOrder(OrderRestaurant order); + OrderRestaurant getOrderById(String id); + OrderRestaurant updateOrder(String id, OrderRestaurant orderDetails); + boolean deleteOrder(String id); + long countOrders(); + +} diff --git a/src/main/java/dev/example/restaurantManager/service/OrderServiceImpl.java b/src/main/java/dev/example/restaurantManager/service/OrderServiceImpl.java new file mode 100644 index 0000000..0d8ee69 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/OrderServiceImpl.java @@ -0,0 +1,47 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.OrderRestaurant; +import dev.example.restaurantManager.repository.OrderRestaurantRepository; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.util.List; + +@Service +public class OrderServiceImpl implements OrderService{ + @Autowired + OrderRestaurantRepository orderRepository; + + @Override + public List getAllOrders() { + return orderRepository.findAll(); + } + + @Override + public OrderRestaurant createOrder(OrderRestaurant order) { + return orderRepository.save(order); + } + + @Override + public OrderRestaurant getOrderById(String id) { + return orderRepository.findById(id).orElse(null); + } + + @Override + public OrderRestaurant updateOrder(String id, OrderRestaurant orderDetails) { + OrderRestaurant order = getOrderById(id); + return orderRepository.save(orderDetails); + } + + @Override + public boolean deleteOrder(String id) { + boolean find = getOrderById(id) != null; + orderRepository.deleteById(id); + return find; + } + + @Override + public long countOrders() { + return 0; + } +} diff --git a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java index 7b7f483..b1c2f0a 100644 --- a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java +++ b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java @@ -174,6 +174,49 @@ public void checkOrderMenuQtyRepository() { } + @Test + public void createOrderAndDeleteSomeMenus() { + ShippingOrderRestaurant so1 = (ShippingOrderRestaurant) orders.get(0); + List menusQty = getRandomMenuQty(so1); + so1.setMenus(menusQty); + shippingOrderRepository.save(so1); + + + + Optional found = shippingOrderRepository.findById(so1.getId()); + assertThat(found).isPresent(); + assertThat(found.get().getId()).isEqualTo(so1.getId()); + ShippingOrderRestaurant soDB = found.get(); + List menus =soDB.getMenus(); + System.out.println(menus); + + String id = menus.get(0).getId(); + OrderMenuQty omq =menus.get(0); + so1.removeMenuQty(omq.getMenu(),omq.getQuantity()); + shippingOrderRepository.save(so1); + + + // https://stackoverflow.com/questions/22688402/delete-not-working-with-jparepository + // orderMenuQtyRepository.deleteById(id); + // orderMenuQtyRepository.flush(); + found = shippingOrderRepository.findById(so1.getId()); + ShippingOrderRestaurant soDB2 = found.get(); + List menus2 =soDB2.getMenus(); + System.out.println(menus2); + List menus3 = orderMenuQtyRepository.findAll(); + + + +// assertThat(found.get().getMenus().stream() +// .count() +// ).isEqualTo(nMenus); +// +// +// List menusQtyDB = orderMenuQtyRepository.findAll(); +// +// assertThat(menusQtyDB).containsAll(menusQty); + + } } From 4d8892fa475912ec0e9deec90292fabb9b8f1278 Mon Sep 17 00:00:00 2001 From: jc-programs Date: Mon, 4 Nov 2024 11:47:44 +0100 Subject: [PATCH 14/28] sql por console log --- src/main/resources/application-memory.properties | 5 ++++- .../java/dev/example/restaurantManager/OrderMenuQtyTest.java | 5 +++-- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/src/main/resources/application-memory.properties b/src/main/resources/application-memory.properties index dd79a7c..12d89f6 100644 --- a/src/main/resources/application-memory.properties +++ b/src/main/resources/application-memory.properties @@ -13,4 +13,7 @@ spring.jpa.hibernate.ddl-auto=create-drop # create-drop ? similar to create, with the addition that # Hibernate will drop the database after all operations are completed; # typically used for unit testing -#https://albertprofe.dev/springboot/sblab0-5.html#ddl \ No newline at end of file +#https://albertprofe.dev/springboot/sblab0-5.html#ddl + +spring.jpa.show-sql=true +spring.jpa.properties.hibernate.format_sql=true \ No newline at end of file diff --git a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java index b1c2f0a..0d3e1c7 100644 --- a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java +++ b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java @@ -195,9 +195,10 @@ public void createOrderAndDeleteSomeMenus() { so1.removeMenuQty(omq.getMenu(),omq.getQuantity()); shippingOrderRepository.save(so1); - // https://stackoverflow.com/questions/22688402/delete-not-working-with-jparepository - // orderMenuQtyRepository.deleteById(id); + System.out.println("before deleteById"); + orderMenuQtyRepository.deleteById(id); + System.out.println("after deleteById"); // orderMenuQtyRepository.flush(); found = shippingOrderRepository.findById(so1.getId()); ShippingOrderRestaurant soDB2 = found.get(); From 30a5cd20f7b15186dca0dea072074ea893b46212 Mon Sep 17 00:00:00 2001 From: jc-programs Date: Mon, 4 Nov 2024 17:59:16 +0100 Subject: [PATCH 15/28] createOrderAndDeleteSomeQtyMenusWithMenuQtyRepository not working --- .../restaurantManager/OrderMenuQtyTest.java | 88 ++++++++++++++++--- 1 file changed, 75 insertions(+), 13 deletions(-) diff --git a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java index 0d3e1c7..6f01cd8 100644 --- a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java +++ b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java @@ -35,7 +35,15 @@ public class OrderMenuQtyTest { Faker faker; @BeforeEach - public void createDataAndSave2DB() { + public void createDataAndSave2DBWithoutRelationship() { + // delete all data + customerRepository.deleteAll(); + tableRepository.deleteAll(); + orderMenuQtyRepository.deleteAll(); + menuRepository.deleteAll(); + shippingOrderRepository.deleteAll(); + + // create always same data faker = new Faker(new Random(42)); // Create sample customers @@ -111,12 +119,17 @@ public void createOrderMenuQtyDB() { ShippingOrderRestaurant so1 = (ShippingOrderRestaurant)orders.get(0); List menusQty = getRandomMenuQty(so1); so1.setMenus(menusQty); + // save relationship to DB shippingOrderRepository.save(so1); + // check if shipping order is in DB Optional found = shippingOrderRepository.findById(so1.getId()); assertThat(found).isPresent(); ShippingOrderRestaurant so1DB = found.get(); + // check if shipping order has all his menus saved to DB + // this method must be @Transactional because + // menus in order are fetch.LAZY int nMenus = so1DB.getMenus().size(); for(int i=0;i menusQty = getRandomMenuQty(so1); int nMenus = 0; int totalQtyMenus = 0; - // for every menu qty will be greater than 1 + // every menu qty will be greater than 1 for(OrderMenuQty q:menusQty){ if(q.getQuantity()<2){ q.setQuantity(faker.random().nextInt(2,8)); @@ -163,48 +176,75 @@ public void createOrderManyMenus() { @Test public void checkOrderMenuQtyRepository() { + List menusQtyDB = orderMenuQtyRepository.findAll(); + // no relationship is on DB + assertThat(menusQtyDB.size()).isEqualTo(0); + ShippingOrderRestaurant so1 = (ShippingOrderRestaurant) orders.get(2); List menusQty = getRandomMenuQty(so1); so1.setMenus(menusQty); + // save some relationships shippingOrderRepository.save(so1); - List menusQtyDB = orderMenuQtyRepository.findAll(); + menusQtyDB = orderMenuQtyRepository.findAll(); + // check relationships are the same that we assign assertThat(menusQtyDB).containsAll(menusQty); } @Test - public void createOrderAndDeleteSomeMenus() { + public void createOrderAndDeleteSomeQtyMenus() { ShippingOrderRestaurant so1 = (ShippingOrderRestaurant) orders.get(0); List menusQty = getRandomMenuQty(so1); so1.setMenus(menusQty); + int nMenusOriginal = menusQty.size(); + // save some order with some menus shippingOrderRepository.save(so1); - + // get order from DB Optional found = shippingOrderRepository.findById(so1.getId()); assertThat(found).isPresent(); + // check order from DB is the same as in memory assertThat(found.get().getId()).isEqualTo(so1.getId()); ShippingOrderRestaurant soDB = found.get(); - List menus =soDB.getMenus(); + // print menu qty from order + List menus = soDB.getMenus(); + int nMenus1 = menus.size(); System.out.println(menus); + // delete first menu qty from order and save to DB using + // method removeMenuQty from OrderRestaurant + // and save to DB String id = menus.get(0).getId(); - OrderMenuQty omq =menus.get(0); + OrderMenuQty omq = menus.get(0); so1.removeMenuQty(omq.getMenu(),omq.getQuantity()); shippingOrderRepository.save(so1); - // https://stackoverflow.com/questions/22688402/delete-not-working-with-jparepository - System.out.println("before deleteById"); - orderMenuQtyRepository.deleteById(id); - System.out.println("after deleteById"); - // orderMenuQtyRepository.flush(); + // load the order from DB + // now should have 1 menu qty less found = shippingOrderRepository.findById(so1.getId()); ShippingOrderRestaurant soDB2 = found.get(); - List menus2 =soDB2.getMenus(); + List menus2 = soDB2.getMenus(); + int nMenus2 = menus2.size(); System.out.println(menus2); List menus3 = orderMenuQtyRepository.findAll(); + assertThat(nMenusOriginal).isEqualTo(nMenus1); + assertThat(nMenusOriginal-1).isEqualTo(nMenus2); + + + + // https://stackoverflow.com/questions/22688402/delete-not-working-with-jparepository + // System.out.println("before deleteById"); + // orderMenuQtyRepository.deleteById(id); + // System.out.println("after deleteById"); + // orderMenuQtyRepository.flush(); +// found = shippingOrderRepository.findById(so1.getId()); +// ShippingOrderRestaurant soDB2 = found.get(); +// List menus2 =soDB2.getMenus(); +// System.out.println(menus2); +// List menus3 = orderMenuQtyRepository.findAll(); @@ -220,4 +260,26 @@ public void createOrderAndDeleteSomeMenus() { } + @Test + public void createOrderAndDeleteSomeQtyMenusWithMenuQtyRepository() { + ShippingOrderRestaurant so1 = (ShippingOrderRestaurant) orders.get(0); + List menusQty = getRandomMenuQty(so1); + so1.setMenus(menusQty); + int nMenusOriginal = menusQty.size(); + // save some order with some menus + shippingOrderRepository.save(so1); + + List menusQtyDB = orderMenuQtyRepository.findAll(); + String id = menusQtyDB.get(0).getId(); + orderMenuQtyRepository.deleteById(id); + List menusQtyDB2 = orderMenuQtyRepository.findAll(); + Optional found = shippingOrderRepository.findById(so1.getId()); + ShippingOrderRestaurant soDB2 = found.get(); + int nMenusAfterDelete = soDB2.getMenus().size(); + + assertThat(nMenusOriginal-1).isEqualTo(nMenusAfterDelete); + + } + + } From fa5aee127cf11a33dfaff801537412d85697474a Mon Sep 17 00:00:00 2001 From: jc-programs Date: Tue, 5 Nov 2024 07:41:29 +0100 Subject: [PATCH 16/28] trying delete from orderMenuQtyRepository --- .../repository/OrderMenuQtyRepository.java | 12 ++++++++- .../restaurantManager/OrderMenuQtyTest.java | 26 ++++++++++++++++--- 2 files changed, 34 insertions(+), 4 deletions(-) diff --git a/src/main/java/dev/example/restaurantManager/repository/OrderMenuQtyRepository.java b/src/main/java/dev/example/restaurantManager/repository/OrderMenuQtyRepository.java index ca18861..b2944ee 100644 --- a/src/main/java/dev/example/restaurantManager/repository/OrderMenuQtyRepository.java +++ b/src/main/java/dev/example/restaurantManager/repository/OrderMenuQtyRepository.java @@ -1,6 +1,16 @@ package dev.example.restaurantManager.repository; import dev.example.restaurantManager.model.OrderMenuQty; +import jakarta.transaction.Transactional; import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Modifying; +import org.springframework.data.jpa.repository.Query; -public interface OrderMenuQtyRepository extends JpaRepository {} +public interface OrderMenuQtyRepository extends JpaRepository { + + @Modifying + @Transactional + @Query("delete from OrderMenuQty omq where omq.id = ?1") + void delete2(String id); + +} diff --git a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java index 6f01cd8..11bdc25 100644 --- a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java +++ b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java @@ -269,10 +269,30 @@ public void createOrderAndDeleteSomeQtyMenusWithMenuQtyRepository() { // save some order with some menus shippingOrderRepository.save(so1); + List menusQtyDB = orderMenuQtyRepository.findAll(); - String id = menusQtyDB.get(0).getId(); - orderMenuQtyRepository.deleteById(id); - List menusQtyDB2 = orderMenuQtyRepository.findAll(); + OrderMenuQty omq = menusQtyDB.get(0); + + int test = 4; + if( test==1){ + omq.setMenu(null); + omq.setOrder(null); + orderMenuQtyRepository.save(omq); + orderMenuQtyRepository.delete(omq); + assertThat(orderMenuQtyRepository.findAll().size()).isEqualTo(2); + } else if( test==2) { + orderMenuQtyRepository.delete(omq); + assertThat(orderMenuQtyRepository.findAll().size()).isEqualTo(2); + } else if( test==3) { + orderMenuQtyRepository.delete2(omq.getId()); + assertThat(orderMenuQtyRepository.findAll().size()).isEqualTo(2); + } else if( test==4) { + String id = menusQtyDB.get(0).getId(); + orderMenuQtyRepository.deleteById(id); + assertThat(orderMenuQtyRepository.findAll().size()).isEqualTo(2); + } + + Optional found = shippingOrderRepository.findById(so1.getId()); ShippingOrderRestaurant soDB2 = found.get(); int nMenusAfterDelete = soDB2.getMenus().size(); From 14143a155a4fb0bba6ee5dd7b50734ed17d304e7 Mon Sep 17 00:00:00 2001 From: jc-programs Date: Tue, 5 Nov 2024 12:01:43 +0100 Subject: [PATCH 17/28] created FakeDataLoader to generate fake data --- .../controller/OrderController.java | 33 +++++ .../repository/OrderMenuQtyRepository.java | 2 +- .../utilities/FakeDataLoader.java | 118 ++++++++++++++++++ .../restaurantManager/OrderMenuQtyTest.java | 118 ++++-------------- 4 files changed, 173 insertions(+), 98 deletions(-) create mode 100644 src/main/java/dev/example/restaurantManager/utilities/FakeDataLoader.java diff --git a/src/main/java/dev/example/restaurantManager/controller/OrderController.java b/src/main/java/dev/example/restaurantManager/controller/OrderController.java index ea49b63..2ec4217 100644 --- a/src/main/java/dev/example/restaurantManager/controller/OrderController.java +++ b/src/main/java/dev/example/restaurantManager/controller/OrderController.java @@ -1,5 +1,7 @@ package dev.example.restaurantManager.controller; +import dev.example.restaurantManager.model.MenuRestaurant; +import dev.example.restaurantManager.model.OrderMenuQty; import dev.example.restaurantManager.model.OrderRestaurant; import dev.example.restaurantManager.service.OrderService; import org.springframework.beans.factory.annotation.Autowired; @@ -61,6 +63,37 @@ public ResponseEntity deleteOrder(@PathVariable String id) { : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); } + + @PutMapping("/{id}/menus/{menus}") + public ResponseEntity updateOrder(@PathVariable String id, @RequestBody List menus) { + OrderRestaurant order = orderService.getOrderById(id); + HttpHeaders headers = getCommonHeaders("Add menu qties to order"); + if( order==null ){ + return new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + } + for (MenuRestaurant m : menus) { + order.addMenu(m); + } + OrderRestaurant orderUpdated = orderService.updateOrder(id,order); + + return orderUpdated != null + ? new ResponseEntity<>(orderUpdated, headers, HttpStatus.OK) + : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + } + +// @DeleteMapping("/{id}") +// public ResponseEntity deleteOrder(@PathVariable String id) { +// boolean deleted = orderService.deleteOrder(id); +// HttpHeaders headers = getCommonHeaders("Delete an order"); +// headers.add("deleted", String.valueOf(deleted)); +// +// +// return deleted +// ? new ResponseEntity<>(headers, HttpStatus.NO_CONTENT) +// : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); +// } + + @GetMapping("/{id}") public ResponseEntity getOrderById(@PathVariable String id) { OrderRestaurant order = orderService.getOrderById(id); diff --git a/src/main/java/dev/example/restaurantManager/repository/OrderMenuQtyRepository.java b/src/main/java/dev/example/restaurantManager/repository/OrderMenuQtyRepository.java index b2944ee..3af7a48 100644 --- a/src/main/java/dev/example/restaurantManager/repository/OrderMenuQtyRepository.java +++ b/src/main/java/dev/example/restaurantManager/repository/OrderMenuQtyRepository.java @@ -11,6 +11,6 @@ public interface OrderMenuQtyRepository extends JpaRepository menus; + private List orders; + + private Faker faker; + + public List getMenus(){ + return menus; + } + + public List getOrders(){ + return orders; + } + + public Faker getFaker(){ + return faker; + } + + + private void createFakerIfNotExists(){ + if(faker!=null){ + return; + } + + // create always same data + faker = new Faker(new Random(42)); + } + + public void createDataAndSave2DBWithoutRelationship(){ + // delete all data + customerRepository.deleteAll(); + tableRepository.deleteAll(); + orderMenuQtyRepository.deleteAll(); + menuRepository.deleteAll(); + shippingOrderRepository.deleteAll(); + + createFakerIfNotExists(); + + // Create sample customers + Customer customer1 = new Customer("C1", "John", "john@email.com", "123-456-7890", 30, false, false); + Customer customer3 = new Customer("C3", "Emily", "emily@email.com", "345-678-9012", 35, false, false); + Customer customer5 = new Customer("C5", "Anna", "anna@email.com", "567-890-1234", 28, false, false); + customerRepository.save(customer1); + customerRepository.save(customer3); + customerRepository.save(customer5); + + // Create sample tables + TableRestaurant table1 = new TableRestaurant("T1", "Window Table", 4, false); + TableRestaurant table2 = new TableRestaurant("T2", "Corner Table", 2, true); + table1.setId("T01"); + table2.setId("T02"); + tableRepository.save(table1); + tableRepository.save(table2); + + + // Create sample menus + MenuRestaurant menu1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true); + MenuRestaurant menu2 = new MenuRestaurant("M02","Pizza Menu", 12.99, "Pizza and salad", true, false); + MenuRestaurant menu3 = new MenuRestaurant("M03","Salad Menu", 8.99, "Mixed salad and dressing", true, true); + menus = new ArrayList<>(Arrays.asList(menu1,menu2,menu3)); + menuRepository.save(menu1); + menuRepository.save(menu2); + menuRepository.save(menu3); + + // Create 3 ShippingOrder objects + ShippingOrderRestaurant so1 = new ShippingOrderRestaurant("SO1", new Date(), "John", 2, 0.0, false, (List)null, "123 Main St", "New York", "Mike"); + ShippingOrderRestaurant so2 = new ShippingOrderRestaurant("SO2", new Date(), "Sarah", 1, 0.0, true, (List)null, "456 Elm St", "Los Angeles", "Tom"); + ShippingOrderRestaurant so3 = new ShippingOrderRestaurant("SO3", new Date(), "Emily", 3, 0.0, false, (List)null, "789 Oak St", "Chicago", "Lisa"); + orders = new ArrayList<>(Arrays.asList(so1,so2,so3)); + shippingOrderRepository.save(so1); + shippingOrderRepository.save(so2); + shippingOrderRepository.save(so3); + + } + + public List getRandomMenuQty(OrderRestaurant orderRestaurant){ + List menusQty = new ArrayList<>(); + for(MenuRestaurant m:menus){ + if (faker.random().nextInt(0,3) == 0){ + continue; + } + OrderMenuQty omq = new OrderMenuQty(); + omq.setOrder(orderRestaurant); + omq.setMenu(m); + omq.setQuantity(faker.random().nextInt(1,5)); + menusQty.add(omq); + } + return menusQty; + } + + + +} diff --git a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java index 11bdc25..22d9c73 100644 --- a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java +++ b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java @@ -3,6 +3,7 @@ import com.github.javafaker.Faker; import dev.example.restaurantManager.model.*; import dev.example.restaurantManager.repository.*; +import dev.example.restaurantManager.utilities.FakeDataLoader; import jakarta.transaction.Transactional; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -17,107 +18,32 @@ @SpringBootTest public class OrderMenuQtyTest { - @Autowired - MenuRestaurantRepository menuRepository; @Autowired ShippingOrderRepository shippingOrderRepository; @Autowired - CustomerRepository customerRepository; - @Autowired - TableRestaurantRepository tableRepository; - @Autowired OrderMenuQtyRepository orderMenuQtyRepository; List menus; List orders; - Faker faker; + @Autowired + FakeDataLoader dataLoader; @BeforeEach public void createDataAndSave2DBWithoutRelationship() { - // delete all data - customerRepository.deleteAll(); - tableRepository.deleteAll(); - orderMenuQtyRepository.deleteAll(); - menuRepository.deleteAll(); - shippingOrderRepository.deleteAll(); - - // create always same data - faker = new Faker(new Random(42)); - - // Create sample customers - Customer customer1 = new Customer("C1", "John", "john@email.com", "123-456-7890", 30, false, false); - Customer customer3 = new Customer("C3", "Emily", "emily@email.com", "345-678-9012", 35, false, false); - Customer customer5 = new Customer("C5", "Anna", "anna@email.com", "567-890-1234", 28, false, false); - customerRepository.save(customer1); - customerRepository.save(customer3); - customerRepository.save(customer5); - - // Create sample tables - TableRestaurant table1 = new TableRestaurant("T1", "Window Table", 4, false); - TableRestaurant table2 = new TableRestaurant("T2", "Corner Table", 2, true); - table1.setId("T01"); - table2.setId("T02"); - tableRepository.save(table1); - tableRepository.save(table2); - - - // Create sample menus - MenuRestaurant menu1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true); - MenuRestaurant menu2 = new MenuRestaurant("M02","Pizza Menu", 12.99, "Pizza and salad", true, false); - MenuRestaurant menu3 = new MenuRestaurant("M03","Salad Menu", 8.99, "Mixed salad and dressing", true, true); - menus = new ArrayList<>(Arrays.asList(menu1,menu2,menu3)); - menuRepository.save(menu1); - menuRepository.save(menu2); - menuRepository.save(menu3); - - // Create 3 ShippingOrder objects - ShippingOrderRestaurant so1 = new ShippingOrderRestaurant("SO1", new Date(), "John", 2, 0.0, false, (List)null, "123 Main St", "New York", "Mike"); - ShippingOrderRestaurant so2 = new ShippingOrderRestaurant("SO2", new Date(), "Sarah", 1, 0.0, true, (List)null, "456 Elm St", "Los Angeles", "Tom"); - ShippingOrderRestaurant so3 = new ShippingOrderRestaurant("SO3", new Date(), "Emily", 3, 0.0, false, (List)null, "789 Oak St", "Chicago", "Lisa"); - orders = new ArrayList<>(Arrays.asList(so1,so2,so3)); - shippingOrderRepository.save(so1); - shippingOrderRepository.save(so2); - shippingOrderRepository.save(so3); - -// // Create 3 EatInOrder objects -// EatInOrderRestaurant eo1 = new EatInOrderRestaurant("EO1", new Date(), "David", 4, 0.0, true, null, new ArrayList<>(Arrays.asList(table1))); -// EatInOrderRestaurant eo2 = new EatInOrderRestaurant("EO2", new Date(), "Anna", 2, 0.0, false, null, new ArrayList<>(Arrays.asList(table2))); -// EatInOrderRestaurant eo3 = new EatInOrderRestaurant("EO3", new Date(), "Mark", 6, 0.0, true, null, new ArrayList<>(Arrays.asList(table1, table2))); -// orders.addAll(Arrays.asList(eo1,eo2,eo3)); -// -// // Create 3 TakeAwayOrder objects -// TakeAwayOrder to1 = new TakeAwayOrder("TO1", new Date(), "Alice", 1, 0.0, true, null, customer1 ); -// TakeAwayOrder to2 = new TakeAwayOrder("TO2", new Date(), "Bob", 2, 0.0, false, null, customer3 ); -// TakeAwayOrder to3 = new TakeAwayOrder("TO3", new Date(), "Charlie", 3, 0.0, true, null, customer5); -// orders.addAll(Arrays.asList(to1,to2,to3)); - } - - - private List getRandomMenuQty(OrderRestaurant orderRestaurant){ - List menusQty = new ArrayList<>(); - for(MenuRestaurant m:menus){ - if (faker.random().nextInt(0,3) == 0){ - continue; - } - OrderMenuQty omq = new OrderMenuQty(); - omq.setOrder(orderRestaurant); - omq.setMenu(m); - omq.setQuantity(faker.random().nextInt(1,5)); - menusQty.add(omq); - } - return menusQty; + dataLoader.createDataAndSave2DBWithoutRelationship(); + menus = dataLoader.getMenus(); + orders = dataLoader.getOrders(); } - @Test // https://stackoverflow.com/questions/11746499/how-to-solve-the-failed-to-lazily-initialize-a-collection-of-role-hibernate-ex @Transactional // (propagation= Propagation.REQUIRED) public void createOrderMenuQtyDB() { ShippingOrderRestaurant so1 = (ShippingOrderRestaurant)orders.get(0); - List menusQty = getRandomMenuQty(so1); + List menusQty = dataLoader.getRandomMenuQty(so1); so1.setMenus(menusQty); // save relationship to DB shippingOrderRepository.save(so1); @@ -135,22 +61,19 @@ public void createOrderMenuQtyDB() { System.out.println(so1DB.getMenus().get(i)); } assertThat(so1DB.getId()).isEqualTo(so1.getId()); - - - } @Test public void createOrderManyMenus() { ShippingOrderRestaurant so1 = (ShippingOrderRestaurant)orders.get(1); - List menusQty = getRandomMenuQty(so1); + List menusQty = dataLoader.getRandomMenuQty(so1); int nMenus = 0; int totalQtyMenus = 0; // every menu qty will be greater than 1 for(OrderMenuQty q:menusQty){ if(q.getQuantity()<2){ - q.setQuantity(faker.random().nextInt(2,8)); + q.setQuantity(dataLoader.getFaker().random().nextInt(2,8)); } totalQtyMenus += q.getQuantity(); nMenus += 1; @@ -181,7 +104,7 @@ public void checkOrderMenuQtyRepository() { assertThat(menusQtyDB.size()).isEqualTo(0); ShippingOrderRestaurant so1 = (ShippingOrderRestaurant) orders.get(2); - List menusQty = getRandomMenuQty(so1); + List menusQty = dataLoader.getRandomMenuQty(so1); so1.setMenus(menusQty); // save some relationships shippingOrderRepository.save(so1); @@ -196,7 +119,7 @@ public void checkOrderMenuQtyRepository() { @Test public void createOrderAndDeleteSomeQtyMenus() { ShippingOrderRestaurant so1 = (ShippingOrderRestaurant) orders.get(0); - List menusQty = getRandomMenuQty(so1); + List menusQty = dataLoader.getRandomMenuQty(so1); so1.setMenus(menusQty); int nMenusOriginal = menusQty.size(); // save some order with some menus @@ -263,34 +186,35 @@ public void createOrderAndDeleteSomeQtyMenus() { @Test public void createOrderAndDeleteSomeQtyMenusWithMenuQtyRepository() { ShippingOrderRestaurant so1 = (ShippingOrderRestaurant) orders.get(0); - List menusQty = getRandomMenuQty(so1); + List menusQty = dataLoader.getRandomMenuQty(so1); so1.setMenus(menusQty); int nMenusOriginal = menusQty.size(); // save some order with some menus shippingOrderRepository.save(so1); - + System.out.println("After shippingOrderRepository.save"); List menusQtyDB = orderMenuQtyRepository.findAll(); OrderMenuQty omq = menusQtyDB.get(0); - int test = 4; + System.out.println("Before orderMenuQtyRepository.delete"); + int test = 2; if( test==1){ omq.setMenu(null); omq.setOrder(null); orderMenuQtyRepository.save(omq); orderMenuQtyRepository.delete(omq); - assertThat(orderMenuQtyRepository.findAll().size()).isEqualTo(2); } else if( test==2) { - orderMenuQtyRepository.delete(omq); - assertThat(orderMenuQtyRepository.findAll().size()).isEqualTo(2); + orderMenuQtyRepository.deleteById(omq.getId()); } else if( test==3) { - orderMenuQtyRepository.delete2(omq.getId()); - assertThat(orderMenuQtyRepository.findAll().size()).isEqualTo(2); + orderMenuQtyRepository.delete(omq); } else if( test==4) { + orderMenuQtyRepository.myDeleteQuery(omq.getId()); + } else if( test==5) { String id = menusQtyDB.get(0).getId(); orderMenuQtyRepository.deleteById(id); - assertThat(orderMenuQtyRepository.findAll().size()).isEqualTo(2); } + System.out.println("After orderMenuQtyRepository.delete"); + assertThat(orderMenuQtyRepository.count()).isEqualTo(nMenusOriginal-1); Optional found = shippingOrderRepository.findById(so1.getId()); From e0e72f4f6f91660ac4a6aef49f209d0bc2ed46e1 Mon Sep 17 00:00:00 2001 From: jc-programs Date: Tue, 5 Nov 2024 13:59:06 +0100 Subject: [PATCH 18/28] Corrected OrderMenuQty ManyToOne --- .../controller/MenuController.java | 46 ++++++++++++++ .../controller/PopulateDataController.java | 24 +++++++ .../model/OrderRestaurant.java | 62 +++++++++---------- .../service/MenuService.java | 10 +++ .../service/MenuServiceImpl.java | 25 ++++++++ .../utilities/FakeDataLoader.java | 7 ++- .../restaurantManager/OrderMenuQtyTest.java | 28 +++++---- .../RelationshipsOrderRestaurantTest.java | 44 ++++++------- 8 files changed, 179 insertions(+), 67 deletions(-) create mode 100644 src/main/java/dev/example/restaurantManager/controller/MenuController.java create mode 100644 src/main/java/dev/example/restaurantManager/controller/PopulateDataController.java create mode 100644 src/main/java/dev/example/restaurantManager/service/MenuService.java create mode 100644 src/main/java/dev/example/restaurantManager/service/MenuServiceImpl.java diff --git a/src/main/java/dev/example/restaurantManager/controller/MenuController.java b/src/main/java/dev/example/restaurantManager/controller/MenuController.java new file mode 100644 index 0000000..1ef5b56 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/controller/MenuController.java @@ -0,0 +1,46 @@ +package dev.example.restaurantManager.controller; + +import dev.example.restaurantManager.model.MenuRestaurant; +import dev.example.restaurantManager.model.OrderRestaurant; +import dev.example.restaurantManager.service.MenuService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import java.util.Date; +import java.util.List; + +@RestController +@RequestMapping("/api/menu") +public class MenuController { + @Autowired + private MenuService menuService; + + + @GetMapping("/allMenus") + public ResponseEntity> getAllMenus( ) { + List menus = menuService.getAllMenus(); + HttpHeaders headers = getCommonHeaders("Get all menus"); + + return menus != null && !menus.isEmpty() + ? new ResponseEntity<>(menus, headers, HttpStatus.OK) + : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + } + + private HttpHeaders getCommonHeaders(String description) { + HttpHeaders headers = new HttpHeaders(); + headers.add("desc", description); + headers.add("content-type", "application/json"); + headers.add("date", new Date().toString()); + headers.add("server", "H2 Database"); + headers.add("version", "1.0.0"); + headers.add("menu-count", String.valueOf(menuService.countMenus())); + headers.add("object", "menus"); + return headers; + } + +} diff --git a/src/main/java/dev/example/restaurantManager/controller/PopulateDataController.java b/src/main/java/dev/example/restaurantManager/controller/PopulateDataController.java new file mode 100644 index 0000000..76dcbaa --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/controller/PopulateDataController.java @@ -0,0 +1,24 @@ +package dev.example.restaurantManager.controller; + +import dev.example.restaurantManager.utilities.FakeDataLoader; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +@RestController +@RequestMapping("api/v1/populate") +public class PopulateDataController { + + @Autowired + private FakeDataLoader dataLoader; + + @PostMapping("/all") + public ResponseEntity PopulateAllData(){ + dataLoader.createDataAndSave2DBWithoutRelationship(); + dataLoader.createSomeRelations(); + return ResponseEntity.ok("All data populated successfully"); + } + +} diff --git a/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java index bceca64..9510101 100644 --- a/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java @@ -2,7 +2,6 @@ import java.util.*; -import com.fasterxml.jackson.annotation.JsonIgnore; import jakarta.persistence.*; import lombok.*; @@ -25,15 +24,16 @@ public class OrderRestaurant { private double totalPayment; private boolean paid; - @JsonIgnore - @ManyToMany(fetch = FetchType.EAGER - , cascade = {CascadeType.PERSIST, CascadeType.MERGE}) - @JoinTable( - name = "ORDER_MENU_QUANTITY", - joinColumns = @JoinColumn(name = "ORDER_ID_FK"), - inverseJoinColumns = @JoinColumn(name = "MENU_ID_FK") - ) - private List menus; +// @JsonIgnore +// @ManyToMany(fetch = FetchType.EAGER +// , cascade = {CascadeType.PERSIST, CascadeType.MERGE}) +// @JoinTable( +// name = "ORDER_MENU_QUANTITY", +// joinColumns = @JoinColumn(name = "ORDER_ID_FK"), +// inverseJoinColumns = @JoinColumn(name = "MENU_ID_FK") +// ) + @OneToMany(cascade = CascadeType.ALL) + private List menusQty; public OrderRestaurant(String id, Date date, String waiter, int peopleQty, double totalPayment, boolean paid, ArrayList menus){ @@ -43,16 +43,16 @@ public OrderRestaurant(String id, Date date, String waiter, int peopleQty, this.peopleQty=peopleQty; this.totalPayment=totalPayment; this.paid=paid; - this.menus = Converter.convertMenus2QtyMenus(this,menus); + this.menusQty = Converter.convertMenus2QtyMenus(this,menus); } public List addMenuQty(MenuRestaurant menu, int qty) { - if(this.getMenus()==null){ - this.setMenus(new ArrayList()); + if(this.getMenusQty()==null){ + this.setMenusQty(new ArrayList()); } boolean found = false; - for(OrderMenuQty omq: this.getMenus()){ + for(OrderMenuQty omq: this.getMenusQty()){ if(omq.getMenu().equals(menu)){ omq.setQuantity(omq.getQuantity()+qty); found = true; @@ -64,17 +64,17 @@ public List addMenuQty(MenuRestaurant menu, int qty) { omq.setMenu(menu); omq.setQuantity(qty); omq.setOrder(this); - this.getMenus().add(omq); + this.getMenusQty().add(omq); } - return this.getMenus(); + return this.getMenusQty(); } public List addMenu(MenuRestaurant menu) { - if(this.getMenus()==null){ - this.setMenus(new ArrayList()); + if(this.getMenusQty()==null){ + this.setMenusQty(new ArrayList()); } boolean found = false; - for(OrderMenuQty omq: this.getMenus()){ + for(OrderMenuQty omq: this.getMenusQty()){ if(omq.getMenu().equals(menu)){ omq.setQuantity(omq.getQuantity()+1); found = true; @@ -86,45 +86,45 @@ public List addMenu(MenuRestaurant menu) { omq.setMenu(menu); omq.setQuantity(1); omq.setOrder(this); - this.getMenus().add(omq); + this.getMenusQty().add(omq); } - return this.getMenus(); + return this.getMenusQty(); } public List removeMenuQty(MenuRestaurant menu, int qty) { - if(this.getMenus()==null){ + if(this.getMenusQty()==null){ return null; } - for(OrderMenuQty omq: this.getMenus()){ + for(OrderMenuQty omq: this.getMenusQty()){ if(omq.getMenu().equals(menu)){ int oldQty = omq.getQuantity(); if (oldQty > qty) { omq.setQuantity(omq.getQuantity() - qty); } else{ - this.getMenus().remove(omq); + this.getMenusQty().remove(omq); } break; } } - return this.getMenus(); + return this.getMenusQty(); } public List removeMenu(MenuRestaurant menu) { - if(this.getMenus()==null){ + if(this.getMenusQty()==null){ return null; } - for(OrderMenuQty omq: this.getMenus()){ + for(OrderMenuQty omq: this.getMenusQty()){ if(omq.getMenu().equals(menu)){ int qty = omq.getQuantity(); if (qty > 1) { omq.setQuantity(omq.getQuantity() - 1); } else{ - this.getMenus().remove(omq); + this.getMenusQty().remove(omq); } break; } } - return this.getMenus(); + return this.getMenusQty(); } @@ -150,8 +150,8 @@ public String toString() { ", peopleQty=" + peopleQty + ", totalPayment=" + totalPayment + ", paid=" + paid + - ", menusCount=" + (menus != null ? menus.size() : 0) + - ", menus=" + menus + + ", menusQtyCount=" + (menusQty != null ? menusQty.size() : 0) + + ", menusQty=" + menusQty + '}'; } diff --git a/src/main/java/dev/example/restaurantManager/service/MenuService.java b/src/main/java/dev/example/restaurantManager/service/MenuService.java new file mode 100644 index 0000000..cb30ea5 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/MenuService.java @@ -0,0 +1,10 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.MenuRestaurant; + +import java.util.List; + +public interface MenuService { + List getAllMenus(); + long countMenus(); +} diff --git a/src/main/java/dev/example/restaurantManager/service/MenuServiceImpl.java b/src/main/java/dev/example/restaurantManager/service/MenuServiceImpl.java new file mode 100644 index 0000000..33e95b1 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/MenuServiceImpl.java @@ -0,0 +1,25 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.MenuRestaurant; +import dev.example.restaurantManager.repository.MenuRestaurantRepository; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.util.List; + +@Service +public class MenuServiceImpl implements MenuService{ + @Autowired + MenuRestaurantRepository menuRepository; + + @Override + public List getAllMenus() { + return menuRepository.findAll(); + } + + @Override + public long countMenus() { + return menuRepository.count(); + } + +} diff --git a/src/main/java/dev/example/restaurantManager/utilities/FakeDataLoader.java b/src/main/java/dev/example/restaurantManager/utilities/FakeDataLoader.java index 71033ee..6d545c5 100644 --- a/src/main/java/dev/example/restaurantManager/utilities/FakeDataLoader.java +++ b/src/main/java/dev/example/restaurantManager/utilities/FakeDataLoader.java @@ -112,7 +112,12 @@ public List getRandomMenuQty(OrderRestaurant orderRestaurant){ } return menusQty; } - + public void createSomeRelations(){ + ShippingOrderRestaurant so1 = (ShippingOrderRestaurant) orders.get(0); + List menusQty = getRandomMenuQty(so1); + so1.setMenusQty(menusQty); + shippingOrderRepository.save(so1); + } } diff --git a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java index 22d9c73..69a7d4a 100644 --- a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java +++ b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java @@ -1,6 +1,5 @@ package dev.example.restaurantManager; -import com.github.javafaker.Faker; import dev.example.restaurantManager.model.*; import dev.example.restaurantManager.repository.*; import dev.example.restaurantManager.utilities.FakeDataLoader; @@ -44,7 +43,7 @@ public void createDataAndSave2DBWithoutRelationship() { public void createOrderMenuQtyDB() { ShippingOrderRestaurant so1 = (ShippingOrderRestaurant)orders.get(0); List menusQty = dataLoader.getRandomMenuQty(so1); - so1.setMenus(menusQty); + so1.setMenusQty(menusQty); // save relationship to DB shippingOrderRepository.save(so1); @@ -56,15 +55,16 @@ public void createOrderMenuQtyDB() { // check if shipping order has all his menus saved to DB // this method must be @Transactional because // menus in order are fetch.LAZY - int nMenus = so1DB.getMenus().size(); + int nMenus = so1DB.getMenusQty().size(); for(int i=0;i menusQty = dataLoader.getRandomMenuQty(so1); @@ -78,7 +78,7 @@ public void createOrderManyMenus() { totalQtyMenus += q.getQuantity(); nMenus += 1; } - so1.setMenus(menusQty); + so1.setMenusQty(menusQty); System.out.println("total menus: " + nMenus); System.out.println("total qty menus: " + totalQtyMenus); shippingOrderRepository.save(so1); @@ -86,10 +86,10 @@ public void createOrderManyMenus() { Optional found = shippingOrderRepository.findById(so1.getId()); assertThat(found).isPresent(); assertThat(found.get().getId()).isEqualTo(so1.getId()); - assertThat(found.get().getMenus().stream() + assertThat(found.get().getMenusQty().stream() .count() ).isEqualTo(nMenus); - assertThat(found.get().getMenus().stream() + assertThat(found.get().getMenusQty().stream() .mapToInt(omq -> omq.getQuantity()) .sum() ).isEqualTo(totalQtyMenus); @@ -105,7 +105,7 @@ public void checkOrderMenuQtyRepository() { ShippingOrderRestaurant so1 = (ShippingOrderRestaurant) orders.get(2); List menusQty = dataLoader.getRandomMenuQty(so1); - so1.setMenus(menusQty); + so1.setMenusQty(menusQty); // save some relationships shippingOrderRepository.save(so1); @@ -117,10 +117,11 @@ public void checkOrderMenuQtyRepository() { } @Test + @Transactional public void createOrderAndDeleteSomeQtyMenus() { ShippingOrderRestaurant so1 = (ShippingOrderRestaurant) orders.get(0); List menusQty = dataLoader.getRandomMenuQty(so1); - so1.setMenus(menusQty); + so1.setMenusQty(menusQty); int nMenusOriginal = menusQty.size(); // save some order with some menus shippingOrderRepository.save(so1); @@ -133,7 +134,7 @@ public void createOrderAndDeleteSomeQtyMenus() { assertThat(found.get().getId()).isEqualTo(so1.getId()); ShippingOrderRestaurant soDB = found.get(); // print menu qty from order - List menus = soDB.getMenus(); + List menus = soDB.getMenusQty(); int nMenus1 = menus.size(); System.out.println(menus); @@ -149,7 +150,7 @@ public void createOrderAndDeleteSomeQtyMenus() { // now should have 1 menu qty less found = shippingOrderRepository.findById(so1.getId()); ShippingOrderRestaurant soDB2 = found.get(); - List menus2 = soDB2.getMenus(); + List menus2 = soDB2.getMenusQty(); int nMenus2 = menus2.size(); System.out.println(menus2); List menus3 = orderMenuQtyRepository.findAll(); @@ -184,10 +185,11 @@ public void createOrderAndDeleteSomeQtyMenus() { @Test + @Transactional public void createOrderAndDeleteSomeQtyMenusWithMenuQtyRepository() { ShippingOrderRestaurant so1 = (ShippingOrderRestaurant) orders.get(0); List menusQty = dataLoader.getRandomMenuQty(so1); - so1.setMenus(menusQty); + so1.setMenusQty(menusQty); int nMenusOriginal = menusQty.size(); // save some order with some menus shippingOrderRepository.save(so1); @@ -219,7 +221,7 @@ public void createOrderAndDeleteSomeQtyMenusWithMenuQtyRepository() { Optional found = shippingOrderRepository.findById(so1.getId()); ShippingOrderRestaurant soDB2 = found.get(); - int nMenusAfterDelete = soDB2.getMenus().size(); + int nMenusAfterDelete = soDB2.getMenusQty().size(); assertThat(nMenusOriginal-1).isEqualTo(nMenusAfterDelete); diff --git a/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java b/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java index d8a4e7f..72e21e8 100644 --- a/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java +++ b/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java @@ -215,7 +215,7 @@ public void testAddingMenusToOrder() { // Retrieve the order and assert the menus Optional foundOrder = orderRestaurantRepository.findById("O01"); assertThat(foundOrder).isPresent(); - assertThat(foundOrder.get().getMenus()).hasSize(3); + assertThat(foundOrder.get().getMenusQty()).hasSize(3); // Since we've implemented equals() and hashCode() methods based on // the compilation of all fields except for orders. // This avoids potential circular reference issues while still providing a comprehensive comparison of the menu items. @@ -223,15 +223,15 @@ public void testAddingMenusToOrder() { // we can now use contains() to check if the retrieved menus match the original ones // assertThat(foundOrder.get().getMenus()).contains(menuRestaurant1, menuRestaurant2, menuRestaurant3); - assertThat(Converter.convertQtyMenus2Menus(foundOrder.get().getMenus())).contains(menuRestaurant1, menuRestaurant2, menuRestaurant3); + assertThat(Converter.convertQtyMenus2Menus(foundOrder.get().getMenusQty())).contains(menuRestaurant1, menuRestaurant2, menuRestaurant3); // Retrieve the menus and assert the order - assertThat(Converter.convertQtyMenus2Menus(foundOrder.get().getMenus())) + assertThat(Converter.convertQtyMenus2Menus(foundOrder.get().getMenusQty())) .extracting("id") .containsExactlyInAnyOrder("M01", "M02", "M03"); - assertThat(Converter.convertQtyMenus2Menus(foundOrder.get().getMenus())) + assertThat(Converter.convertQtyMenus2Menus(foundOrder.get().getMenusQty())) .usingElementComparator(Comparator.comparing(MenuRestaurant::getId)) .containsExactlyInAnyOrder(menuRestaurant1, menuRestaurant2, menuRestaurant3); } @@ -262,17 +262,17 @@ public void testAddingRepeatedMenusToOrder() { // Retrieve the order and assert the menus Optional foundOrder = orderRestaurantRepository.findById("O01"); assertThat(foundOrder).isPresent(); - assertThat(foundOrder.get().getMenus()).hasSize(3); + assertThat(foundOrder.get().getMenusQty()).hasSize(3); // Since we've implemented equals() and hashCode() methods based on // the compilation of all fields except for orders. // This avoids potential circular reference issues while still providing a comprehensive comparison of the menu items. // we can now use contains() to check if the retrieved menus match the original ones - assertThat(Converter.convertQtyMenus2Menus(foundOrder.get().getMenus())).contains(menuRestaurant1, menuRestaurant2, menuRestaurant2, menuRestaurant3, menuRestaurant3, menuRestaurant3); + assertThat(Converter.convertQtyMenus2Menus(foundOrder.get().getMenusQty())).contains(menuRestaurant1, menuRestaurant2, menuRestaurant2, menuRestaurant3, menuRestaurant3, menuRestaurant3); // Retrieve the menus and assert the order - assertThat(Converter.convertQtyMenus2Menus(foundOrder.get().getMenus())) + assertThat(Converter.convertQtyMenus2Menus(foundOrder.get().getMenusQty())) .extracting("id") .containsExactlyInAnyOrder("M01", "M02", "M02","M03", "M03", "M03"); - assertThat(Converter.convertQtyMenus2Menus(foundOrder.get().getMenus())) + assertThat(Converter.convertQtyMenus2Menus(foundOrder.get().getMenusQty())) .usingElementComparator(Comparator.comparing(MenuRestaurant::getId)) .containsExactlyInAnyOrder(menuRestaurant1, menuRestaurant2, menuRestaurant2, menuRestaurant3, menuRestaurant3, menuRestaurant3 ); } @@ -311,12 +311,12 @@ public void testRemovingMenusFromOrder() { // Retrieve the updated order and assert the menus Optional updatedOrderOptional = orderRestaurantRepository.findById("O01"); // print the menus - System.out.println("Menus: " + updatedOrderOptional.get().getMenus()); + System.out.println("Menus: " + updatedOrderOptional.get().getMenusQty()); // assert the menus have been removed assertThat(updatedOrderOptional).isPresent(); - assertThat(updatedOrderOptional.get().getMenus()).hasSize(2); - assertThat(Converter.convertQtyMenus2Menus(updatedOrderOptional.get().getMenus())).contains(menuRestaurant1, menuRestaurant3); - assertThat(Converter.convertQtyMenus2Menus(updatedOrderOptional.get().getMenus())).doesNotContain(menuRestaurant2); + assertThat(updatedOrderOptional.get().getMenusQty()).hasSize(2); + assertThat(Converter.convertQtyMenus2Menus(updatedOrderOptional.get().getMenusQty())).contains(menuRestaurant1, menuRestaurant3); + assertThat(Converter.convertQtyMenus2Menus(updatedOrderOptional.get().getMenusQty())).doesNotContain(menuRestaurant2); // Retrieve the updated order after deleting the menu System.out.println("List of menus AFTER DELETION:"); @@ -385,10 +385,10 @@ public void testRemovingMenusFromOrder_butNotRelationship() { // Retrieve the updated order and assert the menus Optional updatedOrderOptional = orderRestaurantRepository.findById("O01"); // print the menus - System.out.println("Menus: " + updatedOrderOptional.get().getMenus()); + System.out.println("Menus: " + updatedOrderOptional.get().getMenusQty()); // assert the menus have been removed assertThat(updatedOrderOptional).isPresent(); - assertThat(updatedOrderOptional.get().getMenus()).hasSize(2); + assertThat(updatedOrderOptional.get().getMenusQty()).hasSize(2); } @@ -419,9 +419,9 @@ public void testCascadingDeletionOfMenusAndOrders() { orderRestaurantRepository.save(updatedOrder); Optional updatedOrderOptional = orderRestaurantRepository.findById("O01"); assertThat(updatedOrderOptional).isPresent(); - assertThat(updatedOrderOptional.get().getMenus()).hasSize(2); - assertThat(Converter.convertQtyMenus2Menus(updatedOrderOptional.get().getMenus())).contains(menuRestaurant1, menuRestaurant3); - assertThat(Converter.convertQtyMenus2Menus(updatedOrderOptional.get().getMenus())).doesNotContain(menuRestaurant2); + assertThat(updatedOrderOptional.get().getMenusQty()).hasSize(2); + assertThat(Converter.convertQtyMenus2Menus(updatedOrderOptional.get().getMenusQty())).contains(menuRestaurant1, menuRestaurant3); + assertThat(Converter.convertQtyMenus2Menus(updatedOrderOptional.get().getMenusQty())).doesNotContain(menuRestaurant2); // Delete the order and verify the cascade deletion of the order-menu association orderRestaurantRepository.delete(order); @@ -464,8 +464,8 @@ public void testAddingMenusToEatInOrder() { // Retrieve the EatInOrder and assert the menus Optional foundOrder = (Optional) eatInOrderRestaurantRepository.findById("EO1"); assertThat(foundOrder).isPresent(); - assertThat(foundOrder.get().getMenus()).hasSize(3); - assertThat(Converter.convertQtyMenus2Menus(foundOrder.get().getMenus())).contains(menuRestaurant1, menuRestaurant2, menuRestaurant3); + assertThat(foundOrder.get().getMenusQty()).hasSize(3); + assertThat(Converter.convertQtyMenus2Menus(foundOrder.get().getMenusQty())).contains(menuRestaurant1, menuRestaurant2, menuRestaurant3); } // Removing Menus from an EatInOrder: Checks that menus can be removed from an EatInOrder @@ -500,9 +500,9 @@ public void testRemovingMenusFromEatInOrder() { // Retrieve the updated EatInOrder and assert the menus Optional updatedOrderOptional = (Optional) eatInOrderRestaurantRepository.findById("EO1"); assertThat(updatedOrderOptional).isPresent(); - assertThat(updatedOrderOptional.get().getMenus()).hasSize(2); - assertThat(Converter.convertQtyMenus2Menus(updatedOrderOptional.get().getMenus())).contains(menuRestaurant1, menuRestaurant3); - assertThat(Converter.convertQtyMenus2Menus(updatedOrderOptional.get().getMenus())).doesNotContain(menuRestaurant2); + assertThat(updatedOrderOptional.get().getMenusQty()).hasSize(2); + assertThat(Converter.convertQtyMenus2Menus(updatedOrderOptional.get().getMenusQty())).contains(menuRestaurant1, menuRestaurant3); + assertThat(Converter.convertQtyMenus2Menus(updatedOrderOptional.get().getMenusQty())).doesNotContain(menuRestaurant2); } From 52aa046b445dd13ea9e532f87b4a53e0b3351450 Mon Sep 17 00:00:00 2001 From: jc-programs Date: Tue, 5 Nov 2024 20:38:48 +0100 Subject: [PATCH 19/28] relations corrected. 1 test still not working --- .../controller/PopulateDataController.java | 2 +- .../model/MenuRestaurant.java | 8 ++++---- .../restaurantManager/model/OrderMenuQty.java | 14 ++++++++----- .../model/OrderRestaurant.java | 2 +- .../utilities/FakeDataLoader.java | 20 +++++++++++++++++++ .../resources/application-local.properties | 14 +++++++------ src/main/resources/application.properties | 2 +- 7 files changed, 44 insertions(+), 18 deletions(-) diff --git a/src/main/java/dev/example/restaurantManager/controller/PopulateDataController.java b/src/main/java/dev/example/restaurantManager/controller/PopulateDataController.java index 76dcbaa..297ce94 100644 --- a/src/main/java/dev/example/restaurantManager/controller/PopulateDataController.java +++ b/src/main/java/dev/example/restaurantManager/controller/PopulateDataController.java @@ -1,11 +1,11 @@ package dev.example.restaurantManager.controller; -import dev.example.restaurantManager.utilities.FakeDataLoader; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; +import dev.example.restaurantManager.utilities.FakeDataLoader; @RestController @RequestMapping("api/v1/populate") diff --git a/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java index 51de20f..c21095e 100644 --- a/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java @@ -1,10 +1,7 @@ package dev.example.restaurantManager.model; import com.fasterxml.jackson.annotation.JsonIgnore; -import jakarta.persistence.Entity; -import jakarta.persistence.FetchType; -import jakarta.persistence.Id; -import jakarta.persistence.ManyToMany; +import jakarta.persistence.*; import lombok.*; import java.util.ArrayList; import java.util.List; @@ -28,6 +25,9 @@ public class MenuRestaurant { // @ManyToMany(mappedBy = "menus", fetch = FetchType.LAZY) // private List orders = new ArrayList<>(); +// @OneToMany(mappedBy = "menu") +// private List menusQty; + // to execute old tests public MenuRestaurant(String id, String name, Double price, String content, boolean active, boolean water,ArrayList orders){ diff --git a/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java index c01a558..531ea72 100644 --- a/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java +++ b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java @@ -8,21 +8,25 @@ @Data @Entity +@Table(name = "ORDER_MENU_QTY") public class OrderMenuQty { @Id @GeneratedValue(generator = "UUID") @GenericGenerator(name = "UUID", strategy = "org.hibernate.id.UUIDGenerator") private String id; - @ManyToOne(cascade = CascadeType.ALL) - @JoinColumn(name = "order_id") + @ManyToOne + @JoinColumn(name="order_id", referencedColumnName="id") + // @JoinColumn(name = "order_id") private OrderRestaurant order; + @ManyToOne + @JoinColumn(name="menu_id", referencedColumnName="id") + // @JoinColumn(name = "menu_id") + private MenuRestaurant menu; + private int quantity; - @ManyToOne(cascade = CascadeType.ALL) - @JoinColumn(name = "menu_id") - private MenuRestaurant menu; @Override public String toString(){ diff --git a/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java index 9510101..521f90a 100644 --- a/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java @@ -32,7 +32,7 @@ public class OrderRestaurant { // joinColumns = @JoinColumn(name = "ORDER_ID_FK"), // inverseJoinColumns = @JoinColumn(name = "MENU_ID_FK") // ) - @OneToMany(cascade = CascadeType.ALL) + @OneToMany(mappedBy = "order",fetch = FetchType.LAZY,cascade = CascadeType.ALL) private List menusQty; public OrderRestaurant(String id, Date date, String waiter, int peopleQty, diff --git a/src/main/java/dev/example/restaurantManager/utilities/FakeDataLoader.java b/src/main/java/dev/example/restaurantManager/utilities/FakeDataLoader.java index 6d545c5..9c81037 100644 --- a/src/main/java/dev/example/restaurantManager/utilities/FakeDataLoader.java +++ b/src/main/java/dev/example/restaurantManager/utilities/FakeDataLoader.java @@ -52,6 +52,7 @@ private void createFakerIfNotExists(){ } public void createDataAndSave2DBWithoutRelationship(){ + System.out.println("Delete all data"); // delete all data customerRepository.deleteAll(); tableRepository.deleteAll(); @@ -61,6 +62,9 @@ public void createDataAndSave2DBWithoutRelationship(){ createFakerIfNotExists(); + System.out.println("Before creating data"); + + System.out.println("Before creating Customers"); // Create sample customers Customer customer1 = new Customer("C1", "John", "john@email.com", "123-456-7890", 30, false, false); Customer customer3 = new Customer("C3", "Emily", "emily@email.com", "345-678-9012", 35, false, false); @@ -68,17 +72,21 @@ public void createDataAndSave2DBWithoutRelationship(){ customerRepository.save(customer1); customerRepository.save(customer3); customerRepository.save(customer5); + System.out.println("after creating Customers"); // Create sample tables + System.out.println("before creating Tables"); TableRestaurant table1 = new TableRestaurant("T1", "Window Table", 4, false); TableRestaurant table2 = new TableRestaurant("T2", "Corner Table", 2, true); table1.setId("T01"); table2.setId("T02"); tableRepository.save(table1); tableRepository.save(table2); + System.out.println("after creating Tables"); // Create sample menus + System.out.println("before creating Menus"); MenuRestaurant menu1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true); MenuRestaurant menu2 = new MenuRestaurant("M02","Pizza Menu", 12.99, "Pizza and salad", true, false); MenuRestaurant menu3 = new MenuRestaurant("M03","Salad Menu", 8.99, "Mixed salad and dressing", true, true); @@ -86,8 +94,10 @@ public void createDataAndSave2DBWithoutRelationship(){ menuRepository.save(menu1); menuRepository.save(menu2); menuRepository.save(menu3); + System.out.println("after creating Menus"); // Create 3 ShippingOrder objects + System.out.println("before creating ShippingOrderRestaurants"); ShippingOrderRestaurant so1 = new ShippingOrderRestaurant("SO1", new Date(), "John", 2, 0.0, false, (List)null, "123 Main St", "New York", "Mike"); ShippingOrderRestaurant so2 = new ShippingOrderRestaurant("SO2", new Date(), "Sarah", 1, 0.0, true, (List)null, "456 Elm St", "Los Angeles", "Tom"); ShippingOrderRestaurant so3 = new ShippingOrderRestaurant("SO3", new Date(), "Emily", 3, 0.0, false, (List)null, "789 Oak St", "Chicago", "Lisa"); @@ -95,6 +105,7 @@ public void createDataAndSave2DBWithoutRelationship(){ shippingOrderRepository.save(so1); shippingOrderRepository.save(so2); shippingOrderRepository.save(so3); + System.out.println("after creating ShippingOrderRestaurants"); } @@ -116,7 +127,16 @@ public void createSomeRelations(){ ShippingOrderRestaurant so1 = (ShippingOrderRestaurant) orders.get(0); List menusQty = getRandomMenuQty(so1); so1.setMenusQty(menusQty); + System.out.println("before creating relationship ShippingOrderRestaurant <-> OrderMenusQqy"); shippingOrderRepository.save(so1); + System.out.println("after creating relationship ShippingOrderRestaurant <-> OrderMenusQqy"); + + + System.out.println("check relationship ShippingOrderRestaurant <-> OrderMenusQqy"); + ShippingOrderRestaurant so1DB = shippingOrderRepository.findById(so1.getId()).orElse(null); + System.out.println(menusQty.size() + "=" + so1DB.getMenusQty().size() ); + + } diff --git a/src/main/resources/application-local.properties b/src/main/resources/application-local.properties index b773357..8d8917d 100644 --- a/src/main/resources/application-local.properties +++ b/src/main/resources/application-local.properties @@ -1,13 +1,15 @@ +# H2 LOCAL DB SERVER +spring.datasource.url=jdbc:h2:/home/jc/Documents/restaurant-db/db +spring.datasource.username=jc +spring.datasource.password= +# see sql in console +spring.jpa.show-sql=true +spring.jpa.properties.hibernate.format_sql=true -# H2 LOCAL DB SERVER -spring.datasource.url=jdbc:h2:/home/albert/MyProjects/DataBase/customerdb -spring.datasource.username=albert -spring.datasource.password=1234 - # DDL OPTIONS: create-drop, create, update, none, validate -spring.jpa.hibernate.ddl-auto=update +spring.jpa.hibernate.ddl-auto=create # create ? Hibernate first drops existing tables and then creates new tables. # update ? The object model created based on the mappings # (annotations or XML) is compared with the existing schema, diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties index 56fa3b7..cfb2150 100644 --- a/src/main/resources/application.properties +++ b/src/main/resources/application.properties @@ -1,7 +1,7 @@ spring.application.name=restaurantManager # application.properties -spring.profiles.active=memory +spring.profiles.active=local From 351ad5167e5a2ae08f3c11ddf118f8dc1cc4b99d Mon Sep 17 00:00:00 2001 From: jc-programs Date: Tue, 5 Nov 2024 22:38:39 +0100 Subject: [PATCH 20/28] intentando @classId --- .../restaurantManager/model/OrderMenuQty.java | 24 +++- .../model/PK_OrderMenuQty.java | 39 +++++ .../utilities/FakeDataLoader.java | 20 +-- .../restaurantManager/OrderMenuQtyTest.java | 134 +++++++++++------- 4 files changed, 148 insertions(+), 69 deletions(-) create mode 100644 src/main/java/dev/example/restaurantManager/model/PK_OrderMenuQty.java diff --git a/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java index 531ea72..9d1bb4d 100644 --- a/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java +++ b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java @@ -9,17 +9,21 @@ @Data @Entity @Table(name = "ORDER_MENU_QTY") +@IdClass(PK_OrderMenuQty.class) public class OrderMenuQty { - @Id - @GeneratedValue(generator = "UUID") - @GenericGenerator(name = "UUID", strategy = "org.hibernate.id.UUIDGenerator") - private String id; +// @Id +// @GeneratedValue(generator = "UUID") +// @GenericGenerator(name = "UUID", strategy = "org.hibernate.id.UUIDGenerator") +// private String id; + + @Id @ManyToOne @JoinColumn(name="order_id", referencedColumnName="id") // @JoinColumn(name = "order_id") private OrderRestaurant order; + @Id @ManyToOne @JoinColumn(name="menu_id", referencedColumnName="id") // @JoinColumn(name = "menu_id") @@ -28,9 +32,19 @@ public class OrderMenuQty { private int quantity; + public PK_OrderMenuQty getId() { + return new PK_OrderMenuQty(order,menu); + } + + public void setId(PK_OrderMenuQty id) { + this.order = id.getOrder(); + this.menu = id.getMenu(); + } + + @Override public String toString(){ - return "id=" + id + ", menú: " + menu.getId() + ", qty: " + this.quantity; + return "order_id: " + order.getId() + ", menu_id: " + menu.getId() + ", qty: " + this.quantity; } @Override diff --git a/src/main/java/dev/example/restaurantManager/model/PK_OrderMenuQty.java b/src/main/java/dev/example/restaurantManager/model/PK_OrderMenuQty.java new file mode 100644 index 0000000..4426d99 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/model/PK_OrderMenuQty.java @@ -0,0 +1,39 @@ +package dev.example.restaurantManager.model; + +import lombok.Getter; +import lombok.Setter; + +import java.io.Serializable; +import java.util.Objects; + +@Getter +@Setter +public class PK_OrderMenuQty implements Serializable { + private OrderRestaurant order; + private MenuRestaurant menu; + + public PK_OrderMenuQty(OrderRestaurant order, MenuRestaurant menu){ + this.order=order; + this.menu=menu; + } + + public PK_OrderMenuQty(){} + + @Override + public boolean equals(Object o) { + if ( this == o ) { + return true; + } + if ( o == null || getClass() != o.getClass() ) { + return false; + } + PK_OrderMenuQty pk = (PK_OrderMenuQty) o; + return order.getId().equals(pk.order.getId()) && + menu.getId().equals(pk.menu.getId()); + } + + @Override + public int hashCode() { + return Objects.hash( order, menu ); + } +} diff --git a/src/main/java/dev/example/restaurantManager/utilities/FakeDataLoader.java b/src/main/java/dev/example/restaurantManager/utilities/FakeDataLoader.java index 9c81037..c21f402 100644 --- a/src/main/java/dev/example/restaurantManager/utilities/FakeDataLoader.java +++ b/src/main/java/dev/example/restaurantManager/utilities/FakeDataLoader.java @@ -51,7 +51,7 @@ private void createFakerIfNotExists(){ faker = new Faker(new Random(42)); } - public void createDataAndSave2DBWithoutRelationship(){ + public void deleteAllData(){ System.out.println("Delete all data"); // delete all data customerRepository.deleteAll(); @@ -59,7 +59,9 @@ public void createDataAndSave2DBWithoutRelationship(){ orderMenuQtyRepository.deleteAll(); menuRepository.deleteAll(); shippingOrderRepository.deleteAll(); + } + public void createDataAndSave2DBWithoutRelationship(){ createFakerIfNotExists(); System.out.println("Before creating data"); @@ -107,6 +109,7 @@ public void createDataAndSave2DBWithoutRelationship(){ shippingOrderRepository.save(so3); System.out.println("after creating ShippingOrderRestaurants"); + System.out.println("after creating data"); } public List getRandomMenuQty(OrderRestaurant orderRestaurant){ @@ -123,20 +126,19 @@ public List getRandomMenuQty(OrderRestaurant orderRestaurant){ } return menusQty; } + public void createSomeRelations(){ ShippingOrderRestaurant so1 = (ShippingOrderRestaurant) orders.get(0); List menusQty = getRandomMenuQty(so1); so1.setMenusQty(menusQty); - System.out.println("before creating relationship ShippingOrderRestaurant <-> OrderMenusQqy"); - shippingOrderRepository.save(so1); - System.out.println("after creating relationship ShippingOrderRestaurant <-> OrderMenusQqy"); - - - System.out.println("check relationship ShippingOrderRestaurant <-> OrderMenusQqy"); + System.out.println("before saving relationship ShippingOrderRestaurant <-> OrderMenusQqy"); +// shippingOrderRepository.save(so1); +// System.out.println("after saving relationship ShippingOrderRestaurant <-> OrderMenusQqy"); +// +// +// System.out.println("check saving relationship ShippingOrderRestaurant <-> OrderMenusQqy"); ShippingOrderRestaurant so1DB = shippingOrderRepository.findById(so1.getId()).orElse(null); System.out.println(menusQty.size() + "=" + so1DB.getMenusQty().size() ); - - } diff --git a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java index 69a7d4a..a8bbaf2 100644 --- a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java +++ b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java @@ -31,6 +31,7 @@ public class OrderMenuQtyTest { @BeforeEach public void createDataAndSave2DBWithoutRelationship() { + dataLoader.deleteAllData(); dataLoader.createDataAndSave2DBWithoutRelationship(); menus = dataLoader.getMenus(); orders = dataLoader.getOrders(); @@ -141,7 +142,7 @@ public void createOrderAndDeleteSomeQtyMenus() { // delete first menu qty from order and save to DB using // method removeMenuQty from OrderRestaurant // and save to DB - String id = menus.get(0).getId(); + // String id = menus.get(0).getId(); OrderMenuQty omq = menus.get(0); so1.removeMenuQty(omq.getMenu(),omq.getQuantity()); shippingOrderRepository.save(so1); @@ -157,73 +158,96 @@ public void createOrderAndDeleteSomeQtyMenus() { assertThat(nMenusOriginal).isEqualTo(nMenus1); assertThat(nMenusOriginal-1).isEqualTo(nMenus2); - - - // https://stackoverflow.com/questions/22688402/delete-not-working-with-jparepository - // System.out.println("before deleteById"); - // orderMenuQtyRepository.deleteById(id); - // System.out.println("after deleteById"); - // orderMenuQtyRepository.flush(); -// found = shippingOrderRepository.findById(so1.getId()); -// ShippingOrderRestaurant soDB2 = found.get(); -// List menus2 =soDB2.getMenus(); -// System.out.println(menus2); -// List menus3 = orderMenuQtyRepository.findAll(); - - - -// assertThat(found.get().getMenus().stream() -// .count() -// ).isEqualTo(nMenus); -// -// -// List menusQtyDB = orderMenuQtyRepository.findAll(); -// -// assertThat(menusQtyDB).containsAll(menusQty); - } @Test @Transactional - public void createOrderAndDeleteSomeQtyMenusWithMenuQtyRepository() { - ShippingOrderRestaurant so1 = (ShippingOrderRestaurant) orders.get(0); - List menusQty = dataLoader.getRandomMenuQty(so1); - so1.setMenusQty(menusQty); + public void deleteSomeQtyMenusWithMenuQtyRepository() { + // check no relationship is stored on DB + assertThat(orderMenuQtyRepository.findAll().size()).isEqualTo(0); + + // get first order + ShippingOrderRestaurant so = (ShippingOrderRestaurant) orders.get(0); + // get some random QtyMenu + List menusQty = dataLoader.getRandomMenuQty(so); + so.setMenusQty(menusQty); int nMenusOriginal = menusQty.size(); - // save some order with some menus - shippingOrderRepository.save(so1); + System.out.println("Printing " + nMenusOriginal + " menu qty from memory"); + menusQty.forEach(System.out::println); + // save relationship of order with some qty menus + shippingOrderRepository.save(so); System.out.println("After shippingOrderRepository.save"); + // first check: removing one OrderMenuQty with shippingOrderRepository + OrderMenuQty omq = menusQty.get(0); + so.removeMenuQty(omq.getMenu(),omq.getQuantity()); + shippingOrderRepository.save(so); + // get order from db to check if OrderMenuQty is removed + Optional found1 = shippingOrderRepository.findById(so.getId()); + assertThat(found1).isPresent(); + assertThat(found1.get().getMenusQty().size()).isEqualTo(nMenusOriginal-1); + // insert back OrderMenuQty + so.addMenuQty(omq.getMenu(),omq.getQuantity()); + shippingOrderRepository.save(so); + // and check if OrderMenuQty is added + found1 = shippingOrderRepository.findById(so.getId()); + assertThat(found1).isPresent(); + assertThat(found1.get().getMenusQty().size()).isEqualTo(nMenusOriginal); + + // second check: removing one OrderMenuQty with orderMenuQtyRepository List menusQtyDB = orderMenuQtyRepository.findAll(); - OrderMenuQty omq = menusQtyDB.get(0); - + OrderMenuQty omqToDelete = menusQtyDB.get(0); + System.out.println("Printing menu qty from DB"); + menusQtyDB.forEach(System.out::println); + System.out.println("Menu qty to delete: " + omqToDelete); + // As no relationship was stored on DB before this test + // all relationships on DB belong to the order of this test + assertThat(menusQtyDB.stream().map(o -> o.getOrder().getId())).allMatch(id -> id.equals(so.getId()) ); + // must be same number of relationships + assertThat(menusQtyDB.size()).isEqualTo(nMenusOriginal); + // and now remove one OrderMenuQty with orderMenuQtyRepository System.out.println("Before orderMenuQtyRepository.delete"); - int test = 2; - if( test==1){ - omq.setMenu(null); - omq.setOrder(null); - orderMenuQtyRepository.save(omq); - orderMenuQtyRepository.delete(omq); - } else if( test==2) { - orderMenuQtyRepository.deleteById(omq.getId()); - } else if( test==3) { - orderMenuQtyRepository.delete(omq); - } else if( test==4) { - orderMenuQtyRepository.myDeleteQuery(omq.getId()); - } else if( test==5) { - String id = menusQtyDB.get(0).getId(); - orderMenuQtyRepository.deleteById(id); - } + // none of the next 3 methods work !!!! + // orderMenuQtyRepository.deleteById(omqToDelete.getId()); + orderMenuQtyRepository.delete(omqToDelete); + // orderMenuQtyRepository.myDeleteQuery(omqToDelete.getId()); + // no SQL instruction is shown on console !!! System.out.println("After orderMenuQtyRepository.delete"); + // this assert will fail assertThat(orderMenuQtyRepository.count()).isEqualTo(nMenusOriginal-1); - - Optional found = shippingOrderRepository.findById(so1.getId()); - ShippingOrderRestaurant soDB2 = found.get(); - int nMenusAfterDelete = soDB2.getMenusQty().size(); - - assertThat(nMenusOriginal-1).isEqualTo(nMenusAfterDelete); +// +// +// +// +// List menusQtyDB = orderMenuQtyRepository.findAll(); +// OrderMenuQty omq = menusQtyDB.get(0); +// int test = 4; +// if( test==1){ +// omq.setMenu(null); +// omq.setOrder(null); +// orderMenuQtyRepository.save(omq); +// orderMenuQtyRepository.delete(omq); +// } else if( test==2) { +// orderMenuQtyRepository.deleteById(omq.getId()); +// } else if( test==3) { +// orderMenuQtyRepository.delete(omq); +// } else if( test==4) { +// orderMenuQtyRepository.myDeleteQuery(omq.getId()); +// } else if( test==5) { +// String id = menusQtyDB.get(0).getId(); +// orderMenuQtyRepository.deleteById(id); +// } +// System.out.println("After orderMenuQtyRepository.delete"); +// assertThat(orderMenuQtyRepository.count()).isEqualTo(nMenusOriginal-1); +// +// +// Optional found = shippingOrderRepository.findById(so.getId()); +// ShippingOrderRestaurant soDB2 = found.get(); +// int nMenusAfterDelete = soDB2.getMenusQty().size(); +// +// assertThat(nMenusOriginal-1).isEqualTo(nMenusAfterDelete); } From 0be2860376027eb10804fd9aba69740930f5c93c Mon Sep 17 00:00:00 2001 From: jc-programs Date: Wed, 6 Nov 2024 07:38:06 +0100 Subject: [PATCH 21/28] all tests but one working --- .../model/MenuRestaurant.java | 5 +- .../restaurantManager/model/OrderMenuQty.java | 4 +- .../model/OrderRestaurant.java | 3 +- .../repository/OrderMenuQtyRepository.java | 5 +- .../utilities/FakeDataLoader.java | 28 +++++- .../restaurantManager/OrderMenuQtyTest.java | 94 +++++++++---------- 6 files changed, 79 insertions(+), 60 deletions(-) diff --git a/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java index c21095e..458c943 100644 --- a/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java @@ -25,8 +25,9 @@ public class MenuRestaurant { // @ManyToMany(mappedBy = "menus", fetch = FetchType.LAZY) // private List orders = new ArrayList<>(); -// @OneToMany(mappedBy = "menu") -// private List menusQty; + @OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.ALL) + @JoinColumn(name="menu_id") // sin esta anotación se crea la tabla menu_restaurant_menus_qty + private List menusQty; // to execute old tests diff --git a/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java index 9d1bb4d..fc596ee 100644 --- a/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java +++ b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java @@ -19,13 +19,13 @@ public class OrderMenuQty { @Id @ManyToOne - @JoinColumn(name="order_id", referencedColumnName="id") + @JoinColumn(name="order_id", referencedColumnName="id", nullable = false) // @JoinColumn(name = "order_id") private OrderRestaurant order; @Id @ManyToOne - @JoinColumn(name="menu_id", referencedColumnName="id") + @JoinColumn(name="menu_id", referencedColumnName="id", nullable = false) // @JoinColumn(name = "menu_id") private MenuRestaurant menu; diff --git a/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java index 521f90a..ee909c5 100644 --- a/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java @@ -32,7 +32,8 @@ public class OrderRestaurant { // joinColumns = @JoinColumn(name = "ORDER_ID_FK"), // inverseJoinColumns = @JoinColumn(name = "MENU_ID_FK") // ) - @OneToMany(mappedBy = "order",fetch = FetchType.LAZY,cascade = CascadeType.ALL) + @OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.ALL) + @JoinColumn(name="order_id") // Sin esta anotación se crea la tabla order_restaurant_menus_qty !!! private List menusQty; public OrderRestaurant(String id, Date date, String waiter, int peopleQty, diff --git a/src/main/java/dev/example/restaurantManager/repository/OrderMenuQtyRepository.java b/src/main/java/dev/example/restaurantManager/repository/OrderMenuQtyRepository.java index 3af7a48..9b785ce 100644 --- a/src/main/java/dev/example/restaurantManager/repository/OrderMenuQtyRepository.java +++ b/src/main/java/dev/example/restaurantManager/repository/OrderMenuQtyRepository.java @@ -1,16 +1,17 @@ package dev.example.restaurantManager.repository; import dev.example.restaurantManager.model.OrderMenuQty; +import dev.example.restaurantManager.model.PK_OrderMenuQty; import jakarta.transaction.Transactional; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.data.jpa.repository.Modifying; import org.springframework.data.jpa.repository.Query; -public interface OrderMenuQtyRepository extends JpaRepository { +public interface OrderMenuQtyRepository extends JpaRepository { @Modifying @Transactional @Query("delete from OrderMenuQty omq where omq.id = ?1") - void myDeleteQuery(String id); + void myDeleteQuery(PK_OrderMenuQty id); } diff --git a/src/main/java/dev/example/restaurantManager/utilities/FakeDataLoader.java b/src/main/java/dev/example/restaurantManager/utilities/FakeDataLoader.java index c21f402..881ca59 100644 --- a/src/main/java/dev/example/restaurantManager/utilities/FakeDataLoader.java +++ b/src/main/java/dev/example/restaurantManager/utilities/FakeDataLoader.java @@ -3,6 +3,7 @@ import com.github.javafaker.Faker; import dev.example.restaurantManager.model.*; import dev.example.restaurantManager.repository.*; +import jakarta.transaction.Transactional; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; @@ -127,7 +128,32 @@ public List getRandomMenuQty(OrderRestaurant orderRestaurant){ return menusQty; } - public void createSomeRelations(){ + public String createSomeRelations(){ + ShippingOrderRestaurant so = shippingOrderRepository.findAll().getFirst(); + String idOrder = so.getId(); + List menusQty = new ArrayList<>(); + for(MenuRestaurant m:menuRepository.findAll()){ + if (faker.random().nextInt(0,3) == 0){ + continue; + } + OrderMenuQty omq = new OrderMenuQty(); + omq.setOrder(so); + omq.setMenu(m); + omq.setQuantity(faker.random().nextInt(1,5)); + menusQty.add(omq); + } + System.out.println("before saving relationship ShippingOrderRestaurant <-> OrderMenusQqy"); + shippingOrderRepository.save(so); + System.out.println("after saving relationship ShippingOrderRestaurant <-> OrderMenusQqy"); + +// ShippingOrderRestaurant so1DB = shippingOrderRepository.findById(idOrder).orElse(null); +// System.out.println(menusQty.size() + "=" + so1DB.getMenusQty().size() ); + + return idOrder; + } + + + public void createSomeRelationsOld(){ ShippingOrderRestaurant so1 = (ShippingOrderRestaurant) orders.get(0); List menusQty = getRandomMenuQty(so1); so1.setMenusQty(menusQty); diff --git a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java index a8bbaf2..0557946 100644 --- a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java +++ b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java @@ -20,11 +20,13 @@ public class OrderMenuQtyTest { @Autowired ShippingOrderRepository shippingOrderRepository; @Autowired + MenuRestaurantRepository menuRepository; + @Autowired OrderMenuQtyRepository orderMenuQtyRepository; - List menus; - List orders; +// List menus; +// List orders; @Autowired FakeDataLoader dataLoader; @@ -33,17 +35,32 @@ public class OrderMenuQtyTest { public void createDataAndSave2DBWithoutRelationship() { dataLoader.deleteAllData(); dataLoader.createDataAndSave2DBWithoutRelationship(); - menus = dataLoader.getMenus(); - orders = dataLoader.getOrders(); +// menus = dataLoader.getMenus(); +// orders = dataLoader.getOrders(); } + public List getRandomMenuQty(OrderRestaurant orderRestaurant){ + List menusQty = new ArrayList<>(); + for(MenuRestaurant m:menuRepository.findAll()){ + if (dataLoader.getFaker().random().nextInt(0,3) == 0){ + continue; + } + OrderMenuQty omq = new OrderMenuQty(); + omq.setOrder(orderRestaurant); + omq.setMenu(m); + omq.setQuantity(dataLoader.getFaker().random().nextInt(1,5)); + menusQty.add(omq); + } + return menusQty; + } @Test // https://stackoverflow.com/questions/11746499/how-to-solve-the-failed-to-lazily-initialize-a-collection-of-role-hibernate-ex @Transactional // (propagation= Propagation.REQUIRED) public void createOrderMenuQtyDB() { - ShippingOrderRestaurant so1 = (ShippingOrderRestaurant)orders.get(0); - List menusQty = dataLoader.getRandomMenuQty(so1); + List orders = shippingOrderRepository.findAll(); + ShippingOrderRestaurant so1 = orders.get(0); + List menusQty = getRandomMenuQty(so1); so1.setMenusQty(menusQty); // save relationship to DB shippingOrderRepository.save(so1); @@ -67,8 +84,9 @@ public void createOrderMenuQtyDB() { @Test @Transactional public void createOrderManyMenus() { - ShippingOrderRestaurant so1 = (ShippingOrderRestaurant)orders.get(1); - List menusQty = dataLoader.getRandomMenuQty(so1); + List orders = shippingOrderRepository.findAll(); + ShippingOrderRestaurant so1 = orders.get(1); + List menusQty = getRandomMenuQty(so1); int nMenus = 0; int totalQtyMenus = 0; // every menu qty will be greater than 1 @@ -99,29 +117,30 @@ public void createOrderManyMenus() { } @Test + @Transactional public void checkOrderMenuQtyRepository() { - List menusQtyDB = orderMenuQtyRepository.findAll(); // no relationship is on DB - assertThat(menusQtyDB.size()).isEqualTo(0); + assertThat(orderMenuQtyRepository.findAll().size()).isEqualTo(0); - ShippingOrderRestaurant so1 = (ShippingOrderRestaurant) orders.get(2); - List menusQty = dataLoader.getRandomMenuQty(so1); + List orders = shippingOrderRepository.findAll(); + ShippingOrderRestaurant so1 = orders.get(2); + List menusQty = getRandomMenuQty(so1); so1.setMenusQty(menusQty); // save some relationships shippingOrderRepository.save(so1); - menusQtyDB = orderMenuQtyRepository.findAll(); // check relationships are the same that we assign - assertThat(menusQtyDB).containsAll(menusQty); + assertThat(orderMenuQtyRepository.findAll()).containsAll(menusQty); } @Test @Transactional public void createOrderAndDeleteSomeQtyMenus() { - ShippingOrderRestaurant so1 = (ShippingOrderRestaurant) orders.get(0); - List menusQty = dataLoader.getRandomMenuQty(so1); + List orders = shippingOrderRepository.findAll(); + ShippingOrderRestaurant so1 = orders.get(0); + List menusQty = getRandomMenuQty(so1); so1.setMenusQty(menusQty); int nMenusOriginal = menusQty.size(); // save some order with some menus @@ -164,13 +183,15 @@ public void createOrderAndDeleteSomeQtyMenus() { @Test @Transactional public void deleteSomeQtyMenusWithMenuQtyRepository() { + System.out.println("TEST deleteSomeQtyMenusWithMenuQtyRepository BEGIN"); // check no relationship is stored on DB assertThat(orderMenuQtyRepository.findAll().size()).isEqualTo(0); // get first order - ShippingOrderRestaurant so = (ShippingOrderRestaurant) orders.get(0); + List orders = shippingOrderRepository.findAll(); + ShippingOrderRestaurant so = orders.get(0); // get some random QtyMenu - List menusQty = dataLoader.getRandomMenuQty(so); + List menusQty = getRandomMenuQty(so); so.setMenusQty(menusQty); int nMenusOriginal = menusQty.size(); System.out.println("Printing " + nMenusOriginal + " menu qty from memory"); @@ -208,46 +229,15 @@ public void deleteSomeQtyMenusWithMenuQtyRepository() { assertThat(menusQtyDB.size()).isEqualTo(nMenusOriginal); // and now remove one OrderMenuQty with orderMenuQtyRepository System.out.println("Before orderMenuQtyRepository.delete"); - // none of the next 3 methods work !!!! - // orderMenuQtyRepository.deleteById(omqToDelete.getId()); + // none of the next 2 methods work !!!! + orderMenuQtyRepository.deleteById(omqToDelete.getId()); orderMenuQtyRepository.delete(omqToDelete); // orderMenuQtyRepository.myDeleteQuery(omqToDelete.getId()); // no SQL instruction is shown on console !!! System.out.println("After orderMenuQtyRepository.delete"); // this assert will fail assertThat(orderMenuQtyRepository.count()).isEqualTo(nMenusOriginal-1); - -// -// -// -// -// List menusQtyDB = orderMenuQtyRepository.findAll(); -// OrderMenuQty omq = menusQtyDB.get(0); -// int test = 4; -// if( test==1){ -// omq.setMenu(null); -// omq.setOrder(null); -// orderMenuQtyRepository.save(omq); -// orderMenuQtyRepository.delete(omq); -// } else if( test==2) { -// orderMenuQtyRepository.deleteById(omq.getId()); -// } else if( test==3) { -// orderMenuQtyRepository.delete(omq); -// } else if( test==4) { -// orderMenuQtyRepository.myDeleteQuery(omq.getId()); -// } else if( test==5) { -// String id = menusQtyDB.get(0).getId(); -// orderMenuQtyRepository.deleteById(id); -// } -// System.out.println("After orderMenuQtyRepository.delete"); -// assertThat(orderMenuQtyRepository.count()).isEqualTo(nMenusOriginal-1); -// -// -// Optional found = shippingOrderRepository.findById(so.getId()); -// ShippingOrderRestaurant soDB2 = found.get(); -// int nMenusAfterDelete = soDB2.getMenusQty().size(); -// -// assertThat(nMenusOriginal-1).isEqualTo(nMenusAfterDelete); + System.out.println("TEST deleteSomeQtyMenusWithMenuQtyRepository END"); } From de56283b32e48fda5c6a8486f5d992fec1d170d2 Mon Sep 17 00:00:00 2001 From: jc-programs Date: Wed, 6 Nov 2024 07:51:52 +0100 Subject: [PATCH 22/28] all code working but one test --- .../restaurantManager/controller/PopulateDataController.java | 4 ++-- .../example/restaurantManager/utilities/FakeDataLoader.java | 1 + 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/src/main/java/dev/example/restaurantManager/controller/PopulateDataController.java b/src/main/java/dev/example/restaurantManager/controller/PopulateDataController.java index 297ce94..e9b0737 100644 --- a/src/main/java/dev/example/restaurantManager/controller/PopulateDataController.java +++ b/src/main/java/dev/example/restaurantManager/controller/PopulateDataController.java @@ -17,8 +17,8 @@ public class PopulateDataController { @PostMapping("/all") public ResponseEntity PopulateAllData(){ dataLoader.createDataAndSave2DBWithoutRelationship(); - dataLoader.createSomeRelations(); - return ResponseEntity.ok("All data populated successfully"); + String idOrder = dataLoader.createSomeRelations(); + return ResponseEntity.ok("All data populated successfully. Some relationship to order_id="+idOrder); } } diff --git a/src/main/java/dev/example/restaurantManager/utilities/FakeDataLoader.java b/src/main/java/dev/example/restaurantManager/utilities/FakeDataLoader.java index 881ca59..dd30a7b 100644 --- a/src/main/java/dev/example/restaurantManager/utilities/FakeDataLoader.java +++ b/src/main/java/dev/example/restaurantManager/utilities/FakeDataLoader.java @@ -143,6 +143,7 @@ public String createSomeRelations(){ menusQty.add(omq); } System.out.println("before saving relationship ShippingOrderRestaurant <-> OrderMenusQqy"); + so.setMenusQty(menusQty); shippingOrderRepository.save(so); System.out.println("after saving relationship ShippingOrderRestaurant <-> OrderMenusQqy"); From 97c4b637dfb6eb8e51fb12f7dfbebc4ba7ee4f29 Mon Sep 17 00:00:00 2001 From: jc-programs Date: Wed, 6 Nov 2024 13:50:47 +0100 Subject: [PATCH 23/28] intentando arreglar delete OrderMenuQty --- .../controller/OrderController.java | 19 ++++++++------- .../model/MenuRestaurant.java | 1 + .../restaurantManager/model/OrderMenuQty.java | 3 ++- .../model/OrderRestaurant.java | 2 ++ .../service/OrderService.java | 3 +++ .../service/OrderServiceImpl.java | 24 +++++++++++++++++-- .../restaurantManager/OrderMenuQtyTest.java | 24 +++++++++++++++++++ 7 files changed, 64 insertions(+), 12 deletions(-) diff --git a/src/main/java/dev/example/restaurantManager/controller/OrderController.java b/src/main/java/dev/example/restaurantManager/controller/OrderController.java index 2ec4217..a24b211 100644 --- a/src/main/java/dev/example/restaurantManager/controller/OrderController.java +++ b/src/main/java/dev/example/restaurantManager/controller/OrderController.java @@ -66,19 +66,20 @@ public ResponseEntity deleteOrder(@PathVariable String id) { @PutMapping("/{id}/menus/{menus}") public ResponseEntity updateOrder(@PathVariable String id, @RequestBody List menus) { - OrderRestaurant order = orderService.getOrderById(id); + OrderRestaurant orderUpdated = orderService.addMenus(id,menus); + // OrderRestaurant order = orderService.getOrderById(id); HttpHeaders headers = getCommonHeaders("Add menu qties to order"); - if( order==null ){ - return new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); - } - for (MenuRestaurant m : menus) { - order.addMenu(m); - } - OrderRestaurant orderUpdated = orderService.updateOrder(id,order); - return orderUpdated != null ? new ResponseEntity<>(orderUpdated, headers, HttpStatus.OK) : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); +// if( orderUpdated==null ){ +// return new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); +// } +// for (MenuRestaurant m : menus) { +// order.addMenu(m); +// } + // OrderRestaurant orderUpdated = orderService.updateOrder(id,order); + } // @DeleteMapping("/{id}") diff --git a/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java index 458c943..ae26151 100644 --- a/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java @@ -25,6 +25,7 @@ public class MenuRestaurant { // @ManyToMany(mappedBy = "menus", fetch = FetchType.LAZY) // private List orders = new ArrayList<>(); + @JsonIgnore @OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.ALL) @JoinColumn(name="menu_id") // sin esta anotación se crea la tabla menu_restaurant_menus_qty private List menusQty; diff --git a/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java index fc596ee..0300a41 100644 --- a/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java +++ b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java @@ -1,5 +1,6 @@ package dev.example.restaurantManager.model; +import com.fasterxml.jackson.annotation.JsonIgnore; import jakarta.persistence.*; import lombok.Data; import org.hibernate.annotations.GenericGenerator; @@ -53,7 +54,7 @@ public boolean equals(Object o) { if (!(o instanceof OrderMenuQty that)) return false; // don't check because id it's set in db // Objects.equals(id, that.id) - return quantity == that.quantity && Objects.equals(order, that.order) && Objects.equals(menu, that.menu); + return quantity == that.quantity && order.getId().equals(that.order.getId()) && menu.getId().equals(that.menu.getId()); } diff --git a/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java index ee909c5..0aa875a 100644 --- a/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java @@ -2,6 +2,7 @@ import java.util.*; +import com.fasterxml.jackson.annotation.JsonIgnore; import jakarta.persistence.*; import lombok.*; @@ -32,6 +33,7 @@ public class OrderRestaurant { // joinColumns = @JoinColumn(name = "ORDER_ID_FK"), // inverseJoinColumns = @JoinColumn(name = "MENU_ID_FK") // ) + @JsonIgnore @OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.ALL) @JoinColumn(name="order_id") // Sin esta anotación se crea la tabla order_restaurant_menus_qty !!! private List menusQty; diff --git a/src/main/java/dev/example/restaurantManager/service/OrderService.java b/src/main/java/dev/example/restaurantManager/service/OrderService.java index 8553e10..5607716 100644 --- a/src/main/java/dev/example/restaurantManager/service/OrderService.java +++ b/src/main/java/dev/example/restaurantManager/service/OrderService.java @@ -1,5 +1,6 @@ package dev.example.restaurantManager.service; +import dev.example.restaurantManager.model.MenuRestaurant; import dev.example.restaurantManager.model.OrderRestaurant; import java.util.List; @@ -12,4 +13,6 @@ public interface OrderService { boolean deleteOrder(String id); long countOrders(); + + OrderRestaurant addMenus(String idOrder, List menus); } diff --git a/src/main/java/dev/example/restaurantManager/service/OrderServiceImpl.java b/src/main/java/dev/example/restaurantManager/service/OrderServiceImpl.java index 0d8ee69..f71084c 100644 --- a/src/main/java/dev/example/restaurantManager/service/OrderServiceImpl.java +++ b/src/main/java/dev/example/restaurantManager/service/OrderServiceImpl.java @@ -1,8 +1,13 @@ package dev.example.restaurantManager.service; +import dev.example.restaurantManager.model.MenuRestaurant; import dev.example.restaurantManager.model.OrderRestaurant; import dev.example.restaurantManager.repository.OrderRestaurantRepository; +import jakarta.transaction.Transactional; import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; import org.springframework.stereotype.Service; import java.util.List; @@ -29,7 +34,9 @@ public OrderRestaurant getOrderById(String id) { @Override public OrderRestaurant updateOrder(String id, OrderRestaurant orderDetails) { - OrderRestaurant order = getOrderById(id); + // OrderRestaurant order = getOrderById(id); + OrderRestaurant order = orderRepository.getReferenceById(id); + return orderRepository.save(orderDetails); } @@ -42,6 +49,19 @@ public boolean deleteOrder(String id) { @Override public long countOrders() { - return 0; + return orderRepository.count(); + } + + @Override + public OrderRestaurant addMenus(String idOrder, List menus){ + // OrderRestaurant order = orderRepository.findById(idOrder).orElse(null); + OrderRestaurant order = orderRepository.getReferenceById(idOrder); + if( order==null ){ + return null; + } + for (MenuRestaurant m : menus) { + order.addMenu(m); + } + return orderRepository.save(order); } } diff --git a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java index 0557946..77a23f1 100644 --- a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java +++ b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java @@ -20,6 +20,8 @@ public class OrderMenuQtyTest { @Autowired ShippingOrderRepository shippingOrderRepository; @Autowired + OrderRestaurantRepository orderRepository; + @Autowired MenuRestaurantRepository menuRepository; @Autowired OrderMenuQtyRepository orderMenuQtyRepository; @@ -242,4 +244,26 @@ public void deleteSomeQtyMenusWithMenuQtyRepository() { } + @Test + @Transactional + public void orderRepositoryAndShippingRepository() { + System.out.println("TEST orderRepositoryAndShippingRepository BEGIN"); + System.out.println(shippingOrderRepository.findAll()); + String id = shippingOrderRepository.findAll().get(1).getId(); + System.out.println("id from db=" + id); + String shippingOrderId = "SO2"; + System.out.println("id from db=" + shippingOrderId); + assertThat(id).isEqualTo(shippingOrderId); + Optional optionalSO = shippingOrderRepository.findById(shippingOrderId); + assertThat(optionalSO).isPresent(); + ShippingOrderRestaurant so = optionalSO.get(); + + Optional optionalOR = orderRepository.findById(shippingOrderId); + assertThat(optionalOR).isPresent(); + ShippingOrderRestaurant so2 = (ShippingOrderRestaurant)optionalOR.get(); + assertThat(so).isEqualTo(so2); + System.out.println("TEST orderRepositoryAndShippingRepository END"); + } + + } From 9d2f0f091d1969a993b18bb629a9c99036d98ca4 Mon Sep 17 00:00:00 2001 From: jc-programs Date: Wed, 6 Nov 2024 16:28:34 +0100 Subject: [PATCH 24/28] all test working but deleteSomeQtyMenusWithMenuQtyRepository --- .../restaurantManager/OrderMenuQtyTest.java | 39 +++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java index 77a23f1..94220a8 100644 --- a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java +++ b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java @@ -137,6 +137,45 @@ public void checkOrderMenuQtyRepository() { } + @Test + @Transactional + public void checkOrderMenuQtyRepository2() { + // no relationship is on DB + int totalRelationships = 0; + assertThat(orderMenuQtyRepository.findAll().size()).isEqualTo(totalRelationships); + + List orders = shippingOrderRepository.findAll(); + ShippingOrderRestaurant so0 = orders.get(0); + List menusQty0 = getRandomMenuQty(so0); + so0.setMenusQty(menusQty0); + // save some relationships + shippingOrderRepository.save(so0); + totalRelationships += menusQty0.size(); + assertThat(orderMenuQtyRepository.findAll().size()).isEqualTo(totalRelationships); + + + ShippingOrderRestaurant so1 = orders.get(1); + List menusQty1 = new ArrayList<>(); + for(OrderMenuQty omq:menusQty0){ + OrderMenuQty omqNew = new OrderMenuQty(); + omqNew.setOrder(so1); + omqNew.setMenu(omq.getMenu()); + omqNew.setQuantity(omq.getQuantity()); + menusQty1.add(omqNew); + } + so1.setMenusQty(menusQty1); + shippingOrderRepository.save(so1); + totalRelationships += menusQty1.size(); + assertThat(orderMenuQtyRepository.findAll().size()).isEqualTo(totalRelationships); + + ShippingOrderRestaurant so2 = orders.get(2); + List menusQty2 = getRandomMenuQty(so2); + so2.setMenusQty(menusQty2); + shippingOrderRepository.save(so2); + totalRelationships += menusQty2.size(); + assertThat(orderMenuQtyRepository.findAll().size()).isEqualTo(totalRelationships); + } + @Test @Transactional public void createOrderAndDeleteSomeQtyMenus() { From 068a0d64cc4b2e968e8b85dd777e9c2e3aca6636 Mon Sep 17 00:00:00 2001 From: jc-programs Date: Wed, 6 Nov 2024 17:11:35 +0100 Subject: [PATCH 25/28] add deleteByIdInMenuQtyRepository. Test don't work --- .../restaurantManager/OrderMenuQtyTest.java | 46 +++++++++++++++++++ 1 file changed, 46 insertions(+) diff --git a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java index 94220a8..529310b 100644 --- a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java +++ b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java @@ -220,6 +220,52 @@ public void createOrderAndDeleteSomeQtyMenus() { } + @Test + @Transactional + public void testFindByIdInMenuQtyRepository(){ + // get last order + ShippingOrderRestaurant so = shippingOrderRepository.findAll().getLast(); + // get some random QtyMenu + List menusQty = getRandomMenuQty(so); + so.setMenusQty(menusQty); + // save relationships + shippingOrderRepository.save(so); + // print all orders relationships + shippingOrderRepository.findAll().forEach( or -> System.out.println(or.getId() + ": " + or.getMenusQty() )); + + // find from DB first menusQty + OrderMenuQty omqMemory = menusQty.get(0); + Optional foundOmq = orderMenuQtyRepository.findById(omqMemory.getId()); + assertThat(foundOmq).isPresent(); + OrderMenuQty omqDB = foundOmq.get(); + assertThat(omqMemory).isEqualTo(omqDB); + } + + @Test + @Transactional + public void deleteByIdInMenuQtyRepository(){ + // get last order + ShippingOrderRestaurant so = shippingOrderRepository.findAll().getLast(); + // get some random QtyMenu + List menusQty = getRandomMenuQty(so); + so.setMenusQty(menusQty); + // save relationships + shippingOrderRepository.save(so); + // print all orders relationships + shippingOrderRepository.findAll().forEach( or -> System.out.println(or.getId() + ": " + or.getMenusQty() )); + + long nOrderMenuQty = menusQty.size(); + System.out.println("total OrderMenuQty: " + nOrderMenuQty); + // find from DB first menusQty + OrderMenuQty omqToDelete = menusQty.get(0); + System.out.println("OrderMenuQty to delete: " + omqToDelete); + orderMenuQtyRepository.deleteById(omqToDelete.getId()); + orderMenuQtyRepository.flush(); + + Optional found = orderMenuQtyRepository.findById(omqToDelete.getId()); + assertThat(found).isNotPresent(); + assertThat(orderMenuQtyRepository.count()).isEqualTo(nOrderMenuQty-1); + } @Test @Transactional From ad268cc123a2bdc66e77671aa80506f74d283b56 Mon Sep 17 00:00:00 2001 From: jc-programs Date: Wed, 6 Nov 2024 20:45:42 +0100 Subject: [PATCH 26/28] added delete menus from order --- .../controller/OrderController.java | 21 ++++++++----------- .../service/OrderService.java | 1 + .../service/OrderServiceImpl.java | 13 ++++++++++++ .../restaurantManager/OrderMenuQtyTest.java | 3 ++- 4 files changed, 25 insertions(+), 13 deletions(-) diff --git a/src/main/java/dev/example/restaurantManager/controller/OrderController.java b/src/main/java/dev/example/restaurantManager/controller/OrderController.java index a24b211..424eacc 100644 --- a/src/main/java/dev/example/restaurantManager/controller/OrderController.java +++ b/src/main/java/dev/example/restaurantManager/controller/OrderController.java @@ -65,7 +65,7 @@ public ResponseEntity deleteOrder(@PathVariable String id) { @PutMapping("/{id}/menus/{menus}") - public ResponseEntity updateOrder(@PathVariable String id, @RequestBody List menus) { + public ResponseEntity updateOrderAddMenuQty(@PathVariable String id, @RequestBody List menus) { OrderRestaurant orderUpdated = orderService.addMenus(id,menus); // OrderRestaurant order = orderService.getOrderById(id); HttpHeaders headers = getCommonHeaders("Add menu qties to order"); @@ -82,17 +82,14 @@ public ResponseEntity updateOrder(@PathVariable String id, @Req } -// @DeleteMapping("/{id}") -// public ResponseEntity deleteOrder(@PathVariable String id) { -// boolean deleted = orderService.deleteOrder(id); -// HttpHeaders headers = getCommonHeaders("Delete an order"); -// headers.add("deleted", String.valueOf(deleted)); -// -// -// return deleted -// ? new ResponseEntity<>(headers, HttpStatus.NO_CONTENT) -// : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); -// } + @DeleteMapping("/{id}/menus/{menus}") + public ResponseEntity updateOrderDelMenuQty(@PathVariable String id, @RequestBody List menus) { + OrderRestaurant orderUpdated = orderService.deleteMenus(id,menus); + HttpHeaders headers = getCommonHeaders("Delete menu qties from order"); + return orderUpdated != null + ? new ResponseEntity<>(orderUpdated, headers, HttpStatus.OK) + : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + } @GetMapping("/{id}") diff --git a/src/main/java/dev/example/restaurantManager/service/OrderService.java b/src/main/java/dev/example/restaurantManager/service/OrderService.java index 5607716..4be3acc 100644 --- a/src/main/java/dev/example/restaurantManager/service/OrderService.java +++ b/src/main/java/dev/example/restaurantManager/service/OrderService.java @@ -15,4 +15,5 @@ public interface OrderService { OrderRestaurant addMenus(String idOrder, List menus); + OrderRestaurant deleteMenus(String idOrder, List menus); } diff --git a/src/main/java/dev/example/restaurantManager/service/OrderServiceImpl.java b/src/main/java/dev/example/restaurantManager/service/OrderServiceImpl.java index f71084c..1f22c74 100644 --- a/src/main/java/dev/example/restaurantManager/service/OrderServiceImpl.java +++ b/src/main/java/dev/example/restaurantManager/service/OrderServiceImpl.java @@ -64,4 +64,17 @@ public OrderRestaurant addMenus(String idOrder, List menus){ } return orderRepository.save(order); } + + @Override + public OrderRestaurant deleteMenus(String idOrder, List menus){ + // OrderRestaurant order = orderRepository.findById(idOrder).orElse(null); + OrderRestaurant order = orderRepository.getReferenceById(idOrder); + if( order==null ){ + return null; + } + for (MenuRestaurant m : menus) { + order.removeMenu(m); + } + return orderRepository.save(order); + } } diff --git a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java index 529310b..9ee77cc 100644 --- a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java +++ b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java @@ -257,9 +257,10 @@ public void deleteByIdInMenuQtyRepository(){ long nOrderMenuQty = menusQty.size(); System.out.println("total OrderMenuQty: " + nOrderMenuQty); // find from DB first menusQty - OrderMenuQty omqToDelete = menusQty.get(0); + OrderMenuQty omqToDelete = orderMenuQtyRepository.findById(menusQty.get(0).getId()).orElseThrow(); System.out.println("OrderMenuQty to delete: " + omqToDelete); orderMenuQtyRepository.deleteById(omqToDelete.getId()); + orderMenuQtyRepository.delete(omqToDelete); orderMenuQtyRepository.flush(); Optional found = orderMenuQtyRepository.findById(omqToDelete.getId()); From 5721c0536c8716062097c768e78a6dd6b1e46913 Mon Sep 17 00:00:00 2001 From: jc-programs Date: Thu, 7 Nov 2024 07:29:14 +0100 Subject: [PATCH 27/28] avoiding JSON recursion with @JsonIdentityInfo --- .../model/MenuRestaurant.java | 7 +++++- .../restaurantManager/model/OrderMenuQty.java | 2 ++ .../model/OrderRestaurant.java | 7 +++++- .../model/PK_OrderMenuQty.java | 1 + .../service/OrderServiceImpl.java | 24 ++++++++++++------- .../resources/application-local.properties | 5 ++++ 6 files changed, 36 insertions(+), 10 deletions(-) diff --git a/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java index ae26151..18235ba 100644 --- a/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java @@ -1,6 +1,8 @@ package dev.example.restaurantManager.model; +import com.fasterxml.jackson.annotation.JsonIdentityInfo; import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.ObjectIdGenerators; import jakarta.persistence.*; import lombok.*; import java.util.ArrayList; @@ -11,6 +13,10 @@ // @AllArgsConstructor @NoArgsConstructor @Entity +// https://www.baeldung.com/jackson-bidirectional-relationships-and-infinite-recursion +@JsonIdentityInfo( + generator = ObjectIdGenerators.PropertyGenerator.class, + property = "id") public class MenuRestaurant { @Id @@ -25,7 +31,6 @@ public class MenuRestaurant { // @ManyToMany(mappedBy = "menus", fetch = FetchType.LAZY) // private List orders = new ArrayList<>(); - @JsonIgnore @OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.ALL) @JoinColumn(name="menu_id") // sin esta anotación se crea la tabla menu_restaurant_menus_qty private List menusQty; diff --git a/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java index 0300a41..805529a 100644 --- a/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java +++ b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java @@ -18,12 +18,14 @@ public class OrderMenuQty { // private String id; + @JsonIgnore @Id @ManyToOne @JoinColumn(name="order_id", referencedColumnName="id", nullable = false) // @JoinColumn(name = "order_id") private OrderRestaurant order; + @JsonIgnore @Id @ManyToOne @JoinColumn(name="menu_id", referencedColumnName="id", nullable = false) diff --git a/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java index 0aa875a..b1d4d06 100644 --- a/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java @@ -2,7 +2,9 @@ import java.util.*; +import com.fasterxml.jackson.annotation.JsonIdentityInfo; import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.ObjectIdGenerators; import jakarta.persistence.*; import lombok.*; @@ -15,6 +17,10 @@ @Entity @Table(name = "ORDER_RESTAURANT") @Inheritance(strategy = InheritanceType.SINGLE_TABLE) +// https://www.baeldung.com/jackson-bidirectional-relationships-and-infinite-recursion +@JsonIdentityInfo( + generator = ObjectIdGenerators.PropertyGenerator.class, + property = "id") public class OrderRestaurant { @Id @@ -33,7 +39,6 @@ public class OrderRestaurant { // joinColumns = @JoinColumn(name = "ORDER_ID_FK"), // inverseJoinColumns = @JoinColumn(name = "MENU_ID_FK") // ) - @JsonIgnore @OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.ALL) @JoinColumn(name="order_id") // Sin esta anotación se crea la tabla order_restaurant_menus_qty !!! private List menusQty; diff --git a/src/main/java/dev/example/restaurantManager/model/PK_OrderMenuQty.java b/src/main/java/dev/example/restaurantManager/model/PK_OrderMenuQty.java index 4426d99..7af1772 100644 --- a/src/main/java/dev/example/restaurantManager/model/PK_OrderMenuQty.java +++ b/src/main/java/dev/example/restaurantManager/model/PK_OrderMenuQty.java @@ -1,5 +1,6 @@ package dev.example.restaurantManager.model; +import com.fasterxml.jackson.annotation.JsonIgnore; import lombok.Getter; import lombok.Setter; diff --git a/src/main/java/dev/example/restaurantManager/service/OrderServiceImpl.java b/src/main/java/dev/example/restaurantManager/service/OrderServiceImpl.java index 1f22c74..705005e 100644 --- a/src/main/java/dev/example/restaurantManager/service/OrderServiceImpl.java +++ b/src/main/java/dev/example/restaurantManager/service/OrderServiceImpl.java @@ -1,17 +1,17 @@ package dev.example.restaurantManager.service; import dev.example.restaurantManager.model.MenuRestaurant; +import dev.example.restaurantManager.model.OrderMenuQty; import dev.example.restaurantManager.model.OrderRestaurant; import dev.example.restaurantManager.repository.OrderRestaurantRepository; -import jakarta.transaction.Transactional; +import dev.example.restaurantManager.utilities.Converter; import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.http.HttpHeaders; -import org.springframework.http.HttpStatus; -import org.springframework.http.ResponseEntity; import org.springframework.stereotype.Service; import java.util.List; +import static dev.example.restaurantManager.utilities.Converter.convertMenus2QtyMenus; + @Service public class OrderServiceImpl implements OrderService{ @Autowired @@ -59,8 +59,12 @@ public OrderRestaurant addMenus(String idOrder, List menus){ if( order==null ){ return null; } - for (MenuRestaurant m : menus) { - order.addMenu(m); +// for (MenuRestaurant m : menus) { +// order.addMenu(m); +// } + List menusQt = Converter.convertMenus2QtyMenus(order,menus); + for(OrderMenuQty omq:menusQt){ + order.addMenuQty(omq.getMenu(),omq.getQuantity()); } return orderRepository.save(order); } @@ -72,8 +76,12 @@ public OrderRestaurant deleteMenus(String idOrder, List menus){ if( order==null ){ return null; } - for (MenuRestaurant m : menus) { - order.removeMenu(m); +// for (MenuRestaurant m : menus) { +// order.removeMenu(m); +// } + List menusQt = Converter.convertMenus2QtyMenus(order,menus); + for(OrderMenuQty omq:menusQt){ + order.removeMenuQty(omq.getMenu(),omq.getQuantity()); } return orderRepository.save(order); } diff --git a/src/main/resources/application-local.properties b/src/main/resources/application-local.properties index 8d8917d..cb441a4 100644 --- a/src/main/resources/application-local.properties +++ b/src/main/resources/application-local.properties @@ -3,6 +3,11 @@ spring.datasource.url=jdbc:h2:/home/jc/Documents/restaurant-db/db spring.datasource.username=jc spring.datasource.password= +# https://stackoverflow.com/questions/61189480/spring-boot-jackson-responseentity-no-serializer-found-for-class +# TO AVOID THIS ERROR: +# com.fasterxml.jackson.databind.exc.InvalidDefinitionException: No serializer found for class org.hibernate.proxy.pojo.bytebuddy.ByteBuddyInterceptor .... +spring.jackson.serialization.FAIL_ON_EMPTY_BEANS=false + # see sql in console spring.jpa.show-sql=true spring.jpa.properties.hibernate.format_sql=true From 2c9c908ca5b866fc0ff5840fb3845cdc304b5e94 Mon Sep 17 00:00:00 2001 From: jc-programs Date: Thu, 7 Nov 2024 12:08:21 +0100 Subject: [PATCH 28/28] test OrderService: addMenus and removeMenus --- .../restaurantManager/OrderMenuQtyTest.java | 172 ++++++++++++------ 1 file changed, 115 insertions(+), 57 deletions(-) diff --git a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java index 9ee77cc..33687a3 100644 --- a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java +++ b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java @@ -2,7 +2,9 @@ import dev.example.restaurantManager.model.*; import dev.example.restaurantManager.repository.*; +import dev.example.restaurantManager.service.OrderService; import dev.example.restaurantManager.utilities.FakeDataLoader; +import jakarta.persistence.EntityManager; import jakarta.transaction.Transactional; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -17,6 +19,8 @@ @SpringBootTest public class OrderMenuQtyTest { + @Autowired + EntityManager entityManager; @Autowired ShippingOrderRepository shippingOrderRepository; @Autowired @@ -25,6 +29,8 @@ public class OrderMenuQtyTest { MenuRestaurantRepository menuRepository; @Autowired OrderMenuQtyRepository orderMenuQtyRepository; + @Autowired + OrderService orderService; // List menus; @@ -222,7 +228,7 @@ public void createOrderAndDeleteSomeQtyMenus() { @Test @Transactional - public void testFindByIdInMenuQtyRepository(){ + public void findByIdInMenuQtyRepository(){ // get last order ShippingOrderRestaurant so = shippingOrderRepository.findAll().getLast(); // get some random QtyMenu @@ -243,38 +249,12 @@ public void testFindByIdInMenuQtyRepository(){ @Test @Transactional - public void deleteByIdInMenuQtyRepository(){ - // get last order - ShippingOrderRestaurant so = shippingOrderRepository.findAll().getLast(); - // get some random QtyMenu - List menusQty = getRandomMenuQty(so); - so.setMenusQty(menusQty); - // save relationships - shippingOrderRepository.save(so); - // print all orders relationships - shippingOrderRepository.findAll().forEach( or -> System.out.println(or.getId() + ": " + or.getMenusQty() )); - - long nOrderMenuQty = menusQty.size(); - System.out.println("total OrderMenuQty: " + nOrderMenuQty); - // find from DB first menusQty - OrderMenuQty omqToDelete = orderMenuQtyRepository.findById(menusQty.get(0).getId()).orElseThrow(); - System.out.println("OrderMenuQty to delete: " + omqToDelete); - orderMenuQtyRepository.deleteById(omqToDelete.getId()); - orderMenuQtyRepository.delete(omqToDelete); - orderMenuQtyRepository.flush(); - - Optional found = orderMenuQtyRepository.findById(omqToDelete.getId()); - assertThat(found).isNotPresent(); - assertThat(orderMenuQtyRepository.count()).isEqualTo(nOrderMenuQty-1); - } - - @Test - @Transactional - public void deleteSomeQtyMenusWithMenuQtyRepository() { - System.out.println("TEST deleteSomeQtyMenusWithMenuQtyRepository BEGIN"); + public void deleteQtyMenusWithOrderRepository() { + System.out.println("TEST deleteQtyMenusWithOrderRepository BEGIN"); // check no relationship is stored on DB assertThat(orderMenuQtyRepository.findAll().size()).isEqualTo(0); + // get first order List orders = shippingOrderRepository.findAll(); ShippingOrderRestaurant so = orders.get(0); @@ -285,51 +265,31 @@ public void deleteSomeQtyMenusWithMenuQtyRepository() { System.out.println("Printing " + nMenusOriginal + " menu qty from memory"); menusQty.forEach(System.out::println); // save relationship of order with some qty menus - shippingOrderRepository.save(so); + orderRepository.save(so); System.out.println("After shippingOrderRepository.save"); - // first check: removing one OrderMenuQty with shippingOrderRepository + // removing one OrderMenuQty with shippingOrderRepository OrderMenuQty omq = menusQty.get(0); so.removeMenuQty(omq.getMenu(),omq.getQuantity()); - shippingOrderRepository.save(so); + orderRepository.save(so); // get order from db to check if OrderMenuQty is removed Optional found1 = shippingOrderRepository.findById(so.getId()); assertThat(found1).isPresent(); assertThat(found1.get().getMenusQty().size()).isEqualTo(nMenusOriginal-1); // insert back OrderMenuQty so.addMenuQty(omq.getMenu(),omq.getQuantity()); - shippingOrderRepository.save(so); + orderRepository.save(so); // and check if OrderMenuQty is added found1 = shippingOrderRepository.findById(so.getId()); assertThat(found1).isPresent(); assertThat(found1.get().getMenusQty().size()).isEqualTo(nMenusOriginal); - // second check: removing one OrderMenuQty with orderMenuQtyRepository - List menusQtyDB = orderMenuQtyRepository.findAll(); - OrderMenuQty omqToDelete = menusQtyDB.get(0); - System.out.println("Printing menu qty from DB"); - menusQtyDB.forEach(System.out::println); - System.out.println("Menu qty to delete: " + omqToDelete); - // As no relationship was stored on DB before this test - // all relationships on DB belong to the order of this test - assertThat(menusQtyDB.stream().map(o -> o.getOrder().getId())).allMatch(id -> id.equals(so.getId()) ); - // must be same number of relationships - assertThat(menusQtyDB.size()).isEqualTo(nMenusOriginal); - // and now remove one OrderMenuQty with orderMenuQtyRepository - System.out.println("Before orderMenuQtyRepository.delete"); - // none of the next 2 methods work !!!! - orderMenuQtyRepository.deleteById(omqToDelete.getId()); - orderMenuQtyRepository.delete(omqToDelete); - // orderMenuQtyRepository.myDeleteQuery(omqToDelete.getId()); - // no SQL instruction is shown on console !!! - System.out.println("After orderMenuQtyRepository.delete"); - // this assert will fail - assertThat(orderMenuQtyRepository.count()).isEqualTo(nMenusOriginal-1); - System.out.println("TEST deleteSomeQtyMenusWithMenuQtyRepository END"); - + System.out.println("TEST deleteQtyMenusWithOrderRepository END"); } + + @Test @Transactional public void orderRepositoryAndShippingRepository() { @@ -351,5 +311,103 @@ public void orderRepositoryAndShippingRepository() { System.out.println("TEST orderRepositoryAndShippingRepository END"); } + @Test + @Transactional + public void orderServiceAddMenus(){ + System.out.println("TEST orderServiceAddMenus BEGIN"); + // store in memory menus + List menusToAdd = new ArrayList<>(); + HashMap menusNumber = new HashMap<>(); + for(MenuRestaurant m:menuRepository.findAll()){ + int n = dataLoader.getFaker().random().nextInt(2,5); + for(int i=0;i menusQty = getRandomMenuQty(so); + so.setMenusQty(menusQty); + // save relationship of order with some qty menus + shippingOrderRepository.save(so); + int nMenusOriginal = menusQty.size(); + System.out.println("Printing " + nMenusOriginal + " menu qty from memory"); + menusQty.forEach(System.out::println); + + // prepare list of menus to delete + List menusToDelete = new ArrayList<>(); + for(OrderMenuQty omq: so.getMenusQty()){ + for(int i=0;i menusQty = getRandomMenuQty(so); + so.setMenusQty(menusQty); + // save relationships + shippingOrderRepository.save(so); + // print all orders relationships + shippingOrderRepository.findAll().forEach( or -> System.out.println(or.getId() + ": " + or.getMenusQty() )); + + long nOrderMenuQty = menusQty.size(); + System.out.println("total OrderMenuQty: " + nOrderMenuQty); + // find from DB first menusQty + OrderMenuQty omqToDelete = orderMenuQtyRepository.findById(menusQty.get(0).getId()).orElseThrow(); + System.out.println("OrderMenuQty to delete: " + omqToDelete); + System.out.println("Before trying to delete"); + // trying with id -> NOT WORKING + orderMenuQtyRepository.deleteById(omqToDelete.getId()); + // trying with object -> NOT WORKING + orderMenuQtyRepository.delete(omqToDelete); + // flush to DB + orderMenuQtyRepository.flush(); + entityManager.flush(); + entityManager.clear(); + System.out.println("After trying to delete + entityManager.flush(); entityManager.clear();"); + + Optional found = orderMenuQtyRepository.findById(omqToDelete.getId()); + assertThat(found).isNotPresent(); // Fails -> object wasn't deleted + assertThat(orderMenuQtyRepository.count()).isEqualTo(nOrderMenuQty-1); + System.out.println("TEST deleteByIdInMenuQtyRepository END"); + } }