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..88d8384 --- /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.MenuRestaurantService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; + +import java.util.Date; +import java.util.List; + +@RequestMapping("/api/v1/menu") +@RestController +public class MenuController { + + + @Autowired + private MenuRestaurantService 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..96466ef --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/controller/MenuItemController.java @@ -0,0 +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.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; +import java.util.List; + +@RestController +@RequestMapping("/api/menuitems") +public class MenuItemController { + @Autowired + private MenuItemService menuItemService; + + // Get all MenuItems (including MainCourse and Dessert) + + @GetMapping + public ResponseEntity> getAllMenuItems() { + List menuItems = menuItemService.getAllMenuItems(); + return new ResponseEntity<>(menuItems, HttpStatus.OK); + } + + // Create a MenuItem (can be a MainCourse, Dessert, or other MenuItem) + + @PostMapping + public ResponseEntity createMenuItem(@RequestBody MenuItem menuItem) { + 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 + + @PutMapping("/{id}") + public ResponseEntity updateMenuItem(@PathVariable String id, @RequestBody MenuItem menuItemDetails) { + MenuItem updatedMenuItem = menuItemService.updateMenuItem(id, menuItemDetails); + if (updatedMenuItem != null) { + return new ResponseEntity<>(updatedMenuItem, HttpStatus.OK); + } + return new ResponseEntity<>(HttpStatus.NOT_FOUND); + } + // Delete a MenuItem by ID + + @DeleteMapping("/{id}") + public ResponseEntity deleteMenuItem(@PathVariable String id) { + boolean deleted = menuItemService.deleteMenuItem(id); + if (deleted) { + return new ResponseEntity<>(HttpStatus.NO_CONTENT); + } + return new ResponseEntity<>(HttpStatus.NOT_FOUND); + } + // Get the count of all MenuItems + + @GetMapping("/count") + public ResponseEntity countMenuItems() { + long count = menuItemService.countMenuItems(); + return new ResponseEntity<>(count, HttpStatus.OK); + } + + // Endpoint to create a MainCourse + @PostMapping("/maincourse") + public ResponseEntity createMainCourse(@RequestBody MainCourse mainCourse){ + MainCourse newMainCourse = menuItemService.createMainCourse(mainCourse); + return new ResponseEntity<>(newMainCourse, HttpStatus.CREATED); + } + + @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/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/controller/TableRestaurantController.java b/src/main/java/dev/example/restaurantManager/controller/TableRestaurantController.java new file mode 100644 index 0000000..df84d7c --- /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.TableRestaurant; +import dev.example.restaurantManager.service.TableRestaurantService; +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 TableRestaurantService 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 TableRestaurant table){ + TableRestaurant 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 TableRestaurant tableDetails) { + TableRestaurant 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){ + TableRestaurant 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..08bcf7f 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; +import java.util.List; @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) { + double totalPayment, boolean paid, List menus, + 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/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 new file mode 100644 index 0000000..398e6fb --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/model/MenuItem.java @@ -0,0 +1,42 @@ +package dev.example.restaurantManager.model; + +import dev.example.restaurantManager.model.interfaces.IMenuItem; +import jakarta.persistence.*; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import java.util.List; +@Data +@AllArgsConstructor +@NoArgsConstructor +@Entity +@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 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; + } + + @Override + public String getItemType() { + // You can return the class type as the item type + return this.getClass().getSimpleName(); + } + @Override + 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/MenuRestaurant.java b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java index 1d2d819..f41c7b5 100644 --- a/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java @@ -1,20 +1,19 @@ 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 +23,36 @@ public class MenuRestaurant { private boolean active; private boolean water; - @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) { + @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, 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 +65,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/OrderMenuQty.java b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java new file mode 100644 index 0000000..1730748 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java @@ -0,0 +1,48 @@ +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 orderMapped; + + @ManyToOne + @JoinColumn(name = "MENU_FK_ID") + private MenuRestaurant menuMapped; + + private int quantity; + + + 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/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 6375dc2..478defd 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/SideCourse.java b/src/main/java/dev/example/restaurantManager/model/SideCourse.java new file mode 100644 index 0000000..e3f9e3f --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/model/SideCourse.java @@ -0,0 +1,43 @@ +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 + + } + + 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)", + 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 diff --git a/src/main/java/dev/example/restaurantManager/model/TableRestaurant.java b/src/main/java/dev/example/restaurantManager/model/TableRestaurant.java index bc13e0a..196b506 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,51 @@ 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; + } + + public TableRestaurant(String string, String s, E option, Integer integer, boolean bool) { + } + + // 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/model/TakeAwayOrder.java b/src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java index e285789..606b004 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 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..d958094 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/repository/MenuItemRepository.java @@ -0,0 +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(); + + } + + 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/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..5cb1362 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/MenuItemService.java @@ -0,0 +1,24 @@ +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; + +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); + + 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/service/MenuItemServiceImpl.java b/src/main/java/dev/example/restaurantManager/service/MenuItemServiceImpl.java new file mode 100644 index 0000000..ac50ec2 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/MenuItemServiceImpl.java @@ -0,0 +1,75 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.MainCourse; +import dev.example.restaurantManager.model.MenuItem; +import dev.example.restaurantManager.model.SideCourse; +import dev.example.restaurantManager.repository.MenuItemRepository; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; +import java.util.List; +import java.util.UUID; + +@Service +public class MenuItemServiceImpl implements MenuItemService { + @Autowired + private MenuItemRepository menuItemRepository; + + //Retrieve all MenuItems including subtypes + @Override + 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); + } + + //Save a MainCourse + public MainCourse createMainCourse(MainCourse mainCourse){ + mainCourse.setId(UUID.randomUUID().toString()); + return menuItemRepository.save(mainCourse); + } + + //Save SideCourse + + public SideCourse createSideCourse(SideCourse dessert){ + dessert.setId(UUID.randomUUID().toString()); + return menuItemRepository.save(dessert); + } + + //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) { + menuItem.setName(menuItemDetails.getName()); + menuItem.setDescription(menuItemDetails.getDescription()); + menuItem.setPrice(menuItemDetails.getPrice()); + return menuItemRepository.save(menuItem); + } + return null; + } + @Override + public boolean deleteMenuItem(String id) { + if (menuItemRepository.existsById(id)) { + menuItemRepository.deleteById(id); + return true; + } + return false; + } + @Override + public long countMenuItems() { + return menuItemRepository.count(); + } +} + + diff --git a/src/main/java/dev/example/restaurantManager/service/MenuRestaurantService.java b/src/main/java/dev/example/restaurantManager/service/MenuRestaurantService.java new file mode 100644 index 0000000..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/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..c1dbe86 --- /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.setOrderMapped(OrderMenuQtyDetails.getOrderMapped()); + orderMenuQty.setMenuMapped(OrderMenuQtyDetails.getMenuMapped()); + + 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 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/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/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/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/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..8db040d --- /dev/null +++ b/src/test/java/dev/example/restaurantManager/MenuMenuItemTest.java @@ -0,0 +1,219 @@ +package dev.example.restaurantManager; + + +import dev.example.restaurantManager.RestaurantManagerApplication; +import dev.example.restaurantManager.model.MainCourse; +import dev.example.restaurantManager.model.MenuItem; +import dev.example.restaurantManager.model.SideCourse; +import dev.example.restaurantManager.repository.MenuItemRepository; +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.context.SpringBootTest; +import static org.assertj.core.api.Assertions.assertThat; + +import java.util.Optional; +import java.util.UUID; + +@SpringBootTest(classes = RestaurantManagerApplication.class)public class MenuItemTest { + + @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 testUpdateMainCourse() { + // Create and save MainCourse + MainCourse savedMainCourse = menuItemRepository.save(new MainCourse( + UUID.randomUUID().toString(), + "Chicken Breast", + "Grilled chicken breast", + 14.00, + "vegetable", + 500, + true + )); + + savedMainCourse.setName("Chicken Crispy"); + + //save update maincourse + + MainCourse updateMainCourse = menuItemRepository.save(savedMainCourse); + + //verify updated + + assertThat(updateMainCourse.getName()).isEqualTo("Chicken Crispy"); + + + } + + @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 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 a3c8f84..82b0a05 100644 --- a/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java +++ b/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java @@ -1,194 +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