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

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

Location:

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

Files:

• ReservationImpl.java (modified) (9 diffs)
• RestaurantServiceImpl.java (modified) (10 diffs)
• TableServiceImpl.java (modified) (9 diffs)

src/main/java/com/example/rezevirajmasa/demo/service/impl/ReservationImpl.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.UserDto;
 import com.example.rezevirajmasa.demo.mappers.UserMapper;
@@ -12 +14 @@
 import com.example.rezevirajmasa.demo.service.ReservationHistoryService;
 import com.example.rezevirajmasa.demo.service.ReservationService;
+import com.example.rezevirajmasa.demo.service.RestaurantService;
 import com.example.rezevirajmasa.demo.service.UserService;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -31 +34 @@
 @Service
 public class ReservationImpl implements ReservationService {
+
     @Autowired
     private TableRepository tableRepository;
@@ -51 +55 @@
 
     @Override
-    public void makeReservation(User user, TableEntity table, Restaurant restaurant, LocalDateTime localDateTime, LocalDateTime checkInTime, int partySize, String specialRequests) {
-        if (!table.isAvailable(checkInTime)) {
-            // Handle unavailability (throw an exception, return a specific response, etc.)
-            throw new RuntimeException("Table not available for the specified time slot");
-        }
-
-        Reservation reservation =
-                new Reservation(user, table, restaurant, LocalDateTime.now(), partySize, specialRequests, "Reserved", checkInTime, checkInTime.plusHours(2), null);
-
-//        // Update table status or perform additional logic if needed
-//        tableRepository.save(table);
-
-        // Save the reservation
-        reservationRepository.save(reservation);
-    }
-
-    @Override
-    public Reservation makeReservationRest(Reservation reservation, User user) {
-        Optional<TableEntity> optionalTable = tableRepository.findById(reservation.getTable().getId());
+    public Reservation makeReservationRest(ReservationDTO reservationDTO, User user) {
+        Reservation reservation = new Reservation();
+
+        Optional<TableEntity> optionalTable = tableRepository.findById(reservationDTO.getTableNumber());
+
         if (optionalTable.isPresent()) {
             TableEntity table = optionalTable.get();
 
+            LocalDateTime reservationTime = reservationDTO.getReservationDateTime();
+            LocalDateTime startTime = reservationTime.minusHours(2);
+            LocalDateTime endTime = reservationTime.plusHours(2);
+
+            boolean hasConflict = table.getReservations().stream()
+                    .anyMatch(existingReservation -> {
+                        LocalDateTime existingStartTime = existingReservation.getCheckInTime();
+                        LocalDateTime existingEndTime = existingReservation.getCheckOutTime();
+
+                        boolean scenario1 = existingStartTime.isBefore(startTime) && existingEndTime.isAfter(startTime);
+
+                        boolean scenario2 = existingStartTime.isBefore(endTime) && existingEndTime.isAfter(startTime);
+
+                        boolean scenario3 = existingStartTime.isAfter(startTime) && existingEndTime.isBefore(endTime);
+
+                        boolean scenario4 = existingStartTime.isBefore(startTime) && existingEndTime.isAfter(endTime);
+
+                        return scenario1 || scenario2 || scenario3 || scenario4;
+                    });
+            if (hasConflict) {
+                throw new InvalidReservationException("Unsuccessful reservation -> time slot not available");
+            }
+
+            reservation.setTable(table);
+            reservation.setReservationDateTime(LocalDateTime.now());
+            reservation.setSpecialRequests(reservationDTO.getSpecialRequests());
+            reservation.setPartySize(reservationDTO.getPartySize());
+            reservation.setStatus(reservationDTO.getStatus() != null ? reservationDTO.getStatus() : "Pending");
+            reservation.setPaymentStatus(reservationDTO.getPaymentStatus() != null ? reservationDTO.getPaymentStatus() : "Unpaid");
             reservation.setUser(user);
-
-            LocalDateTime startTime = reservation.getCheckInTime().minusHours(2);
-            LocalDateTime endTime = reservation.getCheckInTime().plusHours(2);
-
-            table.getTimeSlots().removeIf(
-                    x -> x.isAfter(startTime) && x.isBefore(endTime)
-            );
+            reservation.setRestaurant(reservationDTO.getRestaurant());
+            reservation.setCheckInTime(reservationTime);
             reservation.setReservationDateTime(LocalDateTime.now());
+            reservation.setCheckOutTime(reservationTime.plusHours(2));
+            reservation.setRestaurant(reservationDTO.getRestaurant());
+
             return reservationRepository.save(reservation);
         } else {
-            throw new InvalidReservationException("Unsuccessful reservation -> time slot not available");
-        }
-    }
-
+            throw new InvalidReservationException("Invalid table number -> table not found");
+        }
+    }
+
+    @Override
+    public Reservation updateReservation(Long reservationId, ReservationDTO reservationDTO, User user) {
+        Reservation existingReservation = findById(reservationId);
+
+        if (!existingReservation.getCheckInTime().equals(reservationDTO.getReservationDateTime())) {
+            TableEntity table = existingReservation.getTable();
+            table.removeReservation(existingReservation);
+
+            LocalDateTime newStartTime = reservationDTO.getReservationDateTime().minusHours(2);
+            LocalDateTime newEndTime = reservationDTO.getReservationDateTime().plusHours(2);
+            boolean hasConflict = table.getReservations().stream()
+                    .anyMatch(r -> r.getCheckInTime().isAfter(newStartTime) && r.getCheckInTime().isBefore(newEndTime));
+
+            if (hasConflict) {
+                throw new InvalidReservationException("New time slot is not available.");
+            }
+
+            table.addReservation(existingReservation);
+        }
+
+        existingReservation.setCheckInTime(reservationDTO.getReservationDateTime());
+        existingReservation.setCheckOutTime(reservationDTO.getReservationDateTime().plusHours(2));
+        existingReservation.setReservationDateTime(LocalDateTime.now());
+        existingReservation.setPartySize(reservationDTO.getPartySize());
+        existingReservation.setSpecialRequests(reservationDTO.getSpecialRequests());
+        existingReservation.setStatus(reservationDTO.getStatus() != null ? reservationDTO.getStatus() : existingReservation.getStatus());
+        existingReservation.setPaymentStatus(reservationDTO.getPaymentStatus() != null ? reservationDTO.getPaymentStatus() : existingReservation.getPaymentStatus());
+
+        return reservationRepository.save(existingReservation);
+    }
 
     @Override
     public List<Reservation> listAll() {
         return reservationRepository.findAll();
+    }
+
+    @Override
+    public List<Reservation> reservationsForTable(TableEntity table) {
+        return reservationRepository.findAllByTableAndCheckInTime(table, LocalDateTime.now());
     }
 
