PRA04-EnriqueMiralles-ManyToManyRefactoring

src/main/java/dev/example/restaurantManager/controller/MenuRestaurantController.java

@@ -0,0 +1,82 @@
+package dev.example.restaurantManager.controller;
+
+import dev.example.restaurantManager.model.MenuRestaurant;
+import dev.example.restaurantManager.service.MenuRestaurantService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.Date;
+import java.util.List;
+
+@RequestMapping("/api/v1/menu")
+@RestController
+public class MenuRestaurantController {
+
+    @Autowired
+    private MenuRestaurantService menuRestaurantService;
+
+    @GetMapping("/allMenus")
+    public ResponseEntity<List<MenuRestaurant>> getAllMenus( ) {
+        List<MenuRestaurant> menuRestaurants = menuRestaurantService.getAllMenus();
+        HttpHeaders headers = getCommonHeaders("Get all menus");
+
+        return menuRestaurants != null && !menuRestaurants.isEmpty()
+                ? new ResponseEntity<>(menuRestaurants, headers, HttpStatus.OK)
+                : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND);
+    }
+
+    @PostMapping("/add")
+    public ResponseEntity<MenuRestaurant> createMenu(@RequestBody MenuRestaurant menuRestaurant) {
+        MenuRestaurant createdMenu = menuRestaurantService.createMenu(menuRestaurant);
+        HttpHeaders headers = getCommonHeaders("Create a new menu");
+
+        return createdMenu != null
+                ? new ResponseEntity<>(createdMenu, headers, HttpStatus.CREATED)
+                : new ResponseEntity<>(headers, HttpStatus.BAD_REQUEST);
+    }
+    @PutMapping("/update/{id}")
+    public ResponseEntity<MenuRestaurant> updateMenu(@PathVariable String id, @RequestBody MenuRestaurant menuRestaurantDetails) {
+        MenuRestaurant updatedMenu = menuRestaurantService.updateMenu(id, menuRestaurantDetails);
+        HttpHeaders headers = getCommonHeaders("Update a menu");
+
+        return updatedMenu != null
+                ? new ResponseEntity<>(updatedMenu, headers, HttpStatus.OK)
+                : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND);
+    }
+
+    @DeleteMapping("/delete/{id}")
+    public ResponseEntity<Void> deleteMenu(@PathVariable String id) {
+        boolean deleted = menuRestaurantService.deleteMenu(id);
+        HttpHeaders headers = getCommonHeaders("Delete a menu");
+        headers.add("deleted", String.valueOf(deleted));
+
+        return deleted
+                ? new ResponseEntity<>(headers, HttpStatus.NO_CONTENT)
+                : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND);
+    }
+
+    @GetMapping("/get/{id}")
+    public ResponseEntity<MenuRestaurant> getMenuById(@PathVariable String id) {
+        MenuRestaurant menu = menuRestaurantService.getMenuById(id);
+        HttpHeaders headers = getCommonHeaders("Get a menu");
+
+        return menu != null
+                ? new ResponseEntity<>(menu, headers, HttpStatus.OK)
+                : new ResponseEntity<>(headers, HttpStatus.NOT_FOUND);
+    }
+
+    private HttpHeaders getCommonHeaders(String description) {
+        HttpHeaders headers = new HttpHeaders();
+        headers.add("desc", description);
+        headers.add("content-type", "application/json");
+        headers.add("date", new Date().toString());
+        headers.add("server", "H2 Database");
+        headers.add("version", "1.0.0");
+        headers.add("menuRestaurant-count", String.valueOf(menuRestaurantService.countMenus()));
+        headers.add("object", "customers");
+        return headers;
+    }
+}

src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java

