From 5d86598bc7b48fb9591ddd3fc29fc0b7a93809b3 Mon Sep 17 00:00:00 2001 From: Marc Rodriguez Date: Wed, 9 Oct 2024 11:53:01 +0200 Subject: [PATCH 1/2] asfasf --- src/main/resources/application.properties | 3 +-- src/main/resources/application.properties~ | 15 +++++++++++++++ 2 files changed, 16 insertions(+), 2 deletions(-) create mode 100644 src/main/resources/application.properties~ diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties index bb3e760..e8948fe 100644 --- a/src/main/resources/application.properties +++ b/src/main/resources/application.properties @@ -1,8 +1,7 @@ spring.application.name=restaurantManager -#spring.datasource.url=jdbc:h2:mem:testdb -spring.datasource.url=jdbc:h2:/home/albert/MyProjects/DataBase/customerdb +spring.datasource.url=jdbc:h2:mem:testdb spring.datasource.driverClassName=org.h2.Driver spring.datasource.username=albert spring.datasource.password=1234 diff --git a/src/main/resources/application.properties~ b/src/main/resources/application.properties~ new file mode 100644 index 0000000..bb3e760 --- /dev/null +++ b/src/main/resources/application.properties~ @@ -0,0 +1,15 @@ +spring.application.name=restaurantManager + + +#spring.datasource.url=jdbc:h2:mem:testdb +spring.datasource.url=jdbc:h2:/home/albert/MyProjects/DataBase/customerdb +spring.datasource.driverClassName=org.h2.Driver +spring.datasource.username=albert +spring.datasource.password=1234 +spring.jpa.database-platform=org.hibernate.dialect.H2Dialect +spring.h2.console.enabled=true + +spring.jpa.hibernate.ddl-auto=create + +springdoc.api-docs.path=/api-docs +springdoc.swagger-ui.path=/swagger-ui.html \ No newline at end of file From 4676645c35eabb9e5e0ed01dde35f147c60e60b7 Mon Sep 17 00:00:00 2001 From: Marc Rodriguez Date: Wed, 23 Oct 2024 14:01:35 +0200 Subject: [PATCH 2/2] practica 3 finalizada --- .../controller/CustomerController.java | 14 +- .../controller/MenuItemController.java | 81 ++ .../controller/MenuRestaurantController.java | 81 ++ .../controller/MenuRestaurantController.java~ | 2 + .../restaurantManager/enums/CourseType.java | 7 + .../model/MenuItemRestaurant.java | 86 +++ .../model/MenuRestaurant.java | 45 +- .../repository/MenuItemRepository.java | 7 + .../service/MenuItemService.java | 15 + .../service/MenuItemServiceImpl.java | 54 ++ .../service/MenuRestaurantService.java | 15 + .../service/MenuRestaurantServiceImpl.java | 72 ++ src/main/resources/application.properties | 2 +- src/main/resources/application.properties~ | 15 - .../restaurantManager/BookingTableTest.java | 80 +- .../CustomerRepositoryTest.java | 166 ++--- .../MenuAndMenuItemRelationshipTest.java | 72 ++ .../RelationshipsOrderRestaurantTest.java | 692 +++++++++--------- 18 files changed, 1010 insertions(+), 496 deletions(-) create mode 100644 src/main/java/dev/example/restaurantManager/controller/MenuItemController.java create mode 100644 src/main/java/dev/example/restaurantManager/controller/MenuRestaurantController.java create mode 100644 src/main/java/dev/example/restaurantManager/controller/MenuRestaurantController.java~ create mode 100644 src/main/java/dev/example/restaurantManager/enums/CourseType.java create mode 100644 src/main/java/dev/example/restaurantManager/model/MenuItemRestaurant.java create mode 100644 src/main/java/dev/example/restaurantManager/repository/MenuItemRepository.java create mode 100644 src/main/java/dev/example/restaurantManager/service/MenuItemService.java create mode 100644 src/main/java/dev/example/restaurantManager/service/MenuItemServiceImpl.java create mode 100644 src/main/java/dev/example/restaurantManager/service/MenuRestaurantService.java create mode 100644 src/main/java/dev/example/restaurantManager/service/MenuRestaurantServiceImpl.java delete mode 100644 src/main/resources/application.properties~ create mode 100644 src/test/java/dev/example/restaurantManager/MenuAndMenuItemRelationshipTest.java diff --git a/src/main/java/dev/example/restaurantManager/controller/CustomerController.java b/src/main/java/dev/example/restaurantManager/controller/CustomerController.java index 57b0429..d51d0e4 100644 --- a/src/main/java/dev/example/restaurantManager/controller/CustomerController.java +++ b/src/main/java/dev/example/restaurantManager/controller/CustomerController.java @@ -16,17 +16,17 @@ public class CustomerController { // inject from application.properties endpoint.url.customers - @Value("${endpoint.url.customers}") - private String endpointUrlCustomers; +// @Value("${endpoint.url.customers}") +// private String endpointUrlCustomers; @Autowired private CustomerService customerService; - @GetMapping("/show-endpoint") - public String showEndpointCustomers() { - - return "The customers endpoint URL is: " + endpointUrlCustomers; - } +// @GetMapping("/show-endpoint") +// public String showEndpointCustomers() { +// +// return "The customers endpoint URL is: " + endpointUrlCustomers; +// } // manage request by ResponseEntity with all customers @GetMapping("/allCustomers") 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..55e5df7 --- /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.MenuItemRestaurant; +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.getAllItemMenus(); + 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 MenuItemRestaurant menuItem) { + MenuItemRestaurant createdMenuItem = menuItemService.createItemMenu(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 MenuItemRestaurant menuItemDetails) { + MenuItemRestaurant updatedMenuItem = menuItemService.updateItemMenu(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.deleteItemMenu(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) { + MenuItemRestaurant menuItem = menuItemService.getItemMenuById(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.countItemMenus())); + headers.add("object", "customers"); + return headers; + } +} 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..24f5318 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/controller/MenuRestaurantController.java @@ -0,0 +1,81 @@ +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; + } +} 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..cc63719 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/controller/MenuRestaurantController.java~ @@ -0,0 +1,2 @@ +package dev.example.restaurantManager.controller;public class MenuRestaurantController { +} diff --git a/src/main/java/dev/example/restaurantManager/enums/CourseType.java b/src/main/java/dev/example/restaurantManager/enums/CourseType.java new file mode 100644 index 0000000..97e89c9 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/enums/CourseType.java @@ -0,0 +1,7 @@ +package dev.example.restaurantManager.enums; + +public enum CourseType { + STARTER, + MAIN, + DESSERT +} diff --git a/src/main/java/dev/example/restaurantManager/model/MenuItemRestaurant.java b/src/main/java/dev/example/restaurantManager/model/MenuItemRestaurant.java new file mode 100644 index 0000000..9c1e4c4 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/model/MenuItemRestaurant.java @@ -0,0 +1,86 @@ +package dev.example.restaurantManager.model; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import dev.example.restaurantManager.enums.CourseType; +import jakarta.persistence.*; +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.Setter; +import org.hibernate.annotations.GenericGenerator; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; +import java.util.UUID; + + +@Getter +@Setter +@Entity +@AllArgsConstructor +public class MenuItemRestaurant { + + @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; + private double price; + @JsonIgnore + @ManyToMany(mappedBy = "menuItems", fetch = FetchType.EAGER) + private List menus = new ArrayList<>(); + @Enumerated(EnumType.STRING) + private CourseType courseType; + + + public MenuItemRestaurant() { + this.id = UUID.randomUUID().toString(); + } + + public void addMenuRestaurant(MenuRestaurant menuRestaurant) { + this.menus.add(menuRestaurant); + if (!menuRestaurant.getMenuItems().contains(this)) { + menuRestaurant.getMenuItems().add(this); + } + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (!(o instanceof MenuItemRestaurant)) return false; + MenuItemRestaurant that = (MenuItemRestaurant) o; + return Objects.equals(id, that.id) && + Objects.equals(name, that.name) && + Objects.equals(description, that.description) && + Objects.equals(isSpicy, that.isSpicy) && + Objects.equals(hasGluten, that.hasGluten) && + Objects.equals(isAvailable, that.isAvailable) && + Objects.equals(price, that.price) && + courseType == that.courseType && + Objects.equals(menus, that.menus); + } + + @Override + public int hashCode() { + return Objects.hash(id, name, description, isSpicy, hasGluten, isAvailable, price, courseType, menus); + } + + @Override + public String toString() { + return "MenuItemRestaurant{" + + "id='" + id + '\'' + + ", name='" + name + '\'' + + ", description='" + description + '\'' + + ", isSpicy=" + isSpicy + + ", hasGluten=" + hasGluten + + ", isAvailable=" + isAvailable + + ", price=" + price + + ", courseType=" + courseType + + ", menus=" + menus + + '}'; + } +} diff --git a/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java index a34fcfa..11aa68c 100644 --- a/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java @@ -1,13 +1,11 @@ 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; +import java.util.Objects; @Getter @Setter @@ -28,6 +26,45 @@ public class MenuRestaurant { @ManyToMany(mappedBy = "menus", fetch = FetchType.LAZY) private List orders = new ArrayList<>(); + @JsonIgnore + @ManyToMany(fetch = FetchType.EAGER + , cascade = {CascadeType.PERSIST, CascadeType.MERGE}) + @JoinTable( + name = "menu_item", + joinColumns = @JoinColumn(name = "menu_id"), + inverseJoinColumns = @JoinColumn(name = "menu_item_id")) + private List menuItems = new ArrayList<>(); + + public void addMenuItem(MenuItemRestaurant menuItemRestaurant) { + this.menuItems.add(menuItemRestaurant); + if (menuItemRestaurant.getMenus() == null) { + menuItemRestaurant.setMenus(new ArrayList<>()); + } + if (!menuItemRestaurant.getMenus().contains(this)) { + menuItemRestaurant.getMenus().add(this); + } + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + MenuRestaurant that = (MenuRestaurant) o; + return active == that.active && + water == that.water && + Objects.equals(id, that.id) && + Objects.equals(name, that.name) && + Objects.equals(price, that.price) && + Objects.equals(content, that.content) && + Objects.equals(menuItems, that.menuItems); + } + + @Override + public int hashCode() { + return Objects.hash(id, name, price, content, active, water, menuItems); + } + + public MenuRestaurant(String id, String name, Double price, String content, boolean active, boolean water) { this.id = id; this.name = name; 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..d0c1194 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/repository/MenuItemRepository.java @@ -0,0 +1,7 @@ +package dev.example.restaurantManager.repository; + +import dev.example.restaurantManager.model.MenuItemRestaurant; +import org.springframework.data.jpa.repository.JpaRepository; + +public interface MenuItemRepository extends JpaRepository { +} 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..cc99e25 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/MenuItemService.java @@ -0,0 +1,15 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.MenuItemRestaurant; + +import java.util.List; + +public interface MenuItemService { + + List getAllItemMenus(); + MenuItemRestaurant getItemMenuById(String id); + MenuItemRestaurant createItemMenu(MenuItemRestaurant menuItemRestaurant); + MenuItemRestaurant updateItemMenu(String id, MenuItemRestaurant menuItemRestaurant); + boolean deleteItemMenu(String id); + long countItemMenus(); +} 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..8801def --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/MenuItemServiceImpl.java @@ -0,0 +1,54 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.MenuItemRestaurant; +import dev.example.restaurantManager.repository.MenuItemRepository; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.util.List; +import java.util.Optional; +import java.util.UUID; + +@Service +public class MenuItemServiceImpl implements MenuItemService { + + @Autowired + MenuItemRepository menuItemRepository; + + public List getAllItemMenus(){ + List menuItemList = menuItemRepository.findAll(); + return menuItemList; + } + public MenuItemRestaurant getItemMenuById(String id){ + Optional menuItem = menuItemRepository.findById(id); + return menuItem.orElse(null); + } + public MenuItemRestaurant createItemMenu(MenuItemRestaurant menuItemRestaurant){ + Optional menuItem = menuItemRepository.findById(menuItemRestaurant.getId()); + if(menuItem.isPresent()){ + return null; + } + menuItemRepository.save(menuItemRestaurant); + return menuItemRestaurant; + } + public MenuItemRestaurant updateItemMenu(String id, MenuItemRestaurant menuItemRestaurant){ + Optional menuItem = menuItemRepository.findById(id); + if(menuItem.isPresent()){ + menuItem.get().setName(menuItemRestaurant.getName()); + menuItem.get().setDescription(menuItemRestaurant.getDescription()); + menuItem.get().setPrice(menuItemRestaurant.getPrice()); + menuItemRepository.save(menuItem.get()); + return menuItem.get(); + }else{ + return null; + } + } + public boolean deleteItemMenu(String id){ + menuItemRepository.deleteById(id); + Optional menuItem = menuItemRepository.findById(id); + return menuItem.isEmpty() ? false : true; + } + public long countItemMenus(){ + return menuItemRepository.count(); + } +} 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..48f2056 --- /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 getMenuById(String id); + MenuRestaurant createMenu(MenuRestaurant menuRestaurant); + MenuRestaurant updateMenu(String id, MenuRestaurant menuRestaurant); + 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..a552636 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/MenuRestaurantServiceImpl.java @@ -0,0 +1,72 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.MenuRestaurant; +import dev.example.restaurantManager.repository.MenuRestaurantRepository; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.util.List; +import java.util.Optional; + +@Service +public class MenuRestaurantServiceImpl implements MenuRestaurantService{ + + + @Autowired + private MenuRestaurantRepository menuRepository; + + + @Override + public MenuRestaurant getMenuById(String id) { + Optional menu = menuRepository.findById(id); + return menu.get(); + } + + @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 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) { + Optional menuOptional = menuRepository.findById(id); + if (menuOptional.isPresent()) { + MenuRestaurant menu = menuOptional.get(); + menuRepository.delete(menu); + return true; + } else { + return false; + } + } + @Override + public List getAllMenus() { + List menus = menuRepository.findAll(); + return menus; + } + @Override + public long countMenus() { + return menuRepository.count(); + } +} diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties index e588a08..8787c0c 100644 --- a/src/main/resources/application.properties +++ b/src/main/resources/application.properties @@ -8,7 +8,7 @@ spring.datasource.password=1234 spring.jpa.database-platform=org.hibernate.dialect.H2Dialect spring.h2.console.enabled=true -spring.jpa.hibernate.ddl-auto=none +spring.jpa.hibernate.ddl-auto=update springdoc.api-docs.path=/api-docs springdoc.swagger-ui.path=/swagger-ui.html \ No newline at end of file diff --git a/src/main/resources/application.properties~ b/src/main/resources/application.properties~ deleted file mode 100644 index bb3e760..0000000 --- a/src/main/resources/application.properties~ +++ /dev/null @@ -1,15 +0,0 @@ -spring.application.name=restaurantManager - - -#spring.datasource.url=jdbc:h2:mem:testdb -spring.datasource.url=jdbc:h2:/home/albert/MyProjects/DataBase/customerdb -spring.datasource.driverClassName=org.h2.Driver -spring.datasource.username=albert -spring.datasource.password=1234 -spring.jpa.database-platform=org.hibernate.dialect.H2Dialect -spring.h2.console.enabled=true - -spring.jpa.hibernate.ddl-auto=create - -springdoc.api-docs.path=/api-docs -springdoc.swagger-ui.path=/swagger-ui.html \ No newline at end of file diff --git a/src/test/java/dev/example/restaurantManager/BookingTableTest.java b/src/test/java/dev/example/restaurantManager/BookingTableTest.java index 17a958b..b8627cc 100644 --- a/src/test/java/dev/example/restaurantManager/BookingTableTest.java +++ b/src/test/java/dev/example/restaurantManager/BookingTableTest.java @@ -20,44 +20,44 @@ public class BookingTableTest { @Autowired private TableRestaurantRepository tableRestaurantRepository; - @Test - public void TestCreateBookingTable() { - - // Create booking object - Booking booking1 = new Booking(); - booking1.setId("BO01"); - booking1.setConfirmed(false); - booking1.setDate(new Date()); - booking1.setName("Emma and friends"); - booking1.setPeopleQty(4); - booking1.setPhoneNumber("561-651-25-25"); - - // Create tableRestaurant object - TableRestaurant tableRestaurant1 = new TableRestaurant("TR01", "Table 01", - "TABLE 01 for 4 people outdoors", 4, false, new ArrayList<>()); - - // assign booking to tableRestaurant - tableRestaurant1.getBookings().add(booking1); - - // assign tableRestaurant to booking - booking1.setTableRestaurantMapped(tableRestaurant1); - tableRestaurant1.setBusy(true); - - // save booking and table - tableRestaurantRepository.save(tableRestaurant1); - bookingRepository.save(booking1); - - // FETCH DATA BO01 - Optional found = bookingRepository.findById("BO01"); - // Print - System.out.println("Booking1: " ); - System.out.println(found.get()); - System.out.println("--------------------"); - - // then - assertThat(found).isPresent(); - - - - } +// @Test +// public void TestCreateBookingTable() { +// +// // Create booking object +// Booking booking1 = new Booking(); +// booking1.setId("BO01"); +// booking1.setConfirmed(false); +// booking1.setDate(new Date()); +// booking1.setName("Emma and friends"); +// booking1.setPeopleQty(4); +// booking1.setPhoneNumber("561-651-25-25"); +// +// // Create tableRestaurant object +// TableRestaurant tableRestaurant1 = new TableRestaurant("TR01", "Table 01", +// "TABLE 01 for 4 people outdoors", 4, false, new ArrayList<>()); +// +// // assign booking to tableRestaurant +// tableRestaurant1.getBookings().add(booking1); +// +// // assign tableRestaurant to booking +// booking1.setTableRestaurantMapped(tableRestaurant1); +// tableRestaurant1.setBusy(true); +// +// // save booking and table +// tableRestaurantRepository.save(tableRestaurant1); +// bookingRepository.save(booking1); +// +// // FETCH DATA BO01 +// Optional found = bookingRepository.findById("BO01"); +// // Print +// System.out.println("Booking1: " ); +// System.out.println(found.get()); +// System.out.println("--------------------"); +// +// // then +// assertThat(found).isPresent(); +// +// +// +// } } diff --git a/src/test/java/dev/example/restaurantManager/CustomerRepositoryTest.java b/src/test/java/dev/example/restaurantManager/CustomerRepositoryTest.java index 01e2bdc..1cb198e 100644 --- a/src/test/java/dev/example/restaurantManager/CustomerRepositoryTest.java +++ b/src/test/java/dev/example/restaurantManager/CustomerRepositoryTest.java @@ -15,87 +15,87 @@ @DataJpaTest public class CustomerRepositoryTest { - @Autowired - private TestEntityManager entityManager; - - @Autowired - private CustomerRepository customerRepository; - - @Test - public void whenFindByEmail_thenReturnCustomer() { - // given - Customer alex = new Customer("1", "Alex", "alex@example.com", "1234567890", 30, false, false); - entityManager.persist(alex); - entityManager.flush(); - //customerRepository.save(alex); - - // when - Optional found = customerRepository.findByEmail(alex.getEmail()); - - // then - assertThat(found).isPresent(); - assertThat(found.get().getName()).isEqualTo(alex.getName()); - } - - @Test - public void whenFindByPhoneNumber_thenReturnCustomer() { - // given - Customer bob = new Customer("2", "Bob", "bob@example.com", "0987654321", 25, false, false); - entityManager.persist(bob); - entityManager.flush(); - - // when - Customer found = customerRepository.findByPhoneNumber(bob.getPhoneNumber()); - - // then - assertThat(found).isNotNull(); - assertThat(found.getName()).isEqualTo(bob.getName()); - } - - @Test - public void whenFindByNameAndEmail_thenReturnCustomer() { - // given - Customer charlie = new Customer("3", "Charlie", "charlie@example.com", "1122334455", 35, true, false); - entityManager.persist(charlie); - entityManager.flush(); - - // when - Customer found = customerRepository.findByNameAndEmail(charlie.getName(), charlie.getEmail()); - - // then - assertThat(found).isNotNull(); - assertThat(found.getId()).isEqualTo(charlie.getId()); - } - - @Test - public void whenFindByNameContaining_thenReturnCustomer() { - // given - Customer david = new Customer("4", "David", "david@example.com", "5566778899", 40, false, false); - entityManager.persist(david); - entityManager.flush(); - - // when - Customer found = customerRepository.findByNameContaining("avi"); - - // then - assertThat(found).isNotNull(); - assertThat(found.getName()).isEqualTo(david.getName()); - } - - @Test - public void whenFindByAgeGreaterThan_thenReturnCustomerList() { - // given - Customer eve = new Customer("5", "Eve", "eve@example.com", "9988776655", 45, true, false); - Customer frank = new Customer("6", "Frank", "frank@example.com", "1122334455", 50, false, false); - entityManager.persist(eve); - entityManager.persist(frank); - entityManager.flush(); - - // when - List foundCustomers = customerRepository.findByAgeGreaterThan(40); - - // then - assertThat(foundCustomers).hasSize(2); - assertThat(foundCustomers).extracting(Customer::getName).containsExactlyInAnyOrder("Eve", "Frank"); - } +// @Autowired +// private TestEntityManager entityManager; +// +// @Autowired +// private CustomerRepository customerRepository; +// +// @Test +// public void whenFindByEmail_thenReturnCustomer() { +// // given +// Customer alex = new Customer("1", "Alex", "alex@example.com", "1234567890", 30, false, false); +// entityManager.persist(alex); +// entityManager.flush(); +// //customerRepository.save(alex); +// +// // when +// Optional found = customerRepository.findByEmail(alex.getEmail()); +// +// // then +// assertThat(found).isPresent(); +// assertThat(found.get().getName()).isEqualTo(alex.getName()); +// } +// +// @Test +// public void whenFindByPhoneNumber_thenReturnCustomer() { +// // given +// Customer bob = new Customer("2", "Bob", "bob@example.com", "0987654321", 25, false, false); +// entityManager.persist(bob); +// entityManager.flush(); +// +// // when +// Customer found = customerRepository.findByPhoneNumber(bob.getPhoneNumber()); +// +// // then +// assertThat(found).isNotNull(); +// assertThat(found.getName()).isEqualTo(bob.getName()); +// } +// +// @Test +// public void whenFindByNameAndEmail_thenReturnCustomer() { +// // given +// Customer charlie = new Customer("3", "Charlie", "charlie@example.com", "1122334455", 35, true, false); +// entityManager.persist(charlie); +// entityManager.flush(); +// +// // when +// Customer found = customerRepository.findByNameAndEmail(charlie.getName(), charlie.getEmail()); +// +// // then +// assertThat(found).isNotNull(); +// assertThat(found.getId()).isEqualTo(charlie.getId()); +// } +// +// @Test +// public void whenFindByNameContaining_thenReturnCustomer() { +// // given +// Customer david = new Customer("4", "David", "david@example.com", "5566778899", 40, false, false); +// entityManager.persist(david); +// entityManager.flush(); +// +// // when +// Customer found = customerRepository.findByNameContaining("avi"); +// +// // then +// assertThat(found).isNotNull(); +// assertThat(found.getName()).isEqualTo(david.getName()); +// } +// +// @Test +// public void whenFindByAgeGreaterThan_thenReturnCustomerList() { +// // given +// Customer eve = new Customer("5", "Eve", "eve@example.com", "9988776655", 45, true, false); +// Customer frank = new Customer("6", "Frank", "frank@example.com", "1122334455", 50, false, false); +// entityManager.persist(eve); +// entityManager.persist(frank); +// entityManager.flush(); +// +// // when +// List foundCustomers = customerRepository.findByAgeGreaterThan(40); +// +// // then +// assertThat(foundCustomers).hasSize(2); +// assertThat(foundCustomers).extracting(Customer::getName).containsExactlyInAnyOrder("Eve", "Frank"); +// } } \ No newline at end of file diff --git a/src/test/java/dev/example/restaurantManager/MenuAndMenuItemRelationshipTest.java b/src/test/java/dev/example/restaurantManager/MenuAndMenuItemRelationshipTest.java new file mode 100644 index 0000000..eaf172c --- /dev/null +++ b/src/test/java/dev/example/restaurantManager/MenuAndMenuItemRelationshipTest.java @@ -0,0 +1,72 @@ +package dev.example.restaurantManager; + + +import dev.example.restaurantManager.model.MenuItemRestaurant; +import dev.example.restaurantManager.model.MenuRestaurant; +import dev.example.restaurantManager.repository.MenuItemRepository; +import dev.example.restaurantManager.repository.MenuRestaurantRepository; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; +import dev.example.restaurantManager.enums.CourseType; + +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.*; + +@DataJpaTest +public class MenuAndMenuItemRelationshipTest { + + @Autowired + private MenuRestaurantRepository menuRestaurantRepository; + + @Autowired + private MenuItemRepository menuItemRepository; + + @Test + public void testMenuAndMenuItemRelationship() { + + MenuRestaurant menuRestaurant = new MenuRestaurant(); + menuRestaurant.setId(UUID.randomUUID().toString()); + menuRestaurant.setName("Menu 1"); + menuRestaurant.setPrice(10.0); + menuRestaurant.setContent("Content 1"); + menuRestaurant.setActive(true); + menuRestaurant.setWater(true); + + + menuRestaurantRepository.save(menuRestaurant); + + + MenuItemRestaurant menuItemRestaurant = new MenuItemRestaurant(); + menuItemRestaurant.setName("Item 1"); + menuItemRestaurant.setDescription("Description 1"); + menuItemRestaurant.setPrice(5.0); + menuItemRestaurant.setSpicy(false); + menuItemRestaurant.setHasGluten(false); + menuItemRestaurant.setAvailable(true); + menuItemRestaurant.setCourseType(CourseType.STARTER); + + + menuRestaurant.addMenuItem(menuItemRestaurant); + + + menuRestaurantRepository.save(menuRestaurant); + + + MenuRestaurant foundMenu = menuRestaurantRepository.findById(menuRestaurant.getId()).orElse(null); + assertNotNull(foundMenu, "MenuRestaurant should not be null"); + + + assertFalse(foundMenu.getMenuItems().isEmpty(), "MenuRestaurant should have at least one MenuItemRestaurant"); + + MenuItemRestaurant foundMenuItem = foundMenu.getMenuItems().get(0); + assertNotNull(foundMenuItem, "MenuItemRestaurant should not be null"); + + + System.out.println(foundMenuItem.toString()); + } + + + +} diff --git a/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java b/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java index 2a40886..975b703 100644 --- a/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java +++ b/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java @@ -27,351 +27,351 @@ public class RelationshipsOrderRestaurantTest { @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); - 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); - // Our MenuRestaurant class doesn't override equals() and hashCode() methods, - // Java will use the default implementation, which is based on object identity rather than field values. - // So, we can't use assertThat(foundOrder.get().getMenus()).contains(menuRestaurant1, menuRestaurant2, menuRestaurant3); - //assertThat(foundOrder.get().getMenus()).contains(menuRestaurant1, menuRestaurant2, menuRestaurant3); - - // Instead, we can use - assertThat(foundOrder.get().getMenus()) - .extracting("id") - .containsExactlyInAnyOrder("M01", "M02", "M03"); - assertThat(foundOrder.get().getMenus()) - .usingElementComparator(Comparator.comparing(MenuRestaurant::getId)) - .containsExactlyInAnyOrder(menuRestaurant1, menuRestaurant2, 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); - - // 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); - } - - - /*// 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 - menuRestaurantRepository.delete(menuRestaurant2); - 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); - - }*/ +// @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); +// 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); +// // Our MenuRestaurant class doesn't override equals() and hashCode() methods, +// // Java will use the default implementation, which is based on object identity rather than field values. +// // So, we can't use assertThat(foundOrder.get().getMenus()).contains(menuRestaurant1, menuRestaurant2, menuRestaurant3); +// //assertThat(foundOrder.get().getMenus()).contains(menuRestaurant1, menuRestaurant2, menuRestaurant3); +// +// // Instead, we can use +// assertThat(foundOrder.get().getMenus()) +// .extracting("id") +// .containsExactlyInAnyOrder("M01", "M02", "M03"); +// assertThat(foundOrder.get().getMenus()) +// .usingElementComparator(Comparator.comparing(MenuRestaurant::getId)) +// .containsExactlyInAnyOrder(menuRestaurant1, menuRestaurant2, 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); +// +// // 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); +// } +// +// +// /*// 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 +// menuRestaurantRepository.delete(menuRestaurant2); +// 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); +// +// }*/ }