diff --git a/src/main/java/dev/example/restaurantManager/controller/MenuItemController.java b/src/main/java/dev/example/restaurantManager/controller/MenuItemController.java new file mode 100644 index 0000000..cbb693d --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/controller/MenuItemController.java @@ -0,0 +1,81 @@ +package dev.example.restaurantManager.controller; + + +import dev.example.restaurantManager.model.MenuItem; +import dev.example.restaurantManager.service.MenuItemService; +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/menuItems") +@RestController +public class MenuItemController { + + @Autowired + private MenuItemService menuItemService; + + @GetMapping("/allMenuItems") + public ResponseEntity> getAllMenuItems() { + List menuItems = menuItemService.getAllMenuItems(); + HttpHeaders headers = getCommonHeaders("Get all menu items"); + return menuItems != null && !menuItems.isEmpty() + ? new ResponseEntity<>(menuItems, headers, HttpStatus.OK) + : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + + } + + @PostMapping("/addMenuItem") + public ResponseEntity createMenuItem(@RequestBody MenuItem menuItem) { + MenuItem createdMenuItem = menuItemService.createMenuItem(menuItem); + HttpHeaders headers = getCommonHeaders("Create a new menu item"); + return createdMenuItem != null + ? new ResponseEntity<>(createdMenuItem, headers, HttpStatus.CREATED) + : new ResponseEntity<>(headers, HttpStatus.BAD_REQUEST); + } + + @PutMapping("/updateMenuItem/{id}") + public ResponseEntity updateMenuItem(@PathVariable String id, @RequestBody MenuItem menuItemDetails) { + MenuItem updatedMenuItem = menuItemService.updateMenuItem(id, menuItemDetails); + HttpHeaders headers = getCommonHeaders("Update a menu item"); + return updatedMenuItem != null + ? new ResponseEntity<>(updatedMenuItem, headers, HttpStatus.OK) + : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + } + + @DeleteMapping("/deleteMenuItem/{id}") + public ResponseEntity deleteMenuItem(@PathVariable String id) { + boolean deleted = menuItemService.deleteMenuItem(id); + HttpHeaders headers = getCommonHeaders("Delete a menu item"); + headers.add("deleted", String.valueOf(deleted)); + return deleted + ? new ResponseEntity<>(headers, HttpStatus.NO_CONTENT) + : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + } + + @GetMapping("/getMenuItem/{id}") + public ResponseEntity getMenuItemById(@PathVariable String id) { + MenuItem menuItem = menuItemService.getMenuItemById(id); + HttpHeaders headers = getCommonHeaders("Get a menu item by Id"); + return menuItem != null + ? new ResponseEntity<>(menuItem, 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("customer-count", String.valueOf(menuItemService.countMenuItems())); + headers.add("object", "customers"); + return headers; + } +} \ No newline at end of file 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..4126c7e --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/controller/MenuRestaurantController.java @@ -0,0 +1,83 @@ +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("menu-count", String.valueOf(menuRestaurantService.countMenus())); + headers.add("object", "customers"); + return headers; + } +} \ No newline at end of file diff --git a/src/main/java/dev/example/restaurantManager/controller/OrderMenuQtyController.java b/src/main/java/dev/example/restaurantManager/controller/OrderMenuQtyController.java new file mode 100644 index 0000000..e4261d8 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/controller/OrderMenuQtyController.java @@ -0,0 +1,76 @@ +package dev.example.restaurantManager.controller; + + +import dev.example.restaurantManager.model.OrderMenuQty; +import dev.example.restaurantManager.service.OrderMenuQtyService; +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/orderMenuQty") +@RestController +public class OrderMenuQtyController { + + @Autowired + private OrderMenuQtyService orderMenuQtyService; + + @PostMapping + public ResponseEntity createOrderMenuQty(@RequestBody OrderMenuQty orderMenuQty) { + OrderMenuQty createdOrderMenuQty = orderMenuQtyService.createOrderMenuQty(orderMenuQty); + HttpHeaders headers = getCommonHeaders("Create a new OrderMenuQty"); + return createdOrderMenuQty != null ? new ResponseEntity<>(createdOrderMenuQty, headers, HttpStatus.CREATED) : new ResponseEntity<>(headers, HttpStatus.BAD_REQUEST); + + } + + @GetMapping("/{id}") + public ResponseEntity getOrderMenuQtyByID(@PathVariable String id) { + OrderMenuQty orderMenuQty = orderMenuQtyService.getOrderMenuQtyById(id); + HttpHeaders headers = getCommonHeaders("Get an OrderMenuQty by Id"); + + return orderMenuQty != null ? new ResponseEntity<>(orderMenuQty, headers, HttpStatus.OK) : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + + } + + @GetMapping("allOrderMenuQty") + public ResponseEntity> getAllOrderMenuQty() { + List orderMenuQtyList = orderMenuQtyService.getAllOrderMenuQts(); + HttpHeaders headers = getCommonHeaders("Get all OrderMenuQty entries"); + + return orderMenuQtyList != null && !orderMenuQtyList.isEmpty() ? new ResponseEntity<>(orderMenuQtyList, headers, HttpStatus.OK) : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + } + + @PutMapping("/{id}") + public ResponseEntity updatedOrderMenuQty(@PathVariable String id, @RequestBody OrderMenuQty orderMenuQtyDetails) { + OrderMenuQty updatedOrderMenuQty = orderMenuQtyService.updateOrderMenuQty(id, orderMenuQtyDetails); + HttpHeaders headers = getCommonHeaders("Updated a OrderMenuQty"); + + return updatedOrderMenuQty != null + ? new ResponseEntity<>(updatedOrderMenuQty, headers, HttpStatus.OK) : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + } + + @DeleteMapping("/{id}") + public ResponseEntity deleteOrderMenuQty(@PathVariable String id) { + boolean deleted = orderMenuQtyService.deleteOrderMenuQty(id); + HttpHeaders headers = getCommonHeaders("delete an OrderMenuQty"); + + return deleted ? new ResponseEntity<>(headers, HttpStatus.NO_CONTENT) : 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("orderMenuQty-count", String.valueOf(orderMenuQtyService.countOrderMenuQts())); + headers.add("object", "orderMenuQty"); + return headers; + } +} \ No newline at end of file diff --git a/src/main/java/dev/example/restaurantManager/model/CourseType.java b/src/main/java/dev/example/restaurantManager/model/CourseType.java new file mode 100644 index 0000000..ed0fd53 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/model/CourseType.java @@ -0,0 +1,7 @@ +package dev.example.restaurantManager.model; + +public enum CourseType { + STARTER, + MAIN, + DESSERT +} \ No newline at end of file diff --git a/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java index 1e2dd12..939cbe6 100644 --- a/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java @@ -19,9 +19,9 @@ 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 orderMenuQty, ArrayList tableRestaurants) { - super(id, date, waiter, peopleQty, totalPayment, paid, menus); + super(id, date, waiter, peopleQty, totalPayment, paid, orderMenuQty); this.tableRestaurants = tableRestaurants; } diff --git a/src/main/java/dev/example/restaurantManager/model/MenuItem.java b/src/main/java/dev/example/restaurantManager/model/MenuItem.java new file mode 100644 index 0000000..f2dd58a --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/model/MenuItem.java @@ -0,0 +1,90 @@ +package dev.example.restaurantManager.model; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import jakarta.persistence.*; +import lombok.*; +import org.hibernate.annotations.GenericGenerator; + +import java.awt.*; +import java.util.*; +import java.util.List; + +@AllArgsConstructor +@Entity +@Data +public class MenuItem { + @Id + @GeneratedValue(generator = "UUID") + @GenericGenerator(name = "UUID", strategy = "org.hibernate.id.UUIDGenerator") + private String id; + + private String name; + private String description; + private boolean isSpicy; + private boolean hasGluten; + private boolean isAvailable; + + @Enumerated(EnumType.STRING) + private CourseType courseType; + +// @ManyToMany(mappedBy = "menuItems") +// private Set menus = new HashSet<>(); + + // Many to many with + @JsonIgnore + @ManyToMany(mappedBy = "menuItems", fetch = FetchType.LAZY) + private List menuRestaurants; + +// // Create add method +// public void addItem(MenuRestaurant menu){ +// this.menuRestaurants.add(menu); +// menu.getMenuItems().add(this); +// +// } +// // Create remove method +// public void removeItem(MenuRestaurant menu) { +// this.menuRestaurants.remove(menu); +// menu.getMenuItems().remove(this); +// } + + // Default constructor + public MenuItem() { + // this.id = UUID.randomUUID().toString(); + } +// Getters and setters + + @Override + public String toString() { + return "MenuRestaurant{" + + "id='" + id + '\'' + + ", name='" + name + '\'' + + ", description=" + description + + ", spicy=" + isSpicy + '\'' + + ", hasGluten=" + hasGluten + + ", available=" + isAvailable + + ", courseType=" + courseType + + //", menus=" + menuRestaurants + + '}'; + } + // Updated equals() method to compare all fields except 'menuRestaurants' + @Override + public boolean equals(Object object) { + if (this == object) return true; + if (!(object instanceof MenuItem)) return false; + MenuItem that = (MenuItem) object; + return isAvailable == that.isAvailable && + hasGluten == that.hasGluten && + isSpicy == that.isSpicy && + Objects.equals(id, that.id) && + Objects.equals(name, that.name) && + Objects.equals(description, that.description) && + Objects.equals(courseType, that.courseType); + } + + @Override + public int hashCode() { + return Objects.hash(id, name, description, isSpicy, hasGluten,isAvailable, courseType); + } + + +} \ No newline at end of file diff --git a/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java index e916706..6e45b1e 100644 --- a/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java @@ -1,11 +1,10 @@ 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 org.hibernate.annotations.GenericGenerator; + import java.util.ArrayList; import java.util.List; import java.util.Objects; @@ -17,6 +16,8 @@ public class MenuRestaurant { @Id + @GeneratedValue(generator = "UUID") + @GenericGenerator(name = "UUID", strategy = "org.hibernate.id.UUIDGenerator") private String id; private String name; private Double price; @@ -24,12 +25,24 @@ public class MenuRestaurant { private boolean active; private boolean water; +// @JsonIgnore +//// @ManyToMany(mappedBy = "menus", fetch = FetchType.LAZY) +//// private List orders = new ArrayList<>(); + @OneToMany(mappedBy = "menuRestaurantMapped", cascade = CascadeType.PERSIST, fetch = FetchType.EAGER) + private ArrayList orderMenuQts; + + @ManyToMany(fetch = FetchType.LAZY) @JsonIgnore - @ManyToMany(mappedBy = "menus", fetch = FetchType.LAZY) - private List orders = new ArrayList<>(); + @JoinTable( + name = "menu_menuItem", + joinColumns = @JoinColumn(name = "menu_id"), + inverseJoinColumns = @JoinColumn(name = "menuItem_id") + ) + private List menuItems = new ArrayList<>(); + - public MenuRestaurant(String id, String name, Double price, String content, boolean active, boolean water) { - this.id = id; + public MenuRestaurant(String name, Double price, String content, boolean active, boolean water) { + //this.id = id; this.name = name; this.price = price; this.content = content; @@ -48,6 +61,7 @@ public String toString() { ", content='" + content + '\'' + ", active=" + active + ", water=" + water + + //", OrderMenuQts=" + orderMenuQts + '}'; } 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..bc67271 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java @@ -0,0 +1,54 @@ +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; + +@Data +@AllArgsConstructor +@NoArgsConstructor +@Entity +public class OrderMenuQty { + + @Id + @GeneratedValue(generator = "UUID") + @GenericGenerator(name = "UUID", strategy = "org.hibernate.id.UUIDGenerator") + private String id; + private int qty; + + @JsonIgnore + @ManyToOne(fetch = FetchType.LAZY, cascade = CascadeType.PERSIST) + @JoinColumn(name = "MENU_FK_ID") + private MenuRestaurant menuRestaurantMapped; + + @JsonIgnore + @ManyToOne(fetch = FetchType.LAZY, cascade = CascadeType.PERSIST) + @JoinColumn(name = "ORDER_FK_ID") + private OrderRestaurant orderRestaurantMapped; + + public OrderMenuQty (int qty, MenuRestaurant menuRestaurant, OrderRestaurant orderRestaurant){ + this.qty = qty; + this.menuRestaurantMapped = menuRestaurant; + this.orderRestaurantMapped = orderRestaurant; + } + + @Override + public String toString() { + return "OrderMenuQty{" + + "id='" + id + '\'' + + "menuRestaurant" + menuRestaurantMapped + + "orderRestaurant" + orderRestaurantMapped + + '}'; + } + + + + + + + +} diff --git a/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java index 994b5a4..d1553ed 100644 --- a/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java @@ -6,6 +6,7 @@ import com.fasterxml.jackson.annotation.JsonIgnore; import jakarta.persistence.*; import lombok.*; +import org.hibernate.annotations.GenericGenerator; @Getter @Setter @@ -17,6 +18,8 @@ public class OrderRestaurant { @Id + @GeneratedValue(generator = "UUID") + @GenericGenerator(name = "UUID", strategy = "org.hibernate.id.UUIDGenerator") private String id; private Date date; private String waiter; @@ -24,27 +27,39 @@ public class OrderRestaurant { private double totalPayment; private boolean paid; - @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; + public OrderRestaurant( Date date, String waiter, int peopleQty, double totalPayment, boolean paid){ + //this.id = id; + this.date = date; + this.waiter = waiter; + this.peopleQty = peopleQty; + this.totalPayment = totalPayment; + this.paid = paid; } - public List removeMenu(MenuRestaurant menu) { - this.menus.remove(menu); - menu.getOrders().remove(this); - return this.menus; - } +// @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") +// ) + + @OneToMany(mappedBy = "orderRestaurantMapped", cascade = CascadeType.PERSIST, fetch = FetchType.EAGER) + private ArrayList orderMenuQts; + //private List menus = new ArrayList<>(); + +// public List addMenuQty(OrderMenuQty menuQty) { +// this.orderMenuQts.add(menuQty); +// menuQty.getQty().add(this); +// return this.orderMenuQts; +// } +// +// public List removeMenuQty(OrderMenuQty menuQty) { +// this.orderMenuQts.remove(menuQty); +// menuQty.getOrders().remove(this); +// return this.orderMenuQts; +// } @Override public String toString() { @@ -55,8 +70,8 @@ public String toString() { ", peopleQty=" + peopleQty + ", totalPayment=" + totalPayment + ", paid=" + paid + - ", menusCount=" + (menus != null ? menus.size() : 0) + - ", menus=" + menus + + //", menusCount=" + (menus != null ? menus.size() : 0) + + //", orderMenuQts=" + orderMenuQts + '}'; } diff --git a/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java index 6375dc2..99a367d 100644 --- a/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java @@ -16,9 +16,9 @@ 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 orderMenuQty, String address, String city, String riderName) { - super(id, date, waiter, peopleQty, totalPayment, paid, menus); + super(id, date, waiter, peopleQty, totalPayment, paid, orderMenuQty); this.address = address; this.city = city; this.riderName = riderName; diff --git a/src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java b/src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java index e285789..c551ba9 100644 --- a/src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java +++ b/src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java @@ -19,11 +19,11 @@ 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 orderMenuQty, Customer customerTakeAway) { // THIS PART is SUPERCLASS - super(id, date, waiter, peopleQty, totalPayment, paid, menus); + super(id, date, waiter, peopleQty, totalPayment, paid, orderMenuQty); // THIS PART is SUBCLASS this.customerTakeAway = customerTakeAway; } diff --git a/src/main/java/dev/example/restaurantManager/repository/MenuItemRepository.java b/src/main/java/dev/example/restaurantManager/repository/MenuItemRepository.java new file mode 100644 index 0000000..58581e2 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/repository/MenuItemRepository.java @@ -0,0 +1,11 @@ +package dev.example.restaurantManager.repository; + +import dev.example.restaurantManager.model.MenuItem; +import org.springframework.data.jpa.repository.JpaRepository; + +import java.util.Optional; + +public interface MenuItemRepository extends JpaRepository { + //Optional findByNameOptional(String name); + MenuItem findByName(String name); +} \ No newline at end of file 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..1d15d08 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/repository/OrderMenuQtyRepository.java @@ -0,0 +1,14 @@ +package dev.example.restaurantManager.repository; + +import dev.example.restaurantManager.model.OrderMenuQty; +import org.springframework.data.jpa.repository.JpaRepository; + +import java.util.List; + +public interface OrderMenuQtyRepository extends JpaRepository { + + + //List findAllByOrderId(String orderId); + List findAllByOrderRestaurantMapped_Id(String orderId); + +} diff --git a/src/main/java/dev/example/restaurantManager/service/MenuItemService.java b/src/main/java/dev/example/restaurantManager/service/MenuItemService.java new file mode 100644 index 0000000..2927aeb --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/MenuItemService.java @@ -0,0 +1,16 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.MenuItem; + + +import java.util.List; + +public interface MenuItemService { + List getAllMenuItems(); + MenuItem createMenuItem(MenuItem menuItem); + MenuItem getMenuItemById(String id); + MenuItem updateMenuItem(String id, MenuItem menuItemDetails); + boolean deleteMenuItem(String id); + long countMenuItems(); + //List getMenuItemsByMenuId(String menuId); +} \ No newline at end of file diff --git a/src/main/java/dev/example/restaurantManager/service/MenuItemServiceImpl.java b/src/main/java/dev/example/restaurantManager/service/MenuItemServiceImpl.java new file mode 100644 index 0000000..f86e772 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/MenuItemServiceImpl.java @@ -0,0 +1,87 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.MenuItem; +import dev.example.restaurantManager.model.MenuRestaurant; +import dev.example.restaurantManager.repository.MenuItemRepository; +import dev.example.restaurantManager.repository.MenuRestaurantRepository; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; +@Service +public class MenuItemServiceImpl implements MenuItemService { + + @Autowired + MenuItemRepository menuItemRepository; + + @Autowired + MenuRestaurantRepository menuRepository; + + @Override + public List getAllMenuItems() { + return menuItemRepository.findAll(); + } + + @Override + public MenuItem createMenuItem(MenuItem menuItem) { + // not needed because it's already generated in the own entity + //menuItem.setId(UUID.randomUUID().toString()); + Optional menuItemCreated = menuItemRepository.findById(menuItem.getId()); + if (menuItemCreated.isPresent()) { + return null; + } + menuItemRepository.save(menuItem); + return menuItem; + } + + + @Override + public MenuItem getMenuItemById(String id) { + return menuItemRepository.findById(id).orElse(null); + } + + @Override + public MenuItem updateMenuItem(String id, MenuItem menuItemDetails) { + MenuItem menuItem = menuItemRepository.findById(id).orElse(null); + if (menuItem != null) { + if (menuItemDetails.getName() != null) { + menuItem.setName(menuItemDetails.getName()); + } + if (menuItemDetails.getDescription() != null) { + menuItem.setDescription(menuItemDetails.getDescription()); + } + if (menuItemDetails.isSpicy()) { + menuItem.setSpicy(menuItemDetails.isSpicy()); + } + if (menuItemDetails.isHasGluten()) { + menuItem.setHasGluten(menuItemDetails.isHasGluten()); + } + if (menuItemDetails.isAvailable()) { + menuItem.setAvailable(menuItemDetails.isAvailable()); + } + return menuItemRepository.save(menuItem); + } + return null; + } + + @Override + public boolean deleteMenuItem(String id) { + menuItemRepository.deleteById(id); + Optional menuItem = menuItemRepository.findById(id); + return menuItem.isEmpty() + ? false : true; + } + + @Override + public long countMenuItems() { + return menuItemRepository.count(); + } + +// @Override +// public List getMenuItemsByMenuId(String menuId) { +// MenuRestaurant menu = menuRepository.findById(menuId).orElse(null); +// return menu != null ? menu.getMenuItems() : new ArrayList<>(); +// } +} \ No newline at end of file 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..3149b07 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/MenuRestaurantService.java @@ -0,0 +1,15 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.MenuRestaurant; + +import java.util.List; + +public interface MenuRestaurantService { + + List getAllMenus(); + MenuRestaurant createMenu(MenuRestaurant menuRestaurant); + MenuRestaurant getMenuById(String id); + MenuRestaurant updateMenu(String id, MenuRestaurant menuRestaurantDetails); + boolean deleteMenu(String id); + long countMenus(); +} \ No newline at end of file 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..aae349c --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/MenuRestaurantServiceImpl.java @@ -0,0 +1,67 @@ +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.Optional; +import java.util.UUID; +import java.util.List; + +@Service +public class MenuRestaurantServiceImpl implements MenuRestaurantService { + + @Autowired + private MenuRestaurantRepository menuRepository; + + @Override + public List getAllMenus() { + return menuRepository.findAll(); + } + + @Override + public MenuRestaurant createMenu(MenuRestaurant menu) { + Optional menuOptional = menuRepository.findById(menu.getId()); + if (menuOptional.isPresent()) { + return null; + } else { + menuRepository.save(menu); + return menu; + } + } + + @Override + public MenuRestaurant getMenuById(String id) { + return menuRepository.findById(id).orElse(null); + } + + @Override + public MenuRestaurant updateMenu(String id, MenuRestaurant menuDetails) { + Optional menuOptional = menuRepository.findById(id); + if (menuOptional.isPresent()) { + MenuRestaurant menu = menuOptional.get(); + menu.setName(menuDetails.getName()); + menu.setPrice(menuDetails.getPrice()); + menu.setContent(menuDetails.getContent()); + menu.setActive(menuDetails.isActive()); + menu.setWater(menuDetails.isWater()); + menuRepository.save(menu); + return menu; + } else { + return null; + } + } + + @Override + public boolean deleteMenu(String id) { + menuRepository.deleteById(id); + Optional menu = menuRepository.findById(id); + + return menu.isPresent(); + } + @Override + public long countMenus() { + return menuRepository.count(); + } + +} \ No newline at end of file diff --git a/src/main/java/dev/example/restaurantManager/service/OrderMenuQtyService.java b/src/main/java/dev/example/restaurantManager/service/OrderMenuQtyService.java new file mode 100644 index 0000000..ec1f5f6 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/OrderMenuQtyService.java @@ -0,0 +1,17 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.OrderMenuQty; + +import java.util.List; + +public interface OrderMenuQtyService { + List getAllOrderMenuQts(); + List getAllByOrderId (String orderId); + OrderMenuQty createOrderMenuQty(OrderMenuQty orderMenuQty); + OrderMenuQty getOrderMenuQtyById(String id); + OrderMenuQty updateOrderMenuQty(String id, OrderMenuQty orderMenuQtyDetails); + boolean deleteOrderMenuQty(String id); + long countOrderMenuQts(); + + +} diff --git a/src/main/java/dev/example/restaurantManager/service/OrderMenuQtyServiceImpl.java b/src/main/java/dev/example/restaurantManager/service/OrderMenuQtyServiceImpl.java new file mode 100644 index 0000000..c54077b --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/OrderMenuQtyServiceImpl.java @@ -0,0 +1,60 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.OrderMenuQty; +import dev.example.restaurantManager.repository.OrderMenuQtyRepository; +import org.hibernate.sql.ast.tree.expression.Over; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.util.List; +import java.util.Optional; + +@Service +public class OrderMenuQtyServiceImpl implements OrderMenuQtyService { + + @Autowired + OrderMenuQtyRepository orderMenuQtyRepository; + + @Override + public List getAllOrderMenuQts() { + return orderMenuQtyRepository.findAll(); + } + public List getAllByOrderId(String orderId) { + return orderMenuQtyRepository.findAllByOrderRestaurantMapped_Id(orderId); + } + + @Override + public OrderMenuQty createOrderMenuQty(OrderMenuQty orderMenuQty) { + return orderMenuQtyRepository.save(orderMenuQty); + } + + @Override + public OrderMenuQty getOrderMenuQtyById(String id) { + return orderMenuQtyRepository.findById(id).orElse(null); + } + + @Override + public OrderMenuQty updateOrderMenuQty(String id, OrderMenuQty orderMenuQtyDetails) { + OrderMenuQty orderMenuQty = orderMenuQtyRepository.findById(id).orElse(null); + if (orderMenuQty != null) { + if (orderMenuQtyDetails.getQty() != 0) { + orderMenuQty.setQty(orderMenuQtyDetails.getQty()); + } + return orderMenuQtyRepository.save(orderMenuQty); + } + return null; + } + + @Override + public boolean deleteOrderMenuQty(String id) { + orderMenuQtyRepository.deleteById(id); + Optional orderMenuQty = orderMenuQtyRepository.findById(id); + return orderMenuQty.isEmpty() ? false : true; + + } + + @Override + public long countOrderMenuQts() { + return orderMenuQtyRepository.count(); + } +} diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties index 56fa3b7..0329d93 100644 --- a/src/main/resources/application.properties +++ b/src/main/resources/application.properties @@ -28,4 +28,6 @@ endpoint.url.customers=/api/v1/customers/ # Enable debug logging #logging.level.org.springframework=DEBUG -#logging.level.dev.example.restaurantManager=DEBUG \ No newline at end of file +#logging.level.dev.example.restaurantManager=DEBUG + +server.port=8081 \ No newline at end of file diff --git a/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java b/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java index 35e2078..7db1d20 100644 --- a/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java +++ b/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java @@ -5,9 +5,15 @@ import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; +import org.springframework.util.Assert; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; + import java.util.*; import static org.assertj.core.api.Assertions.assertThat; + @DataJpaTest public class RelationshipsOrderRestaurantTest { @@ -23,321 +29,319 @@ public class RelationshipsOrderRestaurantTest { private TableRestaurantRepository tableRestaurantRepository; @Autowired private EatInOrderRestaurantRepository eatInOrderRestaurantRepository; +@Autowired +private OrderMenuQtyRepository orderMenuQtyRepository; @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("--------------------"); +// // 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); + + MenuRestaurant menuRestaurant1 = new MenuRestaurant("Burger Menu", 10.99, "Burger, fries, and drink", 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); - - - // 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())); - } + // Create Order object and assign menus + OrderRestaurant orderRestaurant1 = new OrderRestaurant(new Date(), "John", 4, 43.96, true); - // 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 + // Save sample order orderRestaurantRepository.save(orderRestaurant1); - //orderRestaurantRepository.save(orderRestaurant2); - //orderRestaurantRepository.save(orderRestaurant3); - // set menus to orders and save - menuRestaurant1.getOrders().add(orderRestaurant1); - menuRestaurantRepository.save(menuRestaurant1); + // Create MenuQt + OrderMenuQty orderMenuQty1 = new OrderMenuQty(2, menuRestaurant1, orderRestaurant1); + + + // Save sample OrderMenuQty + orderMenuQtyRepository.save(orderMenuQty1); + + + assertFalse(orderMenuQtyRepository.findAll().isEmpty(), "It must not be empty"); + + assertEquals(1, orderMenuQtyRepository.findAll().size(), "Expected size is 1"); - // 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())); } + // 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() { +// @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); +// 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() { +// @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); +// 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 ); - // 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() { +// @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() { +// 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); +// 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); @@ -347,42 +351,42 @@ public void testRemovingMenus_NO_Relationship() { - } + // 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() { +// @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); +// 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); - // 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 @@ -498,4 +502,4 @@ public void testRemovingMenusFromEatInOrder() { }*/ -} +