Changeset deea3c4 for src/main/java/com/example/rezevirajmasa/demo/web/rest/testController.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/web/rest/testController.java (modified) (12 diffs)

src/main/java/com/example/rezevirajmasa/demo/web/rest/testController.java

@@ -1 +1 @@
 package com.example.rezevirajmasa.demo.web.rest;
 
-import com.example.rezevirajmasa.demo.dto.CustomerDTO;
-import com.example.rezevirajmasa.demo.dto.UserDto;
+import com.example.rezevirajmasa.demo.dto.*;
 import com.example.rezevirajmasa.demo.mappers.UserMapper;
 import com.example.rezevirajmasa.demo.model.*;
+import com.example.rezevirajmasa.demo.model.exceptions.InvalidReservationException;
 import com.example.rezevirajmasa.demo.service.*;
 import com.example.rezevirajmasa.demo.service.impl.TokenService;
@@ -25 +25 @@
 import java.time.LocalDateTime;
 import java.time.format.DateTimeFormatter;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
+import java.util.*;
+import java.util.stream.Collectors;
 
 @CrossOrigin(origins = "http://localhost:3000/")
@@ -57 +55 @@
     }
 
-    //restaurants
-
-    @RequestMapping("/api/restaurants")
-    public ResponseEntity<List<Restaurant>> getAllRestaurants() {
-        return new ResponseEntity<List<Restaurant>>(restaurantService.listall(), HttpStatus.OK);
-    }
-
-    @RequestMapping("/api/restaurants/{restaurantId}")
-    public ResponseEntity<Restaurant> getRestaurantById(@PathVariable Long restaurantId) {
-        return new ResponseEntity<Restaurant>(restaurantService.findById(restaurantId), HttpStatus.OK);
+    //restaurants calls
+
+    @GetMapping("/api/restaurants")
+    public ResponseEntity<List<RestaurantDTO>> getAllRestaurants() {
+            return new ResponseEntity<List<RestaurantDTO>>(restaurantService.listall(), HttpStatus.OK);
+    }
+
+    @GetMapping("/api/restaurants/{restaurantId}")
+    public ResponseEntity<RestaurantDTO> getRestaurantById(@PathVariable Long restaurantId) {
+        return new ResponseEntity<RestaurantDTO>(restaurantService.findById(restaurantId), HttpStatus.OK);
     }
 
     @PostMapping("/api/search")
-    public ResponseEntity<List<Restaurant>> searchRestaurants(@RequestBody Map<String, Object> requestData) {
+    public ResponseEntity<List<RestaurantDTO>> searchRestaurants(@RequestBody Map<String, Object> requestData) {
         Optional<String> dateTimeOptional = Optional.ofNullable((String) requestData.get("dateTime"));
         int partySize = Integer.parseInt(requestData.get("partySize").toString());
@@ -84 +82 @@
         }
 
-        List<Restaurant> filteredRestaurants = restaurantService.findRestaurantsBySearchParams(parsedDateTime, partySize, search);
-
-        return new ResponseEntity<List<Restaurant>>(filteredRestaurants, HttpStatus.OK);
+        List<RestaurantDTO> filteredRestaurants = restaurantService.findRestaurantsBySearchParams(parsedDateTime, partySize, search);
+
+        return new ResponseEntity<>(filteredRestaurants, HttpStatus.OK);
     }
 
     @PostMapping("/api/search/shortcut/{param}")
-    public ResponseEntity<List<Restaurant>> searchByCuisineTypeShortcut(@PathVariable String param) {
-        List<Restaurant> filteredRestaurants;
+    public ResponseEntity<List<RestaurantDTO>> searchByCuisineTypeShortcut(@PathVariable String param) {
+        List<RestaurantDTO> filteredRestaurants;
         if(param != null && !param.isEmpty()) {
             filteredRestaurants = restaurantService.findRestaurantsByCuisineType(param);
@@ -97 +95 @@
             filteredRestaurants = restaurantService.listall();
         }
-        return new ResponseEntity<List<Restaurant>>(filteredRestaurants, HttpStatus.OK);
+        return new ResponseEntity<List<RestaurantDTO>>(filteredRestaurants, HttpStatus.OK);
     }
 
@@ -106 +104 @@
     }
 
+    // User calls
+
+    @GetMapping("/api/user/{email}")
+    public ResponseEntity<User> getUserByEmail(@PathVariable String email)
+    {
+        User user = userService.findByMail(email);
+        return ResponseEntity.ok(user);
+    }
+
 //    Customer CALLS
 
-    @RequestMapping("/api/customers")
+    @GetMapping("/api/customers")
     public ResponseEntity<List<CustomerDTO>> getAllCustomers() {
         List<Customer> customers = customerService.listAll();
@@ -119 +126 @@
     }
 
-    @RequestMapping("/api/customers/{id}")
+    @GetMapping("/api/customers/{id}")
     public ResponseEntity<Customer> getCustomerById(@PathVariable Long id) {
         return new ResponseEntity<Customer>(customerService.findById(id), HttpStatus.OK);
@@ -130 +137 @@
         );
     }
