diff --git a/_PRA/PRA03.md b/_PRA/PRA03.md new file mode 100644 index 0000000..4922429 --- /dev/null +++ b/_PRA/PRA03.md @@ -0,0 +1,204 @@ +# PRA03: Implementing ManyToMany Relationships in JPA + +## CIFO La Violeta - FullStack IFCD0021-24 MF01-02-03 + +In this practical exercise, you will enhance the `RestaurantManager` project by implementing a `ManyToMany` relationship between `Menu` and `MenuItem` entities using JPA and Spring Boot. + +You'll design, implement, and test this relationship using an in-memory H2 database and `JpaRepository`, with a focus on the automatic creation of a join table using `@JoinTable`. + +## Objectives + +Implement and test a `ManyToMany` relationship between `Menu` and `MenuItem` entities in the `RestaurantManager` project using **Spring Data JPA**, exploring both unidirectional and bidirectional relationships. + +### Project Base + +- Existing Repository: [Restaurant Manager](https://github.com/AlbertProfe/restaurantManager/commits/master/) +- Reference Lab: [Spring Boot Lab 8.3](https://albertprofe.dev/springboot/sblab8-3.html) +- Reference Lab: [Spring Boot Lab 8.4](https://albertprofe.dev/springboot/sblab8-4.html) + +### Tasks + +Summary tasks: + +- [ ] Design Entity Classes +- [ ] Implement JPA Repositories +- [ ] Create Service Layer +- [ ] Develop REST Controllers +- [ ] Configure H2 Database +- [ ] Write Unit Tests +- [ ] Test with Swagger API + +Tasks: + +1. **Design Entity Classes** + + - Create or update the `Menu` and `MenuItem` entity classes. + - Implement a ManyToMany relationship between `Menu` and `MenuItem`. + - Use appropriate JPA annotations such as `@ManyToMany` and `@JoinTable`. + - Implement both unidirectional and bidirectional cases when it is possible. + - Address the infinite recursion issue that can lead to `StackOverflowError`. + +2. **Implement JPA Repositories** + + - Create JPA repository interfaces for both `Menu` and `MenuItem`. + - ~~Add any necessary custom query methods.~~ + +3. **Create Service Layer** + + - Develop service interfaces and implementations for both entities. + - Include methods to handle the relationship between `Menu` and `MenuItem`. + - Implement CRUD operations ~~and any additional business logic.~~ + +4. **Develop REST Controllers** + + - Create REST controllers for `Menu` and `MenuItem`. + - Implement endpoints that demonstrate the relationship between the entities. + - Use appropriate HTTP methods for each operation. + +5. **Configure H2 Database** + + - Set up the H2 in-memory database in your `application.properties` or `application.yml` file. + - Configure Hibernate to create the schema automatically. + +6. **Write Unit Tests** + + - Create unit tests for your repositories, services, and controllers. + - Test the `ManyToMany` relationships thoroughly. + - Verify that CRUD operations work correctly with the relationship in place. + +7. **Test with Swagger API** + + - Configure Swagger for your Spring Boot application. + - Use Swagger UI to test all implemented REST endpoints. + - Verify that the relationship between `Menu` and `MenuItem` is correctly represented and functional. + +### Example MenuItem Entity + +Here's a proposed example for the `MenuItem` entity: + +```java +@Entity +public class MenuItem { + @Id + @GeneratedValue(generator = "UUID") + @GenericGenerator(name = "UUID", strategy = "org.hibernate.id.UUIDGenerator") + private String id; + + private String name; + private String description; + private boolean isSpicy; + private boolean hasGluten; + private boolean isAvailable; + + @Enumerated(EnumType.STRING) + private CourseType courseType; + + @ManyToMany(mappedBy = "menuItems") + private Set menus = new HashSet<>(); + + // Default constructor + public MenuItem() { + this.id = UUID.randomUUID().toString(); + } + + // Constructors, getters, and setters +} + +public enum CourseType { + STARTER, + MAIN, + DESSERT +} +``` + +### Unidirectional vs Bidirectional ManyToMany + +Explore the differences between unidirectional and bidirectional `ManyToMany` relationships: + +- **Unidirectional**: Only one entity maintains the relationship. +- **Bidirectional**: Both entities are aware of the relationship. + +Address the infinite recursion issue in bidirectional relationships that can lead to StackOverflowError when serializing to JSON. + +Implement a solution using `@JsonIgnore`,`@JsonManagedReference` and `@JsonBackReference` or by customizing the JSON serialization process. + + + +**Unidirectional Relationship** + +- Only one entity maintains the relationship +- Simpler to implement and manage +- Less coupling between entities +- May be sufficient for basic use cases + +**Bidirectional Relationship** + +- Both entities are aware of the relationship +- Provides more flexibility in querying and navigating the relationship +- Requires careful management to maintain consistency +- More suitable for complex domain models + +**Addressing Infinite Recursion** + +Bidirectional relationships can lead to infinite recursion when serializing to JSON, causing a StackOverflowError. This occurs because each entity references the other, creating an endless loop during serialization. + +Solutions + +1. **@JsonIgnore Annotation** + + - Apply `@JsonIgnore` to one side of the relationship + - Prevents the annotated property from being serialized + - Simple but may limit data access in some scenarios + + + + ```java + public class Menu { + + @ManyToMany + @JsonIgnore + private Set menuItems; + } + ``` + +2. **Custom Serialization** + + - Implement custom serializer classes + - Provides fine-grained control over JSON output + - More complex but offers greater flexibility + +3. **DTO Pattern** + + - Create Data Transfer Objects (DTOs) for API responses + - Allows explicit control over what data is transferred + - Separates API representation from domain model + +4. **Lazy Loading** + + - Use lazy loading for related entities + - Prevents automatic loading of related entities unless explicitly requested + - Requires careful handling in service layer + +By implementing one or a combination of these solutions, you can effectively manage bidirectional relationships while avoiding infinite recursion issues in your Spring Boot application. + +### Submission Guidelines + +- Fork the existing [Restaurant Manager](https://github.com/AlbertProfe/restaurantManager/commits/master/) repository and clone it to your local environment. +- Create a new branch named `PRA03-YourName` from the latest commit. +- Commit your changes with clear, descriptive messages. +- Push your branch to your forked repository. +- Create a pull request to the AlbertProfe repository with a summary of your changes, titled: + - `PRA03-YourName-ManyToManyRelationshipImplementation` + +### Evaluation Criteria + +- Correct implementation of the ManyToMany relationship with automatic join table creation. +- Proper use of JPA annotations and Spring Data JPA features. +- Functionality of the service layer and controllers in handling the relationship. +- Quality and coverage of unit tests. +- Successful configuration and use of the H2 in-memory database. +- Clarity and completeness of Swagger API documentation and tests. +- Proper handling of bidirectional relationship and infinite recursion issues. +- Overall code quality, organization, and documentation. + +Good luck with your implementation! Remember to test thoroughly and document your code clearly. \ No newline at end of file diff --git a/src/main/java/dev/example/restaurantManager/RestaurantManagerApplication.java b/src/main/java/dev/example/restaurantManager/RestaurantManagerApplication.java index cfe02ce..99acbf9 100644 --- a/src/main/java/dev/example/restaurantManager/RestaurantManagerApplication.java +++ b/src/main/java/dev/example/restaurantManager/RestaurantManagerApplication.java @@ -1,6 +1,8 @@ package dev.example.restaurantManager; import dev.example.restaurantManager.utilities.CustomerDataLoader; +import dev.example.restaurantManager.utilities.MenuDataLoader; +import dev.example.restaurantManager.utilities.TableDataLoader; import org.springframework.boot.ApplicationRunner; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @@ -14,11 +16,15 @@ public class RestaurantManagerApplication { public static void main(String[] args) { SpringApplication.run(RestaurantManagerApplication.class, args); } -/* - @Bean - public ApplicationRunner dataLoader(CustomerDataLoader customerDataLoader) { - return args -> customerDataLoader.createFakeCustomers(); + +/* @Bean + public ApplicationRunner dataLoader(CustomerDataLoader customerDataLoader, TableDataLoader tableDataLoader, MenuDataLoader menuDataLoader) { + return args -> { + customerDataLoader.createFakeCustomers(); + tableDataLoader.createFakeTables(); + menuDataLoader.createFakeMenus(); + }; } */ 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..5b0ec21 --- /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; + } + +} 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/OrderController.java b/src/main/java/dev/example/restaurantManager/controller/OrderController.java new file mode 100644 index 0000000..82b32a4 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/controller/OrderController.java @@ -0,0 +1,72 @@ +package dev.example.restaurantManager.controller; + +import dev.example.restaurantManager.model.OrderRestaurant; +import dev.example.restaurantManager.repository.OrderMenuQtyRepository; +import dev.example.restaurantManager.repository.OrderRepository; +import dev.example.restaurantManager.service.OrderRestaurantService; +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/orders") +public class OrderController { + + @Autowired + private OrderRestaurantService orderService; + + 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("order-count", String.valueOf(orderService.countOrders())); // Agregando el conteo de órdenes + headers.add("object", "orders"); + return headers; + } + + // Get all orders + @GetMapping + public ResponseEntity> getAllOrders() { + List orders = orderService.getAllOrders(); + HttpHeaders headers = getCommonHeaders("List of all orders"); + return orders != null && !orders.isEmpty() + ? new ResponseEntity<>(orders, headers, HttpStatus.OK) + : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + } + + // Create a new order + @PostMapping + public ResponseEntity createOrder(@RequestBody OrderRestaurant order) { + OrderRestaurant savedOrder = orderService.createOrder(order); + HttpHeaders headers = getCommonHeaders("Order created successfully"); + return new ResponseEntity<>(savedOrder, headers, HttpStatus.CREATED); + } + + // Update an existing order + @PutMapping("/{id}") + public ResponseEntity updateOrder(@PathVariable String id, @RequestBody OrderRestaurant orderDetails) { + OrderRestaurant updatedOrder = orderService.updateOrder(id, orderDetails); + HttpHeaders headers = getCommonHeaders(updatedOrder != null ? "Order updated successfully" : "Order not found"); + return updatedOrder != null + ? new ResponseEntity<>(updatedOrder, headers, HttpStatus.OK) + : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + } + + // Delete an order + @DeleteMapping("/{id}") + public ResponseEntity deleteOrder(@PathVariable String id) { + boolean isDeleted = orderService.deleteOrder(id); + HttpHeaders headers = getCommonHeaders(isDeleted ? "Order deleted successfully" : "Order not found"); + return isDeleted + ? new ResponseEntity<>(null, headers, HttpStatus.NO_CONTENT) + : new ResponseEntity<>(null, headers, HttpStatus.NOT_FOUND); + } +} \ No newline at end of file diff --git a/src/main/java/dev/example/restaurantManager/controller/OrderMenuQtyRestController.java b/src/main/java/dev/example/restaurantManager/controller/OrderMenuQtyRestController.java new file mode 100644 index 0000000..acf0840 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/controller/OrderMenuQtyRestController.java @@ -0,0 +1,85 @@ +package dev.example.restaurantManager.controller; + + +import dev.example.restaurantManager.model.OrderMenuQty; +import dev.example.restaurantManager.service.OrderMenuQtyService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; + +import java.util.Date; +import java.util.List; + +@RequestMapping("/api/v1/orderMenuQty") +@RestController +public class OrderMenuQtyRestController { + + @Autowired + private OrderMenuQtyService orderMenuQtyService; + + @GetMapping("allOrderMenuQty") + public ResponseEntity> getAllOrderMenuQty(){ + List orderMenuQtyList = orderMenuQtyService.getAllOrderMenuQty(); + HttpHeaders headers = getCommonHeaders("Get all OrderMenuQty entries"); + return orderMenuQtyList !=null && !orderMenuQtyList.isEmpty() + ?new ResponseEntity<>(orderMenuQtyList,headers, HttpStatus.OK) + :new ResponseEntity<>(headers,HttpStatus.NOT_FOUND); + } + + @PostMapping + public ResponseEntity createOrderMenuQty(@RequestBody OrderMenuQty orderMenuQty){ + OrderMenuQty createdOrderMenuQty = orderMenuQtyService.createOrderMenuQty(orderMenuQty); + HttpHeaders headers = getCommonHeaders("Create a new OrderMenuQty"); + return createdOrderMenuQty !=null + ?new ResponseEntity<>(createdOrderMenuQty,headers,HttpStatus.CREATED) + :new ResponseEntity<>(headers,HttpStatus.BAD_REQUEST); + + } + + @PutMapping("/{id}") + public ResponseEntity updatedOrderMenuQty(@PathVariable String id, @RequestBody OrderMenuQty orderMenuQtyDetails){ + OrderMenuQty updatedOrderMenuQty = orderMenuQtyService.updateOrderMenuQty(id, orderMenuQtyDetails); + HttpHeaders headers = getCommonHeaders("Updated a OrderMenuQty"); + + return updatedOrderMenuQty !=null + ?new ResponseEntity<>(updatedOrderMenuQty, headers, HttpStatus.OK) + :new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + } + + @DeleteMapping("/{id}") + public ResponseEntity deleteOrderMenuQty(@PathVariable String id){ + boolean deleted = orderMenuQtyService.deleteOrderMenuQty(id); + HttpHeaders headers = getCommonHeaders("delete an OrderMenuQty"); + + return deleted + ? new ResponseEntity<>(headers, HttpStatus.NO_CONTENT) + : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND); + + } + + @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/TableController.java b/src/main/java/dev/example/restaurantManager/controller/TableController.java new file mode 100644 index 0000000..fe60555 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/controller/TableController.java @@ -0,0 +1,83 @@ +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 TableController { + + @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; + } +} + diff --git a/src/main/java/dev/example/restaurantManager/model/Booking.java b/src/main/java/dev/example/restaurantManager/model/Booking.java index 61d80e0..d26f391 100644 --- a/src/main/java/dev/example/restaurantManager/model/Booking.java +++ b/src/main/java/dev/example/restaurantManager/model/Booking.java @@ -24,7 +24,7 @@ public class Booking { @JsonIgnore @ManyToOne(fetch = FetchType.LAZY) @JoinColumn(name = "TABLE_RESTAURANT_FK_ID") - private TableRestaurant tableRestaurantMapped; + private RestaurantTable tableRestaurantMapped; // Custom toString method (optional, as @Data provides a default toString) @Override diff --git a/src/main/java/dev/example/restaurantManager/model/CourseType.java b/src/main/java/dev/example/restaurantManager/model/CourseType.java new file mode 100644 index 0000000..4325f89 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/model/CourseType.java @@ -0,0 +1,9 @@ +package dev.example.restaurantManager.model; + +public enum CourseType { + + STARTER, + MAIN, + DESSERT + +} diff --git a/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java index cd008bd..86705ec 100644 --- a/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java @@ -1,33 +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 RestaurantTable 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, + RestaurantTable 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..326b477 --- /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 CourseType 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 43c2804..25ce12e 100644 --- a/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java @@ -1,22 +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.io.Serializable; 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; @@ -26,20 +23,39 @@ public class MenuRestaurant { private boolean active; private boolean water; - @ManyToMany(mappedBy = "menus", fetch = FetchType.LAZY) - private List orders = new ArrayList<>(); + @ManyToMany(fetch = FetchType.LAZY) + @JsonIgnore + @JoinTable( + name = "menu_menuItem", + joinColumns = @JoinColumn(name = "menu_id"), + inverseJoinColumns = @JoinColumn(name = "menuItem_id") + ) + private List menuItems = new ArrayList<>(); - public MenuRestaurant(String id, String name, Double price, String content, boolean active, boolean water) { + + + + 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 @Override public String toString() { @@ -50,8 +66,27 @@ public String toString() { ", content='" + content + '\'' + ", active=" + active + ", water=" + water + + ", 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 + } + } 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..10bd74f --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java @@ -0,0 +1,51 @@ +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_id") + private OrderRestaurant orderMapped; + + @ManyToOne + @JoinColumn(name = "menu_id") + private MenuRestaurant menuMapped; + + private int quantity; + + + // Constructor con parámetros para inicializar los atributos + public OrderMenuQty(OrderRestaurant orderRestaurant, MenuRestaurant menuRestaurant, int quantity) { + this.orderMapped = orderRestaurant; // Inicializa el campo orderMapped + this.menuMapped = menuRestaurant; // Inicializa el campo menuMapped + this.quantity = quantity; // Inicializa el campo quantity + } + @Override + public String toString() { + return "OrderMenuQty{" + + "id='" + id + '\'' + + ", orderMapped=" + orderMapped.getId() + // Solo el ID para evitar un bucle + ", menuMapped=" + menuMapped.getName() + // Solo el nombre del menú + ", quantity=" + quantity + + '}'; + } + + } + + diff --git a/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java index 303892b..f73d9b0 100644 --- a/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java @@ -26,30 +26,16 @@ 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 @@ -61,8 +47,7 @@ public String toString() { ", peopleQty=" + peopleQty + ", totalPayment=" + totalPayment + ", paid=" + paid + - ", menusCount=" + (menus != null ? menus.size() : 0) + + ", orderMenuQtyList=" + orderMenuQtyList + '}'; } - } \ No newline at end of file diff --git a/src/main/java/dev/example/restaurantManager/model/RestaurantTable.java b/src/main/java/dev/example/restaurantManager/model/RestaurantTable.java new file mode 100644 index 0000000..de0fd91 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/model/RestaurantTable.java @@ -0,0 +1,83 @@ +package dev.example.restaurantManager.model; + +import jakarta.persistence.*; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.util.ArrayList; + +@Data +@AllArgsConstructor +@NoArgsConstructor +@Entity +public class RestaurantTable { + + @Id + private String id; + private String name; + private String description; + 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 RestaurantTable(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 RestaurantTable(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 bookings + public void addBooking(Booking booking) { + this.getBookings().add(booking); + if (booking.getTableRestaurantMapped() != null) booking.getTableRestaurantMapped().getBookings().remove(booking); + booking.setTableRestaurantMapped(this); + } + + @Override + public String toString() { + return "Table{" + + "id='" + id + '\'' + + "name='" + name + '\'' + + ", description='" + description + '\'' + + ", qty=" + qty + + ", busy=" + busy + + '}'; + } + + +} \ 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 364718b..478defd 100644 --- a/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java @@ -4,8 +4,8 @@ import lombok.Data; import lombok.NoArgsConstructor; -import java.util.ArrayList; import java.util.Date; +import java.util.List; @Data @AllArgsConstructor @@ -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, 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/TableRestaurant.java b/src/main/java/dev/example/restaurantManager/model/TableRestaurant.java deleted file mode 100644 index bbd18fd..0000000 --- a/src/main/java/dev/example/restaurantManager/model/TableRestaurant.java +++ /dev/null @@ -1,54 +0,0 @@ -package dev.example.restaurantManager.model; - -import jakarta.persistence.CascadeType; -import jakarta.persistence.Entity; -import jakarta.persistence.Id; -import jakarta.persistence.OneToMany; -import lombok.AllArgsConstructor; -import lombok.Data; -import lombok.NoArgsConstructor; - -import java.util.ArrayList; - -@Data -@AllArgsConstructor -@NoArgsConstructor -@Entity -public class TableRestaurant { - - @Id - private String id; - private String name; - private String description; - private int qty; - private boolean busy; - - @OneToMany(mappedBy = "tableRestaurantMapped", cascade = CascadeType.ALL) - private ArrayList bookings ; - - - // we must create a VERY CONCRETE constructor to RUN the OLD tests - public TableRestaurant(String name, String description , int qty, boolean busy) { - } - - - //method to add - public void addBooking(Booking booking) { - this.getBookings().add(booking); - if (booking.getTableRestaurantMapped() != null) booking.getTableRestaurantMapped().getBookings().remove(booking); - booking.setTableRestaurantMapped(this); - } - - @Override - public String toString() { - return "Table{" + - "id='" + id + '\'' + - "name='" + name + '\'' + - ", description='" + description + '\'' + - ", qty=" + qty + - ", busy=" + busy + - '}'; - } - - -} \ No newline at end of file diff --git a/src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java b/src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java index 3091a2a..76ecff4 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 @@ -18,9 +19,10 @@ public class TakeAwayOrder extends OrderRestaurant { @JoinColumn(name = "CUSTOMER_TA_FK_ID") private Customer customerTakeAway; + // 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..0444684 --- /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 { +} 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..d7b67a2 --- /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 { + + +} diff --git a/src/main/java/dev/example/restaurantManager/repository/OrderMenuQtyRepository.java b/src/main/java/dev/example/restaurantManager/repository/OrderMenuQtyRepository.java new file mode 100644 index 0000000..962ccb7 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/repository/OrderMenuQtyRepository.java @@ -0,0 +1,7 @@ +package dev.example.restaurantManager.repository; + +import dev.example.restaurantManager.model.OrderMenuQty; +import org.springframework.data.jpa.repository.JpaRepository; + +public interface OrderMenuQtyRepository extends JpaRepository { +} diff --git a/src/main/java/dev/example/restaurantManager/repository/TableRepository.java b/src/main/java/dev/example/restaurantManager/repository/TableRepository.java new file mode 100644 index 0000000..9d9e11d --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/repository/TableRepository.java @@ -0,0 +1,12 @@ +package dev.example.restaurantManager.repository; + +import dev.example.restaurantManager.model.RestaurantTable; +import org.springframework.data.jpa.repository.JpaRepository; + +import java.util.Optional; + +public interface TableRepository extends JpaRepository { + + Optional findByName(String name); + +} diff --git a/src/main/java/dev/example/restaurantManager/repository/TableRestaurantRepository.java b/src/main/java/dev/example/restaurantManager/repository/TableRestaurantRepository.java deleted file mode 100644 index f789c82..0000000 --- a/src/main/java/dev/example/restaurantManager/repository/TableRestaurantRepository.java +++ /dev/null @@ -1,9 +0,0 @@ -package dev.example.restaurantManager.repository; - - - -import dev.example.restaurantManager.model.TableRestaurant; -import org.springframework.data.jpa.repository.JpaRepository; - -public interface TableRestaurantRepository extends JpaRepository { -} 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..06c9181 --- /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(); +} 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..7fae2e2 --- /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(); + } + + +} 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..8eab067 --- /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); + +} 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..7cf267f --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/MenuItemServiceImpl.java @@ -0,0 +1,92 @@ +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.MenuRepository; +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 + MenuRepository 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/MenuService.java b/src/main/java/dev/example/restaurantManager/service/MenuService.java new file mode 100644 index 0000000..036ba03 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/MenuService.java @@ -0,0 +1,15 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.MenuRestaurant; + +import java.util.List; + +public interface MenuService { + + 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/MenuServiceImpl.java b/src/main/java/dev/example/restaurantManager/service/MenuServiceImpl.java new file mode 100644 index 0000000..7b5eef5 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/MenuServiceImpl.java @@ -0,0 +1,70 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.MenuRestaurant; +import dev.example.restaurantManager.repository.MenuRepository; +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 MenuServiceImpl implements MenuService { + + @Autowired + private MenuRepository 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..0bc7e8b --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/OrderMenuQtyService.java @@ -0,0 +1,27 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.OrderMenuQty; + +import java.util.List; + +public interface OrderMenuQtyService { + + // Retrieves all OrderMenuQty records + List getAllOrderMenuQty(); + + // Creates a new OrderMenuQty entry + OrderMenuQty createOrderMenuQty(OrderMenuQty orderMenuQty); + + // Retrieves an OrderMenuQty entry by ID + OrderMenuQty getOrderMenuQtyById(String id); + + // Updates an existing OrderMenuQty entry + OrderMenuQty updateOrderMenuQty(String id, OrderMenuQty orderMenuQtyDetails); + + // Deletes an OrderMenuQty entry by ID + boolean deleteOrderMenuQty(String id); + + // Counts all OrderMenuQty entries + 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..97073cf --- /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(); + } + + +} diff --git a/src/main/java/dev/example/restaurantManager/service/OrderRestaurantService.java b/src/main/java/dev/example/restaurantManager/service/OrderRestaurantService.java new file mode 100644 index 0000000..8cce4ca --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/OrderRestaurantService.java @@ -0,0 +1,15 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.OrderRestaurant; + +import java.util.List; + +public interface OrderRestaurantService { + + List getAllOrders(); + OrderRestaurant createOrder(OrderRestaurant order); + OrderRestaurant getOrderById(String id); + OrderRestaurant updateOrder(String id, OrderRestaurant orderDetails); + boolean deleteOrder(String id); + public long countOrders(); +} diff --git a/src/main/java/dev/example/restaurantManager/service/OrderRestaurantServiceImpl.java b/src/main/java/dev/example/restaurantManager/service/OrderRestaurantServiceImpl.java new file mode 100644 index 0000000..9a3d6df --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/OrderRestaurantServiceImpl.java @@ -0,0 +1,60 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.OrderRestaurant; +import dev.example.restaurantManager.repository.OrderRepository; +import org.springframework.beans.factory.annotation.Autowired; + +import java.util.List; + +public class OrderRestaurantServiceImpl implements OrderRestaurantService { + + @Autowired + private OrderRepository orderRepository; + + @Override + public List getAllOrders() { + return orderRepository.findAll(); + } + + @Override + public OrderRestaurant createOrder(OrderRestaurant order) { + return orderRepository.save(order); + } + + @Override + public OrderRestaurant getOrderById(String id) { + return orderRepository.findById(id).orElse(null); + } + + @Override + public OrderRestaurant updateOrder(String id, OrderRestaurant orderDetails) { + OrderRestaurant existingOrder = getOrderById(id); + if (existingOrder != null) { + existingOrder.setDate(orderDetails.getDate()); + existingOrder.setWaiter(orderDetails.getWaiter()); + existingOrder.setPeopleQty(orderDetails.getPeopleQty()); + existingOrder.setTotalPayment(orderDetails.getTotalPayment()); + existingOrder.setPaid(orderDetails.isPaid()); + return orderRepository.save(existingOrder); + } + return null; + } + + @Override + public boolean deleteOrder(String id) { + OrderRestaurant existingOrder = getOrderById(id); + if (existingOrder != null) { + orderRepository.delete(existingOrder); + return true; + } + return false; + } + @Override + public long countOrders() { + return orderRepository.count(); // + } + +} + + + diff --git a/src/main/java/dev/example/restaurantManager/service/TableService.java b/src/main/java/dev/example/restaurantManager/service/TableService.java new file mode 100644 index 0000000..484f4ec --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/TableService.java @@ -0,0 +1,14 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.RestaurantTable; + +import java.util.List; + +public interface TableService { + List getAllTables(); + RestaurantTable createTable(RestaurantTable table); + RestaurantTable getTableByName (String name); + RestaurantTable updateTable (String name, RestaurantTable tableDetails); + boolean deleteTable(String name); + long countTables(); +} diff --git a/src/main/java/dev/example/restaurantManager/service/TableServiceImpl.java b/src/main/java/dev/example/restaurantManager/service/TableServiceImpl.java new file mode 100644 index 0000000..f7152b2 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/TableServiceImpl.java @@ -0,0 +1,68 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.RestaurantTable; +import dev.example.restaurantManager.repository.TableRepository; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.util.List; + +@Service +public class TableServiceImpl implements TableService { + + @Autowired + private TableRepository tableRepository; + @Override + public List getAllTables(){return tableRepository.findAll();} + @Override + public RestaurantTable createTable(RestaurantTable table){ + if(table.getName() == null || table.getName().isEmpty()){ + table.setName("Default Table name"); + } + return tableRepository.save(table); + } + @Override + public RestaurantTable getTableByName(String name) { + return tableRepository.findByName(name).orElse(null); + + } + @Override + public RestaurantTable updateTable(String name, RestaurantTable tableDetails){ + RestaurantTable 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){ + + RestaurantTable table = tableRepository.findByName(name).orElse(null); + if(table == null){ + return false; + } + tableRepository.delete(table); + return true; + } + + @Override + public long countTables(){return tableRepository.count();} + + +} + diff --git a/src/main/java/dev/example/restaurantManager/utilities/MenuDataLoader.java b/src/main/java/dev/example/restaurantManager/utilities/MenuDataLoader.java new file mode 100644 index 0000000..6d290bb --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/utilities/MenuDataLoader.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.MenuRepository; +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 MenuDataLoader { + + @Autowired + private MenuRepository 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"); + + } + } +} \ No newline at end of file diff --git a/src/main/java/dev/example/restaurantManager/utilities/TableDataLoader.java b/src/main/java/dev/example/restaurantManager/utilities/TableDataLoader.java new file mode 100644 index 0000000..3659043 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/utilities/TableDataLoader.java @@ -0,0 +1,47 @@ +package dev.example.restaurantManager.utilities; + +import com.github.javafaker.Faker; +import dev.example.restaurantManager.model.RestaurantTable; +import dev.example.restaurantManager.repository.TableRepository; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; + +import java.util.Locale; +import java.util.UUID; + +@Component +public class TableDataLoader { + + @Autowired + private TableRepository 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++) { + RestaurantTable table = new RestaurantTable(); + + // 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/BookingTableTest.java b/src/test/java/dev/example/restaurantManager/BookingTableTest.java index 2505e1f..aaf20e9 100644 --- a/src/test/java/dev/example/restaurantManager/BookingTableTest.java +++ b/src/test/java/dev/example/restaurantManager/BookingTableTest.java @@ -2,9 +2,9 @@ import dev.example.restaurantManager.model.Booking; -import dev.example.restaurantManager.model.TableRestaurant; +import dev.example.restaurantManager.model.RestaurantTable; import dev.example.restaurantManager.repository.BookingRepository; -import dev.example.restaurantManager.repository.TableRestaurantRepository; +import dev.example.restaurantManager.repository.TableRepository; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; @@ -21,7 +21,7 @@ public class BookingTableTest { @Autowired private BookingRepository bookingRepository; @Autowired - private TableRestaurantRepository tableRestaurantRepository; + private TableRepository tableRepository; @Test public void TestCreateBookingTable() { @@ -36,7 +36,7 @@ public void TestCreateBookingTable() { booking1.setPhoneNumber("561-651-25-25"); // Create tableRestaurant object - TableRestaurant tableRestaurant1 = new TableRestaurant("TR01", "Table 01", + /* RestaurantTable tableRestaurant1 = new RestaurantTable("TR01", "Table 01", "TABLE 01 for 4 people outdoors", 4, false, new ArrayList<>()); // assign booking to tableRestaurant @@ -61,6 +61,8 @@ public void TestCreateBookingTable() { assertThat(found).isPresent(); - + */ } + } + 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..f781396 --- /dev/null +++ b/src/test/java/dev/example/restaurantManager/EatInTest.java @@ -0,0 +1,69 @@ +package dev.example.restaurantManager; + + +import dev.example.restaurantManager.model.EatInOrderRestaurant; +import dev.example.restaurantManager.model.RestaurantTable; +import dev.example.restaurantManager.repository.EatInRepository; +import dev.example.restaurantManager.repository.TableRepository; +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 TableRepository tableRepository; + + @Test + public void TestCreateEatIn(){ + + //Create Table + + RestaurantTable table1 = new RestaurantTable("T01", "Redonda","Mesa pequeña y redonda" , 4,false, new ArrayList<>()); + RestaurantTable table2 = new RestaurantTable("T02", "Cuadrada","Mesa pequeña y cuadrada" ,6,false, new ArrayList<>()); + RestaurantTable table3 = new RestaurantTable("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(); + + } + + } + + + 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..d899f7a --- /dev/null +++ b/src/test/java/dev/example/restaurantManager/MenuMenuItemTest.java @@ -0,0 +1,53 @@ +package dev.example.restaurantManager; + + +import dev.example.restaurantManager.model.CourseType; +import dev.example.restaurantManager.model.MenuItem; +import dev.example.restaurantManager.model.MenuRestaurant; +import dev.example.restaurantManager.repository.MenuItemRepository; +import dev.example.restaurantManager.repository.MenuRepository; +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 MenuRepository 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, CourseType.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); + + } + +} 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..5235638 --- /dev/null +++ b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java @@ -0,0 +1,80 @@ +package dev.example.restaurantManager; + +import dev.example.restaurantManager.model.MenuRestaurant; +import dev.example.restaurantManager.model.OrderMenuQty; +import dev.example.restaurantManager.model.OrderRestaurant; +import dev.example.restaurantManager.repository.MenuRepository; +import dev.example.restaurantManager.repository.OrderMenuQtyRepository; +import dev.example.restaurantManager.repository.OrderRepository; +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.List; +import java.util.Optional; + +@DataJpaTest +public class OrderMenuQtyTest { + + @Autowired + private OrderRepository orderRestaurantRepository; + + @Autowired + private MenuRepository menuRestaurantRepository; + + @Autowired + private OrderMenuQtyRepository orderMenuQtyRepository; + + @Test + public void TestCreateOrderWithMenus() { + // Create Menus + MenuRestaurant menu1 = new MenuRestaurant("M10", "Menu 10", 20.0, "Dos platos y bebida", true, true, new ArrayList<>()); + MenuRestaurant menu2 = new MenuRestaurant("M20", "Menu 20", 25.0, "Tres platos y bebida", true, true, new ArrayList<>()); + MenuRestaurant menu3 = new MenuRestaurant("M30", "Menu 30", 30.0, "Cuatro platos y bebida", true, true, new ArrayList<>()); + + // Save Menus + menuRestaurantRepository.save(menu1); + menuRestaurantRepository.save(menu2); + menuRestaurantRepository.save(menu3); + + // Create an Order + OrderRestaurant order = new OrderRestaurant("01", new Date(), "Juan", 4, 100.0, false, new ArrayList<>()); + + // Add Menus to Order + order.addMenu(menu1, 2); // 2 de Menu 10 + order.addMenu(menu2, 2); // 2 de Menu 20 + order.addMenu(menu3, 1); // 1 de Menu 30 + + // Save Order + orderRestaurantRepository.save(order); + + // Verify the relationship using OrderMenuQty + List orderMenuQtyList = orderMenuQtyRepository.findAll(); + + // Print OrderMenuQty details to console + System.out.println("Order Menu Quantities:"); + for (OrderMenuQty omq : orderMenuQtyList) { + System.out.println("Menu: " + omq.getMenuMapped().getName() + + ", Quantity: " + omq.getQuantity()); + } + + // Verify the size of OrderMenuQty + assertThat(orderMenuQtyList).hasSize(3); // Debe haber 3 menús + + // Verify the order contains the correct menus + Optional foundOrder = orderRestaurantRepository.findById("01"); + assertThat(foundOrder).isPresent(); + + System.out.println("Found Order: " + foundOrder.get()); + + // Check that the found order has the expected OrderMenuQty entries + for (OrderMenuQty omq : foundOrder.get().getOrderMenuQtyList()) { + System.out.println("Menu: " + omq.getMenuMapped().getName() + + ", Quantity: " + omq.getQuantity()); + + } + } +} \ No newline at end of file diff --git a/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java b/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java index 1ac31e0..1ab6e65 100644 --- a/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java +++ b/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java @@ -14,96 +14,96 @@ import static org.assertj.core.api.Assertions.assertThat; -@DataJpaTest -public class RelationshipsOrderRestaurantTest { - -@Autowired -private TakeAwayOrderRepository takeAwayOrderRepository; -@Autowired -private CustomerRepository customerRepository; - - @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 menu3 = new MenuRestaurant("M03","Salad Menu", 8.99, "Mixed salad and dressing", true, true, null); - - // 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, menu3)), "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, menu3)), 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, menu3, menu3)), 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, menu3)), customer3 ); - OrderRestaurant takeAwayOrder3 = new TakeAwayOrder("TO3", new Date(), "Charlie", 3, 32.97, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menu3)), customer5); - OrderRestaurant takeAwayOrder4 = new TakeAwayOrder("TO4", new Date(), "Charlie", 3, 32.97, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menu3, menu3, menu3, menu3)), 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("--------------------"); - } - -} +//@DataJpaTest +//public class RelationshipsOrderRestaurantTest { +// +//@Autowired +//private TakeAwayOrderRepository takeAwayOrderRepository; +//@Autowired +//private CustomerRepository customerRepository; +// +// @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 menu3 = new MenuRestaurant("M03","Salad Menu", 8.99, "Mixed salad and dressing", true, true, null); +// +// // 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 +// RestaurantTable table1 = new RestaurantTable("T1", "Window Table", 4, false); +// RestaurantTable table2 = new RestaurantTable("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, menu3)), "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, menu3)), 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, menu3, menu3)), 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, menu3)), customer3 ); +// OrderRestaurant takeAwayOrder3 = new TakeAwayOrder("TO3", new Date(), "Charlie", 3, 32.97, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menu3)), customer5); +// OrderRestaurant takeAwayOrder4 = new TakeAwayOrder("TO4", new Date(), "Charlie", 3, 32.97, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menu3, menu3, menu3, menu3)), 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("--------------------"); +// } +// +//}