@@ -106 +158 @@
             TableEntity table = reservation.getTable();
 
-            LocalDateTime from = reservation.getCheckInTime().minusHours(2);
-            LocalDateTime till = reservation.getCheckInTime().plusHours(2);
-
-            String[] hours = table.getRestaurant().getOperatingHours().split("-");
-            LocalTime openingHourTime = LocalTime.parse(hours[0], DateTimeFormatter.ofPattern("HH:mm"));
-            LocalDateTime openingDateTime = openingHourTime.atDate(from.toLocalDate());
-            LocalTime closingHourTime = LocalTime.of(22,45);
-            LocalDateTime closingDateTime = closingHourTime.atDate(till.toLocalDate());
-            if(from.isBefore(openingDateTime)) {
-                from = openingDateTime;
-            }
-            if(till.isAfter(closingDateTime)) {
-                till = closingDateTime;
-            }
-            while (from.isBefore(reservation.getCheckInTime().plusHours(2))) {
-                table.addTimeSlot(from);
-                from = from.plusMinutes(15);
-            }
+            table.removeReservation(reservation);
+
             reservationHistoryService.moveReservationToHistory(reservation, "Canceled", "Canceled by user");
             reservationRepository.delete(reservation);
+
             return true;
         } else {
@@ -132 +169 @@
     }
 
-
     @Override
     public List<Reservation> findReservationByUser(User user) {
         LocalDateTime now = LocalDateTime.now();
-        return reservationRepository.findALlByUserAndCheckInTimeAfter(user, now);
+        return reservationRepository.findAllByUserAndCheckInTimeAfter(user, now);
+    }
+
+    @Override
+    public List<Reservation> findAllByUser(User user) {
+        return reservationRepository.findAllByUser(user);
     }
 
