Changeset 8ca35dc for src


Ignore:
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
Files:
2 added
26 edited

Legend:

Unmodified
Added
Removed

  • src/main/java/com/example/rezevirajmasa/demo/bootstrap/ReservationInitializer.java

    rdb39d9e r8ca35dc  
    1 package com.example.rezevirajmasa.demo.bootstrap;
    2 
    3 import com.example.rezevirajmasa.demo.model.Reservation;
    4 import com.example.rezevirajmasa.demo.model.Restaurant;
    5 import com.example.rezevirajmasa.demo.service.ReservationHistoryService;
    6 import com.example.rezevirajmasa.demo.service.ReservationService;
    7 import org.springframework.stereotype.Component;
    8 
    9 import jakarta.annotation.PostConstruct;
    10 import java.time.LocalDateTime;
    11 import java.util.List;
    12 import java.util.stream.Collectors;
    13 
    14 @Component
    15 public class ReservationInitializer {
    16     private final ReservationHistoryService reservationHistoryService;
    17     private final ReservationService reservationService;
    18 
    19     public ReservationInitializer(ReservationHistoryService reservationHistoryService, ReservationService reservationService) {
    20         this.reservationHistoryService = reservationHistoryService;
    21         this.reservationService = reservationService;
    22     }
    23 
    24     @PostConstruct
    25     public void initializePastReservations() {
    26         LocalDateTime currentTime = LocalDateTime.now();
    27         List<Reservation> reservationsToMove = reservationService.findReservationsToMove(currentTime);
    28 
    29         List<Restaurant.ReservationHistory> reservationHistories = reservationsToMove.stream()
    30                 .map(reservation -> new Restaurant.ReservationHistory(
    31                         reservation.getCustomer(),
    32                         reservation.getTable(),
    33                         reservation.getRestaurant(),
    34                         reservation.getReservationDateTime(),
    35                         reservation.getPartySize(),
    36                         reservation.getSpecialRequests(),
    37                         "Done",
    38                         null, // You can set cancellation reason if needed, it's not clear from the code provided
    39                         reservation.getCheckInTime() // Use currentTime for check-in date
    40                 ))
    41                 .collect(Collectors.toList());
    42 
    43         reservationHistoryService.moveReservationsToPast(reservationHistories);
    44 
    45         reservationsToMove.forEach(reservation -> reservationService.deleteReservation(reservation.getReservationID()));
    46     }
    47 
    48 }
     1//package com.example.rezevirajmasa.demo.bootstrap;
     2//
     3//import com.example.rezevirajmasa.demo.model.Reservation;
     4//import com.example.rezevirajmasa.demo.model.Restaurant;
     5//import com.example.rezevirajmasa.demo.service.ReservationHistoryService;
     6//import com.example.rezevirajmasa.demo.service.ReservationService;
     7//import org.springframework.stereotype.Component;
     8//
     9//import jakarta.annotation.PostConstruct;
     10//import java.time.LocalDateTime;
     11//import java.util.List;
     12//import java.util.stream.Collectors;
     13//
     14//@Component
     15//public class ReservationInitializer {
     16//    private final ReservationHistoryService reservationHistoryService;
     17//    private final ReservationService reservationService;
     18//
     19//    public ReservationInitializer(ReservationHistoryService reservationHistoryService, ReservationService reservationService) {
     20//        this.reservationHistoryService = reservationHistoryService;
     21//        this.reservationService = reservationService;
     22//    }
     23//
     24//    @PostConstruct
     25//    public void initializePastReservations() {
     26//        LocalDateTime currentTime = LocalDateTime.now();
     27//        List<Reservation> reservationsToMove = reservationService.findReservationsToMove(currentTime);
     28//
     29//        List<Restaurant.ReservationHistory> reservationHistories = reservationsToMove.stream()
     30//                .map(reservation -> new Restaurant.ReservationHistory(
     31//                        reservation.getUser(),
     32//                        reservation.getTable(),
     33//                        reservation.getRestaurant(),
     34//                        reservation.getReservationDateTime(),
     35//                        reservation.getPartySize(),
     36//                        reservation.getSpecialRequests(),
     37//                        "Done",
     38//                        null,
     39//                        reservation.getCheckInTime()
     40//                ))
     41//                .collect(Collectors.toList());
     42//
     43//        reservationHistoryService.moveReservationsToPast(reservationHistories);
     44//
     45//        reservationsToMove.forEach(reservation -> reservationService.deleteReservation(reservation.getReservationID()));
     46//    }
     47//
     48//}

  • src/main/java/com/example/rezevirajmasa/demo/config/SecurityConfig.java

    rdb39d9e r8ca35dc  
    77import org.springframework.http.HttpMethod;
    88import org.springframework.security.authentication.AuthenticationManager;
     9import org.springframework.security.config.Customizer;
    910import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
    1011import org.springframework.security.config.annotation.web.builders.HttpSecurity;
    … …  
    1516import org.springframework.security.core.userdetails.UserDetailsService;
    1617import org.springframework.security.web.SecurityFilterChain;
     18import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
    1719import org.springframework.security.web.authentication.www.BasicAuthenticationFilter;
     20import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
    1821import org.springframework.web.servlet.config.annotation.CorsRegistry;
     22import org.springframework.context.annotation.Bean;
     23import org.springframework.context.annotation.Configuration;
     24import org.springframework.security.config.annotation.web.builders.HttpSecurity;
     25import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
     26import org.springframework.security.web.SecurityFilterChain;
    1927import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
    2028
    … …  
    4048    public void addCorsMappings(CorsRegistry registry) {
    4149        registry.addMapping("/**")
     50                .allowedOrigins("http://localhost:3000")
     51                .allowedMethods("GET", "POST", "PUT", "DELETE")
     52                .allowedHeaders("*")
    4253                .allowCredentials(true)
    43                 .allowedOrigins("http://localhost:3000") // Allow requests from this origin
    44                 .allowedMethods("GET", "POST", "PUT", "DELETE") // Allow these HTTP methods
    45                 .allowedHeaders("*")
    46                 .maxAge(3600L); // Allow all headers
     54                .maxAge(3600L);
    4755    }
    4856
    4957//    @Bean
    50 //    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception  {
    51 //
     58//    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    5259//        http
     60//                .exceptionHandling(exception -> exception.authenticationEntryPoint(customerAuthenticationEntryPoint))
     61//                .addFilterBefore(new JwtAuthFilter(userAuthProvider), BasicAuthenticationFilter.class)
    5362//                .csrf(AbstractHttpConfigurer::disable)
    54 //                .authorizeHttpRequests( (requests) -> requests
    55 //                        .requestMatchers(AntPathRequestMatcher.antMatcher("/"), AntPathRequestMatcher.antMatcher("/restaurants"))
    56 //                        .permitAll()
    57 //                        .anyRequest()
    58 //                        .hasAnyRole("ADMIN", "USER")
     63//                .sessionManagement(sess -> sess.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
     64//                .authorizeHttpRequests(requests -> requests
     65//                        .requestMatchers(HttpMethod.POST, "/api/login", "/api/register").permitAll()
     66//                        .requestMatchers("/", "/home").authenticated()  // Restrict `/` to authenticated users
     67//                        .anyRequest().authenticated()
    5968//                )
    60 //                .formLogin((form) -> form
    61 //                        .permitAll()
    62 //                        .failureUrl("/login?error=BadCredentials")
    63 //                        .defaultSuccessUrl("/restaurants", true)
    64 //                )
    65 //                .logout((logout) -> logout
     69//                .logout(logout -> logout
    6670//                        .logoutUrl("/logout")
    6771//                        .clearAuthentication(true)
    6872//                        .invalidateHttpSession(true)
    6973//                        .deleteCookies("JSESSIONID")
    70 //                        .logoutSuccessUrl("/")
     74//                        .logoutSuccessUrl("/api/login")  // Redirect to login page after logout
    7175//                );
    7276//
    … …  
    8387                .authorizeHttpRequests((requests) -> requests
    8488                        .requestMatchers(HttpMethod.POST, "/api/login", "/api/register").permitAll()
    85                         .anyRequest().authenticated()
    86                 );
     89                        .anyRequest().authenticated());
    8790        return http.build();
    8891    }
     92
    8993    @Bean
    9094    public AuthenticationManager authManager(HttpSecurity http) throws Exception {
    … …  
    9599    }
    96100}
     101//
     102//import com.example.rezevirajmasa.demo.web.filters.JwtAuthFilter;
     103//import org.springframework.context.annotation.Bean;
     104//import org.springframework.context.annotation.Configuration;
     105//import org.springframework.security.authentication.AuthenticationManager;
     106//import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
     107//import org.springframework.security.config.annotation.web.builders.HttpSecurity;
     108//import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
     109//import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
     110//import org.springframework.security.config.http.SessionCreationPolicy;
     111//import org.springframework.security.core.userdetails.UserDetailsService;
     112//import org.springframework.security.web.SecurityFilterChain;
     113//import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
     114//
     115//@Configuration
     116//@EnableWebSecurity
     117//public class SecurityConfig {
     118//
     119//    private final UserDetailsService userDetailsService;
     120////    private final UserAuthProvider userAuthProvider;
     121//    private final JwtAuthFilter jwtAuthFilter;
     122//
     123//    public SecurityConfig(UserDetailsService userDetailsService) {
     124//        this.userDetailsService = userDetailsService;
     125////        this.userAuthProvider = userAuthProvider;
     126//        this.jwtAuthFilter = new JwtAuthFilter(userAuthProvider);
     127//    }
     128//
     129//    @Bean
     130//    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
     131//        http
     132//                .csrf(AbstractHttpConfigurer::disable)
     133//                .sessionManagement(sess -> sess.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
     134//                .authorizeHttpRequests((requests) -> requests
     135//                        .requestMatchers("/api/login", "/api/register").permitAll()
     136//                        .anyRequest().authenticated())
     137//                .addFilterBefore(jwtAuthFilter, UsernamePasswordAuthenticationFilter.class);
     138//
     139//        return http.build();
     140//    }
     141//
     142//    @Bean
     143//    public AuthenticationManager authenticationManager(HttpSecurity http) throws Exception {
     144//        AuthenticationManagerBuilder authenticationManagerBuilder = http.getSharedObject(AuthenticationManagerBuilder.class);
     145//        authenticationManagerBuilder.userDetailsService(userDetailsService);
     146//        return authenticationManagerBuilder.build();
     147//    }
     148//}

  • src/main/java/com/example/rezevirajmasa/demo/config/UserAuthProvider.java

    rdb39d9e r8ca35dc  
    77import com.example.rezevirajmasa.demo.dto.UserDto;
    88import com.example.rezevirajmasa.demo.service.UserService;
     9import io.jsonwebtoken.Claims;
     10import io.jsonwebtoken.Jwts;
    911import jakarta.annotation.PostConstruct;
    1012import lombok.RequiredArgsConstructor;
    … …  
    1214import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
    1315import org.springframework.security.core.Authentication;
     16import org.springframework.security.core.userdetails.UserDetails;
    1417import org.springframework.stereotype.Component;
    1518
    16 import java.util.Base64;
    17 import java.util.Collections;
    18 import java.util.Date;
     19import java.util.*;
     20import java.util.function.Function;
    1921
    2022@RequiredArgsConstructor
    … …  
    2931    protected void init() {
    3032        secretKey = Base64.getEncoder().encodeToString(secretKey.getBytes());
     33    }
     34
     35    public String generateToken(UserDetails userDetails){
     36        Map<String, Object> claims = new HashMap<>();
     37        return createToken(userDetails.getUsername());
    3138    }
    3239
    … …  
    5057        return new UsernamePasswordAuthenticationToken(user, null, Collections.emptyList());
    5158    }
     59
     60    public String extractUsername(String token) {
     61        return extractClaim(token, Claims::getSubject);
     62    }
     63
     64    public Date extractExpiration(String token) {
     65        return extractClaim(token, Claims::getExpiration);
     66    }
     67
     68    public <T> T extractClaim(String token, Function<Claims, T> claimsResolver) {
     69        final Claims claims = extractAllClaims(token);
     70        return claimsResolver.apply(claims);
     71    }
     72
     73    private Claims extractAllClaims(String token) {
     74        return Jwts.parser().setSigningKey(secretKey).parseClaimsJws(token).getBody();
     75    }
     76
     77    private Boolean isTokenExpired(String token) {
     78        return extractExpiration(token).before(new Date());
     79    }
    5280}

  • src/main/java/com/example/rezevirajmasa/demo/dto/CredentialsDto.java

    rdb39d9e r8ca35dc  
    1111@Data
    1212public class CredentialsDto {
    13     private String login;
     13    private String email;
    1414    private char[] password;
    1515}

  • src/main/java/com/example/rezevirajmasa/demo/dto/SignUpDto.java

    rdb39d9e r8ca35dc  
    1515    private String email;
    1616    private char[] password;
     17    private String phone;
     18    private String address;
     19    private String membershipLevel;
    1720}

  • src/main/java/com/example/rezevirajmasa/demo/dto/UserDto.java

    rdb39d9e r8ca35dc  
    1616    private String email;
    1717    private String token;
     18    private String phone;
     19    private String address;
     20    private String membershipLevel;
    1821}

  • src/main/java/com/example/rezevirajmasa/demo/mappers/UserMapper.java

    rdb39d9e r8ca35dc  
    1414    @Mapping(target = "password", ignore = true)
    1515    User signUpToUser(SignUpDto userDto);
     16
     17    SignUpDto toSignUpDto(UserDto userDto);
     18    User toUser(UserDto userDto);
    1619}

  • src/main/java/com/example/rezevirajmasa/demo/mappers/UserMapperImpl.java

    rdb39d9e r8ca35dc  
    33import com.example.rezevirajmasa.demo.dto.SignUpDto;
    44import com.example.rezevirajmasa.demo.dto.UserDto;
     5import com.example.rezevirajmasa.demo.model.MembershipLevel;
    56import com.example.rezevirajmasa.demo.model.User;
    67import org.springframework.stereotype.Component;
    … …  
    3637        user.setFirstName(userDto.getFirstName());
    3738        user.setLastName(userDto.getLastName());
    38         user.setPassword(Arrays.toString(userDto.getPassword()));
     39        user.setPassword(Arrays.toString(userDto.getPassword())); // Assuming password is a char[] or string array.
     40
     41        return user;
     42    }
     43
     44    @Override
     45    public SignUpDto toSignUpDto(UserDto userDto) {
     46        if (userDto == null) {
     47            return null;
     48        }
     49
     50        SignUpDto signUpDto = new SignUpDto();
     51        signUpDto.setEmail(userDto.getEmail());
     52        signUpDto.setFirstName(userDto.getFirstName());
     53        signUpDto.setLastName(userDto.getLastName());
     54
     55        // Since SignUpDto has password field, you may set it if needed.
     56        // Assuming a default value or handling empty password as required.
     57        signUpDto.setPassword(new char[0]); // Empty password for now or assign actual value if required.
     58
     59        return signUpDto;
     60    }
     61
     62    @Override
     63    public User toUser(UserDto userDto) {
     64        if(userDto == null) {
     65            return null;
     66        }
     67
     68        User user = new User();
     69        user.setLastName(userDto.getLastName());
     70        user.setFirstName(userDto.getFirstName());
     71        user.setPhone(userDto.getPhone());
     72        user.setMembershipLevel(MembershipLevel.valueOf(userDto.getMembershipLevel()));
     73        user.setAddress(userDto.getAddress());
     74        user.setEmail(userDto.getEmail());
     75        user.setId(userDto.getId());
    3976
    4077        return user;

  • src/main/java/com/example/rezevirajmasa/demo/model/Reservation.java

    rdb39d9e r8ca35dc  
    1616
    1717    @ManyToOne
    18     @JoinColumn(name = "CustomerID")
    19     private Customer customer;
     18    @JoinColumn(name = "UserID")
     19    private User user;
    2020
    2121    @ManyToOne
    … …  
    6868    }
    6969
    70     public Reservation(Customer customer, TableEntity table, Restaurant restaurant, LocalDateTime reservationDateTime, int partySize, String specialRequests, String status, LocalDateTime checkInTime, LocalDateTime checkOutTime, String paymentStatus) {
     70    public Reservation(User user, TableEntity table, Restaurant restaurant, LocalDateTime reservationDateTime, int partySize, String specialRequests, String status, LocalDateTime checkInTime, LocalDateTime checkOutTime, String paymentStatus) {
    7171//        this.customer = customer;
    7272        this.table = table;
     73        this.user = user;
    7374        this.restaurant = restaurant;
    7475        this.reservationDateTime = reservationDateTime;
    … …  
    8182    }
    8283
     84    public User getUser() {
     85        return user;
     86    }
     87
     88    public void setUser(User user) {
     89        this.user = user;
     90    }
     91
    8392    public Long getReservationID() {
    8493        return reservationID;
    … …  
    8998    }
    9099
    91     public Customer getCustomer() {
    92         return customer;
    93     }
    94 
    95     public void setCustomer(Customer customer) {
    96         this.customer = customer;
    97     }
    98100
    99101    public TableEntity getTable() {
    … …  
    173175        return "Reservation{" +
    174176                "reservationID=" + reservationID +
    175                 ", customer=" + customer +
     177                ", customer=" + user +
    176178                ", table=" + table +
    177179                ", restaurant=" + restaurant +

  • src/main/java/com/example/rezevirajmasa/demo/model/Restaurant.java

    rdb39d9e r8ca35dc  
    151151        @ManyToOne
    152152        @JoinColumn(name = "customer_id")
    153         private Customer customer;
     153        private User user;
    154154
    155155        @ManyToOne
    … …  
    179179        private LocalDateTime checkInDate;
    180180
    181         public ReservationHistory(Customer customer, TableEntity table, Restaurant restaurant, LocalDateTime reservationDateTime, int partySize, String specialRequests, String status, String cancellationReason, LocalDateTime checkInDate) {
    182             this.customer = customer;
     181        public ReservationHistory(User user, TableEntity table, Restaurant restaurant, LocalDateTime reservationDateTime, int partySize, String specialRequests, String status, String cancellationReason, LocalDateTime checkInDate) {
     182            this.user = user;
    183183            this.table = table;
    184184            this.restaurant = restaurant;
    … …  
    202202        }
    203203
    204         public Customer getCustomer() {
    205             return customer;
    206         }
    207 
    208         public void setCustomer(Customer customer) {
    209             this.customer = customer;
     204        public User getUser() {
     205            return user;
     206        }
     207
     208        public void setUser(User user) {
     209            this.user = user;
    210210        }
    211211
    … …  
    278278            return "ReservationHistory{" +
    279279                    "id=" + id +
    280                     ", customer=" + customer +
     280                    ", user=" + user +
    281281                    ", table=" + table +
    282282                    ", restaurant=" + restaurant +

  • src/main/java/com/example/rezevirajmasa/demo/model/User.java

    rdb39d9e r8ca35dc  
    77import lombok.NoArgsConstructor;
    88import org.springframework.web.bind.annotation.GetMapping;
     9
     10import java.util.Date;
    911
    1012@AllArgsConstructor
    … …  
    3133    @Column(nullable = false)
    3234    private String password;
     35
     36    @Enumerated(EnumType.STRING)
     37    private Role role;
     38
     39    @Column(name = "Phone", length = 20)
     40    private String phone;
     41
     42    @Column(name = "Address", columnDefinition = "TEXT")
     43    private String address;
     44
     45    @Enumerated(EnumType.STRING)
     46    @Column(name = "MembershipLevel", length = 20)
     47    private MembershipLevel membershipLevel;
     48
     49    @Column(name = "RegistrationDate", columnDefinition = "TIMESTAMP DEFAULT CURRENT_TIMESTAMP")
     50    @Temporal(TemporalType.TIMESTAMP)
     51    private Date registrationDate;
    3352}

  • src/main/java/com/example/rezevirajmasa/demo/repository/ReservationHistoryRepository.java

    rdb39d9e r8ca35dc  
    44import com.example.rezevirajmasa.demo.model.Reservation;
    55import com.example.rezevirajmasa.demo.model.Restaurant;
     6import com.example.rezevirajmasa.demo.model.User;
    67import org.springframework.cglib.core.Local;
    78import org.springframework.data.jpa.repository.JpaRepository;
    … …  
    1112
    1213public interface ReservationHistoryRepository extends JpaRepository<Restaurant.ReservationHistory, Long> {
    13     List<Restaurant.ReservationHistory> findAllByCustomer(Customer customer);
     14    List<Restaurant.ReservationHistory> findALlByUser(User user);
    1415    List<Restaurant.ReservationHistory> findByCheckInDateBeforeAndStatus(LocalDateTime currentTime, String scheduled);
    1516    List<Restaurant.ReservationHistory> findAllByCheckInDateBefore(LocalDateTime currentTime);

  • src/main/java/com/example/rezevirajmasa/demo/repository/ReservationRepository.java

    rdb39d9e r8ca35dc  
    11package com.example.rezevirajmasa.demo.repository;
    22
    3 import com.example.rezevirajmasa.demo.model.Customer;
    4 import com.example.rezevirajmasa.demo.model.Reservation;
    5 import com.example.rezevirajmasa.demo.model.Restaurant;
    6 import com.example.rezevirajmasa.demo.model.TableEntity;
     3import com.example.rezevirajmasa.demo.model.*;
    74import org.springframework.data.jpa.repository.JpaRepository;
    85
    … …  
    118
    129public interface ReservationRepository extends JpaRepository<Reservation, Long> {
    13     List<Reservation> findAllByCustomer(Customer customer);
     10    List<Reservation> findALlByUserAndCheckInTimeAfter(User user, LocalDateTime now);
    1411    List<Reservation> findByTableAndCheckInTimeBetween(TableEntity table, LocalDateTime startTime, LocalDateTime endTime);
    1512
    … …  
    1714    List<Reservation> findAllByCheckInTimeBefore(LocalDateTime currentTime);
    1815    List<Reservation> findByCheckInTimeAfterAndCheckInTimeBefore(LocalDateTime startTime, LocalDateTime endTime);
     16    List<Reservation> findALlByUserAndCheckInTimeBefore(User user, LocalDateTime now);
    1917}

  • src/main/java/com/example/rezevirajmasa/demo/service/ReservationHistoryService.java

    rdb39d9e r8ca35dc  
    44import com.example.rezevirajmasa.demo.model.Reservation;
    55import com.example.rezevirajmasa.demo.model.Restaurant;
     6import com.example.rezevirajmasa.demo.model.User;
    67
    78import java.time.LocalDateTime;
    … …  
    1112    public void moveReservationToHistory(Reservation reservation, String status, String cancellationReason);
    1213    public void moveReservationsToPast(List<Restaurant.ReservationHistory> reservationsToMove);
    13     List<Restaurant.ReservationHistory> findByCustomer(Customer customer);
     14    List<Restaurant.ReservationHistory> findByUser(User user);
    1415    List<Restaurant.ReservationHistory> findAll();
    1516    List<Restaurant.ReservationHistory> findReservationsToMove(LocalDateTime currentTime);

  • src/main/java/com/example/rezevirajmasa/demo/service/ReservationService.java

    rdb39d9e r8ca35dc  
    11package com.example.rezevirajmasa.demo.service;
    22
    3 import com.example.rezevirajmasa.demo.model.Customer;
    4 import com.example.rezevirajmasa.demo.model.Reservation;
    5 import com.example.rezevirajmasa.demo.model.Restaurant;
    6 import com.example.rezevirajmasa.demo.model.TableEntity;
     3import com.example.rezevirajmasa.demo.model.*;
     4import org.springframework.security.core.userdetails.UserDetails;
    75
    86import java.time.LocalDateTime;
    … …  
    108
    119public interface ReservationService {
    12     public void makeReservation(Customer customer, TableEntity table, Restaurant restaurant, LocalDateTime localDateTime, LocalDateTime checkInTime, int partySize, String specialRequests);
    13     public Reservation makeReservationRest(Reservation reservation);
     10    public void makeReservation(User user, TableEntity table, Restaurant restaurant, LocalDateTime localDateTime, LocalDateTime checkInTime, int partySize, String specialRequests);
     11    public Reservation makeReservationRest(Reservation reservation, User user);
    1412    public List<Reservation> listAll();
    1513    public Reservation findById(Long id);
    1614    public Reservation getReservationById(Long reservationId);
    1715    public boolean cancelReservation(Long reservationId);
    18     public List<Reservation> findReservationByCustomer(Customer customer);
     16    public List<Reservation> findReservationByUser(User user);
     17    public List<Reservation> findReservationsByUserPast(User user);
    1918    public List<Reservation> findReservationsByTableAndDateRange(TableEntity table, LocalDateTime startDateTime, LocalDateTime endDateTime);
    2019    List<Reservation> findReservationsToMove(LocalDateTime currentTime);

  • src/main/java/com/example/rezevirajmasa/demo/service/UserService.java

    rdb39d9e r8ca35dc  
    44import com.example.rezevirajmasa.demo.dto.SignUpDto;
    55import com.example.rezevirajmasa.demo.dto.UserDto;
     6import com.example.rezevirajmasa.demo.model.User;
    67import lombok.RequiredArgsConstructor;
    78
    … …  
    910public interface UserService {
    1011    public UserDto findByEmail(String email);
     12    public User findByMail(String email);
    1113    public UserDto login(CredentialsDto credentialsDto);
    1214    public UserDto register(SignUpDto userDto);
     15    public User findUserById(Long userId);
    1316}

  • src/main/java/com/example/rezevirajmasa/demo/service/impl/ReservationHistoryServiceImpl.java

    rdb39d9e r8ca35dc  
    44import com.example.rezevirajmasa.demo.model.Reservation;
    55import com.example.rezevirajmasa.demo.model.Restaurant;
     6import com.example.rezevirajmasa.demo.model.User;
    67import com.example.rezevirajmasa.demo.repository.ReservationHistoryRepository;
    78import com.example.rezevirajmasa.demo.service.ReservationHistoryService;
    … …  
    2223    public void moveReservationToHistory(Reservation reservation, String status, String cancellationReason) {
    2324        Restaurant.ReservationHistory history = new Restaurant.ReservationHistory();
    24         history.setCustomer(reservation.getCustomer());
     25        history.setUser(reservation.getUser());
    2526        history.setTable(reservation.getTable());
    2627        history.setReservationDateTime(reservation.getReservationDateTime());
    … …  
    4243
    4344    @Override
    44     public List<Restaurant.ReservationHistory> findByCustomer(Customer customer) {
    45         return reservationHistoryRepository.findAllByCustomer(customer);
     45    public List<Restaurant.ReservationHistory> findByUser(User user) {
     46        return reservationHistoryRepository.findALlByUser(user);
    4647    }
    4748
    4849    @Override
    4950    public void moveReservationsToPast(List<Restaurant.ReservationHistory> reservationsToMove) {
    50         // Update the status of reservations to "Past"
    5151        for (Restaurant.ReservationHistory reservation : reservationsToMove) {
    5252            reservation.setStatus("Past");
    5353        }
    5454
    55         // Save the updated reservations
    5655        reservationHistoryRepository.saveAll(reservationsToMove);
    5756    }

  • src/main/java/com/example/rezevirajmasa/demo/service/impl/ReservationImpl.java

    rdb39d9e r8ca35dc  
    11package com.example.rezevirajmasa.demo.service.impl;
    22
    3 import com.example.rezevirajmasa.demo.model.Customer;
    4 import com.example.rezevirajmasa.demo.model.Reservation;
    5 import com.example.rezevirajmasa.demo.model.Restaurant;
    6 import com.example.rezevirajmasa.demo.model.TableEntity;
     3import com.example.rezevirajmasa.demo.dto.UserDto;
     4import com.example.rezevirajmasa.demo.mappers.UserMapper;
     5import com.example.rezevirajmasa.demo.model.*;
    76import com.example.rezevirajmasa.demo.model.exceptions.InvalidReservationException;
    87import com.example.rezevirajmasa.demo.model.exceptions.InvalidReservationIdException;
    … …  
    1110import com.example.rezevirajmasa.demo.repository.RestaurantRepository;
    1211import com.example.rezevirajmasa.demo.repository.TableRepository;
     12import com.example.rezevirajmasa.demo.service.ReservationHistoryService;
    1313import com.example.rezevirajmasa.demo.service.ReservationService;
     14import com.example.rezevirajmasa.demo.service.UserService;
    1415import org.springframework.beans.factory.annotation.Autowired;
     16import org.springframework.cglib.core.Local;
     17import org.springframework.security.core.Authentication;
     18import org.springframework.security.core.annotation.AuthenticationPrincipal;
     19import org.springframework.security.core.context.SecurityContextHolder;
     20import org.springframework.security.core.userdetails.UserDetails;
    1521import org.springframework.stereotype.Service;
     22import org.springframework.web.bind.annotation.RequestBody;
    1623
    1724import javax.swing.text.html.Option;
    … …  
    2734    private TableRepository tableRepository;
    2835    @Autowired
    29     private RestaurantRepository restaurantRepository;
     36    private ReservationHistoryService reservationHistoryService;
     37    private final UserMapper userMapper;
    3038    @Autowired
    31     private CustomerRepository customerRepository;
     39    private UserService userService;
    3240    @Autowired
    3341    private ReservationRepository reservationRepository;
     42
     43    public ReservationImpl(UserMapper userMapper) {
     44        this.userMapper = userMapper;
     45    }
    3446
    3547    @Override
    … …  
    3951
    4052    @Override
    41     public void makeReservation(Customer customer, TableEntity table, Restaurant restaurant, LocalDateTime localDateTime, LocalDateTime checkInTime, int partySize, String specialRequests) {
     53    public void makeReservation(User user, TableEntity table, Restaurant restaurant, LocalDateTime localDateTime, LocalDateTime checkInTime, int partySize, String specialRequests) {
    4254        if (!table.isAvailable(checkInTime)) {
    4355            // Handle unavailability (throw an exception, return a specific response, etc.)
    … …  
    4658
    4759        Reservation reservation =
    48                 new Reservation(customer, table, restaurant, LocalDateTime.now(), partySize, specialRequests, "Reserved", checkInTime, checkInTime.plusHours(2), null);
     60                new Reservation(user, table, restaurant, LocalDateTime.now(), partySize, specialRequests, "Reserved", checkInTime, checkInTime.plusHours(2), null);
    4961
    5062//        // Update table status or perform additional logic if needed
    … …  
    5668
    5769    @Override
    58     public Reservation makeReservationRest(Reservation reservation) {
     70    public Reservation makeReservationRest(Reservation reservation, User user) {
    5971        Optional<TableEntity> optionalTable = tableRepository.findById(reservation.getTable().getId());
    60         if(optionalTable.isPresent()) {
     72        if (optionalTable.isPresent()) {
    6173            TableEntity table = optionalTable.get();
     74
     75            reservation.setUser(user);
    6276
    6377            LocalDateTime startTime = reservation.getCheckInTime().minusHours(2);
    … …  
    6781                    x -> x.isAfter(startTime) && x.isBefore(endTime)
    6882            );
    69 
     83            reservation.setReservationDateTime(LocalDateTime.now());
    7084            return reservationRepository.save(reservation);
    7185        } else {
    72             throw new InvalidReservationException("Unsuccessful reservation -> time slot not avalaible");
     86            throw new InvalidReservationException("Unsuccessful reservation -> time slot not available");
    7387        }
    7488    }
     89
    7590
    7691    @Override
    … …  
    109124                from = from.plusMinutes(15);
    110125            }
     126            reservationHistoryService.moveReservationToHistory(reservation, "Canceled", "Canceled by user");
    111127            reservationRepository.delete(reservation);
    112             return true; // Return true indicating successful cancellation
     128            return true;
    113129        } else {
    114             return false; // Return false indicating reservation with the given ID not found
     130            return false;
    115131        }
    116132    }
    … …  
    118134
    119135    @Override
    120     public List<Reservation> findReservationByCustomer(Customer customer) {
    121         return reservationRepository.findAllByCustomer(customer);
     136    public List<Reservation> findReservationByUser(User user) {
     137        LocalDateTime now = LocalDateTime.now();
     138        return reservationRepository.findALlByUserAndCheckInTimeAfter(user, now);
     139    }
     140
     141    @Override
     142    public List<Reservation> findReservationsByUserPast(User user) {
     143        LocalDateTime now = LocalDateTime.now();
     144        return reservationRepository.findALlByUserAndCheckInTimeBefore(user, now);
    122145    }
    123146

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

    rdb39d9e r8ca35dc  
    175175                    .collect(Collectors.toList());
    176176        } else {
    177             List<Restaurant> restaurantList = restaurantRepository.findAllByNameLikeIgnoreCase(search);
     177            String searchTerm = "%" + search + "%";
     178            List<Restaurant> restaurantList = restaurantRepository.findAllByNameLikeIgnoreCase(searchTerm);
    178179            if (restaurantList.isEmpty()) {
    179180                restaurantList = restaurantRepository.findAllByCuisineTypeContaining(search);

  • src/main/java/com/example/rezevirajmasa/demo/service/impl/UserServiceImpl.java

    rdb39d9e r8ca35dc  
    66import com.example.rezevirajmasa.demo.mappers.UserMapper;
    77import com.example.rezevirajmasa.demo.mappers.UserMapperImpl;
     8import com.example.rezevirajmasa.demo.model.MembershipLevel;
     9import com.example.rezevirajmasa.demo.model.Role;
    810import com.example.rezevirajmasa.demo.model.User;
    911import com.example.rezevirajmasa.demo.model.exceptions.AppException;
    … …  
    1214import lombok.RequiredArgsConstructor;
    1315import org.mapstruct.control.MappingControl;
     16import org.openqa.selenium.InvalidArgumentException;
    1417import org.springframework.http.HttpStatus;
    1518import org.springframework.security.crypto.password.PasswordEncoder;
    1619import org.springframework.stereotype.Service;
    1720import java.nio.CharBuffer;
     21import java.sql.Date;
     22import java.time.LocalDate;
    1823import java.util.Optional;
    1924
    … …  
    3035    }
    3136
     37    @Override
     38    public User findByMail(String email) {
     39        return userRepository.findByEmail(email).orElseThrow(() -> new AppException(("Unknown user"), HttpStatus.NOT_FOUND));
     40    }
     41
    3242    public UserDto login(CredentialsDto credentialsDto) {
    33         User user = userRepository.findByEmail(credentialsDto.getLogin())
     43        User user = userRepository.findByEmail(credentialsDto.getEmail())
    3444                .orElseThrow(() -> new AppException("Unknown user", HttpStatus.NOT_FOUND));
    3545
    … …  
    5161        user.setPassword(passwordEncoder.encode(CharBuffer.wrap(userDto.getPassword())));
    5262
     63        user.setFirstName(userDto.getFirstName());
     64        user.setLastName(userDto.getLastName());
     65        user.setAddress(userDto.getAddress());
     66        user.setPhone(userDto.getPhone());
     67        user.setMembershipLevel(MembershipLevel.valueOf(userDto.getMembershipLevel()));
     68        user.setRegistrationDate(Date.valueOf(LocalDate.now()));
     69        user.setRole(Role.ROLE_USER);
     70
    5371        User savedUser = userRepository.save(user);
    5472
    55         return userMapper.toUserDto(user);
     73        return userMapper.toUserDto(savedUser);
     74    }
     75
     76    @Override
     77    public User findUserById(Long userId) {
     78        return userRepository.findById(userId).orElseThrow(()->new InvalidArgumentException("Invalid user Id"));
    5679    }
    5780}

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

    rdb39d9e r8ca35dc  
    11package com.example.rezevirajmasa.demo.web.controller;
    22
     3import com.example.rezevirajmasa.demo.dto.SignUpDto;
     4import com.example.rezevirajmasa.demo.dto.UserDto;
     5import com.example.rezevirajmasa.demo.mappers.UserMapper;
    36import com.example.rezevirajmasa.demo.model.*;
    47import com.example.rezevirajmasa.demo.model.exceptions.ExpiredReservationException;
    … …  
    1922public class ReservationController {
    2023    private final ReservationService reservationService;
    21     private final CustomerService customerService;
     24    private final UserService userService;
    2225    private final TableService tableService;
    2326    private final ReservationHistoryService reservationHistoryService;
    2427
    25     public ReservationController(ReservationService reservationService, CustomerService customerService, TableService tableService, ReservationHistoryService reservationHistoryService) {
     28    private final UserMapper userMapper;
     29
     30    public ReservationController(ReservationService reservationService, UserService userService, TableService tableService, ReservationHistoryService reservationHistoryService, UserMapper userMapper) {
    2631        this.reservationService = reservationService;
    27         this.customerService = customerService;
     32        this.userService = userService;
    2833        this.tableService = tableService;
    2934        this.reservationHistoryService = reservationHistoryService;
     35        this.userMapper = userMapper;
    3036    }
    3137
    3238    @GetMapping("/reservations")
    3339    public String showReservations(Model model, Authentication authentication) {
    34         Customer customer = customerService.findByEmail(authentication.getName());
    35         List<Reservation> reservationList;
    36         if(customer.getRole().equals(Role.ROLE_ADMIN)) {
    37             reservationList = reservationService.listAll();
    38         } else {
    39             reservationList = reservationService.findReservationByCustomer(customer);
    40         }
     40        UserDto userDto = userService.findByEmail(authentication.getName());
     41
     42        SignUpDto signUpDto = userMapper.toSignUpDto(userDto);
     43
     44        User user = userMapper.signUpToUser(signUpDto);
     45
     46        List<Reservation> reservationList = reservationService.findReservationByUser(user);
     47
    4148        model.addAttribute("bodyContent", "reservationList");
    4249        model.addAttribute("reservations", reservationList);
    4350        return "index";
    4451    }
     52
    4553
    4654    @GetMapping("/reservations/edit/{reservationId}")
    … …  
    6270        Restaurant restaurant = table.getRestaurant();
    6371
    64         Customer customer = customerService.findByEmail(authentication.getName());
     72        UserDto userDto = userService.findByEmail(authentication.getName());
     73
     74        SignUpDto signUpDto = userMapper.toSignUpDto(userDto);
     75
     76        User user = userMapper.signUpToUser(signUpDto);
    6577
    6678        if(!table.isAvailable(reservationDateTime)) {
    … …  
    6880        }
    6981        tableService.deleteTimeSlotsForReservation(tableNumber, reservationDateTime);
    70         reservationService.makeReservation(customer, table, restaurant, LocalDateTime.now(), reservationDateTime, partySize, specialRequests);
     82        reservationService.makeReservation(user, table, restaurant, LocalDateTime.now(), reservationDateTime, partySize, specialRequests);
    7183        return "redirect:/reservations";
    7284    }

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

    rdb39d9e r8ca35dc  
    11package com.example.rezevirajmasa.demo.web.controller;
    22
     3import com.example.rezevirajmasa.demo.dto.SignUpDto;
     4import com.example.rezevirajmasa.demo.dto.UserDto;
     5import com.example.rezevirajmasa.demo.mappers.UserMapper;
    36import com.example.rezevirajmasa.demo.model.Customer;
    47import com.example.rezevirajmasa.demo.model.Restaurant;
    58import com.example.rezevirajmasa.demo.model.Role;
     9import com.example.rezevirajmasa.demo.model.User;
    610import com.example.rezevirajmasa.demo.service.CustomerService;
    711import com.example.rezevirajmasa.demo.service.ReservationHistoryService;
     12import com.example.rezevirajmasa.demo.service.UserService;
    813import org.springframework.security.core.Authentication;
    914import org.springframework.stereotype.Controller;
    … …  
    1823public class ReservationHistoryController {
    1924    private final ReservationHistoryService reservationHistoryService;
    20     private final CustomerService customerService;
     25    private final UserService userService;
     26    private final UserMapper userMapper;
    2127
    22     public ReservationHistoryController(ReservationHistoryService reservationHistoryService, CustomerService customerService) {
     28    public ReservationHistoryController(ReservationHistoryService reservationHistoryService, UserService userService, UserMapper userMapper) {
    2329        this.reservationHistoryService = reservationHistoryService;
    24         this.customerService = customerService;
     30        this.userService = userService;
     31        this.userMapper = userMapper;
    2532    }
    2633
    … …  
    2835    public String showPastReservations(Authentication authentication, Model model) {
    2936        List<Restaurant.ReservationHistory> reservationHistoryList;
    30         Customer customer = customerService.findByEmail(authentication.getName());
    31         if(customer.getRole().equals(Role.ROLE_ADMIN)) {
    32             reservationHistoryList = reservationHistoryService.findAll();
    33         } else {
    34             reservationHistoryList = reservationHistoryService.findByCustomer(customer);
    35         }
     37        UserDto userDto = userService.findByEmail(authentication.getName());
     38
     39        SignUpDto signUpDto = userMapper.toSignUpDto(userDto);
     40
     41        User user = userMapper.signUpToUser(signUpDto);
     42
     43        reservationHistoryList = reservationHistoryService.findByUser(user);
     44//        if(customer.getRole().equals(Role.ROLE_ADMIN)) {
     45//            reservationHistoryList = reservationHistoryService.findAll();
     46//        } else {
     47//            reservationHistoryList = reservationHistoryService.findByUser(User user);
     48//        }
    3649        model.addAttribute("historyReservations", reservationHistoryList);
    3750        model.addAttribute("bodyContent", "pastReservations");

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

    rdb39d9e r8ca35dc  
    22
    33import com.example.rezevirajmasa.demo.config.UserAuthProvider;
     4import io.jsonwebtoken.ExpiredJwtException;
    45import jakarta.servlet.FilterChain;
    56import jakarta.servlet.ServletException;
    … …  
    78import jakarta.servlet.http.HttpServletResponse;
    89import lombok.RequiredArgsConstructor;
     10import org.springframework.beans.factory.annotation.Autowired;
    911import org.springframework.http.HttpHeaders;
     12import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
    1013import org.springframework.security.core.context.SecurityContextHolder;
    1114import org.springframework.web.filter.OncePerRequestFilter;
    … …  
    1720
    1821    private final UserAuthProvider userAuthProvider;
     22
    1923    @Override
    2024    protected void doFilterInternal(
    … …  
    2428        String header = request.getHeader(HttpHeaders.AUTHORIZATION);
    2529
     30        String username = null;
     31        String jwt = null;
     32
    2633        if(header != null) {
     34            jwt = header.substring(7);
    2735            String[] elements = header.split(" ");
    2836
    2937            if(elements.length == 2 && "Bearer".equals(elements[0])) {
    3038                try {
     39                    username = userAuthProvider.extractUsername(jwt); // logikata vidi ja
    3140                    SecurityContextHolder.getContext().setAuthentication(
    3241                            userAuthProvider.validateToken(elements[1])
    3342                    );
     43                    if (username != null) {
     44                        System.out.println("Authenticated user: " + username); // Debug log
     45                        SecurityContextHolder.getContext().setAuthentication(
     46                                userAuthProvider.validateToken(jwt) // Ensure token validation works properly
     47                        );
     48                    }
     49                } catch (ExpiredJwtException e) {
     50                    String isRefreshToken = request.getHeader("isRefreshToken");
     51                    String requestURL = request.getRequestURL().toString();
     52                    if (isRefreshToken != null && isRefreshToken.equals("true") && requestURL.contains("refresh-token")) {
     53                        allowForRefreshToken(e, request);
     54                    } else
     55                        request.setAttribute("exception", e);
     56
    3457                } catch (RuntimeException e) {
    3558                    SecurityContextHolder.clearContext();
    … …  
    4063        filterChain.doFilter(request, response);
    4164    }
     65
     66    private void allowForRefreshToken(ExpiredJwtException ex, HttpServletRequest request) {
     67        UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(
     68                null, null, null);
     69        SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);
     70        request.setAttribute("claims", ex.getClaims());
     71    }
    4272}

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

    rdb39d9e r8ca35dc  
    1414import org.springframework.http.ResponseEntity;
    1515import org.springframework.security.authentication.AuthenticationManager;
     16import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
     17import org.springframework.security.core.Authentication;
    1618import org.springframework.security.crypto.password.PasswordEncoder;
    1719import org.springframework.web.bind.annotation.CrossOrigin;
    … …  
    3032    public ResponseEntity<UserDto> login(@RequestBody CredentialsDto credentialsDto) {
    3133        UserDto user = userService.login(credentialsDto);
    32         user.setToken(userAuthProvider.createToken(user.getEmail()));
     34        String token = userAuthProvider.createToken(user.getEmail());
     35        user.setToken(token);
     36
    3337        return ResponseEntity.ok(user);
    3438    }
    … …  
    3842        UserDto user = userService.register(signUpDto);
    3943        user.setToken(userAuthProvider.createToken(user.getEmail()));
    40         return ResponseEntity.created(URI.create("/users/" + user.getId()))
    41                 .body(user);
     44        return ResponseEntity.created(URI.create("/users/" + user.getId())).body(user);
    4245    }
    4346}

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

    rdb39d9e r8ca35dc  
    22
    33import com.example.rezevirajmasa.demo.dto.CustomerDTO;
     4import com.example.rezevirajmasa.demo.dto.UserDto;
     5import com.example.rezevirajmasa.demo.mappers.UserMapper;
    46import com.example.rezevirajmasa.demo.model.*;
    5 import com.example.rezevirajmasa.demo.service.CustomerService;
    6 import com.example.rezevirajmasa.demo.service.ReservationService;
    7 import com.example.rezevirajmasa.demo.service.RestaurantService;
    8 import com.example.rezevirajmasa.demo.service.TableService;
     7import com.example.rezevirajmasa.demo.service.*;
     8import com.example.rezevirajmasa.demo.service.impl.TokenService;
     9import jakarta.servlet.http.HttpServletRequest;
    910import jdk.jfr.consumer.RecordingStream;
    1011import org.apache.coyote.Response;
     12import org.apache.http.protocol.HTTP;
    1113import org.springframework.format.annotation.DateTimeFormat;
    1214import org.springframework.http.HttpStatus;
    1315import org.springframework.http.ResponseEntity;
     16import org.springframework.security.core.Authentication;
     17import org.springframework.security.core.annotation.AuthenticationPrincipal;
     18import org.springframework.security.core.context.SecurityContextHolder;
     19import org.springframework.security.core.parameters.P;
     20import org.springframework.security.core.userdetails.UserDetails;
    1421import org.springframework.web.bind.annotation.*;
    1522
     23import java.nio.file.attribute.UserPrincipal;
     24import java.security.Principal;
    1625import java.time.LocalDateTime;
    1726import java.time.format.DateTimeFormatter;
    … …  
    2635    private final RestaurantService restaurantService;
    2736    private final CustomerService customerService;
     37    private final UserService userService;
    2838    private final ReservationService reservationService;
     39    private final ReservationHistoryService reservationHistoryService;
    2940    private final TableService tableService;
    30 
    31     public testController(RestaurantService restaurantService, CustomerService customerService, ReservationService reservationService, TableService tableService) {
     41    private final UserMapper userMapper;
     42    private final TokenService tokenService;
     43    public testController(RestaurantService restaurantService, CustomerService customerService, UserService userService, ReservationService reservationService, ReservationHistoryService reservationHistoryService, TableService tableService, UserMapper userMapper, TokenService tokenService) {
    3244        this.restaurantService = restaurantService;
    3345        this.customerService = customerService;
     46        this.userService = userService;
    3447        this.reservationService = reservationService;
     48        this.reservationHistoryService = reservationHistoryService;
    3549        this.tableService = tableService;
     50        this.userMapper = userMapper;
     51        this.tokenService = tokenService;
    3652    }
    3753
    … …  
    114130        );
    115131    }
     132    @GetMapping("/api/user")
     133    public ResponseEntity<?> getCurrentUser() {
     134        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
     135
     136        if (authentication == null || !authentication.isAuthenticated() || authentication.getPrincipal().equals("anonymousUser")) {
     137            return new ResponseEntity<>("User is not authenticated", HttpStatus.UNAUTHORIZED);
     138        }
     139
     140        Customer customer = (Customer) authentication.getPrincipal();
     141        return new ResponseEntity<>(customer, HttpStatus.OK);
     142    }
     143
    116144
    117145    @PostMapping("/api/customers")
    … …  
    137165//    Reservation Calls
    138166
    139     @GetMapping("/api/reservations")
    140     public ResponseEntity<List<Reservation>> getReservations() {
    141         return new ResponseEntity<List<Reservation>>(reservationService.listAll(), HttpStatus.OK);
    142     }
    143 
    144     @PostMapping("/api/reservations")
    145     public ResponseEntity<Reservation> createReservation(@RequestBody Reservation reservation) {
    146         reservation.setReservationDateTime(LocalDateTime.now());
    147         Reservation savedReservation = reservationService.makeReservationRest(reservation);
     167    @GetMapping("/api/reservations/by/{email}")
     168    public ResponseEntity<List<Reservation>> getReservations(@PathVariable String email) {
     169        User user = userService.findByMail(email);
     170        return new ResponseEntity<List<Reservation>>(reservationService.findReservationByUser(user), HttpStatus.OK);
     171    }
     172
     173    @PostMapping("/api/reservations/{email}")
     174    public ResponseEntity<Reservation> createReservation(@RequestBody Reservation reservation, @PathVariable String email) {
     175        User user = userService.findByMail(email);
     176        Reservation savedReservation = reservationService.makeReservationRest(reservation, user);
     177
    148178        return new ResponseEntity<>(savedReservation, HttpStatus.CREATED);
    149179    }
     180
    150181
    151182    @GetMapping("/api/reservations/{reservationId}")
    … …  
    159190    }
    160191
    161     @PostMapping("/api/reservations/{reservationId}")
     192    @PostMapping("/api/reservations/{reservationId}/{email}")
    162193    public ResponseEntity<Reservation> editReservation(@PathVariable Long reservationId,
    163                                                        @RequestBody Reservation reservation) {
     194                                                       @RequestBody Reservation reservation,
     195                                                       @PathVariable String email) {
     196        User user = userService.findByMail(email);
     197
    164198        if (!reservation.getReservationID().equals(reservationId)) {
    165199            return ResponseEntity.badRequest().build();
    166200        }
    167201
    168         Reservation savedReservation = reservationService.findById(reservationId);
    169         if(!reservation.getCheckInTime().equals(savedReservation.getCheckInTime())) {
    170             tableService.canceledTimeSlots(savedReservation.getTable().getId(), savedReservation.getCheckInTime());
    171         }
    172 
    173         savedReservation.setReservationDateTime(LocalDateTime.now());
    174         savedReservation.setCheckInTime(reservation.getCheckInTime());
    175         savedReservation.setCheckOutTime(reservation.getCheckInTime().plusHours(2));
    176         savedReservation.setPartySize(reservation.getPartySize());
    177         savedReservation.setSpecialRequests(reservation.getSpecialRequests());
    178         tableService.deleteTimeSlotsForReservation(reservation.getTable().getId(), reservation.getCheckInTime());
    179 
    180         //moze da se vovede sistem za ako od 4ca doagjaat samo 2ca da se najde pomala masa po moznost ako ima u toj moment
    181         //listaj samo slotovi za taa masa vo toj moment ili da ima da odbere od novo ama taka bolje nova rezevacij
    182 
    183         Reservation updatedReservation = reservationService.makeReservationRest(savedReservation);
    184         System.out.println("Saved reservation time: " + savedReservation.getCheckInTime());
     202        // Fetch existing reservation
     203        Reservation existingReservation = reservationService.findById(reservationId);
     204        if (existingReservation == null) {
     205            return ResponseEntity.notFound().build();
     206        }
     207
     208        if (!reservation.getCheckInTime().equals(existingReservation.getCheckInTime())) {
     209            tableService.canceledTimeSlots(existingReservation.getTable().getId(), existingReservation.getCheckInTime());
     210
     211            tableService.deleteTimeSlotsForReservation(reservation.getTable().getId(), reservation.getCheckInTime());
     212        }
     213
     214        existingReservation.setReservationDateTime(LocalDateTime.now());
     215        existingReservation.setCheckInTime(reservation.getCheckInTime());
     216        existingReservation.setCheckOutTime(reservation.getCheckInTime().plusHours(2));
     217        existingReservation.setPartySize(reservation.getPartySize());
     218        existingReservation.setSpecialRequests(reservation.getSpecialRequests());
     219
     220        Reservation updatedReservation = reservationService.makeReservationRest(existingReservation, user);
     221
     222        System.out.println("Updated reservation time: " + updatedReservation.getCheckInTime());
    185223        return ResponseEntity.ok(updatedReservation);
    186224    }
     225
    187226
    188227    @DeleteMapping("/api/reservations/delete/{reservationId}")
    … …  
    196235    }
    197236
     237    @GetMapping("/api/reservations/past/{email}")
     238    public ResponseEntity<List<Restaurant.ReservationHistory>> pastReservations(@PathVariable String email) {
     239        User user = userService.findByMail(email);
     240        return null;
     241    }
     242
    198243//    TableEntity Calls
    199244
    … …  
    203248    }
    204249
     250    // past reservation calls
     251    @GetMapping("/api/past-reservations/{email}")
     252    public ResponseEntity<List<Restaurant.ReservationHistory>> findPastReservationsByUser(@PathVariable String email) {
     253        User user = userService.findByMail(email);
     254        List<Restaurant.ReservationHistory> reservations = reservationHistoryService.findByUser(user);
     255        return new ResponseEntity<>(reservations, HttpStatus.OK);
     256    }
     257
    205258}

  • src/main/resources/application.properties

    rdb39d9e r8ca35dc  
    99spring.jpa.show-sql=true
    1010spring.main.allow-bean-definition-overriding=true
     11
     12server.port=8081
Note: See TracChangeset for help on using the changeset viewer.