Changeset 8ca35dc for src/main/java/com/example/rezevirajmasa/demo/web

Timestamp:

01/19/25 23:18:37 (4 months ago)

Author:

Aleksandar Panovski <apano77@…>

Branches:

main

Children:

f5b256e

Parents:

db39d9e

Message:

Done with stupid timeslots

Location:

src/main/java/com/example/rezevirajmasa/demo/web

Files:

• controller/ReservationController.java (modified) (4 diffs)
• controller/ReservationHistoryController.java (modified) (3 diffs)
• filters/JwtAuthFilter.java (modified) (5 diffs)
• rest/AuthController.java (modified) (3 diffs)
• rest/testController.java (modified) (7 diffs)

src/main/java/com/example/rezevirajmasa/demo/web/controller/ReservationController.java

@@ -1 +1 @@
 package com.example.rezevirajmasa.demo.web.controller;
 
+import com.example.rezevirajmasa.demo.dto.SignUpDto;
+import com.example.rezevirajmasa.demo.dto.UserDto;
+import com.example.rezevirajmasa.demo.mappers.UserMapper;
 import com.example.rezevirajmasa.demo.model.*;
 import com.example.rezevirajmasa.demo.model.exceptions.ExpiredReservationException;
@@ -19 +22 @@
 public class ReservationController {
     private final ReservationService reservationService;
-    private final CustomerService customerService;
+    private final UserService userService;
     private final TableService tableService;
     private final ReservationHistoryService reservationHistoryService;
 
-    public ReservationController(ReservationService reservationService, CustomerService customerService, TableService tableService, ReservationHistoryService reservationHistoryService) {
+    private final UserMapper userMapper;
+
+    public ReservationController(ReservationService reservationService, UserService userService, TableService tableService, ReservationHistoryService reservationHistoryService, UserMapper userMapper) {
         this.reservationService = reservationService;
-        this.customerService = customerService;
+        this.userService = userService;
         this.tableService = tableService;
         this.reservationHistoryService = reservationHistoryService;
+        this.userMapper = userMapper;
     }
 
     @GetMapping("/reservations")
     public String showReservations(Model model, Authentication authentication) {
-        Customer customer = customerService.findByEmail(authentication.getName());
-        List<Reservation> reservationList;
-        if(customer.getRole().equals(Role.ROLE_ADMIN)) {
-            reservationList = reservationService.listAll();
-        } else {
-            reservationList = reservationService.findReservationByCustomer(customer);
-        }
+        UserDto userDto = userService.findByEmail(authentication.getName());
+
+        SignUpDto signUpDto = userMapper.toSignUpDto(userDto);
+
+        User user = userMapper.signUpToUser(signUpDto);
+
+        List<Reservation> reservationList = reservationService.findReservationByUser(user);
+
         model.addAttribute("bodyContent", "reservationList");
         model.addAttribute("reservations", reservationList);
         return "index";
     }
+
 
     @GetMapping("/reservations/edit/{reservationId}")
@@ -62 +70 @@
         Restaurant restaurant = table.getRestaurant();
 
-        Customer customer = customerService.findByEmail(authentication.getName());
+        UserDto userDto = userService.findByEmail(authentication.getName());
+
+        SignUpDto signUpDto = userMapper.toSignUpDto(userDto);
+
+        User user = userMapper.signUpToUser(signUpDto);
 
         if(!table.isAvailable(reservationDateTime)) {
@@ -68 +80 @@
         }
         tableService.deleteTimeSlotsForReservation(tableNumber, reservationDateTime);
-        reservationService.makeReservation(customer, table, restaurant, LocalDateTime.now(), reservationDateTime, partySize, specialRequests);
+        reservationService.makeReservation(user, table, restaurant, LocalDateTime.now(), reservationDateTime, partySize, specialRequests);
         return "redirect:/reservations";
     }

src/main/java/com/example/rezevirajmasa/demo/web/controller/ReservationHistoryController.java

@@ -1 +1 @@
 package com.example.rezevirajmasa.demo.web.controller;
 
+import com.example.rezevirajmasa.demo.dto.SignUpDto;
+import com.example.rezevirajmasa.demo.dto.UserDto;
+import com.example.rezevirajmasa.demo.mappers.UserMapper;
 import com.example.rezevirajmasa.demo.model.Customer;
 import com.example.rezevirajmasa.demo.model.Restaurant;
 import com.example.rezevirajmasa.demo.model.Role;
+import com.example.rezevirajmasa.demo.model.User;
 import com.example.rezevirajmasa.demo.service.CustomerService;
 import com.example.rezevirajmasa.demo.service.ReservationHistoryService;
+import com.example.rezevirajmasa.demo.service.UserService;
 import org.springframework.security.core.Authentication;
 import org.springframework.stereotype.Controller;
@@ -18 +23 @@
 public class ReservationHistoryController {
     private final ReservationHistoryService reservationHistoryService;
-    private final CustomerService customerService;
+    private final UserService userService;
+    private final UserMapper userMapper;
 
-    public ReservationHistoryController(ReservationHistoryService reservationHistoryService, CustomerService customerService) {
+    public ReservationHistoryController(ReservationHistoryService reservationHistoryService, UserService userService, UserMapper userMapper) {
         this.reservationHistoryService = reservationHistoryService;
-        this.customerService = customerService;
+        this.userService = userService;
+        this.userMapper = userMapper;
     }
 
@@ -28 +35 @@
     public String showPastReservations(Authentication authentication, Model model) {
         List<Restaurant.ReservationHistory> reservationHistoryList;
-        Customer customer = customerService.findByEmail(authentication.getName());
-        if(customer.getRole().equals(Role.ROLE_ADMIN)) {
-            reservationHistoryList = reservationHistoryService.findAll();
-        } else {
-            reservationHistoryList = reservationHistoryService.findByCustomer(customer);
-        }
+        UserDto userDto = userService.findByEmail(authentication.getName());
+
+        SignUpDto signUpDto = userMapper.toSignUpDto(userDto);
+
+        User user = userMapper.signUpToUser(signUpDto);
+
+        reservationHistoryList = reservationHistoryService.findByUser(user);
+//        if(customer.getRole().equals(Role.ROLE_ADMIN)) {
+//            reservationHistoryList = reservationHistoryService.findAll();
+//        } else {
+//            reservationHistoryList = reservationHistoryService.findByUser(User user);
+//        }
         model.addAttribute("historyReservations", reservationHistoryList);
         model.addAttribute("bodyContent", "pastReservations");

src/main/java/com/example/rezevirajmasa/demo/web/filters/JwtAuthFilter.java

@@ -2 +2 @@
 
 import com.example.rezevirajmasa.demo.config.UserAuthProvider;
+import io.jsonwebtoken.ExpiredJwtException;
 import jakarta.servlet.FilterChain;
 import jakarta.servlet.ServletException;
@@ -7 +8 @@
 import jakarta.servlet.http.HttpServletResponse;
 import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.HttpHeaders;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
 import org.springframework.security.core.context.SecurityContextHolder;
 import org.springframework.web.filter.OncePerRequestFilter;
@@ -17 +20 @@
 
     private final UserAuthProvider userAuthProvider;
+
     @Override
     protected void doFilterInternal(
@@ -24 +28 @@
         String header = request.getHeader(HttpHeaders.AUTHORIZATION);
 
+        String username = null;
+        String jwt = null;
+
         if(header != null) {
+            jwt = header.substring(7);
             String[] elements = header.split(" ");
 
             if(elements.length == 2 && "Bearer".equals(elements[0])) {
                 try {
+                    username = userAuthProvider.extractUsername(jwt); // logikata vidi ja
                     SecurityContextHolder.getContext().setAuthentication(
                             userAuthProvider.validateToken(elements[1])
                     );
+                    if (username != null) {
+                        System.out.println("Authenticated user: " + username); // Debug log
+                        SecurityContextHolder.getContext().setAuthentication(
+                                userAuthProvider.validateToken(jwt) // Ensure token validation works properly
+                        );
+                    }
+                } catch (ExpiredJwtException e) {
+                    String isRefreshToken = request.getHeader("isRefreshToken");
+                    String requestURL = request.getRequestURL().toString();
+                    if (isRefreshToken != null && isRefreshToken.equals("true") && requestURL.contains("refresh-token")) {
+                        allowForRefreshToken(e, request);
+                    } else
+                        request.setAttribute("exception", e);
+
                 } catch (RuntimeException e) {
                     SecurityContextHolder.clearContext();
@@ -40 +63 @@
         filterChain.doFilter(request, response);
     }
+
+    private void allowForRefreshToken(ExpiredJwtException ex, HttpServletRequest request) {
+        UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(
+                null, null, null);
+        SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);
+        request.setAttribute("claims", ex.getClaims());
+    }
 }

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

@@ -14 +14 @@
 import org.springframework.http.ResponseEntity;
 import org.springframework.security.authentication.AuthenticationManager;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.Authentication;
 import org.springframework.security.crypto.password.PasswordEncoder;
 import org.springframework.web.bind.annotation.CrossOrigin;
@@ -30 +32 @@
     public ResponseEntity<UserDto> login(@RequestBody CredentialsDto credentialsDto) {
         UserDto user = userService.login(credentialsDto);
-        user.setToken(userAuthProvider.createToken(user.getEmail()));
+        String token = userAuthProvider.createToken(user.getEmail());
+        user.setToken(token);
+
         return ResponseEntity.ok(user);
     }
@@ -38 +42 @@
         UserDto user = userService.register(signUpDto);
         user.setToken(userAuthProvider.createToken(user.getEmail()));
-        return ResponseEntity.created(URI.create("/users/" + user.getId()))
-                .body(user);
+        return ResponseEntity.created(URI.create("/users/" + user.getId())).body(user);
     }
 }

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

@@ -2 +2 @@
 
 import com.example.rezevirajmasa.demo.dto.CustomerDTO;
+import com.example.rezevirajmasa.demo.dto.UserDto;
+import com.example.rezevirajmasa.demo.mappers.UserMapper;
 import com.example.rezevirajmasa.demo.model.*;
-import com.example.rezevirajmasa.demo.service.CustomerService;
-import com.example.rezevirajmasa.demo.service.ReservationService;
-import com.example.rezevirajmasa.demo.service.RestaurantService;
-import com.example.rezevirajmasa.demo.service.TableService;
+import com.example.rezevirajmasa.demo.service.*;
+import com.example.rezevirajmasa.demo.service.impl.TokenService;
+import jakarta.servlet.http.HttpServletRequest;
 import jdk.jfr.consumer.RecordingStream;
 import org.apache.coyote.Response;
+import org.apache.http.protocol.HTTP;
 import org.springframework.format.annotation.DateTimeFormat;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.core.parameters.P;
+import org.springframework.security.core.userdetails.UserDetails;
 import org.springframework.web.bind.annotation.*;
 
+import java.nio.file.attribute.UserPrincipal;
+import java.security.Principal;
 import java.time.LocalDateTime;
 import java.time.format.DateTimeFormatter;
@@ -26 +35 @@
     private final RestaurantService restaurantService;
     private final CustomerService customerService;
+    private final UserService userService;
     private final ReservationService reservationService;
+    private final ReservationHistoryService reservationHistoryService;
     private final TableService tableService;
-
-    public testController(RestaurantService restaurantService, CustomerService customerService, ReservationService reservationService, TableService tableService) {
+    private final UserMapper userMapper;
+    private final TokenService tokenService;
+    public testController(RestaurantService restaurantService, CustomerService customerService, UserService userService, ReservationService reservationService, ReservationHistoryService reservationHistoryService, TableService tableService, UserMapper userMapper, TokenService tokenService) {
         this.restaurantService = restaurantService;
         this.customerService = customerService;
+        this.userService = userService;
         this.reservationService = reservationService;
+        this.reservationHistoryService = reservationHistoryService;
         this.tableService = tableService;
+        this.userMapper = userMapper;
+        this.tokenService = tokenService;
     }
 
@@ -114 +130 @@
         );
     }
+    @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")
@@ -137 +165 @@
 //    Reservation Calls
 
-    @GetMapping("/api/reservations")
-    public ResponseEntity<List<Reservation>> getReservations() {
-        return new ResponseEntity<List<Reservation>>(reservationService.listAll(), HttpStatus.OK);
-    }
-
-    @PostMapping("/api/reservations")
-    public ResponseEntity<Reservation> createReservation(@RequestBody Reservation reservation) {
-        reservation.setReservationDateTime(LocalDateTime.now());
-        Reservation savedReservation = reservationService.makeReservationRest(reservation);
+    @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);
+        Reservation savedReservation = reservationService.makeReservationRest(reservation, user);
+
         return new ResponseEntity<>(savedReservation, HttpStatus.CREATED);
     }
+
 
     @GetMapping("/api/reservations/{reservationId}")
@@ -159 +190 @@
     }
 
