From 533e770d1ab83c5c38f2571b3abe313846bab6bf Mon Sep 17 00:00:00 2001 From: isaac Date: Tue, 5 Nov 2024 07:31:05 +0100 Subject: [PATCH 01/11] Practica 3: almost done. check last details. --- .../controller/EatInOrderController.java | 88 ++++++++++++++++++ .../controller/MenuController.java | 89 ++++++++++++++++++ .../controller/MenuItemController.java | 93 +++++++++++++++++++ .../controller/TableRestaurantController.java | 82 ++++++++++++++++ .../restaurantManager/model/CourseEnum.java | 9 ++ .../model/EatInOrderRestaurant.java | 21 +++-- .../restaurantManager/model/MenuItem.java | 77 +++++++++++++++ .../model/MenuRestaurant.java | 54 +++++++++-- .../model/TableRestaurant.java | 42 +++++++-- .../repository/EatInRepository.java | 9 ++ .../repository/MenuItemRepository.java | 9 ++ .../repository/TableRestaurantRepository.java | 5 + .../service/EatInService.java | 15 +++ .../service/EatInServiceImpl.java | 65 +++++++++++++ .../service/MenuItemService.java | 18 ++++ .../service/MenuItemServiceImpl.java | 90 ++++++++++++++++++ .../service/TableRestaurantService.java | 15 +++ .../service/TableRestaurantServiceImpl.java | 67 +++++++++++++ .../utilities/MenuRestaurantDataLoader.java | 46 +++++++++ .../utilities/TableRestaurantDataLoader.java | 47 ++++++++++ .../example/restaurantManager/EatInTest.java | 66 +++++++++++++ .../restaurantManager/MenuMenuItemTest.java | 53 +++++++++++ 22 files changed, 1039 insertions(+), 21 deletions(-) create mode 100644 src/main/java/dev/example/restaurantManager/controller/EatInOrderController.java create mode 100644 src/main/java/dev/example/restaurantManager/controller/MenuController.java create mode 100644 src/main/java/dev/example/restaurantManager/controller/MenuItemController.java create mode 100644 src/main/java/dev/example/restaurantManager/controller/TableRestaurantController.java create mode 100644 src/main/java/dev/example/restaurantManager/model/CourseEnum.java create mode 100644 src/main/java/dev/example/restaurantManager/model/MenuItem.java create mode 100644 src/main/java/dev/example/restaurantManager/repository/EatInRepository.java create mode 100644 src/main/java/dev/example/restaurantManager/repository/MenuItemRepository.java create mode 100644 src/main/java/dev/example/restaurantManager/service/EatInService.java create mode 100644 src/main/java/dev/example/restaurantManager/service/EatInServiceImpl.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/TableRestaurantService.java create mode 100644 src/main/java/dev/example/restaurantManager/service/TableRestaurantServiceImpl.java create mode 100644 src/main/java/dev/example/restaurantManager/utilities/MenuRestaurantDataLoader.java create mode 100644 src/main/java/dev/example/restaurantManager/utilities/TableRestaurantDataLoader.java create mode 100644 src/test/java/dev/example/restaurantManager/EatInTest.java create mode 100644 src/test/java/dev/example/restaurantManager/MenuMenuItemTest.java diff --git a/src/main/java/dev/example/restaurantManager/controller/EatInOrderController.java b/src/main/java/dev/example/restaurantManager/controller/EatInOrderController.java new file mode 100644 index 0000000..46d73e2 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/controller/EatInOrderController.java @@ -0,0 +1,88 @@ +package dev.example.restaurantManager.controller; + + +import dev.example.restaurantManager.model.EatInOrderRestaurant; +import dev.example.restaurantManager.service.EatInService; +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/eatinorder") +@RestController +public class EatInOrderController { + + @Autowired + private EatInService eatInService; + + //manage request by ResponseEntity with all EatInOrder + @GetMapping("/alleatinorders") + + public ResponseEntity> getAllEatInOrders(){ + List eatinorders = eatInService.getAllEatInOrders(); + HttpHeaders headers = getCommonHeaders("Get alls Eat In Restaurant Orders"); + return eatinorders !=null && !eatinorders.isEmpty() + ? new ResponseEntity<>(eatinorders,headers, HttpStatus.OK) + : new ResponseEntity<>(headers,HttpStatus.NOT_FOUND); + } + + @PostMapping + + public ResponseEntity createEatInOrder(@RequestBody EatInOrderRestaurant eatinorder) { + EatInOrderRestaurant createdEatInOrder = eatInService.createEatInOrders(eatinorder); + HttpHeaders headers = getCommonHeaders("Create Eat In Order Restaurant"); + return createdEatInOrder !=null + ?new ResponseEntity<>(createdEatInOrder, headers, HttpStatus.CREATED) + : new ResponseEntity<>(headers,HttpStatus.BAD_REQUEST); + } + + @PutMapping("/{id}") + + public ResponseEntity updateEatInOrder(@PathVariable String id, @RequestBody EatInOrderRestaurant eatInOrderDetails){ + EatInOrderRestaurant updatedEatInOrder = eatInService.updateEatInOrders(id, eatInOrderDetails); + HttpHeaders headers = getCommonHeaders("Update Eat In Restaurant Order"); + return updatedEatInOrder != null + ? new ResponseEntity<>(updatedEatInOrder,headers,HttpStatus.OK) + : new ResponseEntity<>(headers,HttpStatus.NOT_FOUND); + } + + @DeleteMapping("/{id}") + public ResponseEntity deleteEatInOrder(@PathVariable String id){ + boolean deleted = eatInService.deleteEatInOrders(id); + HttpHeaders headers = getCommonHeaders("Delete Eat In Order Restaurant"); + return deleted + ?new ResponseEntity<>(headers,HttpStatus.NO_CONTENT) + : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + + } + + @GetMapping("{id}") + public ResponseEntity getEatInOrderById(@PathVariable String id){ + EatInOrderRestaurant eatinorder = eatInService.getEatInOrdersById(id); + HttpHeaders headers = getCommonHeaders("Get a Eat In Order by ID"); + return eatinorder !=null + ? new ResponseEntity<>(eatinorder, 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("eatInOrders-count",String.valueOf(eatInService.countEatInOrders())); + headers.add("object", "EatInOrders"); + return headers; + } + +} diff --git a/src/main/java/dev/example/restaurantManager/controller/MenuController.java b/src/main/java/dev/example/restaurantManager/controller/MenuController.java new file mode 100644 index 0000000..2c9217a --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/controller/MenuController.java @@ -0,0 +1,89 @@ +package dev.example.restaurantManager.controller; + + +import dev.example.restaurantManager.model.MenuRestaurant; +import dev.example.restaurantManager.service.MenuService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; + +import java.util.Date; +import java.util.List; + +@RequestMapping("/api/v1/menu") +@RestController +public class MenuController { + + + @Autowired + private MenuService menuService; + + @GetMapping("/allMenus") + public ResponseEntity> getAllMenus(){ + List menus = menuService.getAllMenus(); + HttpHeaders headers1 = getCommonHeaders("get all menus"); + return menus !=null && !menus.isEmpty() + ? new ResponseEntity<>(menus, headers1, HttpStatus.OK) + : new ResponseEntity<>(headers1, HttpStatus.NOT_FOUND); + } + + @PostMapping + public ResponseEntity createMenu(@RequestBody MenuRestaurant menu) { + MenuRestaurant createdMenu = menuService.createMenu(menu); + HttpHeaders headers1 = getCommonHeaders("Create new menu"); + + return createdMenu !=null + ? new ResponseEntity<>(createdMenu, headers1,HttpStatus.CREATED) + : new ResponseEntity<>(headers1,HttpStatus.BAD_REQUEST); + } + + @PutMapping("{id}") + public ResponseEntity updateMenu(@PathVariable String id, @RequestBody MenuRestaurant menuDetails){ + MenuRestaurant updatedMenu = menuService.updateMenu(id, menuDetails); + HttpHeaders headers = getCommonHeaders("Update menu"); + + + return updatedMenu !=null + ? new ResponseEntity<>(updatedMenu,headers,HttpStatus.OK) + : new ResponseEntity<>(headers,HttpStatus.NOT_FOUND); + + } + + @DeleteMapping("{id}") + public ResponseEntity deleteMenu(@PathVariable String id){ + boolean deleted = menuService.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("/{id}") + public ResponseEntity getMenuById(@PathVariable String id) { + MenuRestaurant menu = menuService.getMenuById(id); + HttpHeaders headers = getCommonHeaders("Get a Menu by Id"); + + return menu != null + ? new ResponseEntity<>(menu, headers, HttpStatus.OK) + : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + } + + + private HttpHeaders getCommonHeaders(String description) { + HttpHeaders headers1 = new HttpHeaders(); + headers1.add("desc", description); + headers1.add("content-type", "application/json"); + headers1.add("date", new Date().toString()); + headers1.add("server", "H2 Database"); + headers1.add("version", "1.0.0"); + headers1.add("menus-count", String.valueOf(menuService.countMenus())); + headers1.add("object", "menus"); + return headers1; + } + +} \ No newline at end of file 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..02414be --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/controller/MenuItemController.java @@ -0,0 +1,93 @@ +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; + +@RestController +@RequestMapping("/api/v1/menu-items") +public class MenuItemController { + + @Autowired + private MenuItemService menuItemService; + + // Obtener todos los MenuItems + @GetMapping("/all-menu-items") + public ResponseEntity> getAllMenuItems() { + List menuItems = menuItemService.getAllMenuItems(); + HttpHeaders headers = getCommonHeaders("Get alls menus"); + return menuItems != null && !menuItems.isEmpty() + ? new ResponseEntity<>(menuItems,headers, HttpStatus.OK) + : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + } + + // Crear un nuevo MenuItem + @PostMapping + 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); + + } + + // Actualizar un MenuItem existente + @PutMapping("/{id}") + public ResponseEntity updateMenuItem(@PathVariable String id, @RequestBody MenuItem menuItemDetails) { + MenuItem updatedMenuItem = menuItemService.updateMenuItem(id, menuItemDetails); + HttpHeaders headers = getCommonHeaders("Update menu-item"); + return updatedMenuItem != null + ? new ResponseEntity<>(updatedMenuItem,headers,HttpStatus.OK) + : new ResponseEntity<>(headers,HttpStatus.NOT_FOUND); + } + + // Eliminar un MenuItem + @DeleteMapping("/{id}") + public ResponseEntity deleteMenuItem(@PathVariable String id) { + boolean deleted = menuItemService.deleteMenuItem(id); + HttpHeaders headers = getCommonHeaders("Delete a menu-item"); + return deleted + ? new ResponseEntity<>(headers,HttpStatus.NO_CONTENT) + : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + } + + // encuentra un menu-item por la id + @GetMapping("/{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); + } + + // Obtener todos los MenuItems de un Menu específico + @GetMapping("/menu/{menuId}/items") + public ResponseEntity> getMenuItemsByMenuId(@PathVariable String menuId) { + List menuItems = menuItemService.getMenuItemsByMenuId(menuId); + HttpHeaders headers = getCommonHeaders("Get all menu-items for a specific menu"); + return menuItems != null && !menuItems.isEmpty() + ? new ResponseEntity<>(menuItems, 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_items-count", String.valueOf(menuItemService.countMenuItems())); + headers.add("object", "menu-items"); + return headers; + } +} \ No newline at end of file diff --git a/src/main/java/dev/example/restaurantManager/controller/TableRestaurantController.java b/src/main/java/dev/example/restaurantManager/controller/TableRestaurantController.java new file mode 100644 index 0000000..4bbe985 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/controller/TableRestaurantController.java @@ -0,0 +1,82 @@ +package dev.example.restaurantManager.controller; + + +import dev.example.restaurantManager.model.RestaurantTable; +import dev.example.restaurantManager.service.TableService; +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/table") +@RestController +public class TableRestaurantController { + + @Autowired + private TableService tableService; + + @GetMapping("/allTables") + public ResponseEntity>getAllTables(){ + List tables = tableService.getAllTables(); + HttpHeaders headers = getCommonHeaders("Get all tables"); + return tables != null && !tables.isEmpty() + ? new ResponseEntity<>(tables, headers, HttpStatus.OK) + : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + } + + @PostMapping + public ResponseEntity createTable(@RequestBody RestaurantTable table){ + RestaurantTable createdTable = tableService.createTable(table); + HttpHeaders headers = getCommonHeaders("Create a new table"); + + return createdTable !=null + ? new ResponseEntity<>(createdTable, headers,HttpStatus.CREATED) + : new ResponseEntity<>(headers, HttpStatus.BAD_REQUEST); + + } + + @PutMapping("/{name}") + public ResponseEntity updateTable(@PathVariable String name, @RequestBody RestaurantTable tableDetails) { + RestaurantTable updatedTable = tableService.updateTable(name, tableDetails); + HttpHeaders headers = getCommonHeaders("Update a table"); + return updatedTable != null + ? new ResponseEntity<>(updatedTable, headers, HttpStatus.OK) + : new ResponseEntity<>(headers,HttpStatus.NOT_FOUND); + } + + // Eliminar una mesa + @DeleteMapping("/{name}") + public ResponseEntity deleteTable(@PathVariable String name) { + boolean deleted = tableService.deleteTable(name); + HttpHeaders headers = getCommonHeaders("Delete a table"); + return deleted + ? new ResponseEntity<>(headers,HttpStatus.NO_CONTENT) + : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + } + + @GetMapping("/{name}") + public ResponseEntity getTableByName(@PathVariable String name){ + RestaurantTable table = tableService.getTableByName(name); + HttpHeaders headers = getCommonHeaders("Get a table by name"); + + return table != null + ? new ResponseEntity<>(table,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("tables-count", String.valueOf(tableService.countTables())); + headers.add("object", "tables"); + return headers; + } +} \ No newline at end of file diff --git a/src/main/java/dev/example/restaurantManager/model/CourseEnum.java b/src/main/java/dev/example/restaurantManager/model/CourseEnum.java new file mode 100644 index 0000000..471203a --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/model/CourseEnum.java @@ -0,0 +1,9 @@ +package dev.example.restaurantManager.model; + +public enum CourseEnum { + + 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 2461711..0fe6e15 100644 --- a/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java @@ -1,32 +1,41 @@ package dev.example.restaurantManager.model; +import com.fasterxml.jackson.annotation.JsonIgnore; +import jakarta.persistence.*; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; + import java.util.ArrayList; import java.util.Date; -import java.util.stream.Collectors; @Data @AllArgsConstructor @NoArgsConstructor +@Entity public class EatInOrderRestaurant extends OrderRestaurant { - private ArrayList tableRestaurants = new ArrayList<>(); - //private TableRestaurant orderedTableRestaurant; + + //Relation with RestaurantTable Many to One + @ManyToOne(fetch = FetchType.LAZY) + @JoinColumn(name = "TABLE_EATIN_FK_ID") + @JsonIgnore + //private ArrayList tableRestaurants = new ArrayList<>(); + private TableRestaurant orderedTableRestaurant; + public EatInOrderRestaurant(String id, Date date, String waiter, int peopleQty, double totalPayment, boolean paid, ArrayList menus, - ArrayList tableRestaurants) { + TableRestaurant orderedTableRestaurant) { super(id, date, waiter, peopleQty, totalPayment, paid, menus); - this.tableRestaurants = tableRestaurants; + this.orderedTableRestaurant = orderedTableRestaurant; } @Override public String toString() { return super.toString() + "\n" + "Type: Eat In\n" + - "Tables: " + tableRestaurants.stream().map(TableRestaurant::getName).collect(Collectors.joining(", ")); + "Tables: " + (orderedTableRestaurant != null ? orderedTableRestaurant.getName() : "No table assigned"); } } 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..4f2042c --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/model/MenuItem.java @@ -0,0 +1,77 @@ +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; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; + +@Data +@AllArgsConstructor +@NoArgsConstructor +@Entity +public class MenuItem { + + @Id + private String id; + + private String name; + private String description; + private boolean isSpicy; + private boolean hasGluten; + private boolean isAvailable; + + @Enumerated(EnumType.STRING) + private CourseEnum courseType; + + @ManyToMany(mappedBy = "menuItems", fetch = FetchType.LAZY) + @JsonIgnore + private List menus = new ArrayList<>(); + + public boolean hasGluten() { + return hasGluten; + } + + // method para agregar un MenuRestaurant a un MenuItem + public void addMenu(MenuRestaurant menuRestaurant) { + this.getMenus().add(menuRestaurant); + if (!menuRestaurant.getMenuItems().contains(this)) { + menuRestaurant.getMenuItems().add(this); + } + } + @Override + public String toString() { + return "MenuItem{" + + "id='" + id + '\'' + + ", name='" + name + '\'' + + ", description='" + description + '\'' + + ", isSpicy=" + isSpicy + + ", hasGluten=" + hasGluten + + ", isAvailable=" + isAvailable + + ", courseType=" + courseType + + '}'; + } + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (!(o instanceof MenuItem)) return false; + MenuItem that = (MenuItem) o; + return isSpicy == that.isSpicy && + hasGluten == that.hasGluten && + isAvailable == that.isAvailable && + Objects.equals(id, that.id) && + Objects.equals(name, that.name) && + Objects.equals(description, that.description) && + 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 1d2d819..f9d1727 100644 --- a/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java @@ -1,20 +1,20 @@ package dev.example.restaurantManager.model; -import jakarta.persistence.Entity; -import jakarta.persistence.FetchType; -import jakarta.persistence.Id; -import jakarta.persistence.ManyToMany; +import com.fasterxml.jackson.annotation.JsonIgnore; +import jakarta.persistence.*; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; + import java.util.ArrayList; import java.util.List; +import java.util.Objects; @Data @AllArgsConstructor @NoArgsConstructor @Entity -public class MenuRestaurant { +public class MenuRestaurant { @Id private String id; @@ -24,16 +24,36 @@ public class MenuRestaurant { private boolean active; private boolean water; + + @ManyToMany(fetch = FetchType.LAZY) + @JsonIgnore + @JoinTable( + name = "menu_menuItem", + joinColumns = @JoinColumn(name = "menu_id"), + inverseJoinColumns = @JoinColumn(name = "menuItem_id") + ) + private List menuItems = new ArrayList<>(); + @ManyToMany(mappedBy = "menus", fetch = FetchType.LAZY) private List orders = new ArrayList<>(); - public MenuRestaurant(String id, String name, Double price, String content, boolean active, boolean water) { + + public MenuRestaurant(String id, String name, Double price, String content, boolean active, boolean water, List menuItems) { this.id = id; this.name = name; this.price = price; this.content = content; this.active = active; this.water = water; + this.menuItems = menuItems != null ? new ArrayList<>(menuItems) : new ArrayList<>(); + } + + // Method para agregar un MenuItem a un MenuRestaurant + public void addMenuItem(MenuItem menuItem) { + this.getMenuItems().add(menuItem); + if (!menuItem.getMenus().contains(this)) { + menuItem.getMenus().add(this); + } } //We might want to exclude 'orders' from toString() to avoid circular references @@ -46,10 +66,26 @@ public String toString() { ", content='" + content + '\'' + ", active=" + active + ", water=" + water + - ", ordersCount=" + (orders != null ? orders.size() : 0) + - ", orders=" + orders + + ", menuItems=" + menuItems + // Agregando la lista de items '}'; } -} + @Override + public boolean equals(Object o) { + if (this == o) return true; // Compara la referencia + if (!(o instanceof MenuRestaurant)) return false; // Comprueba si el objeto es del mismo tipo + MenuRestaurant that = (MenuRestaurant) o; // Cast al objeto de comparación + 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); // Compara todos los atributos relevantes + } + + @Override + public int hashCode() { + return Objects.hash(id, name, price, content, active, water); // Genera un hashcode basado en los mismos atributos + } +} \ No newline at end of file diff --git a/src/main/java/dev/example/restaurantManager/model/TableRestaurant.java b/src/main/java/dev/example/restaurantManager/model/TableRestaurant.java index bc13e0a..686e80f 100644 --- a/src/main/java/dev/example/restaurantManager/model/TableRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/TableRestaurant.java @@ -1,12 +1,10 @@ package dev.example.restaurantManager.model; -import jakarta.persistence.CascadeType; -import jakarta.persistence.Entity; -import jakarta.persistence.Id; -import jakarta.persistence.OneToMany; +import jakarta.persistence.*; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; + import java.util.ArrayList; @Data @@ -22,16 +20,48 @@ public class TableRestaurant { private int qty; private boolean busy; + // One table can have many bookings @OneToMany(mappedBy = "tableRestaurantMapped", cascade = CascadeType.ALL) private ArrayList bookings ; + // One table can have many eat-in orders + @OneToMany(mappedBy = "orderedTableRestaurant", cascade = CascadeType.ALL) + private ArrayList eatInOrders; + + //Constructor with eatinorders + + public TableRestaurant(String id, String name, String description, int qty, boolean busy, ArrayList eatInOrders) { + this.id = id; + this.name = name; + this.description = description; + this.qty = qty; + this.busy = busy; + this.eatInOrders = eatInOrders; + } + // we must create a VERY CONCRETE constructor to RUN the OLD tests - public TableRestaurant(String name, String description , int qty, boolean busy) { + public TableRestaurant(String name, String description , int qty, boolean busy) { + this.name = name; + this.description = description; + this.qty = qty; + this.busy = busy; } + // Méthod tu add orders + + public void addEatInOrder(EatInOrderRestaurant order) { + this.getEatInOrders().add(order); // Agregar la orden a la lista de órdenes + if (order.getOrderedTableRestaurant() != null) { + order.getOrderedTableRestaurant().getEatInOrders().remove(order); // Eliminar de la relación inversa si ya está asignada + } + order.setOrderedTableRestaurant(this); // Establecer la mesa como la mesa ordenada en la orden + } + + + - //method to add + //method to add bookings public void addBooking(Booking booking) { this.getBookings().add(booking); if (booking.getTableRestaurantMapped() != null) booking.getTableRestaurantMapped().getBookings().remove(booking); diff --git a/src/main/java/dev/example/restaurantManager/repository/EatInRepository.java b/src/main/java/dev/example/restaurantManager/repository/EatInRepository.java new file mode 100644 index 0000000..8d0aa74 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/repository/EatInRepository.java @@ -0,0 +1,9 @@ +package dev.example.restaurantManager.repository; + +import dev.example.restaurantManager.model.EatInOrderRestaurant; +import org.springframework.data.jpa.repository.JpaRepository; + +import java.util.Optional; + +public interface EatInRepository extends JpaRepository { +} \ No newline at end of file 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..605a2ab --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/repository/MenuItemRepository.java @@ -0,0 +1,9 @@ +package dev.example.restaurantManager.repository; + +import dev.example.restaurantManager.model.MenuItem; +import org.springframework.data.jpa.repository.JpaRepository; + +public interface MenuItemRepository extends JpaRepository { + + +} \ No newline at end of file diff --git a/src/main/java/dev/example/restaurantManager/repository/TableRestaurantRepository.java b/src/main/java/dev/example/restaurantManager/repository/TableRestaurantRepository.java index f789c82..b1561c2 100644 --- a/src/main/java/dev/example/restaurantManager/repository/TableRestaurantRepository.java +++ b/src/main/java/dev/example/restaurantManager/repository/TableRestaurantRepository.java @@ -5,5 +5,10 @@ import dev.example.restaurantManager.model.TableRestaurant; import org.springframework.data.jpa.repository.JpaRepository; +import java.util.Optional; + public interface TableRestaurantRepository extends JpaRepository { + + Optional findByName(String name); + } diff --git a/src/main/java/dev/example/restaurantManager/service/EatInService.java b/src/main/java/dev/example/restaurantManager/service/EatInService.java new file mode 100644 index 0000000..0ee9544 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/EatInService.java @@ -0,0 +1,15 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.EatInOrderRestaurant; + +import java.util.List; + +public interface EatInService { + + List getAllEatInOrders(); + EatInOrderRestaurant createEatInOrders(EatInOrderRestaurant EatInOrderRestaurant); + EatInOrderRestaurant getEatInOrdersById(String id); + EatInOrderRestaurant updateEatInOrders(String id,EatInOrderRestaurant eatInOrderDetails); + boolean deleteEatInOrders(String id); + long countEatInOrders(); +} \ No newline at end of file diff --git a/src/main/java/dev/example/restaurantManager/service/EatInServiceImpl.java b/src/main/java/dev/example/restaurantManager/service/EatInServiceImpl.java new file mode 100644 index 0000000..444aaed --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/EatInServiceImpl.java @@ -0,0 +1,65 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.EatInOrderRestaurant; +import dev.example.restaurantManager.repository.EatInRepository; +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 EatInServiceImpl implements EatInService { + + @Autowired + private EatInRepository eatInRepository; + + @Override + public List getAllEatInOrders(){ + return eatInRepository.findAll(); + } + @Override + public EatInOrderRestaurant createEatInOrders(EatInOrderRestaurant EatInOrderRestaurant){ + EatInOrderRestaurant.setId(UUID.randomUUID().toString()); + return eatInRepository.save(EatInOrderRestaurant); + } + + @Override + public EatInOrderRestaurant getEatInOrdersById(String id){ + + return eatInRepository.findById(id).orElse(null); + + } + @Override + public EatInOrderRestaurant updateEatInOrders(String id, EatInOrderRestaurant eatInOrderDetails) { + Optional optionalOrder = eatInRepository.findById(id); + if (optionalOrder.isPresent()) { + EatInOrderRestaurant existingOrder = optionalOrder.get(); + + // update + existingOrder.setPeopleQty(eatInOrderDetails.getPeopleQty()); + existingOrder.setTotalPayment(eatInOrderDetails.getTotalPayment()); + existingOrder.setPaid(eatInOrderDetails.isPaid()); + + + return eatInRepository.save(existingOrder); + } + return null; // si no hay orden + + } + @Override + public boolean deleteEatInOrders(String id){ + eatInRepository.deleteById(id); + Optional eatInOrderRestaurant = eatInRepository.findById(id); + return eatInOrderRestaurant.isEmpty() + ? false + : true; + } + @Override + public long countEatInOrders(){ + return eatInRepository.count(); + } + + +} \ No newline at end of file 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..6b25bf8 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/MenuItemService.java @@ -0,0 +1,18 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.Customer; +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..63961ab --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/MenuItemServiceImpl.java @@ -0,0 +1,90 @@ +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; +import java.util.UUID; + +@Service +public class MenuItemServiceImpl implements MenuItemService { + + @Autowired + MenuItemRepository menuItemRepository; + @Autowired + MenuRestaurantRepository menuRepository; + + @Override + public List getMenuItemsByMenuId(String menuId) { + MenuRestaurant menu = menuRepository.findById(menuId).orElse(null); + return menu != null ? menu.getMenuItems() : new ArrayList<>(); + } + + + @Override + + public List getAllMenuItems(){ + return menuItemRepository.findAll(); + } + + @Override + + public MenuItem createMenuItem(MenuItem menuItem){ + menuItem.setId(UUID.randomUUID().toString()); + return menuItemRepository.save(menuItem); + } + + 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()); + } + menuItem.setSpicy(menuItemDetails.isSpicy()); + menuItem.setHasGluten(menuItemDetails.hasGluten()); + menuItem.setAvailable(menuItemDetails.isAvailable()); + + + if (menuItemDetails.getCourseType() != null) { + menuItem.setCourseType(menuItemDetails.getCourseType()); + } + + 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(); + } + + + +} + + diff --git a/src/main/java/dev/example/restaurantManager/service/TableRestaurantService.java b/src/main/java/dev/example/restaurantManager/service/TableRestaurantService.java new file mode 100644 index 0000000..d208987 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/TableRestaurantService.java @@ -0,0 +1,15 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.TableRestaurant; + +import java.util.List; + +public interface TableRestaurantService { + + List getAllTables(); + TableRestaurant createTable(TableRestaurant table); + TableRestaurant getTableByName (String name); + TableRestaurant updateTable (String name, TableRestaurant tableDetails); + boolean deleteTable(String name); + long countTables(); +} \ No newline at end of file diff --git a/src/main/java/dev/example/restaurantManager/service/TableRestaurantServiceImpl.java b/src/main/java/dev/example/restaurantManager/service/TableRestaurantServiceImpl.java new file mode 100644 index 0000000..434f26a --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/TableRestaurantServiceImpl.java @@ -0,0 +1,67 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.TableRestaurant; +import dev.example.restaurantManager.repository.TableRestaurantRepository; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.util.List; + +@Service +public class TableRestaurantServiceImpl implements TableRestaurantService { + + @Autowired + private TableRestaurantRepository tableRepository; + @Override + public List getAllTables(){return tableRepository.findAll();} + @Override + public TableRestaurant createTable(TableRestaurant table){ + if(table.getName() == null || table.getName().isEmpty()){ + table.setName("Default Table name"); + } + return tableRepository.save(table); + } + @Override + public TableRestaurant getTableByName(String name) { + return tableRepository.findByName(name).orElse(null); + + } + @Override + public TableRestaurant updateTable(String name, TableRestaurant tableDetails){ + TableRestaurant table = tableRepository.findByName(name).orElse(null); + if (table == null){ + return null; + } + if(tableDetails.getName()!=null) { + table.setName(tableDetails.getName()); + } + + if(tableDetails.getDescription()!=null) { + table.setDescription(tableDetails.getDescription()); + } + if(tableDetails.getQty()>0) { + table.setQty(tableDetails.getQty()); + } + + table.setBusy(tableDetails.isBusy()); + + return tableRepository.save(table); + + } + + @Override + public boolean deleteTable (String name){ + + TableRestaurant table = tableRepository.findByName(name).orElse(null); + if(table == null){ + return false; + } + tableRepository.delete(table); + return true; + } + + @Override + public long countTables(){return tableRepository.count();} + + +} \ No newline at end of file diff --git a/src/main/java/dev/example/restaurantManager/utilities/MenuRestaurantDataLoader.java b/src/main/java/dev/example/restaurantManager/utilities/MenuRestaurantDataLoader.java new file mode 100644 index 0000000..6e195fe --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/utilities/MenuRestaurantDataLoader.java @@ -0,0 +1,46 @@ +package dev.example.restaurantManager.utilities; + +import com.github.javafaker.Faker; +import dev.example.restaurantManager.model.MenuRestaurant; +import dev.example.restaurantManager.repository.MenuRestaurantRepository; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; + +import java.util.Locale; +import java.util.Random; +import java.util.UUID; + +@Component +public class MenuRestaurantDataLoader { + + @Autowired + private MenuRestaurantRepository menuRepository; + + public void createFakeMenus(){ + if(menuRepository.count()==0){ + System.out.println("o records at the database found"); + Faker faker = new Faker(new Locale("en-US")); + Random random = new Random(); + String[]menuNames = {"Day Menu", "Night Menu", "Weekend Menu", + "Vegetarian Menu", "Kids Menu", "Gourmet Menu" + }; + int qty = 50; + + for(int i = 0; i< qty ;i++){ + MenuRestaurant menu = new MenuRestaurant(); + menu.setId(UUID.randomUUID().toString()); + String menuName = menuNames[random.nextInt(menuNames.length)]; + menu.setName(menuName); + menu.setPrice(faker.number().randomDouble(2,5,100)); + menu.setContent(faker.food().dish()); + menu.setActive(faker.bool().bool()); + menu.setWater(faker.bool().bool()); + + menuRepository.save(menu); + } + + System.out.println(qty + " fake menus have been created and saved to the database"); + + } + } +} diff --git a/src/main/java/dev/example/restaurantManager/utilities/TableRestaurantDataLoader.java b/src/main/java/dev/example/restaurantManager/utilities/TableRestaurantDataLoader.java new file mode 100644 index 0000000..a5a3596 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/utilities/TableRestaurantDataLoader.java @@ -0,0 +1,47 @@ +package dev.example.restaurantManager.utilities; + +import com.github.javafaker.Faker; +import dev.example.restaurantManager.model.TableRestaurant; +import dev.example.restaurantManager.repository.TableRestaurantRepository; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; + +import java.util.Locale; +import java.util.UUID; + +@Component +public class TableRestaurantDataLoader { + + @Autowired + private TableRestaurantRepository tableRepository; + + public void createFakeTables(){ + + // Check if the database is empty + if (tableRepository.count() == 0) { + System.out.println(" 0 records at the database found"); + Faker faker = new Faker(new Locale("en-US")); + + int qty = 50; + // Create and save 100 fake customers + for (int i = 0; i < qty; i++) { + TableRestaurant table = new TableRestaurant(); + + // Using Faker to generate fake data + table.setId(UUID.randomUUID().toString()); + table.setName("Table " + (i + 1)); + table.setDescription(faker.lorem().sentence()); + table.setQty(faker.number().numberBetween(1, 10)); + table.setBusy(faker.bool().bool()); // + + + + tableRepository.save(table); + } + + System.out.println(qty + " fake tables have been created and saved to the database."); + } + } + + +} \ No newline at end of file diff --git a/src/test/java/dev/example/restaurantManager/EatInTest.java b/src/test/java/dev/example/restaurantManager/EatInTest.java new file mode 100644 index 0000000..751d1a0 --- /dev/null +++ b/src/test/java/dev/example/restaurantManager/EatInTest.java @@ -0,0 +1,66 @@ +package dev.example.restaurantManager; + + +import dev.example.restaurantManager.model.EatInOrderRestaurant; +import dev.example.restaurantManager.model.TableRestaurant; +import dev.example.restaurantManager.repository.EatInRepository; +import dev.example.restaurantManager.repository.TableRestaurantRepository; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; +import static org.assertj.core.api.Assertions.assertThat; + + +import java.util.ArrayList; +import java.util.Date; +import java.util.Optional; + +@DataJpaTest +public class EatInTest { + + @Autowired + private EatInRepository eatInRepository; + @Autowired + private TableRestaurantRepository tableRepository; + + @Test + public void TestCreateEatIn(){ + + //Create Table + + TableRestaurant table1 = new TableRestaurant("T01", "Redonda","Mesa pequeña y redonda" , 4,false, new ArrayList<>()); + TableRestaurant table2 = new TableRestaurant("T02", "Cuadrada","Mesa pequeña y cuadrada" ,6,false, new ArrayList<>()); + TableRestaurant table3 = new TableRestaurant("T03", "Rectangular","Mesa grande y rectangular" ,10,false, new ArrayList<>()); + + tableRepository.save(table1); + tableRepository.save(table2); + tableRepository.save(table3); + //create EainOrder + + EatInOrderRestaurant order1 = new EatInOrderRestaurant(); + order1.setId("O001"); + order1.setDate(new Date()); + order1.setWaiter("John Doe"); + order1.setPeopleQty(4); + order1.setTotalPayment(100.50); + order1.setPaid(true); + order1.setOrderedTableRestaurant(table1); + + // Asignar la orden a la mesa + table1.getEatInOrders().add(order1); + + // Guardar mesa y orden + eatInRepository.save(order1); + + // Verificar que la orden ha sido guardada + Optional foundOrder = eatInRepository.findById("O001"); + System.out.println("Order1: "); + System.out.println(foundOrder.get()); + System.out.println("--------------------"); + + // Comprobar que la orden se encuentra presente + assertThat(foundOrder).isPresent(); + + } + +} \ No newline at end of file diff --git a/src/test/java/dev/example/restaurantManager/MenuMenuItemTest.java b/src/test/java/dev/example/restaurantManager/MenuMenuItemTest.java new file mode 100644 index 0000000..ae0c703 --- /dev/null +++ b/src/test/java/dev/example/restaurantManager/MenuMenuItemTest.java @@ -0,0 +1,53 @@ +package dev.example.restaurantManager; + + +import dev.example.restaurantManager.model.CourseEnum; +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.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; +import static org.assertj.core.api.Assertions.assertThat; + +import java.util.ArrayList; +import java.util.Optional; + +@DataJpaTest +public class MenuMenuItemTest { + + @Autowired + private MenuRestaurantRepository menuRepository; + @Autowired + private MenuItemRepository menuItemRepository; + + @Test + public void TestCreateMenu(){ + + //Create Menu Item + + MenuItem menuItem1 = new MenuItem("item1", "Macarrones con tomate", "gratinados al horno", false, true, true, CourseEnum.MAIN, new ArrayList<>()); + menuItemRepository.save(menuItem1); + // Create Menu + MenuRestaurant menu1 = new MenuRestaurant("M01", "Menu básico", 10.0,"Un plato y bebida", true,true,new ArrayList<>()); + + // add menuitem to menu + menu1.addMenuItem(menuItem1); + menuRepository.save(menu1); + + //verify the relationship + + Optional foundMenu = menuRepository.findById("M01"); + System.out.println("Menu1: " ); + System.out.println(foundMenu.get()); + System.out.println("--------------------"); + + // Check that Menu is found + assertThat(foundMenu).isPresent(); + //assertThat(foundMenu.get().getMenuItems()).hasSize(1); + assertThat(foundMenu.get().getMenuItems()).contains(menuItem1); + + } + +} \ No newline at end of file From 5fa39e30247ccf2956ee4edb4ef4005ffb2938c1 Mon Sep 17 00:00:00 2001 From: isaac Date: Tue, 5 Nov 2024 11:43:48 +0100 Subject: [PATCH 02/11] Practica 3: done. checked last details. --- .../controller/MenuController.java | 4 +- .../controller/TableRestaurantController.java | 22 +-- .../service/MenuRestaurantService.java | 15 ++ .../service/MenuRestaurantServiceImpl.java | 70 ++++++++ .../resources/application-local.properties | 6 +- src/main/resources/application.properties | 4 +- .../RelationshipsOrderRestaurantTest.java | 161 +++++++++--------- 7 files changed, 183 insertions(+), 99 deletions(-) create mode 100644 src/main/java/dev/example/restaurantManager/service/MenuRestaurantService.java create mode 100644 src/main/java/dev/example/restaurantManager/service/MenuRestaurantServiceImpl.java diff --git a/src/main/java/dev/example/restaurantManager/controller/MenuController.java b/src/main/java/dev/example/restaurantManager/controller/MenuController.java index 2c9217a..88d8384 100644 --- a/src/main/java/dev/example/restaurantManager/controller/MenuController.java +++ b/src/main/java/dev/example/restaurantManager/controller/MenuController.java @@ -2,7 +2,7 @@ import dev.example.restaurantManager.model.MenuRestaurant; -import dev.example.restaurantManager.service.MenuService; +import dev.example.restaurantManager.service.MenuRestaurantService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.HttpHeaders; import org.springframework.http.HttpStatus; @@ -18,7 +18,7 @@ public class MenuController { @Autowired - private MenuService menuService; + private MenuRestaurantService menuService; @GetMapping("/allMenus") public ResponseEntity> getAllMenus(){ diff --git a/src/main/java/dev/example/restaurantManager/controller/TableRestaurantController.java b/src/main/java/dev/example/restaurantManager/controller/TableRestaurantController.java index 4bbe985..df84d7c 100644 --- a/src/main/java/dev/example/restaurantManager/controller/TableRestaurantController.java +++ b/src/main/java/dev/example/restaurantManager/controller/TableRestaurantController.java @@ -1,8 +1,8 @@ package dev.example.restaurantManager.controller; -import dev.example.restaurantManager.model.RestaurantTable; -import dev.example.restaurantManager.service.TableService; +import dev.example.restaurantManager.model.TableRestaurant; +import dev.example.restaurantManager.service.TableRestaurantService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.HttpHeaders; import org.springframework.http.HttpStatus; @@ -17,11 +17,11 @@ public class TableRestaurantController { @Autowired - private TableService tableService; + private TableRestaurantService tableService; @GetMapping("/allTables") - public ResponseEntity>getAllTables(){ - List tables = tableService.getAllTables(); + public ResponseEntity>getAllTables(){ + List tables = tableService.getAllTables(); HttpHeaders headers = getCommonHeaders("Get all tables"); return tables != null && !tables.isEmpty() ? new ResponseEntity<>(tables, headers, HttpStatus.OK) @@ -29,8 +29,8 @@ public class TableRestaurantController { } @PostMapping - public ResponseEntity createTable(@RequestBody RestaurantTable table){ - RestaurantTable createdTable = tableService.createTable(table); + public ResponseEntity createTable(@RequestBody TableRestaurant table){ + TableRestaurant createdTable = tableService.createTable(table); HttpHeaders headers = getCommonHeaders("Create a new table"); return createdTable !=null @@ -40,8 +40,8 @@ public ResponseEntity createTable(@RequestBody RestaurantTable } @PutMapping("/{name}") - public ResponseEntity updateTable(@PathVariable String name, @RequestBody RestaurantTable tableDetails) { - RestaurantTable updatedTable = tableService.updateTable(name, tableDetails); + public ResponseEntity updateTable(@PathVariable String name, @RequestBody TableRestaurant tableDetails) { + TableRestaurant updatedTable = tableService.updateTable(name, tableDetails); HttpHeaders headers = getCommonHeaders("Update a table"); return updatedTable != null ? new ResponseEntity<>(updatedTable, headers, HttpStatus.OK) @@ -59,8 +59,8 @@ public ResponseEntity deleteTable(@PathVariable String name) { } @GetMapping("/{name}") - public ResponseEntity getTableByName(@PathVariable String name){ - RestaurantTable table = tableService.getTableByName(name); + public ResponseEntity getTableByName(@PathVariable String name){ + TableRestaurant table = tableService.getTableByName(name); HttpHeaders headers = getCommonHeaders("Get a table by name"); return table != null 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..28690e6 --- /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 menu); + MenuRestaurant getMenuById(String id); + MenuRestaurant updateMenu(String id,MenuRestaurant MenuDetails); + 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..1c2898b --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/MenuRestaurantServiceImpl.java @@ -0,0 +1,70 @@ +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; +import java.util.UUID; + +@Service +public class MenuRestaurantServiceImpl implements MenuRestaurantService { + + @Autowired + private MenuRestaurantRepository menuRepository; + + @Override + public List getAllMenus() { + return menuRepository.findAll(); + } + + @Override + public MenuRestaurant createMenu(MenuRestaurant menu) { + menu.setId(UUID.randomUUID().toString()); + return menuRepository.save(menu); + } + + @Override + public MenuRestaurant getMenuById(String id) { + return menuRepository.findById(id).orElse(null); + } + + @Override + public MenuRestaurant updateMenu(String id, MenuRestaurant menuDetails) { + MenuRestaurant menu = menuRepository.findById(id).orElse(null); + if (menu != null) { + if (menuDetails.getName() != null) { + menu.setName(menuDetails.getName()); + } + if (menuDetails.getPrice() >= 0) { + menu.setPrice(menuDetails.getPrice()); + } + if (menuDetails.getContent() != null) { + menu.setContent(menuDetails.getContent()); + } + menu.setActive(menuDetails.isActive()); + menu.setWater(menuDetails.isWater()); + + return menuRepository.save(menu); + + + } + return null; + + + } + @Override + public boolean deleteMenu(String id){ + menuRepository.deleteById(id); + Optional menu = menuRepository.findById(id); + return menu.isEmpty() + ?false : true ; + } + @Override + public long countMenus(){ + return menuRepository.count(); + } + +} \ No newline at end of file diff --git a/src/main/resources/application-local.properties b/src/main/resources/application-local.properties index b773357..04fd785 100644 --- a/src/main/resources/application-local.properties +++ b/src/main/resources/application-local.properties @@ -2,9 +2,9 @@ # H2 LOCAL DB SERVER -spring.datasource.url=jdbc:h2:/home/albert/MyProjects/DataBase/customerdb -spring.datasource.username=albert -spring.datasource.password=1234 +spring.datasource.url=jdbc:h2:/home/isaac/MyPROJECTS/Database/customerdb +spring.datasource.username=sa +spring.datasource.password= # DDL OPTIONS: create-drop, create, update, none, validate spring.jpa.hibernate.ddl-auto=update diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties index 56fa3b7..537f8a9 100644 --- a/src/main/resources/application.properties +++ b/src/main/resources/application.properties @@ -6,7 +6,9 @@ spring.profiles.active=memory # H2 DATABASE SERVER -spring.datasource.driverClassName=org.h2.Driver +#spring.datasource.url=jdbc:h2:mem:testdb +#spring.datasource.url=jdbc:h2:/home/isaac/MyPROJECTS/Database/customerdb +#spring.datasource.driverClassName=org.h2.Driver spring.jpa.database-platform=org.hibernate.dialect.H2Dialect spring.h2.console.enabled=true diff --git a/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java b/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java index a3c8f84..e4ba25e 100644 --- a/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java +++ b/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java @@ -57,9 +57,9 @@ public void TestCreateOrder() { 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))); + //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 ); @@ -70,7 +70,7 @@ public void TestCreateOrder() { // Create a list of all orders ArrayList orders = new ArrayList<>(); orders.addAll(Arrays.asList(shippingOrder1, shippingOrder2, shippingOrder3, - eatInOrder1, eatInOrder2, eatInOrder3, + // eatInOrder1, eatInOrder2, eatInOrder3, takeAwayOrder1, takeAwayOrder2, takeAwayOrder3, takeAwayOrder4)); // Print the number of orders @@ -113,82 +113,79 @@ public void TestCreateOrder() { 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())); - } +// @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())); +// } } From 0b8faa5b84166ecebdff9aee709f3a843654867f Mon Sep 17 00:00:00 2001 From: isaac Date: Mon, 11 Nov 2024 13:18:38 +0100 Subject: [PATCH 03/11] PRA 4: Creted: - OrderMenuQty - OrderMenuQtyController - OrderMenuQtyRepository - OrderMenuQtyService - OrderMenuQtyServiceImpl --- .../controller/OrderMenuQtyController.java | 81 +++++++++++++++++++ .../restaurantManager/model/OrderMenuQty.java | 36 +++++++++ .../repository/OrderMenuQtyRepository.java | 7 ++ .../service/OrderMenuQtyService.java | 18 +++++ .../service/OrderMenuQtyServiceImpl.java | 69 ++++++++++++++++ 5 files changed, 211 insertions(+) create mode 100644 src/main/java/dev/example/restaurantManager/controller/OrderMenuQtyController.java create mode 100644 src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java create mode 100644 src/main/java/dev/example/restaurantManager/repository/OrderMenuQtyRepository.java create mode 100644 src/main/java/dev/example/restaurantManager/service/OrderMenuQtyService.java create mode 100644 src/main/java/dev/example/restaurantManager/service/OrderMenuQtyServiceImpl.java 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..b2b7c45 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/controller/OrderMenuQtyController.java @@ -0,0 +1,81 @@ +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.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.http.HttpHeaders; +import org.springframework.web.bind.annotation.*; + +import java.util.Date; +import java.util.List; + +@RequestMapping("api/v1/OrderMenyQty") +@RestController +public class OrderMenuQtyController { + + @Autowired + private OrderMenuQtyService orderMenuQtyService; + + @GetMapping("/allOrderMenuQty") + public ResponseEntity> getAllOrderMenuQty(){ + List orderMenuQty = orderMenuQtyService.getAllOrderMenuQty(); + HttpHeaders headers = getCommonHeaders("Get all Order Menu Quantity"); + return orderMenuQty != null && !orderMenuQty.isEmpty() + ? new ResponseEntity<>(orderMenuQty,headers, HttpStatus.OK) + : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + } + + @PostMapping + public ResponseEntity createOrderMenuQty(@RequestBody OrderMenuQty orderMenuQty){ + OrderMenuQty newOrderMenuQty = orderMenuQtyService.createOrderMenuQty(orderMenuQty); + HttpHeaders headers = getCommonHeaders("Create Order Menu Quantity"); + return newOrderMenuQty != null + ? new ResponseEntity<>(newOrderMenuQty,headers, HttpStatus.CREATED) + : new ResponseEntity<>(headers, HttpStatus.BAD_REQUEST); + } + + @PutMapping("/{id}") + public ResponseEntity updateOrderMenuQty(@PathVariable String id, @RequestBody OrderMenuQty orderMenuQtyDetails){ + OrderMenuQty updatedOrderMenuQty = orderMenuQtyService.updateOrderMenuQty(id, orderMenuQtyDetails); + HttpHeaders headers = getCommonHeaders("Update Order Menu Quantity"); + 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); + + } + + @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); + + } + + 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.countOrderMenuQty())); + headers.add("object", "orderMenuQty"); + return headers; + } + +} 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..86a5e6a --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java @@ -0,0 +1,36 @@ +package dev.example.restaurantManager.model; + +import jakarta.persistence.*; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import org.hibernate.annotations.GenericGenerator; + +import java.awt.*; +@Data +@AllArgsConstructor +@NoArgsConstructor +@Entity + +public class OrderMenuQty { + + @Id + @GeneratedValue(generator = "UUID") + @GenericGenerator(name = "UUID", strategy = "org.hibernate.id.UUIDGenerator") + private String id; + + @ManyToOne + @JoinColumn(name = "ORDER_FK_ID") + private OrderRestaurant order; + + @ManyToOne + @JoinColumn(name = "MENU_FK_ID") + private MenuRestaurant menu; + + private int quantity; + + + public OrderMenuQty(OrderRestaurant orderRestaurant, MenuRestaurant menuRestaurant, int i) { + + } +} \ 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..2549482 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/repository/OrderMenuQtyRepository.java @@ -0,0 +1,7 @@ +package dev.example.restaurantManager.repository; + +import dev.example.restaurantManager.model.OrderMenuQty; +import org.springframework.data.jpa.repository.JpaRepository; + +public interface OrderMenuQtyRepository extends JpaRepository { +} diff --git a/src/main/java/dev/example/restaurantManager/service/OrderMenuQtyService.java b/src/main/java/dev/example/restaurantManager/service/OrderMenuQtyService.java new file mode 100644 index 0000000..a2db75c --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/OrderMenuQtyService.java @@ -0,0 +1,18 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.OrderMenuQty; + +import java.util.List; + +public interface OrderMenuQtyService { + + List getAllOrderMenuQty(); + OrderMenuQty createOrderMenuQty(OrderMenuQty orderMenuQty); + OrderMenuQty getOrderMenuQtyById(String id); + OrderMenuQty updateOrderMenuQty(String id, OrderMenuQty orderMenuQty); + boolean deleteOrderMenuQty(String id); + long countOrderMenuQty(); + +} + + 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..7f3e7ab --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/OrderMenuQtyServiceImpl.java @@ -0,0 +1,69 @@ +package dev.example.restaurantManager.service; + + +import dev.example.restaurantManager.model.OrderMenuQty; +import dev.example.restaurantManager.repository.OrderMenuQtyRepository; +import jakarta.persistence.EntityNotFoundException; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.util.List; + +@Service +public class OrderMenuQtyServiceImpl implements OrderMenuQtyService { + + @Autowired + OrderMenuQtyRepository orderMenuQtyRepository; + + //Retrieves all OrderMenuQty records + @Override + public List getAllOrderMenuQty(){ + return orderMenuQtyRepository.findAll(); + } + + //Creates a new OrderMenuQty entry + @Override + public OrderMenuQty createOrderMenuQty(OrderMenuQty orderMenuQty){ + return orderMenuQtyRepository.save(orderMenuQty); + } + + //retrieves an OrderMenuQty by ID + + @Override + public OrderMenuQty getOrderMenuQtyById(String id){ + return orderMenuQtyRepository.findById(id).orElse(null); + + } + //Updates an existing OrderMenuQty entry + + @Override + public OrderMenuQty updateOrderMenuQty(String id, OrderMenuQty OrderMenuQtyDetails){ + OrderMenuQty orderMenuQty = orderMenuQtyRepository.findById(id).orElse(null); + assert orderMenuQty != null; + orderMenuQty.setQuantity(OrderMenuQtyDetails.getQuantity()); + orderMenuQty.setOrder(OrderMenuQtyDetails.getOrder()); + orderMenuQty.setMenu(OrderMenuQtyDetails.getMenu()); + + return orderMenuQtyRepository.save(orderMenuQty); + + } + + //Deletes an OrderMenuQty entry by ID + @Override + public boolean deleteOrderMenuQty(String id) { + if (!orderMenuQtyRepository.existsById(id)){ + throw new EntityNotFoundException("OrderMenuQty not found with id: " + id); + + } + orderMenuQtyRepository.deleteById(id); + return true; + } + + //Counts all ORderMenuQty entries + @Override + public long countOrderMenuQty(){ + return orderMenuQtyRepository.count(); + } + + +} \ No newline at end of file From 15baf8cdf02ee8df581c5ef9d5f68d1ed67cfc7c Mon Sep 17 00:00:00 2001 From: isaac Date: Mon, 11 Nov 2024 18:03:31 +0100 Subject: [PATCH 04/11] PRA 4: Refactor: EatInOrderRestaurant.java MenuRestaurant.java OrderMenuQty.java ShippingOrderRestaurant.java TakeAwayOrder.java --- .../model/EatInOrderRestaurant.java | 4 ++-- .../model/MenuRestaurant.java | 4 ++-- .../restaurantManager/model/OrderMenuQty.java | 18 +++++++++++++++--- .../model/ShippingOrderRestaurant.java | 5 +++-- .../restaurantManager/model/TakeAwayOrder.java | 5 +++-- 5 files changed, 25 insertions(+), 11 deletions(-) diff --git a/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java index 0fe6e15..70998a1 100644 --- a/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java @@ -6,8 +6,8 @@ import lombok.Data; import lombok.NoArgsConstructor; -import java.util.ArrayList; import java.util.Date; +import java.util.List; @Data @AllArgsConstructor @@ -26,7 +26,7 @@ public class EatInOrderRestaurant extends OrderRestaurant { public EatInOrderRestaurant(String id, Date date, String waiter, int peopleQty, - double totalPayment, boolean paid, ArrayList menus, + double totalPayment, boolean paid, List menus, TableRestaurant orderedTableRestaurant) { super(id, date, waiter, peopleQty, totalPayment, paid, menus); this.orderedTableRestaurant = orderedTableRestaurant; diff --git a/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java index f9d1727..6f8c947 100644 --- a/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java @@ -34,8 +34,8 @@ public class MenuRestaurant { ) private List menuItems = new ArrayList<>(); - @ManyToMany(mappedBy = "menus", fetch = FetchType.LAZY) - private List orders = new ArrayList<>(); + //@ManyToMany(mappedBy = "menus", fetch = FetchType.LAZY) + //private List orders = new ArrayList<>(); public MenuRestaurant(String id, String name, Double price, String content, boolean active, boolean water, List menuItems) { diff --git a/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java index 86a5e6a..1730748 100644 --- a/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java +++ b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java @@ -21,16 +21,28 @@ public class OrderMenuQty { @ManyToOne @JoinColumn(name = "ORDER_FK_ID") - private OrderRestaurant order; + private OrderRestaurant orderMapped; @ManyToOne @JoinColumn(name = "MENU_FK_ID") - private MenuRestaurant menu; + private MenuRestaurant menuMapped; private int quantity; - public OrderMenuQty(OrderRestaurant orderRestaurant, MenuRestaurant menuRestaurant, int i) { + public OrderMenuQty(OrderRestaurant orderRestaurant, MenuRestaurant menuRestaurant, int quantity) { + this.orderMapped = orderRestaurant; + this.menuMapped = menuRestaurant; + this.quantity = quantity; + } + @Override + public String toString() { + return "OrderMenuQty{" + + "id='" + id + '\'' + + ", orderMapped=" + orderMapped.getId() + + ", menuMapped=" + menuMapped.getName() + + ", quantity=" + quantity + + '}'; } } \ No newline at end of file diff --git a/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java index 6375dc2..c95f622 100644 --- a/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java @@ -3,8 +3,9 @@ import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; -import java.util.ArrayList; + import java.util.Date; +import java.util.List; @Data @AllArgsConstructor @@ -16,7 +17,7 @@ public class ShippingOrderRestaurant extends OrderRestaurant { private String riderName; public ShippingOrderRestaurant(String id, Date date, String waiter, int peopleQty, - double totalPayment, boolean paid, ArrayList menus, + double totalPayment, boolean paid, List menus, String address, String city, String riderName) { super(id, date, waiter, peopleQty, totalPayment, paid, menus); this.address = address; diff --git a/src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java b/src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java index e285789..e55aaa0 100644 --- a/src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java +++ b/src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java @@ -4,8 +4,9 @@ import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; -import java.util.ArrayList; + import java.util.Date; +import java.util.List; @Entity @Data @@ -19,7 +20,7 @@ public class TakeAwayOrder extends OrderRestaurant { // Constructor for TakeAwayOrder with the WHOLE DATA fields public TakeAwayOrder(String id, Date date, String waiter, int peopleQty, - double totalPayment, boolean paid, ArrayList menus, + double totalPayment, boolean paid, List menus, Customer customerTakeAway) { // THIS PART is SUPERCLASS From 83da6a6f1936f207777f98dbb65711ca790fe403 Mon Sep 17 00:00:00 2001 From: isaac Date: Mon, 11 Nov 2024 18:52:58 +0100 Subject: [PATCH 05/11] PRA 4: Refactor, finish details and finish exercise. --- .../model/EatInOrderRestaurant.java | 2 +- .../model/MenuRestaurant.java | 1 - .../model/OrderRestaurant.java | 59 ++---- .../model/ShippingOrderRestaurant.java | 2 +- .../model/TakeAwayOrder.java | 2 +- .../service/OrderMenuQtyServiceImpl.java | 6 +- .../restaurantManager/OrderMenuQtyTest.java | 4 + .../RelationshipsOrderRestaurantTest.java | 197 +----------------- 8 files changed, 40 insertions(+), 233 deletions(-) create mode 100644 src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java diff --git a/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java index 70998a1..08bcf7f 100644 --- a/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java @@ -26,7 +26,7 @@ public class EatInOrderRestaurant extends OrderRestaurant { public EatInOrderRestaurant(String id, Date date, String waiter, int peopleQty, - double totalPayment, boolean paid, List menus, + double totalPayment, boolean paid, List menus, TableRestaurant orderedTableRestaurant) { super(id, date, waiter, peopleQty, totalPayment, paid, menus); this.orderedTableRestaurant = orderedTableRestaurant; diff --git a/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java index 6f8c947..f41c7b5 100644 --- a/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java @@ -11,7 +11,6 @@ import java.util.Objects; @Data -@AllArgsConstructor @NoArgsConstructor @Entity public class MenuRestaurant { diff --git a/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java index 177c3b6..66deec1 100644 --- a/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java @@ -24,44 +24,29 @@ public class OrderRestaurant { private double totalPayment; private boolean paid; - @ManyToMany(fetch = FetchType.LAZY) - @JoinTable( - name = "order_menu", - joinColumns = @JoinColumn(name = "order_id"), - inverseJoinColumns = @JoinColumn(name = "menu_id") - ) - private List menus = new ArrayList<>(); - - public void addMenu(MenuRestaurant menu) { - this.menus.add(menu); - menu.getOrders().add(this); - } - - public void removeMenu(MenuRestaurant menu) { - this.menus.remove(menu); - menu.getOrders().remove(this); - } - - public List getMenus() { - return menus; - } - - public void setMenus(List menus) { - this.menus = menus; + @OneToMany(mappedBy = "orderMapped", cascade = CascadeType.ALL, orphanRemoval = true) + private List orderMenuQtyList = new ArrayList<>(); + + // add menus + public void addMenu(MenuRestaurant menu, int quantity) { + OrderMenuQty orderMenuQty = new OrderMenuQty(); + orderMenuQty.setOrderMapped(this); + orderMenuQty.setMenuMapped(menu); + orderMenuQty.setQuantity(quantity); + this.orderMenuQtyList.add(orderMenuQty); } - @Override - public String toString() { - return "OrderRestaurant{" + - "id='" + id + '\'' + - ", date=" + date + - ", waiter='" + waiter + '\'' + - ", peopleQty=" + peopleQty + - ", totalPayment=" + totalPayment + - ", paid=" + paid + - ", menusCount=" + (menus != null ? menus.size() : 0) + - ", menus=" + menus + - '}'; - } + @Override + public String toString() { + return "OrderRestaurant{" + + "id='" + id + '\'' + + ", date=" + date + + ", waiter='" + waiter + '\'' + + ", peopleQty=" + peopleQty + + ", totalPayment=" + totalPayment + + ", paid=" + paid + + ", orderMenuQtyList=" + orderMenuQtyList + + '}'; + } } \ No newline at end of file diff --git a/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java index c95f622..478defd 100644 --- a/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java @@ -17,7 +17,7 @@ public class ShippingOrderRestaurant extends OrderRestaurant { private String riderName; public ShippingOrderRestaurant(String id, Date date, String waiter, int peopleQty, - double totalPayment, boolean paid, List menus, + double totalPayment, boolean paid, List menus, String address, String city, String riderName) { super(id, date, waiter, peopleQty, totalPayment, paid, menus); this.address = address; diff --git a/src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java b/src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java index e55aaa0..606b004 100644 --- a/src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java +++ b/src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java @@ -20,7 +20,7 @@ public class TakeAwayOrder extends OrderRestaurant { // Constructor for TakeAwayOrder with the WHOLE DATA fields public TakeAwayOrder(String id, Date date, String waiter, int peopleQty, - double totalPayment, boolean paid, List menus, + double totalPayment, boolean paid, List menus, Customer customerTakeAway) { // THIS PART is SUPERCLASS diff --git a/src/main/java/dev/example/restaurantManager/service/OrderMenuQtyServiceImpl.java b/src/main/java/dev/example/restaurantManager/service/OrderMenuQtyServiceImpl.java index 7f3e7ab..c1dbe86 100644 --- a/src/main/java/dev/example/restaurantManager/service/OrderMenuQtyServiceImpl.java +++ b/src/main/java/dev/example/restaurantManager/service/OrderMenuQtyServiceImpl.java @@ -41,8 +41,8 @@ public OrderMenuQty updateOrderMenuQty(String id, OrderMenuQty OrderMenuQtyDetai OrderMenuQty orderMenuQty = orderMenuQtyRepository.findById(id).orElse(null); assert orderMenuQty != null; orderMenuQty.setQuantity(OrderMenuQtyDetails.getQuantity()); - orderMenuQty.setOrder(OrderMenuQtyDetails.getOrder()); - orderMenuQty.setMenu(OrderMenuQtyDetails.getMenu()); + orderMenuQty.setOrderMapped(OrderMenuQtyDetails.getOrderMapped()); + orderMenuQty.setMenuMapped(OrderMenuQtyDetails.getMenuMapped()); return orderMenuQtyRepository.save(orderMenuQty); @@ -59,7 +59,7 @@ public boolean deleteOrderMenuQty(String id) { return true; } - //Counts all ORderMenuQty entries + //Counts all OrderMenuQty entries @Override public long countOrderMenuQty(){ return orderMenuQtyRepository.count(); diff --git a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java new file mode 100644 index 0000000..2593bb3 --- /dev/null +++ b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java @@ -0,0 +1,4 @@ +package dev.example.restaurantManager; + +public class OrderMenuQtyTest { +} diff --git a/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java b/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java index e4ba25e..82b0a05 100644 --- a/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java +++ b/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java @@ -1,191 +1,10 @@ -package dev.example.restaurantManager; +public OrderMenuQty updateOrderMenuQty(String id, OrderMenuQty OrderMenuQtyDetails){ + OrderMenuQty orderMenuQty = orderMenuQtyRepository.findById(id).orElse(null); + assert orderMenuQty != null; + orderMenuQty.setQuantity(OrderMenuQtyDetails.getQuantity()); + orderMenuQty.setOrderMapped(OrderMenuQtyDetails.getOrderMapped()); + orderMenuQty.setMenuMapped(OrderMenuQtyDetails.getMenuMapped()); -import dev.example.restaurantManager.model.*; -import dev.example.restaurantManager.repository.CustomerRepository; -import dev.example.restaurantManager.repository.MenuRestaurantRepository; -import dev.example.restaurantManager.repository.OrderRestaurantRepository; -import dev.example.restaurantManager.repository.TakeAwayOrderRepository; -import org.junit.jupiter.api.Test; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Date; -import java.util.Optional; -import static org.assertj.core.api.Assertions.assertThat; + return orderMenuQtyRepository.save(orderMenuQty); -@DataJpaTest -public class RelationshipsOrderRestaurantTest { - -@Autowired -private TakeAwayOrderRepository takeAwayOrderRepository; -@Autowired -private CustomerRepository customerRepository; -@Autowired -private MenuRestaurantRepository menuRestaurantRepository; -@Autowired -private OrderRestaurantRepository orderRestaurantRepository; - - @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())); -// } -} +} \ No newline at end of file From 8811adc021fe82daa830af46daadd7122a4ef0cf Mon Sep 17 00:00:00 2001 From: isaac Date: Sat, 16 Nov 2024 08:26:45 +0100 Subject: [PATCH 06/11] Refactor MenuItem to abstract class, created MainCourse and SideCourse subclasses added MenuItem interface for common methods. --- .../restaurantManager/model/MainCourse.java | 38 ++++++++++ .../restaurantManager/model/MenuItem.java | 73 +++++-------------- .../model/MenuItemInterface.java | 19 +++++ .../restaurantManager/model/SideCourse.java | 40 ++++++++++ 4 files changed, 116 insertions(+), 54 deletions(-) create mode 100644 src/main/java/dev/example/restaurantManager/model/MainCourse.java create mode 100644 src/main/java/dev/example/restaurantManager/model/MenuItemInterface.java create mode 100644 src/main/java/dev/example/restaurantManager/model/SideCourse.java diff --git a/src/main/java/dev/example/restaurantManager/model/MainCourse.java b/src/main/java/dev/example/restaurantManager/model/MainCourse.java new file mode 100644 index 0000000..f3361f7 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/model/MainCourse.java @@ -0,0 +1,38 @@ +package dev.example.restaurantManager.model; + +import jakarta.persistence.DiscriminatorValue; +import jakarta.persistence.Entity; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@Entity +@DiscriminatorValue("MAIN_COURSE") +public class MainCourse extends MenuItem { + + private String sideDish; // "chips" or "salad" + private int calories; // calories content of the main course + private boolean chefRecommendation;// Indicates if it's a chef's special recommendation + + //constructor inheriting from MenuItem and initializing MainCourse - specific attributes. + public MainCourse(String id, String name, String description, double price, String sideDish, int calories, boolean chefRecommendation){ + super(id, name, description, price); // Calls the constructor of MenuItem + this.sideDish = sideDish; // Sets the side dish + this.calories = calories; // Sets the calories + this.chefRecommendation = chefRecommendation; // Marks if it's a chef's recommendation + } + + public String getFullDescription() { + return String.format("%s - %s (Price: %.2f, Side Dish: %s, Calories: %d, Chef Recommended: %b)", + getName(), getDescription(), getPrice(), sideDish, calories, chefRecommendation); + } + + public boolean isHealthy() { + return calories < 500; // Example threshold for healthy + } + + public int comparePrice(MainCourse other) { + return Double.compare(this.getPrice(), other.getPrice()); // Compares prices of two main courses + } +} \ No newline at end of file diff --git a/src/main/java/dev/example/restaurantManager/model/MenuItem.java b/src/main/java/dev/example/restaurantManager/model/MenuItem.java index 4f2042c..398e6fb 100644 --- a/src/main/java/dev/example/restaurantManager/model/MenuItem.java +++ b/src/main/java/dev/example/restaurantManager/model/MenuItem.java @@ -1,77 +1,42 @@ package dev.example.restaurantManager.model; -import com.fasterxml.jackson.annotation.JsonIgnore; +import dev.example.restaurantManager.model.interfaces.IMenuItem; import jakarta.persistence.*; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; -import org.hibernate.annotations.GenericGenerator; - -import java.util.ArrayList; import java.util.List; -import java.util.Objects; - @Data @AllArgsConstructor @NoArgsConstructor @Entity -public class MenuItem { +@Inheritance(strategy = InheritanceType.SINGLE_TABLE) +@DiscriminatorColumn(name = "item_type", discriminatorType = DiscriminatorType.STRING) + +public abstract class MenuItem implements MenuItemInterface { @Id + @GeneratedValue(strategy = GenerationType.AUTO) private String id; - private String name; private String description; - private boolean isSpicy; - private boolean hasGluten; - private boolean isAvailable; - - @Enumerated(EnumType.STRING) - private CourseEnum courseType; - - @ManyToMany(mappedBy = "menuItems", fetch = FetchType.LAZY) - @JsonIgnore - private List menus = new ArrayList<>(); - - public boolean hasGluten() { - return hasGluten; + private double price; + @ManyToMany(mappedBy = "menuItems") + private List menus; + public MenuItem(String id, String name, String description, double price) { + this.id = id; + this.name = name; + this.description = description; + this.price = price; } - // method para agregar un MenuRestaurant a un MenuItem - public void addMenu(MenuRestaurant menuRestaurant) { - this.getMenus().add(menuRestaurant); - if (!menuRestaurant.getMenuItems().contains(this)) { - menuRestaurant.getMenuItems().add(this); - } - } @Override - public String toString() { - return "MenuItem{" + - "id='" + id + '\'' + - ", name='" + name + '\'' + - ", description='" + description + '\'' + - ", isSpicy=" + isSpicy + - ", hasGluten=" + hasGluten + - ", isAvailable=" + isAvailable + - ", courseType=" + courseType + - '}'; + public String getItemType() { + // You can return the class type as the item type + return this.getClass().getSimpleName(); } @Override - public boolean equals(Object o) { - if (this == o) return true; - if (!(o instanceof MenuItem)) return false; - MenuItem that = (MenuItem) o; - return isSpicy == that.isSpicy && - hasGluten == that.hasGluten && - isAvailable == that.isAvailable && - Objects.equals(id, that.id) && - Objects.equals(name, that.name) && - Objects.equals(description, that.description) && - courseType == that.courseType; - } - - @Override - public int hashCode() { - return Objects.hash(id, name, description, isSpicy, hasGluten, isAvailable, courseType); + public String getSummary() { + return String.format("%s - %s (Price: %.2f)", name, description, price); } } \ No newline at end of file diff --git a/src/main/java/dev/example/restaurantManager/model/MenuItemInterface.java b/src/main/java/dev/example/restaurantManager/model/MenuItemInterface.java new file mode 100644 index 0000000..9a1dcc2 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/model/MenuItemInterface.java @@ -0,0 +1,19 @@ +package dev.example.restaurantManager.model; + +public interface MenuItemInterface { + + //Method to get the name of the menu item + String getName(); + + //Method to get the description of the menu item + String getDescription(); + + //Method to get the price of the menu item + double getPrice(); + + //Method to get the item type + String getItemType(); + + //Method to provide a summary of the menu item + String getSummary(); +} diff --git a/src/main/java/dev/example/restaurantManager/model/SideCourse.java b/src/main/java/dev/example/restaurantManager/model/SideCourse.java new file mode 100644 index 0000000..919b8d7 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/model/SideCourse.java @@ -0,0 +1,40 @@ +package dev.example.restaurantManager.model; + + +import jakarta.persistence.DiscriminatorValue; +import jakarta.persistence.Entity; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@Entity +@DiscriminatorValue("SIDECOURSE") + +public class SideCourse extends MenuItem { + + private boolean isGlutenFree; // indicates if the dessert is gluten-free + private String flavor; //Flavor of dessert + private int sweetnessLevel; //Sweetness Level on a scale from 1 to 10; + + //Constructor that inherits from MenuItem and initializes dessert specific attributes. + + public SideCourse (String id, String name, String description, double price, boolean isGlutenFree){ + super(id, name, description, price); // Calls the constructor of the parent class (MenuItem) + this.isGlutenFree = isGlutenFree; // Initializes the gluten-free attribute + + } + + //method to get a summary of dessert + public String getSideCourseSummary() { + return String.format("%s - %s (Price: %.2f, Gluten Free: %b, Flavor: %s, Sweetness Level: %d)", + getName(), getDescription(), getPrice(), isGlutenFree, flavor, sweetnessLevel); + } + + public boolean isSuitableForDiet(String dietaryNeed) { + if(dietaryNeed.equalsIgnoreCase("gluten-free")){ + return isGlutenFree; + } + return false; //Default case + } +} \ No newline at end of file From c8298e91185a78f8bf70b941d5f3f27eec99db0e Mon Sep 17 00:00:00 2001 From: isaac Date: Sat, 16 Nov 2024 19:29:40 +0100 Subject: [PATCH 07/11] Update MenuItemRepository --- .../repository/MenuItemRepository.java | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/src/main/java/dev/example/restaurantManager/repository/MenuItemRepository.java b/src/main/java/dev/example/restaurantManager/repository/MenuItemRepository.java index 605a2ab..d958094 100644 --- a/src/main/java/dev/example/restaurantManager/repository/MenuItemRepository.java +++ b/src/main/java/dev/example/restaurantManager/repository/MenuItemRepository.java @@ -1,9 +1,23 @@ package dev.example.restaurantManager.repository; + +import dev.example.restaurantManager.model.MainCourse; import dev.example.restaurantManager.model.MenuItem; +import dev.example.restaurantManager.model.SideCourse; import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Query; + +import java.util.List; + + public interface MenuItemRepository extends JpaRepository { + + + @Query("SELECT m FROM MainCourse m") + List findAllMainCourses(); + + @Query("SELECT s FROM SideCourse s") + List findAllSideCourses(); -public interface MenuItemRepository extends JpaRepository { + } -} \ No newline at end of file From 658272f6293466d2272211218f59bc7f34fdba3b Mon Sep 17 00:00:00 2001 From: isaac Date: Sat, 16 Nov 2024 19:40:46 +0100 Subject: [PATCH 08/11] Update MenuItemServiceImpl --- .../service/MenuItemServiceImpl.java | 77 ++++++++----------- 1 file changed, 31 insertions(+), 46 deletions(-) diff --git a/src/main/java/dev/example/restaurantManager/service/MenuItemServiceImpl.java b/src/main/java/dev/example/restaurantManager/service/MenuItemServiceImpl.java index 63961ab..ac50ec2 100644 --- a/src/main/java/dev/example/restaurantManager/service/MenuItemServiceImpl.java +++ b/src/main/java/dev/example/restaurantManager/service/MenuItemServiceImpl.java @@ -1,90 +1,75 @@ package dev.example.restaurantManager.service; - - +import dev.example.restaurantManager.model.MainCourse; import dev.example.restaurantManager.model.MenuItem; -import dev.example.restaurantManager.model.MenuRestaurant; +import dev.example.restaurantManager.model.SideCourse; 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; import java.util.UUID; @Service public class MenuItemServiceImpl implements MenuItemService { - - @Autowired - MenuItemRepository menuItemRepository; @Autowired - MenuRestaurantRepository menuRepository; + private MenuItemRepository menuItemRepository; + //Retrieve all MenuItems including subtypes @Override - public List getMenuItemsByMenuId(String menuId) { - MenuRestaurant menu = menuRepository.findById(menuId).orElse(null); - return menu != null ? menu.getMenuItems() : new ArrayList<>(); + public List getAllMenuItems() { + return menuItemRepository.findAll(); } - + //Save a generic Menu item @Override + public MenuItem createMenuItem(MenuItem menuItem) { + menuItem.setId(UUID.randomUUID().toString()); + return menuItemRepository.save(menuItem); + } - public List getAllMenuItems(){ - return menuItemRepository.findAll(); + //Save a MainCourse + public MainCourse createMainCourse(MainCourse mainCourse){ + mainCourse.setId(UUID.randomUUID().toString()); + return menuItemRepository.save(mainCourse); } - @Override + //Save SideCourse - public MenuItem createMenuItem(MenuItem menuItem){ - menuItem.setId(UUID.randomUUID().toString()); - return menuItemRepository.save(menuItem); + public SideCourse createSideCourse(SideCourse dessert){ + dessert.setId(UUID.randomUUID().toString()); + return menuItemRepository.save(dessert); } - public MenuItem getMenuItemByID (String id){ + //Retrieve a MenuItem by ID + + public MenuItem getMenuItemById(String id) { return menuItemRepository.findById(id).orElse(null); } + //Update an existing MenuItem @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()); - } - menuItem.setSpicy(menuItemDetails.isSpicy()); - menuItem.setHasGluten(menuItemDetails.hasGluten()); - menuItem.setAvailable(menuItemDetails.isAvailable()); - - - if (menuItemDetails.getCourseType() != null) { - menuItem.setCourseType(menuItemDetails.getCourseType()); - } - + menuItem.setName(menuItemDetails.getName()); + menuItem.setDescription(menuItemDetails.getDescription()); + menuItem.setPrice(menuItemDetails.getPrice()); 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 ; + if (menuItemRepository.existsById(id)) { + menuItemRepository.deleteById(id); + return true; + } + return false; } - @Override public long countMenuItems() { return menuItemRepository.count(); } - - - } From 79919057836f75268b6b778a20bbc00e31c49a2b Mon Sep 17 00:00:00 2001 From: isaac Date: Sat, 16 Nov 2024 19:49:50 +0100 Subject: [PATCH 09/11] Update MenuItemController & MenuItemService --- .../controller/MenuItemController.java | 98 +++++++++---------- .../service/MenuItemService.java | 6 ++ 2 files changed, 51 insertions(+), 53 deletions(-) diff --git a/src/main/java/dev/example/restaurantManager/controller/MenuItemController.java b/src/main/java/dev/example/restaurantManager/controller/MenuItemController.java index 02414be..96466ef 100644 --- a/src/main/java/dev/example/restaurantManager/controller/MenuItemController.java +++ b/src/main/java/dev/example/restaurantManager/controller/MenuItemController.java @@ -1,93 +1,85 @@ package dev.example.restaurantManager.controller; +import dev.example.restaurantManager.model.MainCourse; import dev.example.restaurantManager.model.MenuItem; +import dev.example.restaurantManager.model.SideCourse; 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; @RestController -@RequestMapping("/api/v1/menu-items") +@RequestMapping("/api/menuitems") public class MenuItemController { - @Autowired private MenuItemService menuItemService; - // Obtener todos los MenuItems - @GetMapping("/all-menu-items") + // Get all MenuItems (including MainCourse and Dessert) + + @GetMapping public ResponseEntity> getAllMenuItems() { List menuItems = menuItemService.getAllMenuItems(); - HttpHeaders headers = getCommonHeaders("Get alls menus"); - return menuItems != null && !menuItems.isEmpty() - ? new ResponseEntity<>(menuItems,headers, HttpStatus.OK) - : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + return new ResponseEntity<>(menuItems, HttpStatus.OK); } - // Crear un nuevo MenuItem + // Create a MenuItem (can be a MainCourse, Dessert, or other MenuItem) + @PostMapping 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); + MenuItem newMenuItem = menuItemService.createMenuItem(menuItem); + return new ResponseEntity<>(newMenuItem, HttpStatus.CREATED); + } + // Get a MenuItem by ID (including MainCourse and Dessert) + @GetMapping("/{id}") + public ResponseEntity getMenuItemById(@PathVariable String id) { + MenuItem menuItem = menuItemService.getMenuItemById(id); + if (menuItem != null) { + return new ResponseEntity<>(menuItem, HttpStatus.OK); + } + return new ResponseEntity<>(HttpStatus.NOT_FOUND); } + // Update an existing MenuItem - // Actualizar un MenuItem existente @PutMapping("/{id}") public ResponseEntity updateMenuItem(@PathVariable String id, @RequestBody MenuItem menuItemDetails) { MenuItem updatedMenuItem = menuItemService.updateMenuItem(id, menuItemDetails); - HttpHeaders headers = getCommonHeaders("Update menu-item"); - return updatedMenuItem != null - ? new ResponseEntity<>(updatedMenuItem,headers,HttpStatus.OK) - : new ResponseEntity<>(headers,HttpStatus.NOT_FOUND); + if (updatedMenuItem != null) { + return new ResponseEntity<>(updatedMenuItem, HttpStatus.OK); + } + return new ResponseEntity<>(HttpStatus.NOT_FOUND); } + // Delete a MenuItem by ID - // Eliminar un MenuItem @DeleteMapping("/{id}") public ResponseEntity deleteMenuItem(@PathVariable String id) { boolean deleted = menuItemService.deleteMenuItem(id); - HttpHeaders headers = getCommonHeaders("Delete a menu-item"); - return deleted - ? new ResponseEntity<>(headers,HttpStatus.NO_CONTENT) - : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + if (deleted) { + return new ResponseEntity<>(HttpStatus.NO_CONTENT); + } + return new ResponseEntity<>(HttpStatus.NOT_FOUND); } + // Get the count of all MenuItems - // encuentra un menu-item por la id - @GetMapping("/{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); + @GetMapping("/count") + public ResponseEntity countMenuItems() { + long count = menuItemService.countMenuItems(); + return new ResponseEntity<>(count, HttpStatus.OK); } - // Obtener todos los MenuItems de un Menu específico - @GetMapping("/menu/{menuId}/items") - public ResponseEntity> getMenuItemsByMenuId(@PathVariable String menuId) { - List menuItems = menuItemService.getMenuItemsByMenuId(menuId); - HttpHeaders headers = getCommonHeaders("Get all menu-items for a specific menu"); - return menuItems != null && !menuItems.isEmpty() - ? new ResponseEntity<>(menuItems, headers, HttpStatus.OK) - : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + // Endpoint to create a MainCourse + @PostMapping("/maincourse") + public ResponseEntity createMainCourse(@RequestBody MainCourse mainCourse){ + MainCourse newMainCourse = menuItemService.createMainCourse(mainCourse); + return new ResponseEntity<>(newMainCourse, HttpStatus.CREATED); } - 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_items-count", String.valueOf(menuItemService.countMenuItems())); - headers.add("object", "menu-items"); - return headers; + @PostMapping("/sidecourse") + public ResponseEntity createSideCourse (@RequestBody SideCourse sideCourse){ + SideCourse newSideCourse = menuItemService.createSideCourse(sideCourse); + return new ResponseEntity<>(newSideCourse,HttpStatus.CREATED); } + } \ No newline at end of file diff --git a/src/main/java/dev/example/restaurantManager/service/MenuItemService.java b/src/main/java/dev/example/restaurantManager/service/MenuItemService.java index 6b25bf8..5cb1362 100644 --- a/src/main/java/dev/example/restaurantManager/service/MenuItemService.java +++ b/src/main/java/dev/example/restaurantManager/service/MenuItemService.java @@ -1,7 +1,9 @@ package dev.example.restaurantManager.service; import dev.example.restaurantManager.model.Customer; +import dev.example.restaurantManager.model.MainCourse; import dev.example.restaurantManager.model.MenuItem; +import dev.example.restaurantManager.model.SideCourse; import java.util.List; @@ -15,4 +17,8 @@ public interface MenuItemService { long countMenuItems(); List getMenuItemsByMenuId(String menuId); + MenuItem getMenuItemById(String id); + + MainCourse createMainCourse(MainCourse mainCourse); + SideCourse createSideCourse(SideCourse sideCourse); } \ No newline at end of file From f42a1ed57c603da6e04896299149fbe694af2e29 Mon Sep 17 00:00:00 2001 From: isaac Date: Sat, 16 Nov 2024 19:49:50 +0100 Subject: [PATCH 10/11] Create MenuItemTest --- .../controller/MenuItemController.java | 98 ++++---- .../restaurantManager/model/SideCourse.java | 3 + .../model/TableRestaurant.java | 3 + .../service/MenuItemService.java | 6 + .../utilities/DataLoader.java | 155 ++++++++++++ .../restaurantManager/MenuMenuItemTest.java | 220 +++++++++++++++--- 6 files changed, 405 insertions(+), 80 deletions(-) create mode 100644 src/main/java/dev/example/restaurantManager/utilities/DataLoader.java diff --git a/src/main/java/dev/example/restaurantManager/controller/MenuItemController.java b/src/main/java/dev/example/restaurantManager/controller/MenuItemController.java index 02414be..96466ef 100644 --- a/src/main/java/dev/example/restaurantManager/controller/MenuItemController.java +++ b/src/main/java/dev/example/restaurantManager/controller/MenuItemController.java @@ -1,93 +1,85 @@ package dev.example.restaurantManager.controller; +import dev.example.restaurantManager.model.MainCourse; import dev.example.restaurantManager.model.MenuItem; +import dev.example.restaurantManager.model.SideCourse; 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; @RestController -@RequestMapping("/api/v1/menu-items") +@RequestMapping("/api/menuitems") public class MenuItemController { - @Autowired private MenuItemService menuItemService; - // Obtener todos los MenuItems - @GetMapping("/all-menu-items") + // Get all MenuItems (including MainCourse and Dessert) + + @GetMapping public ResponseEntity> getAllMenuItems() { List menuItems = menuItemService.getAllMenuItems(); - HttpHeaders headers = getCommonHeaders("Get alls menus"); - return menuItems != null && !menuItems.isEmpty() - ? new ResponseEntity<>(menuItems,headers, HttpStatus.OK) - : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + return new ResponseEntity<>(menuItems, HttpStatus.OK); } - // Crear un nuevo MenuItem + // Create a MenuItem (can be a MainCourse, Dessert, or other MenuItem) + @PostMapping 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); + MenuItem newMenuItem = menuItemService.createMenuItem(menuItem); + return new ResponseEntity<>(newMenuItem, HttpStatus.CREATED); + } + // Get a MenuItem by ID (including MainCourse and Dessert) + @GetMapping("/{id}") + public ResponseEntity getMenuItemById(@PathVariable String id) { + MenuItem menuItem = menuItemService.getMenuItemById(id); + if (menuItem != null) { + return new ResponseEntity<>(menuItem, HttpStatus.OK); + } + return new ResponseEntity<>(HttpStatus.NOT_FOUND); } + // Update an existing MenuItem - // Actualizar un MenuItem existente @PutMapping("/{id}") public ResponseEntity updateMenuItem(@PathVariable String id, @RequestBody MenuItem menuItemDetails) { MenuItem updatedMenuItem = menuItemService.updateMenuItem(id, menuItemDetails); - HttpHeaders headers = getCommonHeaders("Update menu-item"); - return updatedMenuItem != null - ? new ResponseEntity<>(updatedMenuItem,headers,HttpStatus.OK) - : new ResponseEntity<>(headers,HttpStatus.NOT_FOUND); + if (updatedMenuItem != null) { + return new ResponseEntity<>(updatedMenuItem, HttpStatus.OK); + } + return new ResponseEntity<>(HttpStatus.NOT_FOUND); } + // Delete a MenuItem by ID - // Eliminar un MenuItem @DeleteMapping("/{id}") public ResponseEntity deleteMenuItem(@PathVariable String id) { boolean deleted = menuItemService.deleteMenuItem(id); - HttpHeaders headers = getCommonHeaders("Delete a menu-item"); - return deleted - ? new ResponseEntity<>(headers,HttpStatus.NO_CONTENT) - : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + if (deleted) { + return new ResponseEntity<>(HttpStatus.NO_CONTENT); + } + return new ResponseEntity<>(HttpStatus.NOT_FOUND); } + // Get the count of all MenuItems - // encuentra un menu-item por la id - @GetMapping("/{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); + @GetMapping("/count") + public ResponseEntity countMenuItems() { + long count = menuItemService.countMenuItems(); + return new ResponseEntity<>(count, HttpStatus.OK); } - // Obtener todos los MenuItems de un Menu específico - @GetMapping("/menu/{menuId}/items") - public ResponseEntity> getMenuItemsByMenuId(@PathVariable String menuId) { - List menuItems = menuItemService.getMenuItemsByMenuId(menuId); - HttpHeaders headers = getCommonHeaders("Get all menu-items for a specific menu"); - return menuItems != null && !menuItems.isEmpty() - ? new ResponseEntity<>(menuItems, headers, HttpStatus.OK) - : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + // Endpoint to create a MainCourse + @PostMapping("/maincourse") + public ResponseEntity createMainCourse(@RequestBody MainCourse mainCourse){ + MainCourse newMainCourse = menuItemService.createMainCourse(mainCourse); + return new ResponseEntity<>(newMainCourse, HttpStatus.CREATED); } - 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_items-count", String.valueOf(menuItemService.countMenuItems())); - headers.add("object", "menu-items"); - return headers; + @PostMapping("/sidecourse") + public ResponseEntity createSideCourse (@RequestBody SideCourse sideCourse){ + SideCourse newSideCourse = menuItemService.createSideCourse(sideCourse); + return new ResponseEntity<>(newSideCourse,HttpStatus.CREATED); } + } \ No newline at end of file diff --git a/src/main/java/dev/example/restaurantManager/model/SideCourse.java b/src/main/java/dev/example/restaurantManager/model/SideCourse.java index 919b8d7..e3f9e3f 100644 --- a/src/main/java/dev/example/restaurantManager/model/SideCourse.java +++ b/src/main/java/dev/example/restaurantManager/model/SideCourse.java @@ -25,6 +25,9 @@ public SideCourse (String id, String name, String description, double price, boo } + public SideCourse(String string, String s, String s1, double v, Boolean aBoolean, String s2, int i) { + } + //method to get a summary of dessert public String getSideCourseSummary() { return String.format("%s - %s (Price: %.2f, Gluten Free: %b, Flavor: %s, Sweetness Level: %d)", diff --git a/src/main/java/dev/example/restaurantManager/model/TableRestaurant.java b/src/main/java/dev/example/restaurantManager/model/TableRestaurant.java index 686e80f..196b506 100644 --- a/src/main/java/dev/example/restaurantManager/model/TableRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/TableRestaurant.java @@ -48,6 +48,9 @@ public TableRestaurant(String name, String description , int qty, boolean busy) this.busy = busy; } + public TableRestaurant(String string, String s, E option, Integer integer, boolean bool) { + } + // Méthod tu add orders public void addEatInOrder(EatInOrderRestaurant order) { diff --git a/src/main/java/dev/example/restaurantManager/service/MenuItemService.java b/src/main/java/dev/example/restaurantManager/service/MenuItemService.java index 6b25bf8..5cb1362 100644 --- a/src/main/java/dev/example/restaurantManager/service/MenuItemService.java +++ b/src/main/java/dev/example/restaurantManager/service/MenuItemService.java @@ -1,7 +1,9 @@ package dev.example.restaurantManager.service; import dev.example.restaurantManager.model.Customer; +import dev.example.restaurantManager.model.MainCourse; import dev.example.restaurantManager.model.MenuItem; +import dev.example.restaurantManager.model.SideCourse; import java.util.List; @@ -15,4 +17,8 @@ public interface MenuItemService { long countMenuItems(); List getMenuItemsByMenuId(String menuId); + MenuItem getMenuItemById(String id); + + MainCourse createMainCourse(MainCourse mainCourse); + SideCourse createSideCourse(SideCourse sideCourse); } \ No newline at end of file diff --git a/src/main/java/dev/example/restaurantManager/utilities/DataLoader.java b/src/main/java/dev/example/restaurantManager/utilities/DataLoader.java new file mode 100644 index 0000000..6a47301 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/utilities/DataLoader.java @@ -0,0 +1,155 @@ +package dev.example.restaurantManager.utilities; +import com.github.javafaker.Faker; +import dev.example.restaurantManager.model.*; +import dev.example.restaurantManager.repository.*; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; +import java.time.LocalDate; +import java.util.*; +import java.util.concurrent.TimeUnit; +@Component +public class DataLoader { + @Autowired + private CustomerRepository customerRepository; + @Autowired + private TableRestaurantRepository tableRepository; + @Autowired + private MenuItemRepository menuItemRepository; + @Autowired + private MenuRestaurantRepository menuRepository; + @Autowired + private BookingRepository bookingRepository; + @Autowired + private OrderRestaurantRepository orderRepository; + @Autowired + private OrderMenuQtyRepository orderMenuQtyRepository; + @Autowired + private EatInRepository eatInOrderRepository; + @Autowired + private TakeAwayOrderRepository takeAwayOrderRepository; + private final Faker faker = new Faker(new Locale("en-US")); + + // master method orchestrating all other methods to + // load fake data into the local H2 database + // and create relationships between entities in the database + public void loadAllData() { + // let's create some fake data + // for the inverse entities first + // then create relationships between them + createCustomers(); + createTables(); + createMenuItems(); + // create and assign menu items + createMenusAndAssignMenuItems(); + // create bookings and assign customers and tables + createBookingsAndAssignTablesAndCustomers(); + // create orders and assign menus and customers + createOrdersAndAssignMenus(); + // create eat-in orders, shipping orders and take away orders + createEatInOrders(); + createShippingOrders(); + createTakeAwayOrders(); + } + + private void createTakeAwayOrders() { + } + + private void createShippingOrders() { + } + + private void createEatInOrders() { + } + + private void createOrdersAndAssignMenus() { + } + + private void createBookingsAndAssignTablesAndCustomers() { + } + + private void createMenusAndAssignMenuItems() { + } + + // we are going to create 25 customers + // and save them in the H2 local database + private void createCustomers() { + for (int i = 0; i < 25; i++) { + Customer customer = new Customer( + UUID.randomUUID().toString(), + faker.name().fullName(), + faker.internet().emailAddress(), + faker.phoneNumber().cellPhone(), + faker.random().nextInt(18, 80), + faker.random().nextBoolean(), + faker.random().nextBoolean() + ); + customerRepository.save(customer); + } + } + + // we are going to create 10 tables + // and save them in the H2 local database + private void createTables() { + for (int i = 0; i < 10; i++) { + TableRestaurant table = new TableRestaurant( + UUID.randomUUID().toString(), + " Table-00" + (i + 1), + faker.options().option("Table Type Outdoor from Cisco INC", + "Table Type Indoor from Cisco INC", + "Table Rounded Big", + "Table Little Indoor"), + faker.random().nextInt(2, 8), + faker.bool().bool() + ); + tableRepository.save(table); + } + } + + // we are going to create 25 menu items + // and save them in the H2 local database + private void createMenuItems() { + + // Listas predefinidas para los valores de sideDish, salad y dessert + List sideDishes = Arrays.asList("Fries", "Rice", "Mashed Potatoes", "Grilled Vegetables", "Garlic Bread"); + List flavors = Arrays.asList("Chocolate", "Vanilla", "Strawberry", "Lemon", "Banana"); + List desserts = Arrays.asList("Chocolate Cake", "Ice Cream", "Apple Pie", "Cheesecake", "Tiramisu"); + + // Crear 25 elementos de menú de tipo MainCourse o Dessert + for (int i = 0; i < 25; i++) { + + // Decidir aleatoriamente si el menú será un MainCourse o un Dessert + boolean isMainCourse = faker.random().nextBoolean(); + + if (isMainCourse) { + // Crear un MainCourse + MainCourse mainCourse = new MainCourse( + UUID.randomUUID().toString(), + faker.food().dish(), + faker.food().ingredient() + " " + faker.food().ingredient(), + faker.number().randomDouble(2, 5, 30), + sideDishes.get(faker.random().nextInt(sideDishes.size())), // Selecciona un side dish aleatorio + faker.number().numberBetween(200, 800), // Calorías + faker.random().nextBoolean() // Chef Recommendation + ); + + // Guardar el MainCourse + menuItemRepository.save(mainCourse); + + } else { + // Crear un Dessert + SideCourse dessert = new SideCourse( + UUID.randomUUID().toString(), + desserts.get(faker.random().nextInt(desserts.size())), + faker.food().ingredient() + " " + faker.food().ingredient(), + faker.number().randomDouble(2, 3, 15), + faker.random().nextBoolean(), // Gluten Free + flavors.get(faker.random().nextInt(flavors.size())), // Flavor + faker.number().numberBetween(1, 10) // Sweetness Level + ); + + // Guardar el Dessert + menuItemRepository.save(dessert); + } + } + } + +} diff --git a/src/test/java/dev/example/restaurantManager/MenuMenuItemTest.java b/src/test/java/dev/example/restaurantManager/MenuMenuItemTest.java index ae0c703..8d37ac8 100644 --- a/src/test/java/dev/example/restaurantManager/MenuMenuItemTest.java +++ b/src/test/java/dev/example/restaurantManager/MenuMenuItemTest.java @@ -1,53 +1,219 @@ package dev.example.restaurantManager; -import dev.example.restaurantManager.model.CourseEnum; +import dev.example.restaurantManager.RestaurantManagerApplication; +import dev.example.restaurantManager.model.Dessert; +import dev.example.restaurantManager.model.MainCourse; import dev.example.restaurantManager.model.MenuItem; -import dev.example.restaurantManager.model.MenuRestaurant; +import dev.example.restaurantManager.model.SideCourse; import dev.example.restaurantManager.repository.MenuItemRepository; -import dev.example.restaurantManager.repository.MenuRestaurantRepository; +import jakarta.transaction.Transactional; +import org.junit.jupiter.api.BeforeEach; 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.boot.test.context.SpringBootTest; import static org.assertj.core.api.Assertions.assertThat; -import java.util.ArrayList; import java.util.Optional; +import java.util.UUID; -@DataJpaTest -public class MenuMenuItemTest { +@SpringBootTest(classes = RestaurantManagerApplication.class)public class MenuItemTest { - @Autowired - private MenuRestaurantRepository menuRepository; @Autowired private MenuItemRepository menuItemRepository; + @BeforeEach + public void setUp(){ + //Clean database before each test + menuItemRepository.deleteAll(); + } + + @Test + public void testMainCourseCreationAndPersistence(){ + //Create a MainCourse Object with specific data + + MainCourse mainCourse = new MainCourse( + UUID.randomUUID().toString(), + "Chicken parmesan", + "Fired chicken with Parmesan cheese", + 12.50, + "salad", + 450, + true + ); + + //save to repository + menuItemRepository.save(mainCourse); + + //retrieve the object since database using the ID + + Optional retrievedMainCourse = menuItemRepository.findById(mainCourse.getId()); + + //verify that the object was saved and retrieved correctly + assertThat(retrievedMainCourse).isPresent(); + assertThat(retrievedMainCourse.get().getName()).isEqualTo(mainCourse.getName()); + assertThat(retrievedMainCourse.get().getDescription()).isEqualTo(mainCourse.getDescription()); + assertThat(retrievedMainCourse.get().getPrice()).isEqualTo(mainCourse.getPrice()); + + // Print a message confirming it was saved correctly + System.out.println("MainCourse saved successfully: " + retrievedMainCourse.get().getName()); + + } + + @Test + public void testSideCourseCreationAndPersistence() { + // Create object dessert + SideCourse dessert = new SideCourse( + UUID.randomUUID().toString(), + "Chocolate Cake", + "Rich chocolate dessert", + 6.00, + false, + "Chocolate", + 8 + ); + + // saved database + menuItemRepository.save(dessert); + + // retrieved object of database find by id + Optional retrievedDessert = menuItemRepository.findById(dessert.getId()); + + // verify is saved and confirming + assertThat(retrievedDessert).isPresent(); + assertThat(retrievedDessert.get().getName()).isEqualTo(dessert.getName()); + assertThat(retrievedDessert.get().getDescription()).isEqualTo(dessert.getDescription()); + assertThat(retrievedDessert.get().getPrice()).isEqualTo(dessert.getPrice()); + + // Print a message confirming it was saved correctly + System.out.println("Dessert saved successfully: " + retrievedDessert.get().getName()); + } + + @Test + @Transactional + public void testSaveAndRetrieveAllMenuItems() { + //create objects MainCourse and Dessert + + MainCourse mainCourse = new MainCourse( + UUID.randomUUID().toString(), + "Steak", + "Grilled steak with potatoes", + 20.00, + "fries", + 600, + false + ); + + SideCourse sidecourse = new SideCourse(UUID.randomUUID().toString(), + "Salad", + "Mediterranean Style Salad", + 5.50, + true, + "salad", + 6); + + //saved both objets in database + + menuItemRepository.save(mainCourse); + menuItemRepository.save(sidecourse); + + //verify that both objects can retrieve + Iterable allMenuItems = menuItemRepository.findAll(); + System.out.println("All Menu Items:"); + for (MenuItem menuItem : allMenuItems) { + System.out.println(menuItem.getName() + ": " + menuItem.getDescription()); + } + assertThat(allMenuItems).hasSize(2); + assertThat(menuItemRepository.count()).isEqualTo(2); + + } + @Test - public void TestCreateMenu(){ + public void testUpdateMainCourse() { + // Create and save MainCourse + MainCourse savedMainCourse = menuItemRepository.save(new MainCourse( + UUID.randomUUID().toString(), + "Chicken Breast", + "Grilled chicken breast", + 14.00, + "vegetable", + 500, + true + )); - //Create Menu Item + savedMainCourse.setName("Chicken Crispy"); - MenuItem menuItem1 = new MenuItem("item1", "Macarrones con tomate", "gratinados al horno", false, true, true, CourseEnum.MAIN, new ArrayList<>()); - menuItemRepository.save(menuItem1); - // Create Menu - MenuRestaurant menu1 = new MenuRestaurant("M01", "Menu básico", 10.0,"Un plato y bebida", true,true,new ArrayList<>()); + //save update maincourse - // add menuitem to menu - menu1.addMenuItem(menuItem1); - menuRepository.save(menu1); + MainCourse updateMainCourse = menuItemRepository.save(savedMainCourse); - //verify the relationship + //verify updated - Optional foundMenu = menuRepository.findById("M01"); - System.out.println("Menu1: " ); - System.out.println(foundMenu.get()); - System.out.println("--------------------"); + assertThat(updateMainCourse.getName()).isEqualTo("Chicken Crispy"); - // Check that Menu is found - assertThat(foundMenu).isPresent(); - //assertThat(foundMenu.get().getMenuItems()).hasSize(1); - assertThat(foundMenu.get().getMenuItems()).contains(menuItem1); } + @Test + public void testDeleteMainCourse() { + // Create and save MainCourse + MenuItem savedMainCourse = menuItemRepository.save(new MainCourse( + UUID.randomUUID().toString(), + "Beef Wellington", + "Tender beef wrapped in pastry", + 25.00, + "vegetables", + 700, + false + )); + + // Delete the item + menuItemRepository.delete(savedMainCourse); + + // Verifi that the item doesn't exists in the database + Optional deletedItem = menuItemRepository.findById(savedMainCourse.getId()); + assertThat(deletedItem).isNotPresent(); + } + + @Test + public void testGetItemType() { + // Create a MainCourse and Dessert + MenuItem mainCourse = new MainCourse( + UUID.randomUUID().toString(), // Generar un ID único + "Grilled Chicken", + "Grilled chicken with vegetables", + 12.50, + "vegetable", + 500, + true + ); + + MenuItem sidecourse = new SideCourse( + UUID.randomUUID().toString(), + "Green Beans", + "Fresh steamed green beans", + 6.00, + false, + "beans", + 8 + ); + + // check that the type is correct before saving. + assertThat(mainCourse.getItemType()).isEqualTo("MainCourse"); + assertThat(sidecourse.getItemType()).isEqualTo("Dessert"); + + // save in database + menuItemRepository.save(mainCourse); + menuItemRepository.save(sidecourse); + + // retrieved and verify the type is correct. + Optional retrievedMainCourse = menuItemRepository.findById(mainCourse.getId()); + Optional retrievedDessert = menuItemRepository.findById(sidecourse.getId()); + + assertThat(retrievedMainCourse).isPresent(); + assertThat(retrievedMainCourse.get().getItemType()).isEqualTo("MainCourse"); + + assertThat(retrievedDessert).isPresent(); + assertThat(retrievedDessert.get().getItemType()).isEqualTo("SideCourse"); + } } \ No newline at end of file From 518eb159253483d6ba4d3c25d893c4bcfae0c1ed Mon Sep 17 00:00:00 2001 From: isaac Date: Sat, 16 Nov 2024 20:30:47 +0100 Subject: [PATCH 11/11] Create MenuItemTest --- .../java/dev/example/restaurantManager/MenuMenuItemTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/java/dev/example/restaurantManager/MenuMenuItemTest.java b/src/test/java/dev/example/restaurantManager/MenuMenuItemTest.java index 8d37ac8..8db040d 100644 --- a/src/test/java/dev/example/restaurantManager/MenuMenuItemTest.java +++ b/src/test/java/dev/example/restaurantManager/MenuMenuItemTest.java @@ -2,7 +2,6 @@ import dev.example.restaurantManager.RestaurantManagerApplication; -import dev.example.restaurantManager.model.Dessert; import dev.example.restaurantManager.model.MainCourse; import dev.example.restaurantManager.model.MenuItem; import dev.example.restaurantManager.model.SideCourse; @@ -128,6 +127,7 @@ public void testSaveAndRetrieveAllMenuItems() { } + @Test public void testUpdateMainCourse() { // Create and save MainCourse