Changeset deea3c4 for src/main/java/com/example/rezevirajmasa/demo/service/impl/ReservationImpl.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/ReservationImpl.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());
+    }
 }