@@ -142 +183 @@
     public List<Reservation> findReservationsByUserPast(User user) {
         LocalDateTime now = LocalDateTime.now();
-        return reservationRepository.findALlByUserAndCheckInTimeBefore(user, now);
+        return reservationRepository.findAllByUserAndCheckInTimeBefore(user, now);
     }
 
@@ -151 +192 @@
 
     @Override
-    public List<Reservation> findReservationsToMove(LocalDateTime currentTime) {
-        return reservationRepository.findAllByCheckInTimeBefore(currentTime);
+    public void findReservationsToMove() {
+        List<Reservation> pastReservations = reservationRepository.findAllByCheckInTimeBefore(LocalDateTime.now());
+        for(Reservation reservation : pastReservations) {
+            reservationHistoryService.moveReservationToHistory(reservation, "successful", "/");
+            reservationRepository.delete(reservation);
+        }
     }
 
@@ -160 +205 @@
         reservationRepository.delete(reservation);
     }
+
+    @Override
+    public List<Reservation> findAllByRestaurant(Restaurant restaurant) {
+        return reservationRepository.findAllByRestaurantAndCheckInTimeAfter(restaurant, LocalDateTime.now());
+    }
 }

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);
     }
 }

src/main/java/com/example/rezevirajmasa/demo/service/impl/TableServiceImpl.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.exceptions.InvalidRestaurantIdException;
 import com.example.rezevirajmasa.demo.model.exceptions.InvalidTableNumberException;
+import com.example.rezevirajmasa.demo.repository.ReservationRepository;
 import com.example.rezevirajmasa.demo.repository.RestaurantRepository;
 import com.example.rezevirajmasa.demo.repository.TableRepository;
 import com.example.rezevirajmasa.demo.service.TableService;
+import jakarta.persistence.Table;
+import org.modelmapper.ModelMapper;
+import org.openqa.selenium.InvalidArgumentException;
 import org.springframework.cglib.core.Local;
 import org.springframework.stereotype.Service;
@@ -18 +25 @@
 import java.time.chrono.ChronoLocalDateTime;
 import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
@@ -25 +33 @@
     private final TableRepository tableRepository;
     private final RestaurantRepository restaurantRepository;
+    private final ReservationRepository reservationRepository;
+    private ModelMapper modelMapper = new ModelMapper();
 
-    public TableServiceImpl(TableRepository tableRepository, RestaurantRepository restaurantRepository) {
+    public TableServiceImpl(TableRepository tableRepository, RestaurantRepository restaurantRepository, ReservationRepository reservationRepository) {
         this.tableRepository = tableRepository;
         this.restaurantRepository = restaurantRepository;
-    }
-
-    @Override
-    public TableEntity findById(Long id) {
-        return tableRepository.findById(id).orElseThrow(InvalidTableNumberException::new);
+        this.reservationRepository = reservationRepository;
     }
 
@@ -41 +47 @@
     }
 
