diff --git a/src/main/java/dev/example/restaurantManager/controller/MenuRestaurantController.java b/src/main/java/dev/example/restaurantManager/controller/MenuRestaurantController.java new file mode 100644 index 0000000..8393d9d --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/controller/MenuRestaurantController.java @@ -0,0 +1,82 @@ +package dev.example.restaurantManager.controller; + +import dev.example.restaurantManager.model.MenuRestaurant; +import dev.example.restaurantManager.service.MenuRestaurantService; +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/menu") +@RestController +public class MenuRestaurantController { + + @Autowired + private MenuRestaurantService menuRestaurantService; + + @GetMapping("/allMenus") + public ResponseEntity> getAllMenus( ) { + List menuRestaurants = menuRestaurantService.getAllMenus(); + HttpHeaders headers = getCommonHeaders("Get all menus"); + + return menuRestaurants != null && !menuRestaurants.isEmpty() + ? new ResponseEntity<>(menuRestaurants, headers, HttpStatus.OK) + : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + } + + @PostMapping("/add") + public ResponseEntity createMenu(@RequestBody MenuRestaurant menuRestaurant) { + MenuRestaurant createdMenu = menuRestaurantService.createMenu(menuRestaurant); + HttpHeaders headers = getCommonHeaders("Create a new menu"); + + return createdMenu != null + ? new ResponseEntity<>(createdMenu, headers, HttpStatus.CREATED) + : new ResponseEntity<>(headers, HttpStatus.BAD_REQUEST); + } + @PutMapping("/update/{id}") + public ResponseEntity updateMenu(@PathVariable String id, @RequestBody MenuRestaurant menuRestaurantDetails) { + MenuRestaurant updatedMenu = menuRestaurantService.updateMenu(id, menuRestaurantDetails); + HttpHeaders headers = getCommonHeaders("Update a menu"); + + return updatedMenu != null + ? new ResponseEntity<>(updatedMenu, headers, HttpStatus.OK) + : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + } + + @DeleteMapping("/delete/{id}") + public ResponseEntity deleteMenu(@PathVariable String id) { + boolean deleted = menuRestaurantService.deleteMenu(id); + HttpHeaders headers = getCommonHeaders("Delete a menu"); + headers.add("deleted", String.valueOf(deleted)); + + return deleted + ? new ResponseEntity<>(headers, HttpStatus.NO_CONTENT) + : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + } + + @GetMapping("/get/{id}") + public ResponseEntity getMenuById(@PathVariable String id) { + MenuRestaurant menu = menuRestaurantService.getMenuById(id); + HttpHeaders headers = getCommonHeaders("Get a menu"); + + return menu != null + ? new ResponseEntity<>(menu, 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("menuRestaurant-count", String.valueOf(menuRestaurantService.countMenus())); + headers.add("object", "customers"); + return headers; + } +} diff --git a/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java index 1e2dd12..f7f150f 100644 --- a/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java @@ -19,7 +19,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, ArrayList 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..6d0903e 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; @@ -24,9 +21,13 @@ public class MenuRestaurant { private boolean active; private boolean water; +// @JsonIgnore +// @ManyToMany(mappedBy = "menus", fetch = FetchType.LAZY) +// private List orders = new ArrayList<>(); + + @OneToMany(mappedBy = "menuRestaurant", cascade = CascadeType.ALL, fetch = FetchType.EAGER) @JsonIgnore - @ManyToMany(mappedBy = "menus", fetch = FetchType.LAZY) - private List orders = new ArrayList<>(); + private List ordersQty = new ArrayList<>(); 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..49bbb0a --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java @@ -0,0 +1,51 @@ +package dev.example.restaurantManager.model; +import com.fasterxml.jackson.annotation.JsonIgnore; +import jakarta.persistence.*; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import org.hibernate.annotations.GenericGenerator; + +@Entity +@Data +@AllArgsConstructor +@NoArgsConstructor +public class OrderMenuQty { + + @Id + @GeneratedValue(generator = "UUID") + @GenericGenerator(name = "UUID", strategy = "org.hibernate.id.UUIDGenerator") + private String id; + + private long qty; + + @ManyToOne + @JoinColumn(name = "order_id") + @JsonIgnore + private OrderRestaurant orderRestaurant; + + @ManyToOne + @JoinColumn(name = "menu_id") + @JsonIgnore + private MenuRestaurant menuRestaurant; + + public OrderMenuQty(long qty, OrderRestaurant orderRestaurant, MenuRestaurant menuRestaurant) { + this.qty = qty; + this.orderRestaurant = orderRestaurant; + this.menuRestaurant = menuRestaurant; + } + + public String getMenuName() { + return menuRestaurant.getName(); + } + + @Override + public String toString() { + return "OrderMenuQty{" + + "id:'" + id + '\'' + + ", qty:" + qty + + ", order:" + orderRestaurant.getId() + + ", menu:" + menuRestaurant.getName() + + '}'; + } +} diff --git a/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java index 994b5a4..93ce966 100644 --- a/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java @@ -5,6 +5,7 @@ import java.util.List; import com.fasterxml.jackson.annotation.JsonIgnore; import jakarta.persistence.*; +import java.util.stream.Collectors; import lombok.*; @Getter @@ -24,39 +25,43 @@ public class OrderRestaurant { private double totalPayment; private boolean paid; + @OneToMany(mappedBy = "orderRestaurant", cascade = CascadeType.ALL, fetch = FetchType.EAGER) @JsonIgnore - @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") - ) - private List menus = new ArrayList<>(); - - public List addMenu(MenuRestaurant menu) { - this.menus.add(menu); - menu.getOrders().add(this); - return this.menus; + private List ordersQty = new ArrayList<>(); + + public List addOrderMenuQty(OrderMenuQty orderMenuQty) { + if(ordersQty == null) { + ordersQty = new ArrayList<>(); + ordersQty.add(orderMenuQty); + return ordersQty; + }else { + ordersQty.add(orderMenuQty); + return ordersQty; + } + } + public List getOrderMenuQtyIds() { + return ordersQty.stream() + .map(OrderMenuQty::getId) + .collect(Collectors.toList()); } - public List removeMenu(MenuRestaurant menu) { - this.menus.remove(menu); - menu.getOrders().remove(this); - return this.menus; + public void removeOrderMenuQty(OrderMenuQty orderMenuQty) { + ordersQty.remove(orderMenuQty); } @Override public String toString() { return "OrderRestaurant{" + - "id='" + id + '\'' + - ", date=" + date + - ", waiter='" + waiter + '\'' + - ", peopleQty=" + peopleQty + - ", totalPayment=" + totalPayment + - ", paid=" + paid + - ", menusCount=" + (menus != null ? menus.size() : 0) + - ", menus=" + menus + + "id:'" + id + '\'' + + ", date:" + date + + ", waiter:'" + waiter + '\'' + + ", peopleQty:" + peopleQty + + ", totalPayment:" + totalPayment + + ", paid:" + paid + + ", Quantity orders: " + (ordersQty == null ? 0 : ordersQty.size()) + " ordenes" + + ", Ids: " + getOrderMenuQtyIds() + + ", Quantity menu:" + ordersQty.stream().collect(Collectors.groupingBy(OrderMenuQty::getMenuName, Collectors.counting())) + + ", Menus:" + ordersQty.stream().map(OrderMenuQty::getMenuName).collect(Collectors.toList()) + '}'; } diff --git a/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java index 6375dc2..4290974 100644 --- a/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java @@ -16,7 +16,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, ArrayList 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..8303a7f 100644 --- a/src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java +++ b/src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java @@ -19,7 +19,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, ArrayList menus, Customer customerTakeAway) { // THIS PART is SUPERCLASS 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..962ccb7 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/repository/OrderMenuQtyRepository.java @@ -0,0 +1,7 @@ +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/main/java/dev/example/restaurantManager/service/MenuRestaurantService.java b/src/main/java/dev/example/restaurantManager/service/MenuRestaurantService.java new file mode 100644 index 0000000..4e1cfdc --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/MenuRestaurantService.java @@ -0,0 +1,14 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.MenuRestaurant; + +import java.util.List; + +public interface MenuRestaurantService { + List getAllMenus(); + MenuRestaurant getMenuById(String id); + MenuRestaurant createMenu(MenuRestaurant menuRestaurant); + MenuRestaurant updateMenu(String id, MenuRestaurant menuRestaurantDetails); + boolean deleteMenu(String id); + long countMenus(); +} diff --git a/src/main/java/dev/example/restaurantManager/service/MenuRestaurantServiceImpl.java b/src/main/java/dev/example/restaurantManager/service/MenuRestaurantServiceImpl.java new file mode 100644 index 0000000..8d4687c --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/MenuRestaurantServiceImpl.java @@ -0,0 +1,83 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.MenuRestaurant; +import dev.example.restaurantManager.model.OrderMenuQty; +import dev.example.restaurantManager.repository.MenuRestaurantRepository; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.lang.reflect.Field; +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; +import java.util.stream.Collectors; + +@Service +public class MenuRestaurantServiceImpl implements MenuRestaurantService { + + @Autowired + private MenuRestaurantRepository menuRestaurantRepository; + + @Override + public List getAllMenus() { + List lstMenuRestaurant = menuRestaurantRepository.findAll().stream().collect(Collectors.toList()); + for (MenuRestaurant m : lstMenuRestaurant){ + List lstOrderMenuQty = new ArrayList<>(); + for (OrderMenuQty o : m.getOrdersQty().stream().collect(Collectors.toList())){ + lstOrderMenuQty.add(o); + m.setOrdersQty(lstOrderMenuQty); + //o.getOrderRestaurant() + } + } + return lstMenuRestaurant; + //return menuRestaurantRepository.findAll(); + } + + @Override + public MenuRestaurant getMenuById(String id) { + return menuRestaurantRepository.findById(id).orElse(null); + } + + @Override + public MenuRestaurant createMenu(MenuRestaurant menuRestaurant) { + return menuRestaurantRepository.save(menuRestaurant); + } + + @Override + public MenuRestaurant updateMenu(String id, MenuRestaurant menuRestaurantDetails) { + boolean isTrue = false; + MenuRestaurant menuRestaurantElement = menuRestaurantRepository.findById(id).orElse(null); + if(menuRestaurantElement != null){ + Field[] fields = menuRestaurantDetails.getClass().getDeclaredFields(); + for (Field field : fields) { + try { + field.setAccessible(true); + if(field.get(menuRestaurantElement) != field.get(menuRestaurantDetails)){ + isTrue = true; + field.set(menuRestaurantElement,field.get(menuRestaurantDetails)); + } + } catch (IllegalAccessException e) { + throw new RuntimeException(e); + } + } + menuRestaurantRepository.save(menuRestaurantElement); + } + + return isTrue ? menuRestaurantElement : menuRestaurantDetails; + } + + @Override + public boolean deleteMenu(String id) { + Optional menuRestaurantElement = menuRestaurantRepository.findById(id); + if(menuRestaurantElement != null){ + menuRestaurantRepository.deleteById(id); + return true; + } + return false; + } + + @Override + public long countMenus() { + return menuRestaurantRepository.count(); + } +} diff --git a/src/main/java/dev/example/restaurantManager/service/OrderRestaurantService.java b/src/main/java/dev/example/restaurantManager/service/OrderRestaurantService.java new file mode 100644 index 0000000..2d70dc1 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/OrderRestaurantService.java @@ -0,0 +1,14 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.OrderRestaurant; + +import java.util.List; + +public interface OrderRestaurantService { + List getAllOrders(); + OrderRestaurant getOrderById(String id); + OrderRestaurant createOrder(OrderRestaurant order); + OrderRestaurant updateOrder(String id, OrderRestaurant orderDetails); + boolean deleteOrder(String id); + long countOrders(); +} diff --git a/src/main/java/dev/example/restaurantManager/service/OrderRestaurantServiceImpl.java b/src/main/java/dev/example/restaurantManager/service/OrderRestaurantServiceImpl.java new file mode 100644 index 0000000..70ac5fd --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/OrderRestaurantServiceImpl.java @@ -0,0 +1,72 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.OrderRestaurant; +import dev.example.restaurantManager.repository.OrderMenuQtyRepository; +import dev.example.restaurantManager.repository.OrderRestaurantRepository; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.lang.reflect.Field; +import java.util.List; +import java.util.Optional; + +@Service +public class OrderRestaurantServiceImpl implements OrderRestaurantService{ + + @Autowired + private OrderRestaurantRepository orderRestaurantRepository; + + @Override + public List getAllOrders() { + return orderRestaurantRepository.findAll(); + } + + @Override + public OrderRestaurant getOrderById(String id) { + return orderRestaurantRepository.findById(id).orElse(null); + } + + @Override + public OrderRestaurant createOrder(OrderRestaurant order) { + return orderRestaurantRepository.save(order); + } + + @Override + public OrderRestaurant updateOrder(String id, OrderRestaurant orderDetails) { + boolean isTrue = false; + OrderRestaurant OrderRestaurantElement = orderRestaurantRepository.findById(id).orElse(null); + if(OrderRestaurantElement != null){ + Field[] fields = orderDetails.getClass().getDeclaredFields(); + for (Field field : fields) { + try { + field.setAccessible(true); + if(field.get(OrderRestaurantElement) != field.get(orderDetails)){ + isTrue = true; + field.set(OrderRestaurantElement,field.get(orderDetails)); + } + } catch (IllegalAccessException e) { + throw new RuntimeException(e); + } + } + orderRestaurantRepository.save(OrderRestaurantElement); + } + + return isTrue ? OrderRestaurantElement : orderDetails; + } + + @Override + public boolean deleteOrder(String id) { + Optional order = orderRestaurantRepository.findById(id); + if(order.isEmpty()){ + return false; + }else{ + orderRestaurantRepository.deleteById(id); + return true; + } + } + + @Override + public long countOrders() { + return orderRestaurantRepository.count(); + } +} diff --git a/src/test/java/dev/example/restaurantManager/OrderMenuQtyWithRestaurantAndOrderMenuTest.java b/src/test/java/dev/example/restaurantManager/OrderMenuQtyWithRestaurantAndOrderMenuTest.java new file mode 100644 index 0000000..8bbddac --- /dev/null +++ b/src/test/java/dev/example/restaurantManager/OrderMenuQtyWithRestaurantAndOrderMenuTest.java @@ -0,0 +1,68 @@ +package dev.example.restaurantManager; + +import dev.example.restaurantManager.model.MenuRestaurant; +import dev.example.restaurantManager.model.OrderMenuQty; +import dev.example.restaurantManager.model.OrderRestaurant; +import dev.example.restaurantManager.repository.MenuRestaurantRepository; +import dev.example.restaurantManager.repository.OrderMenuQtyRepository; +import dev.example.restaurantManager.repository.OrderRestaurantRepository; +import dev.example.restaurantManager.service.OrderRestaurantService; +import jakarta.persistence.EntityManager; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; + +import java.util.*; + +@DataJpaTest +public class OrderMenuQtyWithRestaurantAndOrderMenuTest { + + @Autowired + private MenuRestaurantRepository menuRestaurantRepository; + @Autowired + private OrderMenuQtyRepository orderMenuQtyRepository; + @Autowired + private OrderRestaurantRepository orderRestaurantRepository; + + @Test + public void orderServiceAddMenusAndAddOrderMenuQty(){ + // store in memory menus + MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.5, "Burger, fries, and drink", true, true); + MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02", "Pizza Menu", 17.5, "Pizza and salad", true, false); + MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03", "Salad Menu", 8.0, "Mixed salad and dressing", true, true); + menuRestaurantRepository.save(menuRestaurant1); + menuRestaurantRepository.save(menuRestaurant2); + menuRestaurantRepository.save(menuRestaurant3); + + OrderRestaurant order1 = new OrderRestaurant("O01", new Date(), "JohnQ", 4, 49.5, true, null); + OrderRestaurant order2 = new OrderRestaurant("002", new Date(), "Ernesto", 5, 35.10, true, null); + OrderRestaurant order3 = new OrderRestaurant("003", new Date(), "Juan", 6, 60.5, true, null); + orderRestaurantRepository.save(order1); + orderRestaurantRepository.save(order2); + orderRestaurantRepository.save(order3); + + OrderMenuQty orderMenuQty1 = new OrderMenuQty("1",5,null,null); + OrderMenuQty orderMenuQty2 = new OrderMenuQty("2",4,null,null); + OrderMenuQty orderMenuQty3 = new OrderMenuQty("3",3,null,null); + + orderMenuQty1.setMenuRestaurant(menuRestaurant1); + orderMenuQty2.setMenuRestaurant(menuRestaurant2); + orderMenuQty3.setMenuRestaurant(menuRestaurant3); + + orderMenuQty1.setOrderRestaurant(order1); + orderMenuQty2.setOrderRestaurant(order2); + orderMenuQty3.setOrderRestaurant(order3); + + orderMenuQtyRepository.save(orderMenuQty1); + orderMenuQtyRepository.save(orderMenuQty2); + orderMenuQtyRepository.save(orderMenuQty3); + + System.out.println(orderMenuQty1.toString()); + order1.addOrderMenuQty(orderMenuQty1); + order1.addOrderMenuQty(orderMenuQty2); + order1.addOrderMenuQty(orderMenuQty3); + System.out.println(order1.toString()); + order1.getOrderMenuQtyIds().forEach(System.out::println); + + } +} diff --git a/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java b/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java index 35e2078..f59d64f 100644 --- a/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java +++ b/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java @@ -11,491 +11,491 @@ @DataJpaTest public class RelationshipsOrderRestaurantTest { -@Autowired -private TakeAwayOrderRepository takeAwayOrderRepository; -@Autowired -private CustomerRepository customerRepository; -@Autowired -private MenuRestaurantRepository menuRestaurantRepository; -@Autowired -private OrderRestaurantRepository orderRestaurantRepository; -@Autowired -private TableRestaurantRepository tableRestaurantRepository; -@Autowired -private EatInOrderRestaurantRepository eatInOrderRestaurantRepository; - - @Test - public void TestCreateOrder() { - // Create sample menus - MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true, null); - MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02","Pizza Menu", 12.99, "Pizza and salad", true, false, null); - MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03","Salad Menu", 8.99, "Mixed salad and dressing", true, true, null); - // Save sample menus - menuRestaurantRepository.save(menuRestaurant1); - menuRestaurantRepository.save(menuRestaurant2); - menuRestaurantRepository.save(menuRestaurant3); - // Create sample customers - Customer customer1 = new Customer("C1", "John", "john@email.com", "123-456-7890", 30, false, false); - Customer customer2 = new Customer("C2", "Sarah", "sarah@email.com", "234-567-8901", 25, true, false); - Customer customer3 = new Customer("C3", "Emily", "emily@email.com", "345-678-9012", 35, false, false); - Customer customer4 = new Customer("C4", "David", "david@email.com", "456-789-0123", 40, true, false); - Customer customer5 = new Customer("C5", "Anna", "anna@email.com", "567-890-1234", 28, false, false); - Customer customer6 = new Customer("C6", "Mark", "mark@email.com", "678-901-2345", 45, true, false); - Customer customer7 = new Customer("C7", "Paul", "paul@email.com", "789-012-3456", 33, false, false); - Customer customer8 = new Customer("C8", "Linda", "linda@email.com", "890-123-4567", 38, true, false); - Customer customer9 = new Customer("C9", "George", "george@email.com", "901-234-5678", 50, false, false); - - // Create sample tables - TableRestaurant table1 = new TableRestaurant("T1", "Window Table", 4, false); - TableRestaurant table2 = new TableRestaurant("T2", "Corner Table", 2, true); - - // Create 3 ShippingOrder objects - OrderRestaurant shippingOrder1 = new ShippingOrderRestaurant("SO1", new Date(), "John", 2, 21.98, false, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant1)), "123 Main St", "New York", "Mike"); - OrderRestaurant shippingOrder2 = new ShippingOrderRestaurant("SO2", new Date(), "Sarah", 1, 12.99, true, new ArrayList<>(Arrays.asList(menuRestaurant2)), "456 Elm St", "Los Angeles", "Tom"); - OrderRestaurant shippingOrder3 = new ShippingOrderRestaurant("SO3", new Date(), "Emily", 3, 32.97, false, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3)), "789 Oak St", "Chicago", "Lisa"); - - // Create 3 EatInOrder objects - OrderRestaurant eatInOrder1 = new EatInOrderRestaurant("EO1", new Date(), "David", 4, 43.96, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant1, menuRestaurant2, menuRestaurant2)), new ArrayList<>(Arrays.asList(table1))); - OrderRestaurant eatInOrder2 = new EatInOrderRestaurant("EO2", new Date(), "Anna", 2, 21.98, false, new ArrayList<>(Arrays.asList(menuRestaurant2, menuRestaurant3)), new ArrayList<>(Arrays.asList(table2))); - OrderRestaurant eatInOrder3 = new EatInOrderRestaurant("EO3", new Date(), "Mark", 6, 65.94, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant1, menuRestaurant2, menuRestaurant2, menuRestaurant3, menuRestaurant3)), new ArrayList<>(Arrays.asList(table1, table2))); - - // Create 3 TakeAwayOrder objects - OrderRestaurant takeAwayOrder1 = new TakeAwayOrder("TO1", new Date(), "Alice", 1, 10.99, true, new ArrayList<>(Arrays.asList(menuRestaurant1)), customer1 ); - OrderRestaurant takeAwayOrder2 = new TakeAwayOrder("TO2", new Date(), "Bob", 2, 21.98, false, new ArrayList<>(Arrays.asList(menuRestaurant2, menuRestaurant3)), customer3 ); - OrderRestaurant takeAwayOrder3 = new TakeAwayOrder("TO3", new Date(), "Charlie", 3, 32.97, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3)), customer5); - OrderRestaurant takeAwayOrder4 = new TakeAwayOrder("TO4", new Date(), "Charlie", 3, 32.97, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3, menuRestaurant3, menuRestaurant3, menuRestaurant3)), customer9); - - // Create a list of all orders - ArrayList orders = new ArrayList<>(); - orders.addAll(Arrays.asList(shippingOrder1, shippingOrder2, shippingOrder3, - eatInOrder1, eatInOrder2, eatInOrder3, - takeAwayOrder1, takeAwayOrder2, takeAwayOrder3, takeAwayOrder4)); - - // Print the number of orders - System.out.println("Orders"); - System.out.println("Total number of orders: " + orders.size() + " orders."); - System.out.println("--------------------"); - // Print all orders - for (OrderRestaurant order : orders) { - System.out.println("Order ID: " + order.getId()); - System.out.println(order); - System.out.println("--------------------"); - } - - // Save the customer with JPA Repository to use in order T11 - customerRepository.save(customer1); - // let's create an order to save and test - // we do not create orderToSave as OrderRestaurant but - // as TakeAwayOrder to AVOID casting because - // in this test is easier to work with - TakeAwayOrder orderToSave = new TakeAwayOrder( - "T11", new Date(), "Alice", 1, 10.99, - true, new ArrayList<>(Arrays.asList(menuRestaurant1)), null ); - // we assign the customer to the order - //((TakeAwayOrder) orderToSave).setCustomerTakeAway(customer1); - orderToSave.setCustomerTakeAway(customer1); - // Save the order with JPA Repository - //takeAwayOrderRepository.save(orderToSave); - takeAwayOrderRepository.save(orderToSave); - - - // when - Optional found = takeAwayOrderRepository.findById("T11"); - System.out.println("--------------------"); - System.out.println("TakeAwayOrder ID: " + found.get().getId()); - System.out.println(found.get()); - // then - assertThat(found).isPresent(); - assertThat(found.get().getCustomerTakeAway().getName().equals(customer1.getName())); - - System.out.println("--------------------"); - } - - @Test - public void TestCreateOrderMenu () { - MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true, null); - MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02","Pizza Menu", 12.99, "Pizza and salad", true, false, null); - MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03","Salad Menu", 8.99, "Mixed salad and dressing", true, true, null); - // Save sample menus - menuRestaurantRepository.save(menuRestaurant1); - menuRestaurantRepository.save(menuRestaurant2); - menuRestaurantRepository.save(menuRestaurant3); - // Create 3 Order objects and assign menus - OrderRestaurant orderRestaurant1 = new OrderRestaurant("O01", new Date(), "John", 4, 43.96, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3))); - OrderRestaurant orderRestaurant2 = new OrderRestaurant("O02", new Date(), "John", 4, 43.96, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant3))); - OrderRestaurant orderRestaurant3 = new OrderRestaurant("O03", new Date(), "John", 4, 43.96, true, new ArrayList<>(Arrays.asList(menuRestaurant2))); - - // Save sample orders - orderRestaurantRepository.save(orderRestaurant1); - //orderRestaurantRepository.save(orderRestaurant2); - //orderRestaurantRepository.save(orderRestaurant3); - - - // when - Optional found = orderRestaurantRepository.findById("O01"); - System.out.println("--------------------"); - System.out.println("Order ID: " + found.get().getId()); - System.out.println(found.get()); - // then - assertThat(found).isPresent(); - assertThat(found.get().getMenus().get(0).getName().equals(menuRestaurant1.getName())); - } - - // java.lang.StackOverflowError toString - @Test - public void TestCreateOrderMenu_stackOverflow () { - // Create sample menus - MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, - "Burger, fries, and drink", true, true); - MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02","Pizza Menu", - 12.99, "Pizza and salad", true, false); - MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03","Salad Menu", - 8.99, "Mixed salad and dressing", true, true); - // Save sample menus - menuRestaurantRepository.save(menuRestaurant1); - menuRestaurantRepository.save(menuRestaurant2); - menuRestaurantRepository.save(menuRestaurant3); - // Create 3 Order objects and assign menus - OrderRestaurant orderRestaurant1 = new OrderRestaurant("O01", new Date(), "John", 4, 43.96, - true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3))); - OrderRestaurant orderRestaurant2 = new OrderRestaurant("O02", new Date(), "John", 4, 43.96, true, - new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant3))); - OrderRestaurant orderRestaurant3 = new OrderRestaurant("O03", new Date(), "John", 4, 43.96, true, - new ArrayList<>(Arrays.asList(menuRestaurant2))); - - // Save sample orders - orderRestaurantRepository.save(orderRestaurant1); - //orderRestaurantRepository.save(orderRestaurant2); - //orderRestaurantRepository.save(orderRestaurant3); - - // set menus to orders and save - menuRestaurant1.getOrders().add(orderRestaurant1); - menuRestaurantRepository.save(menuRestaurant1); - - // when - Optional found = orderRestaurantRepository.findById("O01"); - System.out.println("--------------------"); - System.out.println("Order ID: " + found.get().getId()); - // stack-overflow toString does not work in this case - //System.out.println(found.get()); - - Optional menuFound = menuRestaurantRepository.findById("M01"); - System.out.println("--------------------"); - System.out.println("Menu ID: " + menuFound.get().getId()); - // stack-overflow toString does not work in this case - //System.out.println(menuFound.get()); - - // then - assertThat(found).isPresent(); - assertThat(found.get().getMenus().get(0).getName().equals(menuRestaurant1.getName())); - } - - // Adding Menus to an Order: Verifies that menus can be added to an order - // and the association is correctly persisted in the database. - @Test - public void testAddingMenusToOrder() { - // Create sample menus and save them - MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true); - MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02", "Pizza Menu", 12.99, "Pizza and salad", true, false); - MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03", "Salad Menu", 8.99, "Mixed salad and dressing", true, true); - // Save sample menus - menuRestaurantRepository.save(menuRestaurant1); - menuRestaurantRepository.save(menuRestaurant2); - menuRestaurantRepository.save(menuRestaurant3); - - // Create an order and add menus - OrderRestaurant order = new OrderRestaurant("O01", new Date(), "John", 4, - 43.96, true, new ArrayList<>()); - order.addMenu(menuRestaurant1); - order.addMenu(menuRestaurant2); - order.addMenu(menuRestaurant3); - orderRestaurantRepository.save(order); - - // Retrieve the order and assert the menus - Optional foundOrder = orderRestaurantRepository.findById("O01"); - assertThat(foundOrder).isPresent(); - 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(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()) - .usingElementComparator(Comparator.comparing(MenuRestaurant::getId)) - .containsExactlyInAnyOrder(menuRestaurant1, menuRestaurant2, menuRestaurant3); - } - - // Adding Menus to an Order: Verifies that menus can be added to an order - @Test - public void testAddingRepeatedMenusToOrder() { - // Create sample menus and save them - MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true); - MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02", "Pizza Menu", 12.99, "Pizza and salad", true, false); - MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03", "Salad Menu", 8.99, "Mixed salad and dressing", true, true); - // Save sample menus - menuRestaurantRepository.save(menuRestaurant1); - menuRestaurantRepository.save(menuRestaurant2); - menuRestaurantRepository.save(menuRestaurant3); - - // Create an order and add menus - OrderRestaurant order = new OrderRestaurant("O01", new Date(), "John", 4, - 43.96, true, new ArrayList<>()); - order.addMenu(menuRestaurant1); - order.addMenu(menuRestaurant2); - order.addMenu(menuRestaurant2); - order.addMenu(menuRestaurant3); - order.addMenu(menuRestaurant3); - order.addMenu(menuRestaurant3); - orderRestaurantRepository.save(order); - - // Retrieve the order and assert the menus - Optional foundOrder = orderRestaurantRepository.findById("O01"); - assertThat(foundOrder).isPresent(); - assertThat(foundOrder.get().getMenus()).hasSize(6); - // 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, 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()) - .usingElementComparator(Comparator.comparing(MenuRestaurant::getId)) - .containsExactlyInAnyOrder(menuRestaurant1, menuRestaurant2, menuRestaurant2, menuRestaurant3, menuRestaurant3, menuRestaurant3 ); - } - - // Removing Menus from an Order: Checks that menus can be removed from an order - // and the changes are reflected in the database. - @Test - public void testRemovingMenusFromOrder() { - // Create sample menus and save them - MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true); - MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02", "Pizza Menu", 12.99, "Pizza and salad", true, false); - MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03", "Salad Menu", 8.99, "Mixed salad and dressing", true, true); - menuRestaurantRepository.save(menuRestaurant1); - menuRestaurantRepository.save(menuRestaurant2); - menuRestaurantRepository.save(menuRestaurant3); - - // Retrieve the updated order after deleting the menu - System.out.println("List of menus AFTER DELETION:"); - menuRestaurantRepository.findAll().forEach(System.out::println); - - // Create an order with multiple menus and save it - OrderRestaurant order = new OrderRestaurant("O01", new Date(), "John", 4, - 43.96, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3))); - orderRestaurantRepository.save(order); - - // Retrieve the order, remove a menu, and save the updated order - Optional foundOrder = orderRestaurantRepository.findById("O01"); - assertThat(foundOrder).isPresent(); - OrderRestaurant updatedOrder = foundOrder.get(); - // Let's remove the second menu - //updatedOrder.removeMenu(menuRestaurant2); - updatedOrder.removeMenu(updatedOrder.getMenus().get(1)); - orderRestaurantRepository.save(updatedOrder); - - // Retrieve the updated order and assert the menus - Optional updatedOrderOptional = orderRestaurantRepository.findById("O01"); - // print the menus - System.out.println("Menus: " + updatedOrderOptional.get().getMenus()); - // 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); - - // Retrieve the updated order after deleting the menu - System.out.println("List of menus AFTER DELETION:"); - menuRestaurantRepository.findAll().forEach(System.out::println); - } - - @Test - public void testRemovingMenus_NO_Relationship() { - // Create sample menus and save them - MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true); - MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02", "Pizza Menu", 12.99, "Pizza and salad", true, false); - MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03", "Salad Menu", 8.99, "Mixed salad and dressing", true, true); - menuRestaurantRepository.save(menuRestaurant1); - menuRestaurantRepository.save(menuRestaurant2); - menuRestaurantRepository.save(menuRestaurant3); - - // Create an order with multiple menus and save it - OrderRestaurant order = new OrderRestaurant("O01", new Date(), "John", 4, - 43.96, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2))); - orderRestaurantRepository.save(order); - - // Retrieve the order, remove a menu, and save the updated order - Optional foundOrder = orderRestaurantRepository.findById("O01"); - assertThat(foundOrder).isPresent(); - - menuRestaurantRepository.delete(menuRestaurant3); - // Retrieve the updated order after deleting the menu - System.out.println("List of menus AFTER DELETION:"); - menuRestaurantRepository.findAll().forEach(System.out::println); - - // We CAN NOT delete a menu that has a relationship - /*menuRestaurantRepository.delete(menuRestaurant2); - // Retrieve the updated order after deleting the menu - System.out.println("List of menus AFTER DELETION:"); - menuRestaurantRepository.findAll().forEach(System.out::println);*/ - - - - } - - // Removing Menus from an Order: Checks that menus can be removed from an order - // and the changes are reflected in the database. - // BE CAREFUL! This test should fail. - @Test - public void testRemovingMenusFromOrder_butNotRelationship() { - // Create sample menus and save them - MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true); - MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02", "Pizza Menu", 12.99, "Pizza and salad", true, false); - MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03", "Salad Menu", 8.99, "Mixed salad and dressing", true, true); - menuRestaurantRepository.save(menuRestaurant1); - menuRestaurantRepository.save(menuRestaurant2); - menuRestaurantRepository.save(menuRestaurant3); - - // Create an order with multiple menus and save it - OrderRestaurant order = new OrderRestaurant("O01", new Date(), "John", 4, - 43.96, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3))); - orderRestaurantRepository.save(order); - - // Let's remove the second menu - menuRestaurantRepository.delete(menuRestaurant2); - - // Retrieve the updated order after deleting the menu - System.out.println("List of menus AFTER DELETION:"); - menuRestaurantRepository.findAll().forEach(System.out::println); - - // Retrieve the updated order and assert the menus - Optional updatedOrderOptional = orderRestaurantRepository.findById("O01"); - // print the menus - System.out.println("Menus: " + updatedOrderOptional.get().getMenus()); - // assert the menus have been removed - assertThat(updatedOrderOptional).isPresent(); - assertThat(updatedOrderOptional.get().getMenus()).hasSize(2); - - } - - - // Cascading Deletion of Menus and Orders: Ensures that the deletion of a menu - // or an order correctly cascades to the associated records in the order-menu join table. - /*@Test - public void testCascadingDeletionOfMenusAndOrders() { - // Create sample menus and save them - MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true); - MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02", "Pizza Menu", 12.99, "Pizza and salad", true, false); - MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03", "Salad Menu", 8.99, "Mixed salad and dressing", true, true); - menuRestaurantRepository.save(menuRestaurant1); - menuRestaurantRepository.save(menuRestaurant2); - menuRestaurantRepository.save(menuRestaurant3); - - // Create an order with multiple menus and save it - OrderRestaurant order = new OrderRestaurant("O01", new Date(), "John", 4, 43.96, true, - new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3))); - orderRestaurantRepository.save(order); - - // Delete the menu and verify the cascade deletion of the order-menu association - Optional foundOrder = orderRestaurantRepository.findById("O01"); - assertThat(foundOrder).isPresent(); - OrderRestaurant updatedOrder = foundOrder.get(); - updatedOrder.removeMenu(menuRestaurant2); - //menuRestaurantRepository.delete(menuRestaurant2); - orderRestaurantRepository.save(updatedOrder); - 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); - - // Delete the order and verify the cascade deletion of the order-menu association - orderRestaurantRepository.delete(order); - Optional menuRestaurant1Optional = menuRestaurantRepository.findById("M01"); - Optional menuRestaurant2Optional = menuRestaurantRepository.findById("M02"); - Optional menuRestaurant3Optional = menuRestaurantRepository.findById("M03"); - assertThat(menuRestaurant1Optional).isPresent(); - assertThat(menuRestaurant2Optional).isPresent(); - assertThat(menuRestaurant3Optional).isPresent(); - 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 - // to an EatInOrderRestaurant and the association is correctly persisted in the database. - /*@Test - public void testAddingMenusToEatInOrder() { - // Create sample menus and save them - MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true, null); - MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02", "Pizza Menu", 12.99, "Pizza and salad", true, false, null); - MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03", "Salad Menu", 8.99, "Mixed salad and dressing", true, true, null); - menuRestaurantRepository.save(menuRestaurant1); - menuRestaurantRepository.save(menuRestaurant2); - menuRestaurantRepository.save(menuRestaurant3); - - // Create sample tables and save them - TableRestaurant table1 = new TableRestaurant("T1", "Window Table", 4, false); - TableRestaurant table2 = new TableRestaurant("T2", "Corner Table", 2, true); - tableRestaurantRepository.save(table1); - 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))); - eatInOrder.addMenu(menuRestaurant1); - eatInOrder.addMenu(menuRestaurant2); - eatInOrder.addMenu(menuRestaurant3); - eatInOrderRestaurantRepository.save(eatInOrder); - - // Retrieve the EatInOrder and assert the menus - Optional foundOrder = (Optional) eatInOrderRestaurantRepository.findById("EO1"); - assertThat(foundOrder).isPresent(); - assertThat(foundOrder.get().getMenus()).hasSize(3); - assertThat(foundOrder.get().getMenus()).contains(menuRestaurant1, menuRestaurant2, menuRestaurant3); - } - - // Removing Menus from an EatInOrder: Checks that menus can be removed from an EatInOrder - // and the changes are reflected in the database. - @Test - public void testRemovingMenusFromEatInOrder() { - // Create sample menus and save them - MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true, null); - MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02", "Pizza Menu", 12.99, "Pizza and salad", true, false, null); - MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03", "Salad Menu", 8.99, "Mixed salad and dressing", true, true, null); - menuRestaurantRepository.save(menuRestaurant1); - menuRestaurantRepository.save(menuRestaurant2); - menuRestaurantRepository.save(menuRestaurant3); - - // Create sample tables and save them - TableRestaurant table1 = new TableRestaurant("T1", "Window Table", 4, false); - TableRestaurant table2 = new TableRestaurant("T2", "Corner Table", 2, true); - tableRestaurantRepository.save(table1); - tableRestaurantRepository.save(table2); - - // Create an EatInOrder with multiple menus and save it - EatInOrderRestaurant eatInOrder = new EatInOrderRestaurant("EO1", new Date(), "John", 4, 43.96, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3)), new ArrayList<>(Arrays.asList(table1, table2))); - eatInOrderRestaurantRepository.save(eatInOrder); - - // Retrieve the EatInOrder, remove a menu, and save the updated order - Optional foundOrder = (Optional) eatInOrderRestaurantRepository.findById("EO1"); - assertThat(foundOrder).isPresent(); - EatInOrderRestaurant updatedOrder = foundOrder.get(); - updatedOrder.removeMenu(menuRestaurant2); - orderRestaurantRepository.save(updatedOrder); - - // Retrieve the updated EatInOrder and assert the menus - 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); - - }*/ +//@Autowired +//private TakeAwayOrderRepository takeAwayOrderRepository; +//@Autowired +//private CustomerRepository customerRepository; +//@Autowired +//private MenuRestaurantRepository menuRestaurantRepository; +//@Autowired +//private OrderRestaurantRepository orderRestaurantRepository; +//@Autowired +//private TableRestaurantRepository tableRestaurantRepository; +//@Autowired +//private EatInOrderRestaurantRepository eatInOrderRestaurantRepository; +// +// @Test +// public void TestCreateOrder() { +// // Create sample menus +// MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true, null); +// MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02","Pizza Menu", 12.99, "Pizza and salad", true, false, null); +// MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03","Salad Menu", 8.99, "Mixed salad and dressing", true, true, null); +// // Save sample menus +// menuRestaurantRepository.save(menuRestaurant1); +// menuRestaurantRepository.save(menuRestaurant2); +// menuRestaurantRepository.save(menuRestaurant3); +// // Create sample customers +// Customer customer1 = new Customer("C1", "John", "john@email.com", "123-456-7890", 30, false, false); +// Customer customer2 = new Customer("C2", "Sarah", "sarah@email.com", "234-567-8901", 25, true, false); +// Customer customer3 = new Customer("C3", "Emily", "emily@email.com", "345-678-9012", 35, false, false); +// Customer customer4 = new Customer("C4", "David", "david@email.com", "456-789-0123", 40, true, false); +// Customer customer5 = new Customer("C5", "Anna", "anna@email.com", "567-890-1234", 28, false, false); +// Customer customer6 = new Customer("C6", "Mark", "mark@email.com", "678-901-2345", 45, true, false); +// Customer customer7 = new Customer("C7", "Paul", "paul@email.com", "789-012-3456", 33, false, false); +// Customer customer8 = new Customer("C8", "Linda", "linda@email.com", "890-123-4567", 38, true, false); +// Customer customer9 = new Customer("C9", "George", "george@email.com", "901-234-5678", 50, false, false); +// +// // Create sample tables +// TableRestaurant table1 = new TableRestaurant("T1", "Window Table", 4, false); +// TableRestaurant table2 = new TableRestaurant("T2", "Corner Table", 2, true); +// +// // Create 3 ShippingOrder objects +// OrderRestaurant shippingOrder1 = new ShippingOrderRestaurant("SO1", new Date(), "John", 2, 21.98, false, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant1)), "123 Main St", "New York", "Mike"); +// OrderRestaurant shippingOrder2 = new ShippingOrderRestaurant("SO2", new Date(), "Sarah", 1, 12.99, true, new ArrayList<>(Arrays.asList(menuRestaurant2)), "456 Elm St", "Los Angeles", "Tom"); +// OrderRestaurant shippingOrder3 = new ShippingOrderRestaurant("SO3", new Date(), "Emily", 3, 32.97, false, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3)), "789 Oak St", "Chicago", "Lisa"); +// +// // Create 3 EatInOrder objects +// OrderRestaurant eatInOrder1 = new EatInOrderRestaurant("EO1", new Date(), "David", 4, 43.96, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant1, menuRestaurant2, menuRestaurant2)), new ArrayList<>(Arrays.asList(table1))); +// OrderRestaurant eatInOrder2 = new EatInOrderRestaurant("EO2", new Date(), "Anna", 2, 21.98, false, new ArrayList<>(Arrays.asList(menuRestaurant2, menuRestaurant3)), new ArrayList<>(Arrays.asList(table2))); +// OrderRestaurant eatInOrder3 = new EatInOrderRestaurant("EO3", new Date(), "Mark", 6, 65.94, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant1, menuRestaurant2, menuRestaurant2, menuRestaurant3, menuRestaurant3)), new ArrayList<>(Arrays.asList(table1, table2))); +// +// // Create 3 TakeAwayOrder objects +// OrderRestaurant takeAwayOrder1 = new TakeAwayOrder("TO1", new Date(), "Alice", 1, 10.99, true, new ArrayList<>(Arrays.asList(menuRestaurant1)), customer1 ); +// OrderRestaurant takeAwayOrder2 = new TakeAwayOrder("TO2", new Date(), "Bob", 2, 21.98, false, new ArrayList<>(Arrays.asList(menuRestaurant2, menuRestaurant3)), customer3 ); +// OrderRestaurant takeAwayOrder3 = new TakeAwayOrder("TO3", new Date(), "Charlie", 3, 32.97, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3)), customer5); +// OrderRestaurant takeAwayOrder4 = new TakeAwayOrder("TO4", new Date(), "Charlie", 3, 32.97, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3, menuRestaurant3, menuRestaurant3, menuRestaurant3)), customer9); +// +// // Create a list of all orders +// ArrayList orders = new ArrayList<>(); +// orders.addAll(Arrays.asList(shippingOrder1, shippingOrder2, shippingOrder3, +// eatInOrder1, eatInOrder2, eatInOrder3, +// takeAwayOrder1, takeAwayOrder2, takeAwayOrder3, takeAwayOrder4)); +// +// // Print the number of orders +// System.out.println("Orders"); +// System.out.println("Total number of orders: " + orders.size() + " orders."); +// System.out.println("--------------------"); +// // Print all orders +// for (OrderRestaurant order : orders) { +// System.out.println("Order ID: " + order.getId()); +// System.out.println(order); +// System.out.println("--------------------"); +// } +// +// // Save the customer with JPA Repository to use in order T11 +// customerRepository.save(customer1); +// // let's create an order to save and test +// // we do not create orderToSave as OrderRestaurant but +// // as TakeAwayOrder to AVOID casting because +// // in this test is easier to work with +// TakeAwayOrder orderToSave = new TakeAwayOrder( +// "T11", new Date(), "Alice", 1, 10.99, +// true, new ArrayList<>(Arrays.asList(menuRestaurant1)), null ); +// // we assign the customer to the order +// //((TakeAwayOrder) orderToSave).setCustomerTakeAway(customer1); +// orderToSave.setCustomerTakeAway(customer1); +// // Save the order with JPA Repository +// //takeAwayOrderRepository.save(orderToSave); +// takeAwayOrderRepository.save(orderToSave); +// +// +// // when +// Optional found = takeAwayOrderRepository.findById("T11"); +// System.out.println("--------------------"); +// System.out.println("TakeAwayOrder ID: " + found.get().getId()); +// System.out.println(found.get()); +// // then +// assertThat(found).isPresent(); +// assertThat(found.get().getCustomerTakeAway().getName().equals(customer1.getName())); +// +// System.out.println("--------------------"); +// } +// +// @Test +// public void TestCreateOrderMenu () { +// MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true, null); +// MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02","Pizza Menu", 12.99, "Pizza and salad", true, false, null); +// MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03","Salad Menu", 8.99, "Mixed salad and dressing", true, true, null); +// // Save sample menus +// menuRestaurantRepository.save(menuRestaurant1); +// menuRestaurantRepository.save(menuRestaurant2); +// menuRestaurantRepository.save(menuRestaurant3); +// // Create 3 Order objects and assign menus +// OrderRestaurant orderRestaurant1 = new OrderRestaurant("O01", new Date(), "John", 4, 43.96, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3))); +// OrderRestaurant orderRestaurant2 = new OrderRestaurant("O02", new Date(), "John", 4, 43.96, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant3))); +// OrderRestaurant orderRestaurant3 = new OrderRestaurant("O03", new Date(), "John", 4, 43.96, true, new ArrayList<>(Arrays.asList(menuRestaurant2))); +// +// // Save sample orders +// orderRestaurantRepository.save(orderRestaurant1); +// //orderRestaurantRepository.save(orderRestaurant2); +// //orderRestaurantRepository.save(orderRestaurant3); +// +// +// // when +// Optional found = orderRestaurantRepository.findById("O01"); +// System.out.println("--------------------"); +// System.out.println("Order ID: " + found.get().getId()); +// System.out.println(found.get()); +// // then +// assertThat(found).isPresent(); +// assertThat(found.get().getMenus().get(0).getName().equals(menuRestaurant1.getName())); +// } +// +// // java.lang.StackOverflowError toString +// @Test +// public void TestCreateOrderMenu_stackOverflow () { +// // Create sample menus +// MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, +// "Burger, fries, and drink", true, true); +// MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02","Pizza Menu", +// 12.99, "Pizza and salad", true, false); +// MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03","Salad Menu", +// 8.99, "Mixed salad and dressing", true, true); +// // Save sample menus +// menuRestaurantRepository.save(menuRestaurant1); +// menuRestaurantRepository.save(menuRestaurant2); +// menuRestaurantRepository.save(menuRestaurant3); +// // Create 3 Order objects and assign menus +// OrderRestaurant orderRestaurant1 = new OrderRestaurant("O01", new Date(), "John", 4, 43.96, +// true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3))); +// OrderRestaurant orderRestaurant2 = new OrderRestaurant("O02", new Date(), "John", 4, 43.96, true, +// new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant3))); +// OrderRestaurant orderRestaurant3 = new OrderRestaurant("O03", new Date(), "John", 4, 43.96, true, +// new ArrayList<>(Arrays.asList(menuRestaurant2))); +// +// // Save sample orders +// orderRestaurantRepository.save(orderRestaurant1); +// //orderRestaurantRepository.save(orderRestaurant2); +// //orderRestaurantRepository.save(orderRestaurant3); +// +// // set menus to orders and save +// menuRestaurant1.getOrders().add(orderRestaurant1); +// menuRestaurantRepository.save(menuRestaurant1); +// +// // when +// Optional found = orderRestaurantRepository.findById("O01"); +// System.out.println("--------------------"); +// System.out.println("Order ID: " + found.get().getId()); +// // stack-overflow toString does not work in this case +// //System.out.println(found.get()); +// +// Optional menuFound = menuRestaurantRepository.findById("M01"); +// System.out.println("--------------------"); +// System.out.println("Menu ID: " + menuFound.get().getId()); +// // stack-overflow toString does not work in this case +// //System.out.println(menuFound.get()); +// +// // then +// assertThat(found).isPresent(); +// assertThat(found.get().getMenus().get(0).getName().equals(menuRestaurant1.getName())); +// } +// +// // Adding Menus to an Order: Verifies that menus can be added to an order +// // and the association is correctly persisted in the database. +// @Test +// public void testAddingMenusToOrder() { +// // Create sample menus and save them +// MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true); +// MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02", "Pizza Menu", 12.99, "Pizza and salad", true, false); +// MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03", "Salad Menu", 8.99, "Mixed salad and dressing", true, true); +// // Save sample menus +// menuRestaurantRepository.save(menuRestaurant1); +// menuRestaurantRepository.save(menuRestaurant2); +// menuRestaurantRepository.save(menuRestaurant3); +// +// // Create an order and add menus +// OrderRestaurant order = new OrderRestaurant("O01", new Date(), "John", 4, +// 43.96, true, new ArrayList<>()); +// order.addMenu(menuRestaurant1); +// order.addMenu(menuRestaurant2); +// order.addMenu(menuRestaurant3); +// orderRestaurantRepository.save(order); +// +// // Retrieve the order and assert the menus +// Optional foundOrder = orderRestaurantRepository.findById("O01"); +// assertThat(foundOrder).isPresent(); +// 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(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()) +// .usingElementComparator(Comparator.comparing(MenuRestaurant::getId)) +// .containsExactlyInAnyOrder(menuRestaurant1, menuRestaurant2, menuRestaurant3); +// } +// +// // Adding Menus to an Order: Verifies that menus can be added to an order +// @Test +// public void testAddingRepeatedMenusToOrder() { +// // Create sample menus and save them +// MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true); +// MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02", "Pizza Menu", 12.99, "Pizza and salad", true, false); +// MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03", "Salad Menu", 8.99, "Mixed salad and dressing", true, true); +// // Save sample menus +// menuRestaurantRepository.save(menuRestaurant1); +// menuRestaurantRepository.save(menuRestaurant2); +// menuRestaurantRepository.save(menuRestaurant3); +// +// // Create an order and add menus +// OrderRestaurant order = new OrderRestaurant("O01", new Date(), "John", 4, +// 43.96, true, new ArrayList<>()); +// order.addMenu(menuRestaurant1); +// order.addMenu(menuRestaurant2); +// order.addMenu(menuRestaurant2); +// order.addMenu(menuRestaurant3); +// order.addMenu(menuRestaurant3); +// order.addMenu(menuRestaurant3); +// orderRestaurantRepository.save(order); +// +// // Retrieve the order and assert the menus +// Optional foundOrder = orderRestaurantRepository.findById("O01"); +// assertThat(foundOrder).isPresent(); +// assertThat(foundOrder.get().getMenus()).hasSize(6); +// // 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, 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()) +// .usingElementComparator(Comparator.comparing(MenuRestaurant::getId)) +// .containsExactlyInAnyOrder(menuRestaurant1, menuRestaurant2, menuRestaurant2, menuRestaurant3, menuRestaurant3, menuRestaurant3 ); +// } +// +// // Removing Menus from an Order: Checks that menus can be removed from an order +// // and the changes are reflected in the database. +// @Test +// public void testRemovingMenusFromOrder() { +// // Create sample menus and save them +// MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true); +// MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02", "Pizza Menu", 12.99, "Pizza and salad", true, false); +// MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03", "Salad Menu", 8.99, "Mixed salad and dressing", true, true); +// menuRestaurantRepository.save(menuRestaurant1); +// menuRestaurantRepository.save(menuRestaurant2); +// menuRestaurantRepository.save(menuRestaurant3); +// +// // Retrieve the updated order after deleting the menu +// System.out.println("List of menus AFTER DELETION:"); +// menuRestaurantRepository.findAll().forEach(System.out::println); +// +// // Create an order with multiple menus and save it +// OrderRestaurant order = new OrderRestaurant("O01", new Date(), "John", 4, +// 43.96, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3))); +// orderRestaurantRepository.save(order); +// +// // Retrieve the order, remove a menu, and save the updated order +// Optional foundOrder = orderRestaurantRepository.findById("O01"); +// assertThat(foundOrder).isPresent(); +// OrderRestaurant updatedOrder = foundOrder.get(); +// // Let's remove the second menu +// //updatedOrder.removeMenu(menuRestaurant2); +// updatedOrder.removeMenu(updatedOrder.getMenus().get(1)); +// orderRestaurantRepository.save(updatedOrder); +// +// // Retrieve the updated order and assert the menus +// Optional updatedOrderOptional = orderRestaurantRepository.findById("O01"); +// // print the menus +// System.out.println("Menus: " + updatedOrderOptional.get().getMenus()); +// // 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); +// +// // Retrieve the updated order after deleting the menu +// System.out.println("List of menus AFTER DELETION:"); +// menuRestaurantRepository.findAll().forEach(System.out::println); +// } +// +// @Test +// public void testRemovingMenus_NO_Relationship() { +// // Create sample menus and save them +// MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true); +// MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02", "Pizza Menu", 12.99, "Pizza and salad", true, false); +// MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03", "Salad Menu", 8.99, "Mixed salad and dressing", true, true); +// menuRestaurantRepository.save(menuRestaurant1); +// menuRestaurantRepository.save(menuRestaurant2); +// menuRestaurantRepository.save(menuRestaurant3); +// +// // Create an order with multiple menus and save it +// OrderRestaurant order = new OrderRestaurant("O01", new Date(), "John", 4, +// 43.96, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2))); +// orderRestaurantRepository.save(order); +// +// // Retrieve the order, remove a menu, and save the updated order +// Optional foundOrder = orderRestaurantRepository.findById("O01"); +// assertThat(foundOrder).isPresent(); +// +// menuRestaurantRepository.delete(menuRestaurant3); +// // Retrieve the updated order after deleting the menu +// System.out.println("List of menus AFTER DELETION:"); +// menuRestaurantRepository.findAll().forEach(System.out::println); +// +// // We CAN NOT delete a menu that has a relationship +// /*menuRestaurantRepository.delete(menuRestaurant2); +// // Retrieve the updated order after deleting the menu +// System.out.println("List of menus AFTER DELETION:"); +// menuRestaurantRepository.findAll().forEach(System.out::println);*/ +// +// +// +// } +// +// // Removing Menus from an Order: Checks that menus can be removed from an order +// // and the changes are reflected in the database. +// // BE CAREFUL! This test should fail. +// @Test +// public void testRemovingMenusFromOrder_butNotRelationship() { +// // Create sample menus and save them +// MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true); +// MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02", "Pizza Menu", 12.99, "Pizza and salad", true, false); +// MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03", "Salad Menu", 8.99, "Mixed salad and dressing", true, true); +// menuRestaurantRepository.save(menuRestaurant1); +// menuRestaurantRepository.save(menuRestaurant2); +// menuRestaurantRepository.save(menuRestaurant3); +// +// // Create an order with multiple menus and save it +// OrderRestaurant order = new OrderRestaurant("O01", new Date(), "John", 4, +// 43.96, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3))); +// orderRestaurantRepository.save(order); +// +// // Let's remove the second menu +// menuRestaurantRepository.delete(menuRestaurant2); +// +// // Retrieve the updated order after deleting the menu +// System.out.println("List of menus AFTER DELETION:"); +// menuRestaurantRepository.findAll().forEach(System.out::println); +// +// // Retrieve the updated order and assert the menus +// Optional updatedOrderOptional = orderRestaurantRepository.findById("O01"); +// // print the menus +// System.out.println("Menus: " + updatedOrderOptional.get().getMenus()); +// // assert the menus have been removed +// assertThat(updatedOrderOptional).isPresent(); +// assertThat(updatedOrderOptional.get().getMenus()).hasSize(2); +// +// } +// +// +// // Cascading Deletion of Menus and Orders: Ensures that the deletion of a menu +// // or an order correctly cascades to the associated records in the order-menu join table. +// /*@Test +// public void testCascadingDeletionOfMenusAndOrders() { +// // Create sample menus and save them +// MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true); +// MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02", "Pizza Menu", 12.99, "Pizza and salad", true, false); +// MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03", "Salad Menu", 8.99, "Mixed salad and dressing", true, true); +// menuRestaurantRepository.save(menuRestaurant1); +// menuRestaurantRepository.save(menuRestaurant2); +// menuRestaurantRepository.save(menuRestaurant3); +// +// // Create an order with multiple menus and save it +// OrderRestaurant order = new OrderRestaurant("O01", new Date(), "John", 4, 43.96, true, +// new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3))); +// orderRestaurantRepository.save(order); +// +// // Delete the menu and verify the cascade deletion of the order-menu association +// Optional foundOrder = orderRestaurantRepository.findById("O01"); +// assertThat(foundOrder).isPresent(); +// OrderRestaurant updatedOrder = foundOrder.get(); +// updatedOrder.removeMenu(menuRestaurant2); +// //menuRestaurantRepository.delete(menuRestaurant2); +// orderRestaurantRepository.save(updatedOrder); +// 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); +// +// // Delete the order and verify the cascade deletion of the order-menu association +// orderRestaurantRepository.delete(order); +// Optional menuRestaurant1Optional = menuRestaurantRepository.findById("M01"); +// Optional menuRestaurant2Optional = menuRestaurantRepository.findById("M02"); +// Optional menuRestaurant3Optional = menuRestaurantRepository.findById("M03"); +// assertThat(menuRestaurant1Optional).isPresent(); +// assertThat(menuRestaurant2Optional).isPresent(); +// assertThat(menuRestaurant3Optional).isPresent(); +// 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 +// // to an EatInOrderRestaurant and the association is correctly persisted in the database. +// /*@Test +// public void testAddingMenusToEatInOrder() { +// // Create sample menus and save them +// MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true, null); +// MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02", "Pizza Menu", 12.99, "Pizza and salad", true, false, null); +// MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03", "Salad Menu", 8.99, "Mixed salad and dressing", true, true, null); +// menuRestaurantRepository.save(menuRestaurant1); +// menuRestaurantRepository.save(menuRestaurant2); +// menuRestaurantRepository.save(menuRestaurant3); +// +// // Create sample tables and save them +// TableRestaurant table1 = new TableRestaurant("T1", "Window Table", 4, false); +// TableRestaurant table2 = new TableRestaurant("T2", "Corner Table", 2, true); +// tableRestaurantRepository.save(table1); +// 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))); +// eatInOrder.addMenu(menuRestaurant1); +// eatInOrder.addMenu(menuRestaurant2); +// eatInOrder.addMenu(menuRestaurant3); +// eatInOrderRestaurantRepository.save(eatInOrder); +// +// // Retrieve the EatInOrder and assert the menus +// Optional foundOrder = (Optional) eatInOrderRestaurantRepository.findById("EO1"); +// assertThat(foundOrder).isPresent(); +// assertThat(foundOrder.get().getMenus()).hasSize(3); +// assertThat(foundOrder.get().getMenus()).contains(menuRestaurant1, menuRestaurant2, menuRestaurant3); +// } +// +// // Removing Menus from an EatInOrder: Checks that menus can be removed from an EatInOrder +// // and the changes are reflected in the database. +// @Test +// public void testRemovingMenusFromEatInOrder() { +// // Create sample menus and save them +// MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true, null); +// MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02", "Pizza Menu", 12.99, "Pizza and salad", true, false, null); +// MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03", "Salad Menu", 8.99, "Mixed salad and dressing", true, true, null); +// menuRestaurantRepository.save(menuRestaurant1); +// menuRestaurantRepository.save(menuRestaurant2); +// menuRestaurantRepository.save(menuRestaurant3); +// +// // Create sample tables and save them +// TableRestaurant table1 = new TableRestaurant("T1", "Window Table", 4, false); +// TableRestaurant table2 = new TableRestaurant("T2", "Corner Table", 2, true); +// tableRestaurantRepository.save(table1); +// tableRestaurantRepository.save(table2); +// +// // Create an EatInOrder with multiple menus and save it +// EatInOrderRestaurant eatInOrder = new EatInOrderRestaurant("EO1", new Date(), "John", 4, 43.96, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3)), new ArrayList<>(Arrays.asList(table1, table2))); +// eatInOrderRestaurantRepository.save(eatInOrder); +// +// // Retrieve the EatInOrder, remove a menu, and save the updated order +// Optional foundOrder = (Optional) eatInOrderRestaurantRepository.findById("EO1"); +// assertThat(foundOrder).isPresent(); +// EatInOrderRestaurant updatedOrder = foundOrder.get(); +// updatedOrder.removeMenu(menuRestaurant2); +// orderRestaurantRepository.save(updatedOrder); +// +// // Retrieve the updated EatInOrder and assert the menus +// 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); +// +// }*/ }