Changeset deea3c4 for src/main/java/com/example/rezevirajmasa/demo/service/impl/RestaurantServiceImpl.java

Timestamp:

04/28/25 14:21:17 (3 weeks ago)

Author:

Aleksandar Panovski <apano77@…>

Branches:

main

Children:

e15e8d9

Parents:

f5b256e

Message:

Big change done fully handle_reservation_update() trigger works

File:

• src/main/java/com/example/rezevirajmasa/demo/service/impl/RestaurantServiceImpl.java (modified) (10 diffs)

src/main/java/com/example/rezevirajmasa/demo/service/impl/RestaurantServiceImpl.java

@@ -1 +1 @@
 package com.example.rezevirajmasa.demo.service.impl;
 
+import com.example.rezevirajmasa.demo.dto.ReservationDTO;
+import com.example.rezevirajmasa.demo.dto.RestaurantDTO;
+import com.example.rezevirajmasa.demo.dto.TableDTO;
+import com.example.rezevirajmasa.demo.model.Reservation;
 import com.example.rezevirajmasa.demo.model.Restaurant;
 import com.example.rezevirajmasa.demo.model.TableEntity;
+import com.example.rezevirajmasa.demo.model.User;
 import com.example.rezevirajmasa.demo.model.exceptions.InvalidRestaurantIdException;
 import com.example.rezevirajmasa.demo.repository.RestaurantRepository;
 import com.example.rezevirajmasa.demo.repository.TableRepository;
+import com.example.rezevirajmasa.demo.service.ReservationService;
 import com.example.rezevirajmasa.demo.service.RestaurantService;
 import com.example.rezevirajmasa.demo.service.TableService;
 import com.sun.tools.jconsole.JConsoleContext;
 import jakarta.transaction.Transactional;
+import org.openqa.selenium.InvalidArgumentException;
 import org.springframework.stereotype.Service;
-
+import org.modelmapper.ModelMapper;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
@@ -31 +38 @@
     private final TableRepository tableRepository;
     private final TableService tableService;