-    @PostMapping("/api/reservations/{reservationId}")
+    @PostMapping("/api/reservations/{reservationId}/{email}")
     public ResponseEntity<Reservation> editReservation(@PathVariable Long reservationId,
-                                                       @RequestBody Reservation reservation) {
+                                                       @RequestBody Reservation reservation,
+                                                       @PathVariable String email) {
+        User user = userService.findByMail(email);
+
         if (!reservation.getReservationID().equals(reservationId)) {
             return ResponseEntity.badRequest().build();
         }
 
-        Reservation savedReservation = reservationService.findById(reservationId);
-        if(!reservation.getCheckInTime().equals(savedReservation.getCheckInTime())) {
-            tableService.canceledTimeSlots(savedReservation.getTable().getId(), savedReservation.getCheckInTime());
-        }
-
-        savedReservation.setReservationDateTime(LocalDateTime.now());
-        savedReservation.setCheckInTime(reservation.getCheckInTime());
-        savedReservation.setCheckOutTime(reservation.getCheckInTime().plusHours(2));
-        savedReservation.setPartySize(reservation.getPartySize());
-        savedReservation.setSpecialRequests(reservation.getSpecialRequests());
-        tableService.deleteTimeSlotsForReservation(reservation.getTable().getId(), reservation.getCheckInTime());
-
-        //moze da se vovede sistem za ako od 4ca doagjaat samo 2ca da se najde pomala masa po moznost ako ima u toj moment
-        //listaj samo slotovi za taa masa vo toj moment ili da ima da odbere od novo ama taka bolje nova rezevacij
-
-        Reservation updatedReservation = reservationService.makeReservationRest(savedReservation);
-        System.out.println("Saved reservation time: " + savedReservation.getCheckInTime());
+        // 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);
     }
+
 
     @DeleteMapping("/api/reservations/delete/{reservationId}")
@@ -196 +235 @@
     }
 
+    @GetMapping("/api/reservations/past/{email}")
+    public ResponseEntity<List<Restaurant.ReservationHistory>> pastReservations(@PathVariable String email) {
+        User user = userService.findByMail(email);
+        return null;
+    }
+
 //    TableEntity Calls
 
@@ -203 +248 @@
     }
 
+    // past reservation calls
+    @GetMapping("/api/past-reservations/{email}")
+    public ResponseEntity<List<Restaurant.ReservationHistory>> findPastReservationsByUser(@PathVariable String email) {
+        User user = userService.findByMail(email);
+        List<Restaurant.ReservationHistory> reservations = reservationHistoryService.findByUser(user);
+        return new ResponseEntity<>(reservations, HttpStatus.OK);
+    }
+
 }