-    @GetMapping("/api/user")
-    public ResponseEntity<?> getCurrentUser() {
-        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
-
-        if (authentication == null || !authentication.isAuthenticated() || authentication.getPrincipal().equals("anonymousUser")) {
-            return new ResponseEntity<>("User is not authenticated", HttpStatus.UNAUTHORIZED);
-        }
-
-        Customer customer = (Customer) authentication.getPrincipal();
-        return new ResponseEntity<>(customer, HttpStatus.OK);
-    }
-
 
     @PostMapping("/api/customers")
@@ -166 +161 @@
 
     @GetMapping("/api/reservations/by/{email}")
-    public ResponseEntity<List<Reservation>> getReservations(@PathVariable String email) {
-        User user = userService.findByMail(email);
-        return new ResponseEntity<List<Reservation>>(reservationService.findReservationByUser(user), HttpStatus.OK);
-    }
-
-    @PostMapping("/api/reservations/{email}")
-    public ResponseEntity<Reservation> createReservation(@RequestBody Reservation reservation, @PathVariable String email) {
-        User user = userService.findByMail(email);
+    public ResponseEntity<List<ReservationDTO>> getReservations(@PathVariable String email) {
+        if (email == null || email.isEmpty()) {
+            return ResponseEntity.badRequest().build();
+        }
+        User user = userService.findByMail(email);
+        if (user == null) {
+            return ResponseEntity.notFound().build();
+        }
+
+        List<Reservation> reservations = reservationService.findReservationByUser(user);
+        List<ReservationDTO> reservationDTOs = reservations.stream()
+                .map(ReservationDTO::new)
+                .collect(Collectors.toList());
+
+        return ResponseEntity.ok(reservationDTOs);
+    }
+
+    @PostMapping("/api/reservations")
+    public ResponseEntity<?> createReservation(@RequestBody ReservationDTO reservation) {
+        User user = userService.findByMail(reservation.getUserEmail());
         Reservation savedReservation = reservationService.makeReservationRest(reservation, user);
 
@@ -179 +186 @@
     }
 
-
     @GetMapping("/api/reservations/{reservationId}")
-    public ResponseEntity<Reservation> getReservation(@PathVariable Long reservationId) {
+    public ResponseEntity<ReservationDTO> getReservation(@PathVariable Long reservationId) {
         Reservation reservation = reservationService.findById(reservationId);
         if (reservation != null) {
-            return ResponseEntity.ok(reservation);
-        } else {
-            return ResponseEntity.notFound().build();
-        }
-    }
+            return ResponseEntity.ok(new ReservationDTO(reservation));
+        } else {
+            return ResponseEntity.notFound().build();
+        }
+    }
+
+//    @GetMapping("/api/reservations/{restaurantId}")
+//    public ResponseEntity<List<Reservation>> getReservationsByRestaurant(@PathVariable Long restaurantId)
+//    {
+//        Restaurant restaurant = restaurantService.findByIdRestaurant(restaurantId);
+//        List<Reservation> reservations = reservationService.findAllByRestaurant(restaurant);
+//        return ResponseEntity.ok(reservations);
+//    }
+
+    @GetMapping("/api/table-reservations/{tableId}")
+    public ResponseEntity<List<LocalDateTime>> tableReservations(@PathVariable Long tableId) {
+        TableEntity table = tableService.findByIdTable(tableId);
+        if (table == null) {
+            return ResponseEntity.notFound().build();
+        }
+
+        List<Reservation> reservations = reservationService.reservationsForTable(table);
+        List<LocalDateTime> reservedTimes = reservations.stream()
+                .map(Reservation::getReservationDateTime)
+                .collect(Collectors.toList());
+
+        return ResponseEntity.ok(reservedTimes);
+    }
+
 
     @PostMapping("/api/reservations/{reservationId}/{email}")
     public ResponseEntity<Reservation> editReservation(@PathVariable Long reservationId,
-                                                       @RequestBody Reservation reservation,
+                                                       @RequestBody ReservationDTO reservationDTO,
                                                        @PathVariable String email) {
         User user = userService.findByMail(email);
 
-        if (!reservation.getReservationID().equals(reservationId)) {
+        if (!reservationDTO.getReservationID().equals(reservationId)) {
             return ResponseEntity.badRequest().build();
         }
 
-        // Fetch existing reservation
-        Reservation existingReservation = reservationService.findById(reservationId);
-        if (existingReservation == null) {
-            return ResponseEntity.notFound().build();
-        }
-
-        if (!reservation.getCheckInTime().equals(existingReservation.getCheckInTime())) {
-            tableService.canceledTimeSlots(existingReservation.getTable().getId(), existingReservation.getCheckInTime());
-
-            tableService.deleteTimeSlotsForReservation(reservation.getTable().getId(), reservation.getCheckInTime());
-        }
-
-        existingReservation.setReservationDateTime(LocalDateTime.now());
-        existingReservation.setCheckInTime(reservation.getCheckInTime());
-        existingReservation.setCheckOutTime(reservation.getCheckInTime().plusHours(2));
-        existingReservation.setPartySize(reservation.getPartySize());
-        existingReservation.setSpecialRequests(reservation.getSpecialRequests());
-
-        Reservation updatedReservation = reservationService.makeReservationRest(existingReservation, user);
-
-        System.out.println("Updated reservation time: " + updatedReservation.getCheckInTime());
-        return ResponseEntity.ok(updatedReservation);
-    }
+        try {
+            Reservation updatedReservation = reservationService.updateReservation(reservationId, reservationDTO, user);
+            return ResponseEntity.ok(updatedReservation);
+        } catch (InvalidReservationException e) {
+            return ResponseEntity.status(409).body(null);
+        } catch (Exception e) {
+            return ResponseEntity.status(500).build();
+        }
+    }
+
 
 
@@ -241 +258 @@
     }
 
-//    TableEntity Calls
-
+    // TableEntity Calls
     @GetMapping("/api/tables/{tableId}")
-    public ResponseEntity<TableEntity> findTableById(@PathVariable Long tableId) {
-        return new ResponseEntity<TableEntity>(tableService.findById(tableId), HttpStatus.OK);
+    public ResponseEntity<TableDTO> findTableById(@PathVariable Long tableId) {
+        TableDTO tableDTO = tableService.findById(tableId);
+        return new ResponseEntity<>(tableDTO, HttpStatus.OK);
     }
 
@@ -255 +272 @@
         return new ResponseEntity<>(reservations, HttpStatus.OK);
     }
-
 }