-
-    public RestaurantServiceImpl(RestaurantRepository restaurantRepository, TableRepository tableRepository, TableService tableService) {
+    private final ReservationService reservationService;
+    private ModelMapper modelMapper = new ModelMapper();
+
+    public RestaurantServiceImpl(RestaurantRepository restaurantRepository, TableRepository tableRepository, TableService tableService, ReservationService reservationService) {
         this.restaurantRepository = restaurantRepository;
         this.tableRepository = tableRepository;
         this.tableService = tableService;
-    }
-
-    @Override
-    public List<Restaurant> listall() {
+        this.reservationService = reservationService;
+    }
+
+    @Override
+    public List<RestaurantDTO> listall() {
+        List<Restaurant> restaurants = restaurantRepository.findAll();
+
+        List<RestaurantDTO> restaurantDTOS = new ArrayList<>();
+
+        for (Restaurant restaurant : restaurants) {
+            RestaurantDTO restaurantDTO = modelMapper.map(restaurant, RestaurantDTO.class);
+            List<TableDTO> tableDTOS = new ArrayList<>();
+            for (TableEntity table : restaurant.getTablesList()) {
+                TableDTO tableDTO = modelMapper.map(table, TableDTO.class);
+                List<ReservationDTO> reservationDTOS = new ArrayList<>();
+                for (Reservation reservation : table.getReservations()) {
+                    ReservationDTO reservationDTO = modelMapper.map(reservation, ReservationDTO.class);
+
+                    reservationDTOS.add(reservationDTO);
+                }
+                tableDTO.setReservations(reservationDTOS);
+                tableDTOS.add(tableDTO);
+            }
+            restaurantDTO.setTablesList(tableDTOS);
+            restaurantDTOS.add(restaurantDTO);
+        }
+        return restaurantDTOS;
+    }
+
+    @Override
+    public List<Restaurant> listAll() {
         return restaurantRepository.findAll();
     }
@@ -51 +87 @@
     @Override
     public void save(Restaurant restaurant, int numberOfTables, List<Integer> tableCapacities, List<String> tableLocations, List<String> tableSmokingAreas, List<String> tableDescriptions) {
+        if (numberOfTables != tableCapacities.size() || numberOfTables != tableLocations.size() || numberOfTables != tableSmokingAreas.size() || numberOfTables != tableDescriptions.size()) {
+            throw new IllegalArgumentException("Mismatched table data. Number of tables does not match the size of the input lists.");
+        }
+
         restaurantRepository.save(restaurant);
         String[] hours = restaurant.getOperatingHours().split("-");
@@ -60 +100 @@
             LocalTime startTime = LocalTime.parse(hours[0], DateTimeFormatter.ofPattern("HH:mm"));
             LocalTime endTime = LocalTime.parse(hours[1], DateTimeFormatter.ofPattern("HH:mm"));
-            System.out.println("IsBefore: " + startTime.isBefore(endTime) + " and equals: " + startTime.equals(endTime));
 
             for (int i = 0; i < numberOfTables; i++) {
                 TableEntity table = new TableEntity();
-
-//                table.initializeTimeSlots(startTime, endTime);
-
                 table.setCapacity(tableCapacities.get(i));
                 table.setLocation(tableLocations.get(i));
-
-                String smokingAreaString = tableSmokingAreas.get(i);
-                table.setSmokingArea(smokingAreaString.equalsIgnoreCase("on"));
+                table.setSmokingArea(tableSmokingAreas.get(i).equalsIgnoreCase("on"));
                 table.setDescription(tableDescriptions.get(i));
                 table.setRestaurant(restaurant);
-
                 tableRepository.save(table);
             }
@@ -84 +117 @@
     }
     @Override
-    public Restaurant findById(Long restaurantId) {
-        return restaurantRepository.findById(restaurantId).orElseThrow(InvalidRestaurantIdException::new);
-    }
+    public RestaurantDTO findById(Long restaurantId) {
+        Restaurant restaurant = restaurantRepository.findById(restaurantId)
+                .orElseThrow(InvalidRestaurantIdException::new);
+
+        RestaurantDTO restaurantDTO = modelMapper.map(restaurant, RestaurantDTO.class);
+
+        List<TableDTO> tableDTOS = new ArrayList<>();
+        for (TableEntity table : restaurant.getTablesList()) {
+            TableDTO tableDTO = modelMapper.map(table, TableDTO.class);
+
+            List<ReservationDTO> reservationDTOS = new ArrayList<>();
+            for (Reservation reservation : table.getReservations()) {
+                ReservationDTO reservationDTO = modelMapper.map(reservation, ReservationDTO.class);
+                reservationDTOS.add(reservationDTO);
+            }
+
+            tableDTO.setReservations(reservationDTOS);
+            tableDTOS.add(tableDTO);
+        }
+
+        restaurantDTO.setTablesList(tableDTOS);
+
+        return restaurantDTO;
+    }
+
+    @Override
+    public Restaurant findByIdRestaurant(Long restaurantId) {
+        return restaurantRepository.findById(restaurantId).orElseThrow(()-> new InvalidArgumentException("No restaurant with provided id"));
+    }
+
 
     @Override
@@ -115 +175 @@
     @Override
     public List<Restaurant> listRestaurantBy(String search) {
-        // Get all restaurants from the repository
         List<Restaurant> allRestaurants = restaurantRepository.findAll();
 
@@ -134 +193 @@
 
         for (Restaurant restaurant : restaurants) {
-            // Check if the restaurant has available time slots for today
             boolean hasAvailableTimeSlots = tableService.hasAvailableTimeSlotsForRestaurantAndDate(restaurant, today);
             if (hasAvailableTimeSlots) {
@@ -146 +204 @@
     @Override
     public List<Restaurant> findRestaurantsByDateTimeAndPartySize(LocalDateTime dateTime, int partySize, String search) {
+        LocalDateTime checkOutTime = dateTime.plusHours(2);
         List<Restaurant> allRestaurants = restaurantRepository.findAll();
+
         return allRestaurants.stream()
-                .filter(restaurant -> hasAvailableTable(restaurant, dateTime, partySize))
+                .filter(restaurant -> restaurant.getTablesList().stream()
+                        .anyMatch(table -> tableRepository.findAvailableTables(dateTime, checkOutTime, partySize)
+                                .contains(table)))
                 .filter(restaurant -> isMatch(restaurant, search))
                 .collect(Collectors.toList());
     }
 
-    private boolean hasAvailableTable(Restaurant restaurant, LocalDateTime dateTime, int partySize) {
-        for (TableEntity table : restaurant.getTablesList()) {
-            if (table.isAvailable(dateTime) && table.getCapacity() >= partySize) {
-                return true;
-            }
-        }
-        return false;
-    }
-
     private boolean isMatch(Restaurant restaurant, String name) {
         return name == null || name.isEmpty() || restaurant.getName().contains(name);
@@ -167 +220 @@
 
     @Override
-    public List<Restaurant> findRestaurantsBySearchParams(LocalDateTime dateTime, int partySize, String search) {
+    public List<RestaurantDTO> findRestaurantsBySearchParams(LocalDateTime dateTime, int partySize, String search) {
+        List<Restaurant> availableRestaurants = new ArrayList<>();
+
+        List<Restaurant> restaurantList;
         if (search == null || search.isEmpty()) {
-            List<TableEntity> tableEntities = tableRepository.findAllByTimeSlotsContainingAndCapacityGreaterThanEqual(dateTime, partySize);
-            return tableEntities.stream()
-                    .map(TableEntity::getRestaurant)
-                    .distinct()
-                    .collect(Collectors.toList());
+            restaurantList = restaurantRepository.findAll();
         } else {
             String searchTerm = "%" + search + "%";
-            List<Restaurant> restaurantList = restaurantRepository.findAllByNameLikeIgnoreCase(searchTerm);
+            restaurantList = restaurantRepository.findAllByNameLikeIgnoreCase(searchTerm);
+
             if (restaurantList.isEmpty()) {
                 restaurantList = restaurantRepository.findAllByCuisineTypeContaining(search);
             }
-            return restaurantList;
-        }
+        }
+
+        for (Restaurant restaurant : restaurantList) {
+            boolean hasAvailableTable = restaurant.getTablesList().stream()
+                    .anyMatch(table -> table.isAvailable(dateTime, partySize));
+
+            if (hasAvailableTable) {
+                availableRestaurants.add(restaurant);
+            }
+        }
+
+        List<RestaurantDTO> restaurantDTOS = availableRestaurants.stream().map(this::convertToDto).toList();
+        return restaurantDTOS;
     }
 
@@ -190 +254 @@
 
     @Override
-    public List<Restaurant> findRestaurantsByCuisineType(String param) {
-        return restaurantRepository.findAllByCuisineType(param);
+    public List<RestaurantDTO> findRestaurantsByCuisineType(String param) {
+        List<Restaurant> restaurants = restaurantRepository.findAllByCuisineType(param);
+        return restaurants.stream().map(this::convertToDto).toList();
+    }
+
+    public RestaurantDTO convertToDto(Restaurant restaurant) {
+        return modelMapper.map(restaurant, RestaurantDTO.class);
+    }
+
+    public TableDTO convertToDto(TableEntity table) {
+        return modelMapper.map(table, TableDTO.class);
+    }
+
+    public ReservationDTO convertToDto(Reservation reservation) {
+        return modelMapper.map(reservation, ReservationDTO.class);
     }
 }