+    @Override
+    public TableDTO findById(Long id) {
+        TableEntity table = tableRepository.findById(id)
+                .orElseThrow(InvalidTableNumberException::new);
+
+        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);
+
+        return tableDTO;
+    }
+
+    @Override
+    public TableEntity findByIdTable(Long id) {
+        return tableRepository.findById(id).orElseThrow(() -> new InvalidArgumentException("Invalid table id"));
+    }
+
+
+    @Override
     public void save(int numberOfTables, List<Integer> tableCapacities, List<String> tableLocations, List<String> tableSmokingAreas, List<String> tableDescriptions, Restaurant restaurant) {
         for (int i = 0; i < numberOfTables; i++) {
@@ -55 +86 @@
     @Override
     public void deleteTimeSlotsForReservation(Long tableId, LocalDateTime reservationTime) {
-        LocalDateTime startTime = reservationTime.minusHours(2);
-        LocalDateTime endTime = reservationTime.plusHours(2);
-
-        TableEntity table = findById(tableId);
-        List<LocalDateTime> timeSlots = table.getTimeSlots();
-
-        timeSlots.removeIf(timeSlot -> timeSlot.isAfter(startTime) && timeSlot.isBefore(endTime));
-
-        table.setTimeSlots(timeSlots);
+        TableDTO tableDTO = findById(tableId);
+        TableEntity table = convertFromDTO(tableDTO);
+        LocalDate threeDaysAgo = LocalDate.now().minusDays(3);
+        table.cleanUnusedTimeSlots(threeDaysAgo);
 
         tableRepository.saveAndFlush(table);
@@ -70 +96 @@
     @Override
     public void canceledTimeSlots(Long tableId, LocalDateTime reservationTime) {
-        TableEntity table = findById(tableId);
-        List<LocalDateTime> timeSlots = table.getTimeSlots();
+        TableDTO tableDTO = findById(tableId);
+        TableEntity table = convertFromDTO(tableDTO);
         LocalDateTime startTime = reservationTime.minusHours(1).minusMinutes(45);
         LocalDateTime endTime = reservationTime.plusHours(1).plusMinutes(45);
 
-        LocalDate localDate = reservationTime.toLocalDate();
-
         String[] hours = table.getRestaurant().getOperatingHours().split("-");
         LocalTime openingHourTime = LocalTime.parse(hours[0], DateTimeFormatter.ofPattern("HH:mm"));
+        LocalDateTime openingHour = openingHourTime.atDate(reservationTime.toLocalDate());
+        LocalDateTime closingHour = LocalTime.of(23, 45).atDate(reservationTime.toLocalDate());
 
-        LocalDateTime openingHour = openingHourTime.atDate(localDate);
-        LocalDateTime closingHour = LocalTime.of(23, 45).atDate(localDate);
-        if(startTime.isBefore(openingHour)) {
-            startTime = LocalDateTime.from(openingHour);
+        if (startTime.isBefore(openingHour)) {
+            startTime = openingHour;
         }
-        while(startTime.isBefore(endTime) || startTime.equals(endTime)) {
-            timeSlots.add(startTime);
-            startTime = startTime.plusMinutes(15);
-            if(startTime.isAfter(closingHour) || startTime.equals(closingHour)) {
+
+        while (startTime.isBefore(endTime) || startTime.equals(endTime)) {
+            if (startTime.isAfter(closingHour) || startTime.equals(closingHour)) {
                 break;
             }
+
+            Reservation reservation = new Reservation();
+            reservation.setReservationDateTime(startTime);
+            reservation.setTable(table);
+            reservationRepository.save(reservation);
+
+            startTime = startTime.plusMinutes(15);
         }
-        table.setTimeSlots(timeSlots);
+
         tableRepository.saveAndFlush(table);
     }
@@ -105 +135 @@
         return tableRepository.findById(number).orElseThrow(InvalidTableNumberException::new);
     }
+
     @Override
     public TableEntity deleteTable(Long number) {
@@ -116 +147 @@
         List<TableEntity> tables = tableRepository.findByRestaurant(restaurant);
 
-        // Iterate through each table to check for available time slots
         for (TableEntity table : tables) {
             boolean hasAvailableTimeSlots = hasAvailableTimeSlotsForTableAndDate(table, today);
             if (hasAvailableTimeSlots) {
-                return true; // If any table has available time slots, return true
+                return true;
             }
         }
@@ -128 +158 @@
 
     public boolean hasAvailableTimeSlotsForTableAndDate(TableEntity table, LocalDate date) {
-        List<LocalDateTime> timeSlots = table.getTimeSlots();
+        for (Reservation reservation : table.getReservations()) {
+            LocalDateTime startTime = reservation.getReservationDateTime();
+            LocalDateTime endTime = startTime.plusHours(reservation.getTable().getReservationDurationHours());
 
-        // Implement your logic to check if the table has available time slots for the given date
-        // This could involve querying the database for reservations for the given table and date,
-        // and checking if there are any open time slots.
-        // You may need to consider factors such as operating hours, existing reservations, etc.
-        // Return true if there are available time slots, false otherwise.
-        return false;
+            if (startTime.toLocalDate().equals(date) || endTime.toLocalDate().equals(date)) {
+                return false;
+            }
+        }
+        return true;
     }
 
+    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);
+    }
+
+    public TableEntity convertFromDTO(TableDTO tableDTO) {
+        return modelMapper.map(tableDTO, TableEntity.class);
+    }
 }