@@ -19,7 +19,7 @@ public class EatInOrderRestaurant extends OrderRestaurant {
 
 
     public EatInOrderRestaurant(String id, Date date, String waiter, int peopleQty,
-                                double totalPayment, boolean paid, ArrayList<MenuRestaurant> menus,
+                                double totalPayment, boolean paid, ArrayList<OrderMenuQty> menus,
                                 ArrayList<TableRestaurant> tableRestaurants) {
         super(id, date, waiter, peopleQty, totalPayment, paid, menus);
         this.tableRestaurants = tableRestaurants;

src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java

@@ -1,10 +1,7 @@
 package dev.example.restaurantManager.model;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
-import jakarta.persistence.Entity;
-import jakarta.persistence.FetchType;
-import jakarta.persistence.Id;
-import jakarta.persistence.ManyToMany;
+import jakarta.persistence.*;
 import lombok.*;
 import java.util.ArrayList;
 import java.util.List;
@@ -24,9 +21,13 @@ public class MenuRestaurant  {
     private boolean active;
     private boolean water;
 
+//    @JsonIgnore
+//    @ManyToMany(mappedBy = "menus", fetch = FetchType.LAZY)
+//    private List<OrderRestaurant> orders = new ArrayList<>();
+
+    @OneToMany(mappedBy = "menuRestaurant", cascade = CascadeType.ALL, fetch = FetchType.EAGER)
     @JsonIgnore
-    @ManyToMany(mappedBy = "menus", fetch = FetchType.LAZY)
-    private List<OrderRestaurant> orders = new ArrayList<>();
+    private List<OrderMenuQty> ordersQty = new ArrayList<>();
 
     public MenuRestaurant(String id, String name, Double price, String content, boolean active, boolean water) {
         this.id = id;

src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java

@@ -0,0 +1,51 @@
+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;
+
+@Entity
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class OrderMenuQty {
+
+    @Id
+    @GeneratedValue(generator = "UUID")
+    @GenericGenerator(name = "UUID", strategy = "org.hibernate.id.UUIDGenerator")
+    private String id;
+
+    private long qty;
+
+    @ManyToOne
+    @JoinColumn(name = "order_id")
+    @JsonIgnore
+    private OrderRestaurant orderRestaurant;
+
+    @ManyToOne
+    @JoinColumn(name = "menu_id")
+    @JsonIgnore
+    private MenuRestaurant menuRestaurant;
+
+    public OrderMenuQty(long qty, OrderRestaurant orderRestaurant, MenuRestaurant menuRestaurant) {
+        this.qty = qty;
+        this.orderRestaurant = orderRestaurant;
+        this.menuRestaurant = menuRestaurant;
+    }
+
+    public String getMenuName() {
+        return menuRestaurant.getName();
+    }
+
+    @Override
+    public String toString() {
+        return "OrderMenuQty{" +
+                "id:'" + id + '\'' +
+                ", qty:" + qty +
+                ", order:" + orderRestaurant.getId() +
+                ", menu:" + menuRestaurant.getName() +
+                '}';
+    }
+}

src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java

@@ -5,6 +5,7 @@
 import java.util.List;
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import jakarta.persistence.*;
+import java.util.stream.Collectors;
 import lombok.*;
 
 @Getter
@@ -24,39 +25,43 @@ public class OrderRestaurant {
     private double totalPayment;
     private boolean paid;
 
+    @OneToMany(mappedBy = "orderRestaurant", cascade = CascadeType.ALL, fetch = FetchType.EAGER)
     @JsonIgnore
-    @ManyToMany(fetch = FetchType.LAZY
-            , cascade = {CascadeType.PERSIST, CascadeType.MERGE})
-    @JoinTable(
-            name = "ORDER_RESTAURANT_MENU",
-            joinColumns = @JoinColumn(name = "ORDER_RESTAURANT_FK_ID"),
-            inverseJoinColumns = @JoinColumn(name = "MENU_RESTAURANT_FK_ID")
-    )
-    private List<MenuRestaurant> menus = new ArrayList<>();
-
-    public List<MenuRestaurant> addMenu(MenuRestaurant menu) {
-            this.menus.add(menu);
-            menu.getOrders().add(this);
-        return this.menus;
+    private List<OrderMenuQty> ordersQty = new ArrayList<>();
+
+    public List<OrderMenuQty> addOrderMenuQty(OrderMenuQty orderMenuQty) {
+        if(ordersQty == null) {
+            ordersQty = new ArrayList<>();
+            ordersQty.add(orderMenuQty);
+            return ordersQty;
+        }else {
+            ordersQty.add(orderMenuQty);
+            return ordersQty;
+        }
+    }
+    public List<String> getOrderMenuQtyIds() {
+        return ordersQty.stream()
+                .map(OrderMenuQty::getId)
+                .collect(Collectors.toList());
     }
 
-    public List<MenuRestaurant> removeMenu(MenuRestaurant menu) {
-            this.menus.remove(menu);
-            menu.getOrders().remove(this);
-        return this.menus;
+    public void removeOrderMenuQty(OrderMenuQty orderMenuQty) {
+        ordersQty.remove(orderMenuQty);
     }
 
     @Override
     public String toString() {
         return "OrderRestaurant{" +
-                "id='" + id + '\'' +
-                ", date=" + date +
-                ", waiter='" + waiter + '\'' +
-                ", peopleQty=" + peopleQty +
-                ", totalPayment=" + totalPayment +
-                ", paid=" + paid +
-                ", menusCount=" + (menus != null ? menus.size() : 0) +
-                ", menus=" + menus +
+                "id:'" + id + '\'' +
+                ", date:" + date +
+                ", waiter:'" + waiter + '\'' +
+                ", peopleQty:" + peopleQty +
+                ", totalPayment:" + totalPayment +
+                ", paid:" + paid +
+                ", Quantity orders: " + (ordersQty == null ? 0 : ordersQty.size()) + " ordenes" +
+                ", Ids: " + getOrderMenuQtyIds() +
+                ", Quantity menu:" + ordersQty.stream().collect(Collectors.groupingBy(OrderMenuQty::getMenuName, Collectors.counting())) +
+                ", Menus:" + ordersQty.stream().map(OrderMenuQty::getMenuName).collect(Collectors.toList()) +
                 '}';
     }
 

src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java

@@ -16,7 +16,7 @@ public class ShippingOrderRestaurant extends OrderRestaurant {
     private String riderName;
 
     public ShippingOrderRestaurant(String id, Date date, String waiter, int peopleQty,
-                                   double totalPayment, boolean paid, ArrayList<MenuRestaurant> menus,
+                                   double totalPayment, boolean paid, ArrayList<OrderMenuQty> menus,
                                    String address, String city, String riderName) {
         super(id, date, waiter, peopleQty, totalPayment, paid, menus);
         this.address = address;

src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java

@@ -19,7 +19,7 @@ public class TakeAwayOrder extends OrderRestaurant {
 
     // Constructor for TakeAwayOrder with the WHOLE DATA fields
     public TakeAwayOrder(String id, Date date, String waiter, int peopleQty,
-                         double totalPayment, boolean paid, ArrayList<MenuRestaurant> menus,
+                         double totalPayment, boolean paid, ArrayList<OrderMenuQty> menus,
                          Customer customerTakeAway) {
 
         // THIS PART is SUPERCLASS

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<OrderMenuQty,String> {
+}

src/main/java/dev/example/restaurantManager/service/MenuRestaurantService.java

@@ -0,0 +1,14 @@
+package dev.example.restaurantManager.service;
+
+import dev.example.restaurantManager.model.MenuRestaurant;
+
+import java.util.List;
+
+public interface MenuRestaurantService {
+    List<MenuRestaurant> getAllMenus();
+    MenuRestaurant getMenuById(String id);
+    MenuRestaurant createMenu(MenuRestaurant menuRestaurant);
+    MenuRestaurant updateMenu(String id, MenuRestaurant menuRestaurantDetails);
+    boolean deleteMenu(String id);
+    long countMenus();
+}

src/main/java/dev/example/restaurantManager/service/MenuRestaurantServiceImpl.java

@@ -0,0 +1,83 @@
+package dev.example.restaurantManager.service;
+
+import dev.example.restaurantManager.model.MenuRestaurant;
+import dev.example.restaurantManager.model.OrderMenuQty;
+import dev.example.restaurantManager.repository.MenuRestaurantRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+@Service
+public class MenuRestaurantServiceImpl implements MenuRestaurantService {
+
+    @Autowired
+    private MenuRestaurantRepository menuRestaurantRepository;
+
+    @Override
+    public List<MenuRestaurant> getAllMenus() {
+        List<MenuRestaurant> lstMenuRestaurant = menuRestaurantRepository.findAll().stream().collect(Collectors.toList());
+        for (MenuRestaurant m : lstMenuRestaurant){
+            List<OrderMenuQty> lstOrderMenuQty = new ArrayList<>();
+            for (OrderMenuQty o : m.getOrdersQty().stream().collect(Collectors.toList())){
+                lstOrderMenuQty.add(o);
+                m.setOrdersQty(lstOrderMenuQty);
+                //o.getOrderRestaurant()
+            }
+        }
+        return lstMenuRestaurant;
+        //return menuRestaurantRepository.findAll();
+    }
+
+    @Override
+    public MenuRestaurant getMenuById(String id) {
+        return menuRestaurantRepository.findById(id).orElse(null);
+    }
+
+    @Override
+    public MenuRestaurant createMenu(MenuRestaurant menuRestaurant) {
+        return menuRestaurantRepository.save(menuRestaurant);
+    }
+
+    @Override
+    public MenuRestaurant updateMenu(String id, MenuRestaurant menuRestaurantDetails) {
+        boolean isTrue = false;
+        MenuRestaurant menuRestaurantElement = menuRestaurantRepository.findById(id).orElse(null);
+        if(menuRestaurantElement != null){
+            Field[] fields = menuRestaurantDetails.getClass().getDeclaredFields();
+            for (Field field : fields) {
+                try {
+                    field.setAccessible(true);
+                    if(field.get(menuRestaurantElement) != field.get(menuRestaurantDetails)){
+                        isTrue = true;
+                        field.set(menuRestaurantElement,field.get(menuRestaurantDetails));
+                    }
+                } catch (IllegalAccessException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            menuRestaurantRepository.save(menuRestaurantElement);
+        }
+
+        return isTrue ? menuRestaurantElement : menuRestaurantDetails;
+    }
+
+    @Override
+    public boolean deleteMenu(String id) {
+        Optional<MenuRestaurant> menuRestaurantElement = menuRestaurantRepository.findById(id);
+        if(menuRestaurantElement != null){
+            menuRestaurantRepository.deleteById(id);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public long countMenus() {
+        return menuRestaurantRepository.count();
+    }
+}

src/main/java/dev/example/restaurantManager/service/OrderRestaurantService.java

@@ -0,0 +1,14 @@
+package dev.example.restaurantManager.service;
+
+import dev.example.restaurantManager.model.OrderRestaurant;
+
+import java.util.List;
+
+public interface OrderRestaurantService {
+    List<OrderRestaurant> getAllOrders();
+    OrderRestaurant getOrderById(String id);
+    OrderRestaurant createOrder(OrderRestaurant order);
+    OrderRestaurant updateOrder(String id, OrderRestaurant orderDetails);
+    boolean deleteOrder(String id);
+    long countOrders();
+}