Changeset 07f4e8b for src


Ignore:
Timestamp:
01/24/24 17:42:28 (10 months ago)
Author:
darsov2 <62809499+darsov2@…>
Branches:
master
Children:
0f5aa27
Parents:
5528b99
Message:

prefinal fixes

Location:
src/main/java/com/tourMate
Files:
3 added
1 deleted
47 edited

Legend:

Unmodified
Added
Removed

  • src/main/java/com/tourMate/config/SecurityConfig.java

    r5528b99 r07f4e8b  
    55import org.springframework.context.annotation.Bean;
    66import org.springframework.context.annotation.Configuration;
    7 import org.springframework.http.HttpHeaders;
    87import org.springframework.http.HttpMethod;
     8import org.springframework.http.HttpStatus;
    99import org.springframework.security.config.annotation.web.builders.HttpSecurity;
    1010import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
    … …  
    1313import org.springframework.security.crypto.password.PasswordEncoder;
    1414import org.springframework.security.web.SecurityFilterChain;
    15 import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
     15import org.springframework.security.web.authentication.logout.HttpStatusReturningLogoutSuccessHandler;
    1616import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
    1717import org.springframework.web.cors.CorsConfiguration;
    … …  
    2121import java.util.Arrays;
    2222
    23 import static org.springframework.security.config.Customizer.withDefaults;
    24 
    2523@Configuration
    2624@EnableWebSecurity
    2725public class SecurityConfig {
     26
     27    private final UserSecurity userSecurity;
     28
     29    public SecurityConfig(UserSecurity userSecurity) {
     30        this.userSecurity = userSecurity;
     31    }
    2832
    2933    @Bean
    … …  
    6468                            try {
    6569                                authz
    66                                         .requestMatchers(new AntPathRequestMatcher("/1/hasBusiness")).permitAll()
    67                                         .requestMatchers(new AntPathRequestMatcher("/business/1/unapproved")).permitAll()
     70                                        .requestMatchers(new AntPathRequestMatcher("/{userId}/hasBusiness")).access(userSecurity)
     71                                        .requestMatchers(new AntPathRequestMatcher("/business/*/unapproved")).permitAll()
    6872                                        .requestMatchers(new AntPathRequestMatcher("/register")).permitAll()
    6973                                        .requestMatchers(new AntPathRequestMatcher("/hotel/search")).permitAll()
    … …  
    7175                                        .requestMatchers(new AntPathRequestMatcher("/restaurant/search")).permitAll()
    7276                                        .requestMatchers(new AntPathRequestMatcher("/upload")).permitAll()
    73                                         .requestMatchers(new AntPathRequestMatcher("/business/*")).hasAnyAuthority("SUPERADMIN")
    74                                         .anyRequest().authenticated()
     77                                        .requestMatchers(new AntPathRequestMatcher("/business/approve/*")).hasAnyAuthority("SUPERADMIN")
     78                                        .requestMatchers(new AntPathRequestMatcher("/business/add/*")).authenticated()
     79                                        .requestMatchers(new AntPathRequestMatcher("/*/user/{userId}")).access(userSecurity)
     80                                        .anyRequest().permitAll()
     81//                                        .anyRequest().authenticated()
    7582                                        .and()
    76                                         .formLogin().loginPage("http://localhost:3000/login")
     83                                        .formLogin()
    7784                                        .loginProcessingUrl("/api/login").usernameParameter("username").passwordParameter("password")
    7885                                        .successHandler((request, response, authentication) -> {
    7986                                            response.setStatus(HttpServletResponse.SC_OK);
     87                                            response.setCharacterEncoding("UTF-8");
    8088                                            response.setContentType("application/json");
    8189                                            response.getWriter().print("{\"message\": \"Login successful\",");
    … …  
    8593                                        .failureHandler((request, response, exception) -> {
    8694                                            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
    87                                             response.getWriter().print("Pukla veza\n" + exception.getMessage());
     95                                            response.sendRedirect("/login");
     96                                            response.getWriter().print("Neuspesna najava\n" + exception.getMessage());
    8897                                            response.getWriter().flush();
    8998                                        })
    … …  
    93102                                        .sessionCreationPolicy(SessionCreationPolicy.ALWAYS)
    94103                                        .and()
    95                                         .logout()
     104                                        .logout().logoutSuccessHandler((new HttpStatusReturningLogoutSuccessHandler(HttpStatus.OK)))
    96105                                        .permitAll();
    97106

  • src/main/java/com/tourMate/controllers/HotelController.java

    r5528b99 r07f4e8b  
    22
    33import com.tourMate.dto.HotelDto;
     4import com.tourMate.dto.HotelReservationDto;
     5import com.tourMate.dto.HotelReservationUserDto;
    46import com.tourMate.entities.*;
    57import com.tourMate.services.HotelManager;
    … …  
    5052    }
    5153
    52     @GetMapping(path = "/hotel/list/{id}")
     54    @GetMapping(path = "/hotel/{id}/list")
    5355    public ResponseEntity<Hotels> getHotelById (@PathVariable(name = "id") long hotelId)
    5456    {
    … …  
    104106    //HOTEL ROOM CRUD
    105107    @PostMapping(path = "/hotel/rooms/add")
    106     public void addRoom(@RequestBody HotelRoom room, @RequestParam(name = "hotelId") long hotelId) {
     108    public void addRoom(@RequestBody HotelRoom room,
     109                        @RequestParam(name = "hotelId") long hotelId) {
    107110        Hotels h = hotelManager.findHotelByID(hotelId);
    108         hotelManager.createRoom(h, room.getHotelRoomDescription(), room.getHotelRoomName(), room.getKitchenAvailable(), room.getAirConditioning(), room.getBalcony(), room.getPrice());
     111        hotelManager.createRoom(h, room.getHotelRoomDescription(), room.getHotelRoomName(), room.getKitchenAvailable(), room.getAirConditioning(), room.getBalcony(), room.getPrice(), room.getNumOfBeds());
    109112    }
    110113
    … …  
    149152        //HOTEL AVAILABILITY CRUD
    150153    @PostMapping(path = "/hotel/rooms/available/{id}/add")
    151     public void addRoomAvailible(@RequestBody HotelRoomAvailable hotelRoomAvailable, @PathVariable long id)
     154    public void addRoomAvailible(@RequestBody HotelRoomAvailable hotelRoomAvailable,
     155                                 @PathVariable long id)
    152156    {
    153157        HotelRoom hotelRoom = hotelManager.findRoomById(id);
    … …  
    178182    public List<HotelRoomAvailable> getRoomAvailability(@PathVariable Long id)
    179183    {
    180         return hotelManager.getRoomsAvailibility();
     184        return hotelManager.getRoomsAvailableById(id);
    181185    }
    182186
    183187    @GetMapping(path = "/hotel/search")
    184     public List<HotelDto> searchAvailibleRooms(@RequestParam(name = "hotelLocation") String hotelLocation, @RequestParam(name = "dateFrom") @DateTimeFormat(pattern = "yyyy-MM-dd") Date dateFrom,
    185                                                @RequestParam(name = "dateTo") @DateTimeFormat(pattern = "yyyy-MM-dd") Date dateTo, @RequestParam(name = "numBeds") int numBeds)
    186     {
    187         System.out.println(hotelLocation);
     188    public List<HotelDto> searchAvailibleRooms(@RequestParam(name = "hotelLocation") String hotelLocation,
     189                                               @RequestParam(name = "dateFrom") @DateTimeFormat(pattern = "yyyy-MM-dd") Date dateFrom,
     190                                               @RequestParam(name = "dateTo") @DateTimeFormat(pattern = "yyyy-MM-dd") Date dateTo,
     191                                               @RequestParam(name = "numBeds") int numBeds,
     192                                               @RequestParam(name = "flexible") Boolean flexible)
     193    {
     194        System.out.println(flexible);
    188195        System.out.println(dateFrom + " " + dateTo);
    189         return hotelManager.getRoomsAvailibilityByDateAndLocation(hotelLocation, dateFrom, dateTo, numBeds);
     196        return hotelManager.getRoomsAvailibilityByDateAndLocation(hotelLocation, dateFrom, dateTo, numBeds, flexible);
    190197    }
    191198
    … …  
    203210    }
    204211
    205 <<<<<<< HEAD
    206212    @GetMapping(path = "/hotel/{id}/reservations/active")
    207213    public List<HotelReservationDto> getActiveReservationsForHotel(@PathVariable Long id)
    … …  
    233239        return hotelManager.getRoomImages(id);
    234240    }
    235 =======
    236 >>>>>>> parent of ac19a0c (authContext impl, admin panel impl, search bar fixes, reservations listings impl)
     241
     242    @PostMapping("/hotel/{id}/cancel")
     243    public void cancelHotelReservation(@PathVariable Long id){
     244        hotelManager.deleteReservation(id);
     245    }
     246
    237247}

  • src/main/java/com/tourMate/controllers/RestaurantController.java

    r5528b99 r07f4e8b  
    11package com.tourMate.controllers;
    22
     3import com.tourMate.dto.HotelReservationDto;
    34import com.tourMate.dto.RestaurantDto;
     5import com.tourMate.dto.RestaurantReservationDto;
    46import com.tourMate.dto.RestaurantReservationUserDto;
    57import com.tourMate.entities.*;
    … …  
    3436    }
    3537
     38    @PostMapping("/restaurant/{id}/cancel")
     39    public void removeRestaurant(@PathVariable Long id){
     40        restaurantManager.deleteReservation(id);
     41    }
     42
    3643    @GetMapping(path = "/restaurant")
    3744    public List<Restaurant> showRestaurants() {
    … …  
    4249    public List<Restaurant> showRestaurantsForUser(@PathVariable(name = "id") long userId) {
    4350
    44         return restaurantManager.getRestaurants();
     51        return restaurantManager.getRestaurantsByUser(userId);
    4552    }
    4653
    … …  
    133140                                  @PathVariable Long id) {
    134141        System.out.println(restaurantsAvailible.getHourFrom() + " " + restaurantsAvailible.getHourTo());
    135         restaurantManager.createTableAvailable(id, restaurantsAvailible.getHourFrom(), restaurantsAvailible.getHourTo());
     142        restaurantManager.createTableAvailable(id, restaurantsAvailible.getHourFrom(), restaurantsAvailible.getHourTo(), restaurantsAvailible.getNumTables());
    136143    }
    137144
    … …  
    170177        return restaurantManager.getRestaurantImages(id);
    171178    }
     179
     180    @GetMapping(path = "/menu/{id}/images")
     181    public List<MenuImages> getImagesForMenu(@PathVariable Long id)
     182    {
     183        return restaurantManager.getMenuImages(id);
     184    }
     185
     186    @GetMapping(path = "/restaurant/{id}/reservations/active")
     187    public List<RestaurantReservationDto> getActiveReservationsForHotel(@PathVariable Long id)
     188    {
     189        return restaurantManager.findReservationByRestaurant(id);
     190    }
    172191}
    173192

  • src/main/java/com/tourMate/controllers/ReviewController.java

    r5528b99 r07f4e8b  
    2020                    @RequestParam(name = "hotelId", required = false) Long hotelId,
    2121                    @RequestParam(name = "restaurantId", required = false) Long restaurantId,
    22                     @RequestParam(name = "transportId", required = false) Long transportId ) {
    23         reviewManager.createReview(title, numStars, description, hotelId, restaurantId, transportId);
     22                    @RequestParam(name = "transportId", required = false) Long transportId,
     23                    @RequestParam(name = "reservationId") Long reservationId) {
     24        reviewManager.createReview(title, numStars, description, hotelId, restaurantId, transportId, reservationId);
    2425    }
    2526

  • src/main/java/com/tourMate/controllers/TransportController.java

    r5528b99 r07f4e8b  
    2020
    2121    // TRANSPORT CRUD //
    22     @PostMapping(path = "/transport/add")
    23     public void add(@RequestBody Transport transport) {
    24         transportManager.createTransport(transport.getTransportName(), transport.getCarBrand(), transport.getCarType(), transport.getCarManufacturedYear(), transport.getNoPassengers(), transport.getNoBags(), transport.getEMBG(), new User(), transport.getCarPlate());
     22    @PostMapping(path = "/transport/add/{userId}")
     23    public void add(@RequestBody Transport transport,
     24                    @PathVariable Long userId) {
     25        transportManager.createTransport(transport.getTransportName(), transport.getCarBrand(), transport.getCarType(), transport.getCarManufacturedYear(), transport.getNoPassengers(), transport.getNoBags(), transport.getEMBG(), userId, transport.getCarPlate());
    2526
    2627    }
    … …  
    4546    public TransportDto getTransport(@PathVariable(name = "id") long transportId)
    4647    {
    47         System.out.println("TUKA SUUUUUM");
    4848        return transportManager.findTransportById(transportId);
    4949    }
    … …  
    8484    @PostMapping(path = "/transport/available/add")
    8585    public void add(@RequestBody TransportAvailible transportAvailable, @RequestParam(name = "transportId") long transportId) {
    86         System.out.println("OREEEEEL");
    87         System.out.println("DVA ORLA");
    8886        Transport t = transportManager.getTransportById(transportId);
    8987        List<TransportRoute> routes = transportAvailable.getRoutes().stream().toList();
    … …  
    127125
    128126    @GetMapping(path = "/transport/search")
    129     public List<TransportListingDto> searchAvailableTransport(@RequestParam(name = "from") String from, @RequestParam(name = "to") String to,
    130                                                               @RequestParam(name = "date") @DateTimeFormat(pattern = "yyyy-MM-dd") Date date){
    131         return transportManager.getTransportsAvailableByFilters(from, to, date);
     127    public List<TransportListingDto> searchAvailableTransport(@RequestParam(name = "from") String from,
     128                                                              @RequestParam(name = "to") String to,
     129                                                              @RequestParam(name = "date") @DateTimeFormat(pattern = "yyyy-MM-dd") Date date,
     130                                                              @RequestParam(name = "numPassengers") int numPassengers){
     131        return transportManager.getTransportsAvailableByFilters(from, to, date, numPassengers);
    132132    }
    133133
    … …  
    151151        return transportManager.findPastTransportReservationsByUser(id);
    152152    }
     153
     154    @GetMapping(path = "/transport/{id}/reservations/active")
     155    public List<TransportReservation> showTransportReservationsByTransport(@PathVariable Long id) {
     156        return transportManager.findTransportReservationByTransportId(id);
     157    }
    153158}

  • src/main/java/com/tourMate/controllers/UsersController.java

    r5528b99 r07f4e8b  
    1111import org.springframework.web.bind.annotation.*;
    1212
    13 import java.util.ArrayList;
    1413import java.util.List;
    1514
    … …  
    3938    {
    4039        return businessManager.getUnapprovedBusinessesOfUser(userId);
     40    }
     41
     42    @GetMapping(path = "/business/unapproved")
     43    public List<Business> getAllUnapprovedBusinesses()
     44    {
     45        return businessManager.getUnapprovedBusinesses();
     46    }
     47
     48    @GetMapping(path = "/users/unapproved")
     49    public List<User> getAllUnapprovedUsers()
     50    {
     51        return usersManager.getUnapprovedUsers();
     52    }
     53
     54    @GetMapping(path = "/users/approve/{userId}")
     55    public ResponseEntity<?> approveUserProfile(@PathVariable Long userId)
     56    {
     57        usersManager.approveUserProfile(userId);
     58        return new ResponseEntity<>(HttpStatus.OK);
     59
     60
     61    }
     62
     63    @GetMapping(path = "/business/approve/{businessId}")
     64    public ResponseEntity<?> approveBusiness(@PathVariable Long businessId)
     65    {
     66        businessManager.approveBusiness(businessId);
     67        return new ResponseEntity<>(HttpStatus.OK);
    4168    }
    4269
    … …  
    85112        }
    86113    }
     114
     115    @GetMapping("/users/unlock/{id}")
     116    public ResponseEntity unlock(@PathVariable Long id)
     117    {
     118        usersManager.unlock(id);
     119        return new ResponseEntity(HttpStatus.OK);
     120    }
    87121}
    88122

  • src/main/java/com/tourMate/dao/BusinessDao.java

    r5528b99 r07f4e8b  
    99public interface BusinessDao {
    1010
    11     @Transactional
    12     void createBusiness(Business business, long userId);
    13     public List<Business> getUnapprovedBusinessesOfUser(long userId);
    14     public void deleteBusiness(long businessId);
    15     public List<Business> getCreatedBusinesses();
    16     public Business findBusinessById (long businessId);
     11    List<Business> getCreatedBusinesses();
     12
     13    Business findBusinessById(long businessId);
    1714
    1815    @Transactional
    19     void editBusiness(long businessId, String name, String phone, String address, String edbs, User user, boolean approved);
    20     public boolean hasBusiness(long userId);
     16    void createBusiness(Business business);
    2117
     18    List<Business> getUnapprovedBusinessesOfUser(User u);
     19
     20    @Transactional
     21    void deleteBusiness(Business business);
     22
     23    boolean hasBusiness(User u);
     24
     25    List<Business> getUnapprovedBusinesses();
     26
     27    void approveBusiness(Business business);
     28
     29    @Transactional
     30    void editBusiness(Business business);
    2231}

  • src/main/java/com/tourMate/dao/HotelDao.java

    r5528b99 r07f4e8b  
    99
    1010public interface HotelDao {
    11     public void createHotel(Hotels hotel, long userId);
    12     public void editHotel(long hotelId, String hotelName, String hotelDescripiton, String hotelLocation, String hotelEDBS, Boolean parking, Boolean petFriendly, Boolean internetAvailable);
    13     public void deleteHotel(long hotelId);
    14     public Hotels findHotelByID (long hotelId);
    15     public List<Hotels> getHotels();
    16     public List<Hotels> getHotelsForUser(long userId);
    17     public List<Hotels> getHotelsByLocation(String hotelLocation);
     11    @Transactional
     12    void createHotel(Hotels hotel);
    1813
    19     public void deleteHotelImage(long hotelImageId);
    20     public HotelsImages findHotelImageById(long hotelImageId);
    21     public List<HotelsImages> getHotelImages(Hotels hotels);
    22     public List<HotelRoomImages> getRoomImages(HotelRoom hotelRoom);
     14    List<Hotels> getHotels();
    2315
    24     public void createRoom(Hotels hotel, String hotelRoomDescription, String hotelRoomName, Boolean kitchenAvailable, Boolean airConditioning, Boolean balcony, double price);
    25     public void editRoom(long hotelRoomId, Hotels hotel, String hotelRoomDescription, String HotelRoomName, Boolean kitchenAvailable, Boolean airConditioning, Boolean balcony, double price);
    26     public void deleteRoom(long hotelRoomId);
    27     public HotelRoom findRoomById (long hotelRoomId);
    28     public List<HotelRoom> getRoomsOfHotel (long hotelId);
    29     public List<HotelRoomAvailable> getRoomsAvailable(Long id);
     16    List<Hotels> getHotelsForUser(User u);
     17
     18    List<Hotels> getHotelsByLocation(String hotelLocation);
    3019
    3120    @Transactional
    32     public void createRoomAvailible(HotelRoom hotelRoom, Date dateFrom, Date dateTo, int numberOfBeds);
    33     public void editRoomAvailible(long hotelRoomAvailableId, HotelRoom hotelRoom, Date dateFrom, Date dateTo, int numberOfBeds);
    34     public void deleteRoomAvailible(long hotelRoomAvailableId);
    35     public HotelRoomAvailable findAvailibleRoomById(long hotelRoomAvailableId);
    36     public List<HotelRoomAvailable> getRoomsAvailibility();
    37     public List<HotelRoomAvailable> getRoomsAvailibilityByHotel(Hotels hotel);
    38     public List<HotelRoomAvailable> getRoomsAvailibilityByDateAndLocation(String hotelLocation, Date dateFrom, Date dateTo, int numberOfBeds);
     21    void editHotel(Hotels hotel);
    3922
    40     public void createReservation(User user, HotelRoom hotelRoom, Date dateFrom, Date dateTo, Integer numberOfBeds);
    41     public void editReservation(long hotelRoomReservedId, User user, HotelRoom hotelRoom, Date dateFrom, Date dateTo, Integer numberOfBeds);
    42     public void deleteReservation(long hotelRoomReservedId);
    43     public HotelRoomReservations findReservationById(long hotelRoomReservedId);
    44     public List<HotelRoomReservations> findReservationByUser(User user);
    45     public List<HotelRoomReservations> findReservationByHotel(Hotels hotel);
    46     public List<HotelRoomReservations> getReservations();
     23    @Transactional
     24    void deleteHotel(Hotels hotel);
     25
     26    Hotels findHotelByID(long hotelId);
     27
     28    List<HotelsImages> getHotelImages(Hotels hotel);
     29
     30    @Transactional
     31    void addHotelImage(HotelsImages image);
     32
     33    @Transactional
     34    void addRoomImage(HotelRoomImages x);
     35
     36    @Transactional
     37    void  saveReservation(HotelRoomReservations hotelRoomReservations);
     38
     39    @Transactional
     40    HotelsImages findHotelImageById(long hotelImageId);
     41
     42    @Transactional
     43    void deleteHotelImage(HotelsImages hotelsImages);
     44
     45    List<HotelRoom> getRoomsOfHotel(Hotels hotel);
     46
     47    List<HotelRoomAvailable> getRoomsAvailable(Long id);
     48
     49    HotelRoom findRoomById(long hotelRoomId);
     50
     51    List<HotelRoomImages> getRoomImages(HotelRoom hotelRoom);
     52
     53    @Transactional
     54    void createRoom(HotelRoom hotelRoom);
     55
     56    @Transactional
     57    void editRoom(HotelRoom hr);
     58
     59    @Transactional
     60    void deleteRoom(HotelRoom hr);
     61
     62    @Transactional
     63    void createRoomAvailible(HotelRoomAvailable hra);
     64
     65    @Transactional
     66    void editRoomAvailible(HotelRoomAvailable hr);
     67
     68    @Transactional
     69    void deleteRoomAvailible(HotelRoomAvailable hra);
     70
     71    HotelRoomAvailable findAvailibleRoomById(long hotelRoomAvailableId);
     72
     73    List<HotelRoomAvailable> getRoomsAvailibility();
     74
     75    List<HotelRoomAvailable> getRoomsAvailibilityByHotel(Hotels hotel);
     76
     77    List<HotelRoomAvailable> getRoomsAvailibilityByDateAndLocation(String hotelLocation, Date dateFrom, Date dateTo, int numberOfBeds, Boolean flexible);
     78
     79    @Transactional
     80    void createReservation(HotelRoomReservations r);
     81
     82    @Transactional
     83    void editReservation(HotelRoomReservations hr);
     84
     85    @Transactional
     86    void deleteReservation(HotelRoomReservations hr);
     87
     88    HotelRoomReservations findReservationById(long hotelRoomReservedId);
     89
     90    List<HotelRoomReservations> findReservationByUser(User user);
     91
     92    List<HotelRoomReservations> findReservationByHotel(Hotels hotel);
     93
     94    List<HotelRoomReservations> getReservations();
    4795
    4896    List<Reviews> findReviewsByHotel(Hotels hotel);
    4997
    5098    List<HotelRoomReservations> findPastReservationByUser(User u);
    51 
    52     void addHotelImage(HotelsImages x);
    53 
    54     void addRoomImage(HotelRoomImages x);
     99//    public void createHotel(Hotels hotel, long userId);
     100//    public void editHotel(long hotelId, String hotelName, String hotelDescripiton, String hotelLocation, String hotelEDBS, Boolean parking, Boolean petFriendly, Boolean internetAvailable);
     101//    public void deleteHotel(long hotelId);
     102//    public Hotels findHotelByID (long hotelId);
     103//    public List<Hotels> getHotels();
     104//    public List<Hotels> getHotelsForUser(long userId);
     105//    public List<Hotels> getHotelsByLocation(String hotelLocation);
     106//
     107//    public void deleteHotelImage(long hotelImageId);
     108//    public HotelsImages findHotelImageById(long hotelImageId);
     109//    public List<HotelsImages> getHotelImages(Hotels hotels);
     110//    public List<HotelRoomImages> getRoomImages(HotelRoom hotelRoom);
     111//
     112//    public void createRoom(Hotels hotel, String hotelRoomDescription, String hotelRoomName, Boolean kitchenAvailable, Boolean airConditioning, Boolean balcony, double price, int numOfBeds);
     113//    public void editRoom(long hotelRoomId, Hotels hotel, String hotelRoomDescription, String HotelRoomName, Boolean kitchenAvailable, Boolean airConditioning, Boolean balcony, double price);
     114//    public void deleteRoom(long hotelRoomId);
     115//    public HotelRoom findRoomById (long hotelRoomId);
     116//    public List<HotelRoom> getRoomsOfHotel (long hotelId);
     117//    public List<HotelRoomAvailable> getRoomsAvailable(Long id);
     118//
     119//    @Transactional
     120//    public void createRoomAvailible(HotelRoom hotelRoom, Date dateFrom, Date dateTo, int numberOfBeds);
     121//    public void editRoomAvailible(long hotelRoomAvailableId, HotelRoom hotelRoom, Date dateFrom, Date dateTo, int numberOfBeds);
     122//    public void deleteRoomAvailible(long hotelRoomAvailableId);
     123//    public HotelRoomAvailable findAvailibleRoomById(long hotelRoomAvailableId);
     124//    public List<HotelRoomAvailable> getRoomsAvailibility();
     125//    public List<HotelRoomAvailable> getRoomsAvailibilityByHotel(Hotels hotel);
     126//    public List<HotelRoomAvailable> getRoomsAvailibilityByDateAndLocation(String hotelLocation, Date dateFrom, Date dateTo, int numberOfBeds, Boolean flexible);
     127//
     128//    public void createReservation(User user, HotelRoom hotelRoom, Date dateFrom, Date dateTo, Integer numberOfBeds);
     129//    public void editReservation(long hotelRoomReservedId, User user, HotelRoom hotelRoom, Date dateFrom, Date dateTo, Integer numberOfBeds);
     130//    public void deleteReservation(long hotelRoomReservedId);
     131//    public HotelRoomReservations findReservationById(long hotelRoomReservedId);
     132//    public List<HotelRoomReservations> findReservationByUser(User user);
     133//    public List<HotelRoomReservations> findReservationByHotel(Hotels hotel);
     134//    public List<HotelRoomReservations> getReservations();
     135//
     136//    List<Reviews> findReviewsByHotel(Hotels hotel);
     137//
     138//    List<HotelRoomReservations> findPastReservationByUser(User u);
     139//
     140//    void addHotelImage(HotelsImages x);
     141//
     142//    void addRoomImage(HotelRoomImages x);
     143//    void saveReservation(HotelRoomReservations hotelRoomReservations);
    55144}

  • src/main/java/com/tourMate/dao/MenuDao.java

    r5528b99 r07f4e8b  
    22
    33import com.tourMate.entities.Menu;
     4import jakarta.transaction.Transactional;
    45
    56import java.util.List;
    67
    78public interface MenuDao {
    8     public void createMenu(String name, String ingredients, double price);
    9     public void deleteMenu(long menuId);
    10     public List<Menu> getCreatedMenus();
    11     public Menu findMenuById(long menuId);
    12     public void editMenu(long menuId, String name, String ingredients, double price);
     9    @Transactional
     10    void createMenu(Menu menu);
     11
     12    @Transactional
     13    void deleteMenu(Menu menu);
     14
     15    List<Menu> getCreatedMenus();
     16
     17    Menu findMenuById(long menuId);
     18
     19    @Transactional
     20    void editMenu(Menu menu);
     21//    public void createMenu(String name, String ingredients, double price);
     22//
     23//    @Transactional
     24//    void createMenu(Menu menu);
     25//
     26//    public void deleteMenu(long menuId);
     27//
     28//    @Transactional
     29//    void deleteMenu(Menu menu);
     30//
     31//    public List<Menu> getCreatedMenus();
     32//    public Menu findMenuById(long menuId);
     33//    public void editMenu(long menuId, String name, String ingredients, double price);
    1334}

  • src/main/java/com/tourMate/dao/RestaurantDao.java

    r5528b99 r07f4e8b  
    88
    99public interface RestaurantDao {
    10     public void createRestaurant(Restaurant restaurant, long userId);
    11     public void deleteRestaurant(long restaurantID);
    1210    @Transactional
    13     public void editRestaurant(long restaurantID, String restaurantName, String restaurantLocation, String cousineType, String restaurantDescription, String restaurantEdbs, User restaurantOwner);
    14     public Restaurant findRestaurantByID (long restaurantID);
    15     public List<Restaurant> searchByRestaurantName(String restaurantName);
    16     public List<Restaurant> searchByRestaurantLocation(String restaurantLocation);
    17     public List<Restaurant> getRestaurants();
     11    void createRestaurant(Restaurant restaurant);
     12    List<RestaurantsAvailible> getTablesByDateAndLocation(String restaurantLocation, Date hourFrom, Date hourTo, int noSeats);
    1813    @Transactional
    19     public void addMenuToRestaurant(long restaurantId, Menu menu);
     14    void addRestaurantImage(RestaurantImages restaurantImages);
     15    @Transactional
     16    void removeRestaurantImage(RestaurantImages image);
     17    @Transactional
     18    void saveTable(RestaurantsTable resTable);
     19    @Transactional
     20    RestaurantImages findRestaurantImageById(long restaurantImageId);
     21    void deleteRestaurant(Restaurant r);
     22    List<Restaurant> getRestaurants();
     23    @Transactional
     24    void addMenuToRestaurant(Menu menu);
     25    Restaurant findRestaurantByID(long restaurantID);
     26    List<RestaurantImages> getRestaurantImages(long restaurantID);
     27    List<RestaurantsTable> getRestaurantTables(long restaurantID);
     28    RestaurantsTable findTableById(long tableId);
     29    @Transactional
     30    void deleteTable(RestaurantsTable rt);
     31    List<Restaurant> getRestaurantsByUser(User u);
     32    List<RestaurantsAvailible> getTablesAvailabilityById(Long id);
     33    @Transactional
     34    void saveTableAvailable(RestaurantsAvailible ra);
     35    @Transactional
     36    void deleteTableAvailable(RestaurantsAvailible ra);
    2037
    21     public List<RestaurantsAvailible> getTablesByDateAndLocation(String restaurantLocation, Date hourFrom, Date hourTo, int noSeats);
     38    List<RestaurantsAvailible> getTablesAvailability();
    2239
    23     public void createTable(Restaurant restaurant, int noSeats);
    24     public void editTable(Restaurant restaurant, long tableId, int noSeats);
    25     public void deleteTable(long tableId);
    26     public List<Restaurant> getRestaurantsByUser(long userId);
    27     public RestaurantsTable findTableById(long tableId);
    28     public List<RestaurantsTable> searchByNoSeats(int noSeats);
    29     public List<RestaurantsTable> getRestaurantTables(long restaurantID);
     40    //    List<RestaurantsAvailible> getTablesAvailability();
     41    @Transactional
     42    void createReservation(RestaurantReservations reservations);
     43    @Transactional
     44    void deleteReservation(RestaurantReservations r);
     45    RestaurantReservations findReservationByID(long tableId);
     46    RestaurantsAvailible findAvailableReservationByID(long availibleId);
     47    List<RestaurantReservations> findReservationByUser(User user);
     48    List<RestaurantReservations> findReservationByRestaurant(Restaurant restaurant);
     49    List<RestaurantReservations> getReservations();
     50    List<Restaurant> searchByRestaurantName(String restaurantName);
    3051
    31     public void addRestaurantImage(RestaurantImages restaurantImages);
    32     public void removeRestaurantImage(long restaurantImageId);
    33     public RestaurantImages findRestaurantImageById(long restaurantImageId);
    34     public List<RestaurantImages> getRestaurantImages(long restaurantID);
     52    List<Restaurant> searchByRestaurantLocation(String restaurantLocation);
    3553
    36     public void createTableAvailable(RestaurantsTable restaurantsTable, Date hourFrom, Date hourTo, int noSeats);
    37     @Transactional
    38     abstract void createTableAvailable(RestaurantsTable restaurantsTable, Date hourFrom, Date hourTo);
    39     public List<RestaurantsAvailible> getTablesAvailabilityById(Long id);
    40     public void editTableAvailable(long tableId, Restaurant restaurant, int noSeats);
    41     public void deleteTableAvailable(long tableId);
    42     public RestaurantsAvailible findAvailableReservationByID(long availibleId);
    43 
    44     public List<RestaurantsAvailible> getTablesAvailability();
    45     public void createReservation(RestaurantReservations reservations);
    46     public void editReservation(long restaurantsTableId, RestaurantsTable rt, Date hourFrom, Date hourTo, int noSeats, User user);
    47     public void deleteReservation(long restaurantsTableId);
    48     public RestaurantReservations findReservationByID(long tableId);
    49     public List<RestaurantReservations> findReservationByUser(User user);
    50     public List<RestaurantReservations> findReservationByRestaurant(Restaurant restaurant);
    51     public List<RestaurantReservations> getReservations();
     54    List<RestaurantsTable> searchByNoSeats(int noSeats);
    5255
    5356    List<Reviews> findReviewsByRestaurant(Restaurant restaurant);
    5457
    55     List<RestaurantReservations> findPastReservationsByUser(User u);
     58    List<RestaurantReservations> findPastReservationsByUser(User user);
     59
     60    List<MenuImages> getMenuImages(long menuId);
     61
     62    List<MenuImages> getMenuImagesByRestaurant(Restaurant restaurant);
     63
     64    @Transactional
     65    void addMenuImage(MenuImages menuImages);
     66
     67    Menu findMenuId(Long menuId);
     68
     69    void saveReservation(RestaurantReservations r);
     70
     71//    public void createRestaurant(Restaurant restaurant, long userId);
     72//    public void deleteRestaurant(long restaurantID);
     73//    @Transactional
     74//    public void editRestaurant(long restaurantID, String restaurantName, String restaurantLocation, String cousineType, String restaurantDescription, String restaurantEdbs, User restaurantOwner);
     75//    public Restaurant findRestaurantByID (long restaurantID);
     76//    public List<Restaurant> searchByRestaurantName(String restaurantName);
     77//    public List<Restaurant> searchByRestaurantLocation(String restaurantLocation);
     78//    public List<Restaurant> getRestaurants();
     79//    @Transactional
     80//    public void addMenuToRestaurant(long restaurantId, Menu menu);
     81//
     82//    public List<RestaurantsAvailible> getTablesByDateAndLocation(String restaurantLocation, Date hourFrom, Date hourTo, int noSeats);
     83//
     84//    public void createTable(Restaurant restaurant, int noSeats);
     85//    public void editTable(Restaurant restaurant, long tableId, int noSeats);
     86//    public void deleteTable(long tableId);
     87//    public List<Restaurant> getRestaurantsByUser(long userId);
     88//    public RestaurantsTable findTableById(long tableId);
     89//    public List<RestaurantsTable> searchByNoSeats(int noSeats);
     90//    public List<RestaurantsTable> getRestaurantTables(long restaurantID);
     91//
     92//    public void addRestaurantImage(RestaurantImages restaurantImages);
     93//    public void removeRestaurantImage(long restaurantImageId);
     94//    public RestaurantImages findRestaurantImageById(long restaurantImageId);
     95//    public List<RestaurantImages> getRestaurantImages(long restaurantID);
     96//
     97//    public void createTableAvailable(RestaurantsTable restaurantsTable, Date hourFrom, Date hourTo, int noSeats);
     98//    @Transactional
     99//    abstract void createTableAvailable(RestaurantsTable restaurantsTable, Date hourFrom, Date hourTo);
     100//    public List<RestaurantsAvailible> getTablesAvailabilityById(Long id);
     101//    public void editTableAvailable(long tableId, Restaurant restaurant, int noSeats);
     102//    public void deleteTableAvailable(long tableId);
     103//    public RestaurantsAvailible findAvailableReservationByID(long availibleId);
     104//
     105//    public List<RestaurantsAvailible> getTablesAvailability();
     106//    public void createReservation(RestaurantReservations reservations);
     107//    public void editReservation(long restaurantsTableId, RestaurantsTable rt, Date hourFrom, Date hourTo, int noSeats, User user);
     108//    public void deleteReservation(long restaurantsTableId);
     109//    public RestaurantReservations findReservationByID(long tableId);
     110//    public List<RestaurantReservations> findReservationByUser(User user);
     111//    public List<RestaurantReservations> findReservationByRestaurant(Restaurant restaurant);
     112//    public List<RestaurantReservations> getReservations();
     113//
     114//    List<Reviews> findReviewsByRestaurant(Restaurant restaurant);
     115//
     116//    List<RestaurantReservations> findPastReservationsByUser(User u);
     117//    List<MenuImages> getMenuImages(long menuId);
     118//    public void addMenuImage(MenuImages menuImages);
     119//
     120//    Menu findMenuId(Long menuId);
     121//
     122//    void saveReservation(RestaurantReservations restaurantReservations);
    56123}

  • src/main/java/com/tourMate/dao/ReviewDao.java

    r5528b99 r07f4e8b  
    1010
    1111public interface ReviewDao {
    12 
    1312    @Transactional
    1413    void createReview(Reviews review);
    1514
    16     public void deleteReview(long id);
    17     public void editReview(long id, String title, String description, int numStar, Hotels hotel, Restaurant restaurant, Transport transport);
    18     public Reviews findReviewById(long id);
    19     public List<Reviews> getAllReviews();
    20     public List<Reviews> getHotelReviews();
    21     public List<Reviews> getTransportReviews();
    22     public List<Reviews> getRestaurantReviews();
    23     public List<Reviews> getHotelReviews(Hotels hotel);
    24     public List<Reviews> getRestaurantReviews(Restaurant restaurant);
    25     public List<Reviews> getTransportReviews(Transport transport);
     15    void deleteReview(Reviews review);
     16
     17    Reviews findReviewById(long id);
     18
     19    void editReview(Reviews review);
     20
     21    List<Reviews> getAllReviews();
     22
     23    List<Reviews> getHotelReviews();
     24
     25    List<Reviews> getTransportReviews();
     26
     27    List<Reviews> getRestaurantReviews();
     28
     29    List<Reviews> getHotelReviews(Hotels hotel);
     30
     31    List<Reviews> getRestaurantReviews(Restaurant restaurant);
     32
     33    List<Reviews> getTransportReviews(Transport transport);
     34//    @Transactional
     35//    void createReview(Reviews review);
     36//
     37//    public void deleteReview(long id);
     38//    public void editReview(long id, String title, String description, int numStar, Hotels hotel, Restaurant restaurant, Transport transport);
     39//    public Reviews findReviewById(long id);
     40//    public List<Reviews> getAllReviews();
     41//    public List<Reviews> getHotelReviews();
     42//    public List<Reviews> getTransportReviews();
     43//    public List<Reviews> getRestaurantReviews();
     44//    public List<Reviews> getHotelReviews(Hotels hotel);
     45//    public List<Reviews> getRestaurantReviews(Restaurant restaurant);
     46//    public List<Reviews> getTransportReviews(Transport transport);
    2647
    2748}

  • src/main/java/com/tourMate/dao/TransportDao.java

    r5528b99 r07f4e8b  
    44import com.tourMate.dto.TransportDto;
    55import com.tourMate.entities.*;
     6import jakarta.transaction.Transactional;
    67
    78
    8 import java.util.Collection;
    99import java.util.Date;
    1010import java.util.List;
    1111
    1212public interface TransportDao {
     13    @Transactional
     14    void createTransport(Transport t);
    1315
    14     public void createTransport(String transportName, String carBrand, String carType, int carManufacturedYear, int noPassengers, int noBags, long EMBG, User owner, String carPlate);
     16    @Transactional
     17    void deleteTransport(Transport t);
    1518
    16     public void deleteTransport(long transportId);
     19    List<Transport> getTransports();
    1720
    18     public void editTransport(long transportID, String transportName, String carBrand, String carType, int carManufacturedYear, int noPassengers, int noBags, long EMBG, User owner, String carPlate);
     21    List<TransportDto> getTransportsByUser(User u);
    1922
    20     public List<Transport> getTransports();
    21     public List<TransportDto> getTransportsByUser(long userId);
     23    List<RouteListingDto> getRoutesForTransport(Transport t);
    2224
    23     public List<RouteListingDto> getRoutesForTransport(long transportId);
    24     public Transport getTransportById(long transportId);
    25     public TransportDto findTransportById (long transportId);
     25    TransportDto findTransportById(long transportId);
    2626
    27     public void createTransportReservation(TransportReservation transportReservation);
     27    Transport getTransportById(long transportId);
    2828
    29     public void editTransportReservation(Transport transport, long reservationID, String departureLocation, String arrivalLocation, Date date, Integer noSeats, User user, Date departureHour);
     29    @Transactional
     30    void editTransport(Transport t);
    3031
    31     public void deleteTransportReservation(long reservationID);
     32    @Transactional
     33    void createTransportReservation(TransportReservation transportReservation);
    3234
    33     public TransportReservation findTransportReservationByID(long reservationID);
     35    TransportReservation findTransportReservationByID(long reservationID);
    3436
    35     public List<TransportReservation> getTransportReservations();
     37    List<TransportReservation> getTransportReservations();
    3638
    37     public List<TransportReservation> getTransportsReservationsByUserID(long userID);
     39    TransportAvailible findTransportAvailableByID(long reservationID);
    3840
    39     public void createTransportAvailable(Transport transport, String departureLocation, String arrivalLocation, Date date, Integer noSeats, Date departureHour, Collection<TransportRoute> routes);
     41    List<TransportRoute> getTransportsAvailableByFilters(String fromL, String toL, Date date, int numPassengers);
    4042
    41     public void editTransportAvailable(Transport transport, long availableID, String departureLocation, String arrivalLocation, Date date, Integer noSeats, Date departureHour);
     43    List<TransportReservation> getTransportsReservationsByUserID(long userID);
    4244
    43     public void deleteTransportAvailable(long availableID);
     45    List<TransportAvailible> getTransportsAvailable();
    4446
    45     public TransportAvailible findTransportAvailableByID (long reservationID);
     47    @Transactional
     48    void createTransportAvailable(TransportAvailible ta);
    4649
    47     public List<TransportAvailible> getTransportsAvailable();
     50    void editTransportAvailable(TransportAvailible ta);
    4851
    49     public List<TransportRoute> getTransportsAvailableByFilters (String from,String to,Date date);
    50 
    51     public void createTransportRoute(TransportAvailible parentRoute, String from, String to, double price, Date departure, Date arrival, int freeSpace, int order);
    52 
    53     public void deleteTransportRoute(long transportRouteId);
    54 
    55     public void editTransportRoute(long transportRouteId, TransportAvailible parentRoute, String from, String to, double price, Date departure, Date arrival, int freeSpace, int order);
    56 
    57     public TransportRoute findTransportRouteById(long transportRouteId);
     52    TransportRoute findTransportRouteById(long transportRouteId);
    5853
    5954    List<Reviews> getReviewsForTransport(Transport transport);
    6055
    61     List<TransportReservation> findReservationByUser(User u);
     56    List<TransportReservation> findPastReservationByUser(User user);
    6257
    63     List<TransportReservation> findPastReservationByUser(User user);
     58    @Transactional
     59    void saveReservation(TransportReservation transportReservation);
     60
     61    List<TransportReservation> findReservationByUser(User user);
     62
     63    @Transactional
     64    void deleteTransportReservation(TransportReservation tr);
     65
     66    @Transactional
     67    void deleteTransportAvailable(TransportAvailible ta);
     68
     69    void createTransportRoute(TransportRoute tr);
     70
     71    void deleteTransportRoute(TransportRoute tr);
     72
     73    void editTransportRoute(TransportRoute tr);
     74
     75    List<TransportReservation> findTransportReservationByTransportId(Transport t);
     76
     77//    public void createTransport(String transportName, String carBrand, String carType, int carManufacturedYear, int noPassengers, int noBags, long EMBG, Long userId, String carPlate);
     78//
     79//    public void deleteTransport(long transportId);
     80//
     81//    public void editTransport(long transportID, String transportName, String carBrand, String carType, int carManufacturedYear, int noPassengers, int noBags, long EMBG, User owner, String carPlate);
     82//
     83//    public List<Transport> getTransports();
     84//    public List<TransportDto> getTransportsByUser(long userId);
     85//
     86//    public List<RouteListingDto> getRoutesForTransport(long transportId);
     87//    public Transport getTransportById(long transportId);
     88//    public TransportDto findTransportById (long transportId);
     89//
     90//    public void createTransportReservation(TransportReservation transportReservation);
     91//
     92//    public void editTransportReservation(Transport transport, long reservationID, String departureLocation, String arrivalLocation, Date date, Integer noSeats, User user, Date departureHour);
     93//
     94//    public void deleteTransportReservation(long reservationID);
     95//
     96//    public TransportReservation findTransportReservationByID(long reservationID);
     97//
     98//    public List<TransportReservation> getTransportReservations();
     99//
     100//    public List<TransportReservation> getTransportsReservationsByUserID(long userID);
     101//
     102//    public void createTransportAvailable(Transport transport, String departureLocation, String arrivalLocation, Date date, Integer noSeats, Date departureHour, Collection<TransportRoute> routes);
     103//
     104//    public void editTransportAvailable(Transport transport, long availableID, String departureLocation, String arrivalLocation, Date date, Integer noSeats, Date departureHour);
     105//
     106//    public void deleteTransportAvailable(long availableID);
     107//
     108//    public TransportAvailible findTransportAvailableByID (long reservationID);
     109//
     110//    public List<TransportAvailible> getTransportsAvailable();
     111//
     112//    public List<TransportRoute> getTransportsAvailableByFilters (String from, String to, Date date, int numPassengers);
     113//
     114//    public void createTransportRoute(TransportAvailible parentRoute, String from, String to, double price, Date departure, Date arrival, int freeSpace, int order);
     115//
     116//    public void deleteTransportRoute(long transportRouteId);
     117//
     118//    public void editTransportRoute(long transportRouteId, TransportAvailible parentRoute, String from, String to, double price, Date departure, Date arrival, int freeSpace, int order);
     119//
     120//    public TransportRoute findTransportRouteById(long transportRouteId);
     121//
     122//    List<Reviews> getReviewsForTransport(Transport transport);
     123//
     124//    List<TransportReservation> findReservationByUser(User u);
     125//
     126//    List<TransportReservation> findPastReservationByUser(User user);
     127//
     128//    void saveReservation(TransportReservation transportReservation);
    64129}

  • src/main/java/com/tourMate/dao/UsersDao.java

    r5528b99 r07f4e8b  
    2323
    2424    UserDetails findUserByUsername(String username);
     25
     26    List<User> getUnapprovedUsers();
     27
     28    void approveUserProfile(User u);
     29
     30    Role findById(Long id);
     31    void updateUser(User s);
    2532}

  • src/main/java/com/tourMate/dao/impl/BusinessDaoImpl.java

    r5528b99 r07f4e8b  
    1919    @Transactional
    2020    @Override
    21     public void createBusiness(Business business, long userId) {
    22         User u = em.find(User.class, userId);
    23         business.setUser(u);
     21    public void createBusiness(Business business) {
    2422        em.persist(business);
    2523    }
    2624
    2725    @Override
    28     public List<Business> getUnapprovedBusinessesOfUser(long userId) {
    29         User u = em.find(User.class, userId);
     26    public List<Business> getUnapprovedBusinessesOfUser(User u) {
    3027        return em.createQuery("SELECT b FROM Business b WHERE b.user = :user").setParameter("user", u).getResultList();
    3128    }
    … …  
    3330    @Transactional
    3431    @Override
    35     public void deleteBusiness(long businessId) {
    36         Business business = findBusinessById(businessId);
     32    public void deleteBusiness(Business business) {
    3733        em.remove(business);
    38 
    3934    }
    4035
    4136    @Override
    42     public boolean hasBusiness(long userId)
     37    public boolean hasBusiness(User u)
    4338    {
    44         User u = em.find(User.class, userId);
    4539        return Integer.parseInt(em.createQuery("SELECT COUNT(b) FROM Business b WHERE b.user = :user").setParameter("user", u).getSingleResult().toString()) > 0;
     40    }
     41
     42    @Override
     43    public List<Business> getUnapprovedBusinesses() {
     44        return em.createQuery("select b from Business b where not b.approved").getResultList();
     45    }
     46
     47    @Override
     48    @Transactional
     49    public void approveBusiness(Business b) {
     50        em.persist(b);
    4651    }
    4752
    … …  
    5762    }
    5863
     64
    5965    @Transactional
    6066    @Override
    61     public void editBusiness(long businessId, String name, String phone, String address, String edbs, User user, boolean approved) {
    62         Business business = findBusinessById(businessId);
    63         business.setName(name);
    64         business.setPhone(phone);
    65         business.setAddress(address);
    66         business.setEdbs(edbs);
    67         business.setUser(user);
    68         business.setApproved(approved);
     67    public void editBusiness(Business business) {
    6968        em.persist(business);
    7069    }

  • src/main/java/com/tourMate/dao/impl/HotelDaoImpl.java

    r5528b99 r07f4e8b  
    88import org.springframework.stereotype.Service;
    99
     10import java.util.Calendar;
    1011import java.util.Date;
    1112import java.util.List;
    … …  
    1920    @Override
    2021    @Transactional
    21     public void createHotel(Hotels hotel, long userId) {
    22         User u = em.find(User.class, userId);
    23         Hotels h = new Hotels(hotel.getHotelName(), hotel.getHotelDescripiton(), hotel.getHotelLocation(), hotel.getHotelEDBS(), hotel.getParking(), hotel.getPetFriendly(), hotel.getInternetAvailable(), u);
    24         em.persist(h);
     22    public void createHotel(Hotels hotel) {
     23        em.persist(hotel);
    2524    }
    2625
    2726    @Override
    2827    public List<Hotels> getHotels() {
    29         List<Hotels> hoteli = em.createQuery("select h from Hotels h order by h.hotelId").getResultList();
    30         System.out.println("OREEEEEEL");
    31         return hoteli;
    32         //return em.createQuery("select h from Hotels h order by h.hotelId").getResultList();
    33     }
    34 
    35     @Override
    36     public List<Hotels> getHotelsForUser(long userId) {
    37         User u = em.find(User.class, userId);
     28        return em.createQuery("select h from Hotels h order by h.hotelId").getResultList();
     29    }
     30
     31    @Override
     32    public List<Hotels> getHotelsForUser(User u) {
    3833        return em.createQuery("select h from Hotels h where h.owner = :u").setParameter("u", u).getResultList();
    3934    }
    … …  
    4641    @Transactional
    4742    @Override
    48     public void editHotel(long hotelId, String hotelName, String hotelDescripiton, String hotelLocation, String hotelEDBS, Boolean parking, Boolean petFriendly, Boolean internetAvailable) {
    49         Hotels hotel = findHotelByID(hotelId);
    50         hotel.setHotelName(hotelName);
    51         hotel.setHotelDescripiton(hotelDescripiton);
    52         hotel.setHotelLocation(hotelLocation);
    53         hotel.setHotelEDBS(hotelEDBS);
    54         hotel.setParking(parking);
    55         hotel.setPetFriendly(petFriendly);
    56         hotel.setInternetAvailable(internetAvailable);
     43    public void editHotel(Hotels hotel) {
    5744        em.persist(hotel);
    5845    }
    … …  
    6047    @Transactional
    6148    @Override
    62     public void deleteHotel(long hotelId) {
    63         Hotels h = findHotelByID(hotelId);
    64         em.remove(h);
     49    public void deleteHotel(Hotels hotel) {
     50        em.remove(hotel);
    6551    }
    6652
    … …  
    8975    @Override
    9076    @Transactional
     77    public void  saveReservation(HotelRoomReservations hotelRoomReservations) {
     78        em.persist(hotelRoomReservations);
     79    }
     80
     81    @Override
     82    @Transactional
    9183    public HotelsImages findHotelImageById(long hotelImageId) {
    9284        return em.find(HotelsImages.class, hotelImageId);
    … …  
    9587    @Override
    9688    @Transactional
    97     public void deleteHotelImage(long hotelImageId) {
    98         HotelsImages hotelsImages = findHotelImageById(hotelImageId);
     89    public void deleteHotelImage(HotelsImages hotelsImages) {
    9990        em.remove(hotelsImages);
    10091    }
    10192
    10293    @Override
    103     public List<HotelRoom> getRoomsOfHotel(long hotelId) {
    104         Hotels h = findHotelByID(hotelId);
    105         return em.createQuery("SELECT hr from HotelRoom hr where hr.hotel = :hotel").setParameter("hotel", h).getResultList();
     94    public List<HotelRoom> getRoomsOfHotel(Hotels hotel) {
     95        return em.createQuery("SELECT hr from HotelRoom hr where hr.hotel = :hotel").setParameter("hotel", hotel).getResultList();
    10696    }
    10797
    … …  
    123113    @Transactional
    124114    @Override
    125     public void createRoom(Hotels hotel, String hotelRoomDescription, String hotelRoomName, Boolean kitchenAvailable, Boolean airConditioning, Boolean balcony, double price) {
    126         HotelRoom hotelRoom = new HotelRoom(hotel, hotelRoomDescription, hotelRoomName, kitchenAvailable, airConditioning, balcony, price);
     115    public void createRoom(HotelRoom hotelRoom) {
    127116        em.persist(hotelRoom);
    128117    }
    … …  
    130119    @Transactional
    131120    @Override
    132     public void editRoom(long hotelRoomId, Hotels hotel, String hotelRoomDescription, String hotelRoomName, Boolean kitchenAvailable, Boolean airConditioning, Boolean balcony, double price) {
    133         HotelRoom hr = findRoomById(hotelRoomId);
    134         hr.setHotel(hotel);
    135         hr.setHotelRoomDescription(hotelRoomDescription);
    136         hr.setHotelRoomName(hotelRoomName);
    137         hr.setKitchenAvailable(kitchenAvailable);
    138         hr.setAirConditioning(airConditioning);
    139         hr.setBalcony(balcony);
    140         hr.setPrice(price);
     121    public void editRoom(HotelRoom hr) {
    141122        em.persist(hr);
    142123    }
    … …  
    144125    @Transactional
    145126    @Override
    146     public void deleteRoom(long hotelRoomId) {
    147         HotelRoom hr = findRoomById(hotelRoomId);
     127    public void deleteRoom(HotelRoom hr) {
    148128        em.remove(hr);
    149129    }
    … …  
    151131    @Transactional
    152132    @Override
    153     public void createRoomAvailible(HotelRoom hotelRoom, Date dateFrom, Date dateTo, int numberOfBeds) {
    154         HotelRoomAvailable hra = new HotelRoomAvailable(hotelRoom, dateFrom, dateTo, numberOfBeds);
     133    public void createRoomAvailible(HotelRoomAvailable hra) {
    155134        em.persist(hra);
    156135    }
    … …  
    158137    @Transactional
    159138    @Override
    160     public void editRoomAvailible(long hotelRoomAvailableId, HotelRoom hotelRoom, Date dateFrom, Date dateTo, int numberOfBeds) {
    161         HotelRoomAvailable hr = findAvailibleRoomById(hotelRoomAvailableId);
    162         hr.setHotelRoom(hotelRoom);
    163         hr.setDateFrom(dateFrom);
    164         hr.setDateTo(dateTo);
    165         hr.setNumberOfBeds(numberOfBeds);
     139    public void editRoomAvailible(HotelRoomAvailable hr) {
    166140        em.persist(hr);
    167141    }
    … …  
    169143    @Transactional
    170144    @Override
    171     public void deleteRoomAvailible(long hotelRoomAvailableId) {
    172         HotelRoomAvailable hra = findAvailibleRoomById(hotelRoomAvailableId);
     145    public void deleteRoomAvailible(HotelRoomAvailable hra) {
    173146        em.remove(hra);
    174147    }
    … …  
    190163
    191164    @Override
    192     public List<HotelRoomAvailable> getRoomsAvailibilityByDateAndLocation(String hotelLocation, Date dateFrom, Date dateTo, int numberOfBeds) {
    193         return em.createQuery("select hr from HotelRoomAvailable hr where hr.dateFrom <= :dateFrom and hr.dateTo >= :dateTo " +
    194 <<<<<<< HEAD
    195                         "and hr.hotelRoom.hotel.hotelLocation LIKE :hotelLocation and hr.hotelRoom.numOfBeds >= :numBeds")
    196 =======
    197                 "and hr.hotelRoom.hotel.hotelLocation LIKE :hotelLocation and hr.numberOfBeds >= :numBeds")
    198 >>>>>>> parent of ac19a0c (authContext impl, admin panel impl, search bar fixes, reservations listings impl)
    199                 .setParameter("hotelLocation", hotelLocation)
    200                 .setParameter("dateFrom", dateFrom)
    201                 .setParameter("dateTo", dateTo)
    202                 .setParameter("numBeds", numberOfBeds)
    203                 .getResultList();
    204     }
    205 
    206     @Override
    207     @Transactional
    208     public void createReservation(User user, HotelRoom hotelRoom, Date dateFrom, Date dateTo, Integer numberOfBeds) {
    209         HotelRoomReservations r = new HotelRoomReservations(user, hotelRoom, dateFrom, dateTo, numberOfBeds);
     165    public List<HotelRoomAvailable> getRoomsAvailibilityByDateAndLocation(String hotelLocation, Date dateFrom, Date dateTo, int numberOfBeds, Boolean flexible) {
     166        if(flexible)
     167        {
     168            Calendar calendar = Calendar.getInstance();
     169            Calendar calendar1 = Calendar.getInstance();
     170            calendar.setTime(dateTo);
     171            calendar1.setTime(dateFrom);
     172            return em.createQuery("SELECT hr FROM HotelRoomAvailable hr WHERE " +
     173                            "((hr.dateFrom <= :dateTo AND hr.dateTo >= :dateFrom) OR " +
     174                            "(hr.dateFrom <= :dateToMinus1 AND hr.dateTo >= :dateFromMinus1) OR " +
     175                            "(hr.dateFrom <= :dateToMinus2 AND hr.dateTo >= :dateFromMinus2) OR " +
     176                            "(hr.dateFrom <= :dateToMinus3 AND hr.dateTo >= :dateFromMinus3) OR " +
     177                            "(hr.dateFrom <= :dateToPlus1 AND hr.dateTo >= :dateFromPlus1) OR " +
     178                            "(hr.dateFrom <= :dateToPlus2 AND hr.dateTo >= :dateFromPlus2) OR " +
     179                            "(hr.dateFrom <= :dateToPlus3 AND hr.dateTo >= :dateFromPlus3)) " +
     180                            "AND hr.hotelRoom.hotel.hotelLocation LIKE :hotelLocation " +
     181                            "AND hr.hotelRoom.numOfBeds >= :numBeds")
     182                    .setParameter("hotelLocation", hotelLocation)
     183                    .setParameter("dateFrom", dateFrom)
     184                    .setParameter("dateTo", dateTo)
     185                    .setParameter("dateToMinus1", subtractDays(calendar, 1))
     186                    .setParameter("dateToMinus2", subtractDays(calendar, 2))
     187                    .setParameter("dateToMinus3", subtractDays(calendar, 3))
     188                    .setParameter("dateToPlus1", addDays(calendar, 1))
     189                    .setParameter("dateToPlus2", addDays(calendar, 2))
     190                    .setParameter("dateToPlus3", addDays(calendar, 3))
     191                    .setParameter("dateFromMinus1", subtractDays(calendar1, 1))
     192                    .setParameter("dateFromMinus2", subtractDays(calendar1, 2))
     193                    .setParameter("dateFromMinus3", subtractDays(calendar1, 3))
     194                    .setParameter("dateFromPlus1", addDays(calendar1, 1))
     195                    .setParameter("dateFromPlus2", addDays(calendar1, 2))
     196                    .setParameter("dateFromPlus3", addDays(calendar1, 3))
     197                    .setParameter("numBeds", numberOfBeds)
     198                    .getResultList();
     199        }
     200        else
     201        {
     202            return em.createQuery("SELECT hr FROM HotelRoomAvailable hr WHERE " +
     203                            "((hr.dateFrom <= :dateTo AND hr.dateTo >= :dateFrom)) " +
     204                            "AND hr.hotelRoom.hotel.hotelLocation LIKE :hotelLocation " +
     205                            "AND hr.hotelRoom.numOfBeds >= :numBeds")
     206                    .setParameter("hotelLocation", hotelLocation)
     207                    .setParameter("dateFrom", dateFrom)
     208                    .setParameter("dateTo", dateTo)
     209                    .setParameter("numBeds", numberOfBeds)
     210                    .getResultList();
     211        }
     212
     213
     214
     215
     216    }
     217
     218    private Date addDays(Calendar calendar, int days) {
     219        Calendar newCalendar = (Calendar) calendar.clone();
     220        newCalendar.add(Calendar.DAY_OF_MONTH, days);
     221        return newCalendar.getTime();
     222    }
     223
     224    private Date subtractDays(Calendar calendar, int days) {
     225        Calendar newCalendar = (Calendar) calendar.clone();
     226        newCalendar.add(Calendar.DAY_OF_MONTH, -days);
     227        return newCalendar.getTime();
     228    }
     229
     230    @Override
     231    @Transactional
     232    public void createReservation(HotelRoomReservations  r) {
    210233        em.persist(r);
    211234    }
    … …  
    213236    @Override
    214237    @Transactional
    215     public void editReservation(long hotelRoomReservedId, User user, HotelRoom hotelRoom, Date dateFrom, Date dateTo, Integer numberOfBeds) {
    216         HotelRoomReservations hr = findReservationById(hotelRoomReservedId);
    217         hr.setUser(user);
    218         hr.setHotelRoom(hotelRoom);
    219         hr.setDateFrom(dateFrom);
    220         hr.setDateTo(dateTo);
    221         hr.setNumberOfBeds(numberOfBeds);
     238    public void editReservation(HotelRoomReservations hr) {
    222239        em.persist(hr);
    223 
    224     }
    225 
    226     @Transactional
    227     @Override
    228     public void deleteReservation(long hotelRoomReservedId) {
    229         HotelRoomReservations r = findReservationById(hotelRoomReservedId);
    230         em.remove(hotelRoomReservedId);
     240    }
     241
     242    @Transactional
     243    @Override
     244    public void deleteReservation(HotelRoomReservations hr) {
     245
     246        em.remove(hr);
    231247    }
    232248
    … …  
    244260    @Override
    245261    public List<HotelRoomReservations> findReservationByHotel(Hotels hotel) {
    246         List<HotelRoom> hotelRooms = getRoomsOfHotel(hotel.getHotelId());
    247         return em.createQuery("select hr from HotelRoomReservations hr where hr.hotelRoom in :hotelRooms").setParameter("hotelRooms", hotelRooms).getResultList();
     262        List<HotelRoom> hotelRooms = getRoomsOfHotel(hotel);
     263        return em.createQuery("select hr from HotelRoomReservations hr where hr.hotelRoom.hotel = :hotel").setParameter("hotel", hotel).getResultList();
    248264    }
    249265

  • src/main/java/com/tourMate/dao/impl/MenuDaoImpl.java

    r5528b99 r07f4e8b  
    1818    @Transactional
    1919    @Override
    20     public void createMenu(String name, String ingredients, double price) {
    21         Menu menu = new Menu(name, ingredients, price);
     20    public void createMenu(Menu menu) {
    2221        em.persist(menu);
    2322    }
    … …  
    2524    @Transactional
    2625    @Override
    27     public void deleteMenu(long menuId) {
    28         Menu menu = findMenuById(menuId);
     26    public void deleteMenu(Menu menu) {
    2927        em.remove(menu);
    3028    }
    … …  
    4240    @Transactional
    4341    @Override
    44     public void editMenu(long menuId, String name, String ingredients, double price) {
    45         Menu menu = findMenuById(menuId);
    46         menu.setName(name);
    47         menu.setIngredients(ingredients);
    48         menu.setPrice(price);
     42    public void editMenu(Menu menu) {
     43
    4944        em.persist(menu);
    5045    }

  • src/main/java/com/tourMate/dao/impl/RestaurantDaoImpl.java

    r5528b99 r07f4e8b  
    1818    @Override
    1919    @Transactional
    20     public void createRestaurant(Restaurant restaurant, long userId) {
    21         User u = em.find(User.class, userId);
    22         Restaurant r = new Restaurant(restaurant.getRestaurantName(), restaurant.getRestaurantLocation(), restaurant.getCousineType(), restaurant.getRestaurantDescription(), restaurant.getRestaurantEdbs(), u);
    23         em.persist(r);
     20    public void createRestaurant(Restaurant restaurant) {
     21        em.persist(restaurant);
    2422    }
    2523
    … …  
    4341    @Transactional
    4442    @Override
    45     public void removeRestaurantImage(long restaurantImageId){
    46         RestaurantImages restaurantImage = findRestaurantImageById(restaurantImageId);
    47         em.remove(restaurantImage);
     43    public void removeRestaurantImage(RestaurantImages image){
     44        em.remove(image);
    4845    }
    4946
    … …  
    5552
    5653    @Override
    57     public void deleteRestaurant(long restaurantID) {
    58         Restaurant r = findRestaurantByID(restaurantID);
     54    public void deleteRestaurant(Restaurant r) {
    5955        em.remove(r);
    6056    }
    … …  
    6763    @Override
    6864    @Transactional
    69     public void addMenuToRestaurant(long restaurantId, Menu menu) {
    70         Restaurant r = findRestaurantByID(restaurantId);
    71         menu.setRestaurant(r);
     65    public void addMenuToRestaurant(Menu menu) {
    7266        em.persist(menu);
    7367    }
    … …  
    8478
    8579    @Override
    86     @Transactional
    87     public void editRestaurant(long restaurantID, String restaurantName, String restaurantLocation, String cousineType, String restaurantDescription, String restaurantEdbs, User restaurantOwner) {
    88         Restaurant res = findRestaurantByID(restaurantID);
    89         res.setRestaurantName(restaurantName);
    90         res.setRestaurantLocation(restaurantLocation);
    91         res.setRestaurantEdbs(restaurantEdbs);
    92         res.setRestaurantDescription(restaurantDescription);
    93         res.setRestaurantOwner(restaurantOwner);
    94         res.setCousineType(cousineType);
    95         em.persist(res);
    96     }
    97 
    98     @Override
    9980    public List<RestaurantsTable> getRestaurantTables(long restaurantID) {
    100         List<RestaurantsTable> restaurantsTables = getRestaurantTables(restaurantID);
    101         return restaurantsTables;
     81        return em.createQuery("select rt from RestaurantsTable rt where rt.restaurant.restaurantID = :restaurantId").setParameter("restaurantId", restaurantID).getResultList();
    10282    }
    10383
    … …  
    10989    @Override
    11090    @Transactional
    111     public void createTable(Restaurant restaurant, int noSeats) {
    112         RestaurantsTable resTable = new RestaurantsTable(restaurant, noSeats);
     91    public void saveTable(RestaurantsTable resTable) {
    11392        em.persist(resTable);
    11493    }
    11594
    116     @Override
    117     @Transactional
    118     public void editTable(Restaurant restaurant, long tableId, int noSeats) {
    119         RestaurantsTable resTable = findTableById(tableId);
    120         resTable.setRestaurant(restaurant);
    121         resTable.setNoSeats(noSeats);
    122         em.persist(resTable);
    123     }
    124 
    125     @Override
    126     @Transactional
    127     public void deleteTable(long tableId) {
    128         RestaurantsTable rt  = findTableById(tableId);
     95
     96    @Override
     97    @Transactional
     98    public void deleteTable(RestaurantsTable rt) {
    12999        em.persist(rt);
    130100    }
    131101
    132102    @Override
    133     public List<Restaurant> getRestaurantsByUser(long userId) {
    134         User u = em.find(User.class, userId);
     103    public List<Restaurant> getRestaurantsByUser(User u) {
    135104        return em.createQuery("select r from Restaurant r where r.restaurantOwner = :u").setParameter("u", u).getResultList();
    136     }
    137 
    138     @Override
    139     @Transactional
    140     public void createTableAvailable(RestaurantsTable restaurantsTable, Date hourFrom, Date hourTo, int noSeats) {
    141         RestaurantsAvailible ra = new RestaurantsAvailible(restaurantsTable, hourFrom, hourTo, noSeats);
    142         em.persist(ra);
    143105    }
    144106
    … …  
    151113    @Override
    152114    @Transactional
    153     public void createTableAvailable(RestaurantsTable restaurantsTable, Date hourFrom, Date hourTo){
    154         RestaurantsAvailible rta = new RestaurantsAvailible(restaurantsTable, hourFrom, hourTo);
    155         em.persist(rta);
    156     }
    157 
    158     @Override
    159     @Transactional
    160     public void editTableAvailable(long tableId, Restaurant restaurant, int noSeats) {
    161         RestaurantsTable rt = findTableById(tableId);
    162         rt.setRestaurant(restaurant);
    163         rt.setNoSeats(noSeats);
    164         em.persist(rt);
    165     }
    166 
    167     @Override
    168     @Transactional
    169     public void deleteTableAvailable(long tableId) {
    170         RestaurantsAvailible ra = findAvailableReservationByID(tableId);
     115    public void saveTableAvailable(RestaurantsAvailible ra){
     116        em.persist(ra);
     117    }
     118
     119    @Override
     120    @Transactional
     121    public void deleteTableAvailable(RestaurantsAvailible ra) {
    171122        em.remove(ra);
    172123    }
    … …  
    183134    }
    184135
    185     @Override
    186     @Transactional
    187     public void editReservation(long restaurantsTableId, RestaurantsTable rt, Date hourFrom, Date hourTo, int noSeats, User user) {
    188         RestaurantReservations r = findReservationByID(restaurantsTableId);
    189         r.setTable(rt);
    190         r.setTimeFrom(hourFrom);
    191         r.setTimeTo(hourTo);
    192         r.setNoSeats(noSeats);
    193         r.setUser(user);
    194         em.persist(r);
    195     }
    196 
    197     @Override
    198     @Transactional
    199     public void deleteReservation(long restaurantsTableId) {
    200         RestaurantReservations r = findReservationByID(restaurantsTableId);
     136
     137    @Override
     138    @Transactional
     139    public void deleteReservation(RestaurantReservations r) {
    201140        em.remove(r);
    202141    }
    … …  
    259198
    260199    }
     200
     201    @Override
     202    public List<MenuImages> getMenuImages(long menuId) {
     203        return em.createQuery("select ri from MenuImages ri where ri.menu.id = :menuId").setParameter("menuId", menuId).getResultList();
     204    }
     205
     206    @Override
     207    public List<MenuImages> getMenuImagesByRestaurant(Restaurant resta) {
     208        return em.createQuery("select mi from MenuImages mi where mi.menu.restaurant = :restaurant")
     209                .setParameter("restaurant", resta)
     210                .getResultList();
     211    }
     212
     213    @Transactional
     214    @Override
     215    public void addMenuImage(MenuImages menuImages) {
     216        em.persist(menuImages);
     217    }
     218
     219    @Override
     220    public Menu findMenuId(Long menuId) {
     221        return em.find(Menu.class, menuId);
     222    }
     223
     224    @Override
     225    @Transactional
     226    public void saveReservation(RestaurantReservations restaurantReservations) {
     227        em.persist(restaurantReservations);
     228    }
    261229}

  • src/main/java/com/tourMate/dao/impl/ReviewDaoImpl.java

    r5528b99 r07f4e8b  
    2525
    2626    @Override
    27     public void deleteReview(long id) {
    28         Reviews review = findReviewById(id);
     27    public void deleteReview(Reviews review) {
    2928        em.remove(review);
    3029    }
    … …  
    3635
    3736    @Override
    38     public void editReview(long id, String title, String description, int numStar, Hotels hotel, Restaurant restaurant, Transport transport) {
    39         Reviews review = findReviewById(id);
    40         review.setDescription(description);
    41         review.setHotel(hotel);
    42         review.setRestaurant(restaurant);
    43         review.setTitle(title);
    44         review.setNumStar(numStar);
    45         review.setTransport(transport);
     37    public void editReview(Reviews review) {
    4638        em.persist(review);
    4739    }

  • src/main/java/com/tourMate/dao/impl/TransportDaoImpl.java

    r5528b99 r07f4e8b  
    1010import org.springframework.stereotype.Service;
    1111
    12 import java.util.Collection;
    1312import java.util.Date;
    1413import java.util.List;
    … …  
    2221    @Override
    2322    @Transactional
    24     public void createTransport(String transportName, String carBrand, String carType, int carManufacturedYear, int noPassengers, int noBags, long EMBG, User owner, String carPlate) {
    25         User u = em.find(User.class, 1);
    26         Transport t=new Transport(transportName,carBrand,carType,carManufacturedYear,noPassengers,noBags,EMBG,u,carPlate);
     23    public void createTransport(Transport t) {
    2724        em.persist(t);
    2825    }
    … …  
    3027    @Override
    3128    @Transactional
    32     public void deleteTransport(long transportId) {
    33         Transport t=getTransportById(transportId);
     29    public void deleteTransport(Transport t) {
    3430        em.remove(t);
    3531    }
    … …  
    4137
    4238    @Override
    43     public List<TransportDto> getTransportsByUser(long userId) {
    44         User u = em.find(User.class, userId);
     39    public List<TransportDto> getTransportsByUser(User u) {
    4540        List<Transport> transports = em.createQuery("select t from Transport t where t.owner = :u").setParameter("u", u).getResultList();
    4641        return transports.stream().map(x -> new TransportDto(
    … …  
    6257                        y.getFreeSpace(),
    6358                        y.getTime(),
    64                         y.getRoutes()
    65                 )).toList()
     59                        y.getRoutes(),
     60                        y.getRoutes().stream()
     61                                .mapToDouble(TransportRoute::getPrice)
     62                                .max().orElse(0)
     63                )).toList(),
     64                x.getAvailableRoutes().stream()
     65                        .flatMapToDouble(y -> y.getRoutes()
     66                                .stream()
     67                                .mapToDouble(TransportRoute::getPrice)).max().orElseGet(() -> 0)
    6668        )).toList();
    6769    }
    6870
    6971    @Override
    70     public List<RouteListingDto> getRoutesForTransport(long transportId) {
    71         Transport t = em.find(Transport.class, transportId);
     72    public List<RouteListingDto> getRoutesForTransport(Transport t) {
    7273        List<TransportAvailible> transportsAvailible = em.createQuery("select ta from TransportAvailible ta where ta.transport = :transport").setParameter("transport", t).getResultList();
    7374        return transportsAvailible.stream().map(x -> new RouteListingDto(
    … …  
    7879                x.getFreeSpace(),
    7980                x.getTime(),
    80                 x.getRoutes()
     81                x.getRoutes(),
     82                x.getRoutes().stream()
     83                        .mapToDouble(TransportRoute::getPrice)
     84                        .max().orElse(0)
    8185        )).toList();
    8286    }
    … …  
    103107                        y.getFreeSpace(),
    104108                        y.getTime(),
    105                         y.getRoutes()
    106                 )).toList());
    107     }
    108 
     109                        y.getRoutes(),
     110                        y.getRoutes().stream()
     111                                .mapToDouble(TransportRoute::getPrice)
     112                                .max().orElse(0)
     113                )).toList(),
     114                x.getAvailableRoutes().stream()
     115                        .flatMapToDouble(y -> y.getRoutes()
     116                                                        .stream()
     117                                                        .mapToDouble(TransportRoute::getPrice)).max().orElseGet(() -> 0));
     118    }
     119
     120    @Override
    109121    public Transport getTransportById(long transportId)
    110122    {
    … …  
    114126    @Override
    115127    @Transactional
    116     public void editTransport(long transportID, String transportName, String carBrand, String carType, int carManufacturedYear, int noPassengers, int noBags, long EMBG, User owner, String carPlate) {
    117         Transport t=getTransportById(transportID);
    118         t.setTransportName(transportName);
    119         t.setCarBrand(carBrand);
    120         t.setCarType(carType);
    121         t.setCarManufacturedYear(carManufacturedYear);
    122         t.setNoPassengers(noPassengers);
    123         t.setNoBags(noBags);
    124         t.setEMBG(EMBG);
    125         t.setOwner(owner);
    126         t.setCarPlate(carPlate);
     128    public void editTransport(Transport t) {
    127129        em.persist(t);
    128130    }
    … …  
    150152
    151153    @Override
    152     public List<TransportRoute> getTransportsAvailableByFilters(String fromL, String toL, Date date) {
     154    public List<TransportRoute> getTransportsAvailableByFilters(String fromL, String toL, Date date, int numPassengers) {
    153155        System.out.println(fromL + " " + toL);
    154         return em.createQuery("select h from TransportRoute h where h.from = :froml and h.to = :tol").setParameter("froml", fromL).
    155                 setParameter("tol", toL).getResultList();
     156        return em.createQuery("select h from TransportRoute h where h.from = :froml and h.to = :tol and h.freeSpace >= :nump")
     157                .setParameter("froml", fromL)
     158                .setParameter("tol", toL)
     159                .setParameter("nump", numPassengers)
     160                .getResultList();
    156161    }
    157162
    … …  
    168173    @Override
    169174    @Transactional
    170     public void createTransportAvailable(Transport transport, String departureLocation, String arrivalLocation, Date date, Integer noSeats, Date departureHour, Collection<TransportRoute> routes) {
    171         TransportAvailible ta=new TransportAvailible(transport,departureLocation,arrivalLocation,date,noSeats,departureHour);
     175    public void createTransportAvailable(TransportAvailible ta) {
    172176        em.persist(ta);
    173         List<TransportRoute> routes1 = routes.stream().toList();
    174         routes.forEach(x -> {
    175             createTransportRoute(ta, x.getFrom(), x.getTo(), x.getPrice(), x.getDeparture(), x.getArrival(), x.getFreeSpace(), x.getOrder());
    176         });
    177     }
    178 
    179     @Override
    180     @Transactional
    181     public void editTransportReservation(Transport transport, long reservationID, String departureLocation, String arrivalLocation, Date date, Integer noSeats, User user, Date departureHour)
    182     {
    183 //        TransportReservation tr=findTransportReservationByID(reservationID);
    184 //        tr.setTransport(transport);
    185 //        tr.setDepartureLocation(departureLocation);
    186 //        tr.setArrivalLocation(arrivalLocation);
    187 //        tr.setDate(date);
    188 //        tr.setNoSeats(noSeats);
    189 //        tr.setUser(user);
    190 //        tr.setDepartureHour(departureHour);
    191 //        em.persist(tr);
    192     }
    193 
    194     @Override
    195     public void editTransportAvailable(Transport transport, long availableID, String departureLocation, String arrivalLocation, Date date, Integer noSeats, Date departureHour) {
    196         TransportAvailible ta=findTransportAvailableByID(availableID);
    197         ta.setTransport(transport);
    198         ta.setFrom(departureLocation);
    199         ta.setTo(arrivalLocation);
    200         ta.setDate(date);
    201         ta.setFreeSpace(noSeats);
    202         ta.setTime(departureHour);
     177
     178    }
     179
     180    @Override
     181    public void editTransportAvailable(TransportAvailible ta) {
    203182        em.persist(ta);
    204183    }
    … …  
    224203    }
    225204
     205    @Transactional
     206    @Override
     207    public void saveReservation(TransportReservation transportReservation) {
     208        em.persist(transportReservation);
     209    }
     210
    226211    @Override
    227212    public List<TransportReservation> findReservationByUser(User user) {
    … …  
    235220    @Override
    236221    @Transactional
    237     public void deleteTransportReservation(long reservationID) {
    238         TransportReservation tr=findTransportReservationByID(reservationID);
     222    public void deleteTransportReservation(TransportReservation tr) {
    239223        em.remove(tr);
    240224    }
    … …  
    242226    @Override
    243227    @Transactional
    244     public void deleteTransportAvailable(long availableID) {
    245         TransportAvailible ta=findTransportAvailableByID(availableID);
     228    public void deleteTransportAvailable(TransportAvailible ta) {
    246229        em.remove(ta);
    247230    }
    248231
    249232    @Override
    250     public void createTransportRoute(TransportAvailible parentRoute, String from, String to, double price, Date departure, Date arrival, int freeSpace, int order) {
    251         TransportRoute tr = new TransportRoute(parentRoute, from, to, price, departure, arrival, freeSpace, order);
     233    @Transactional
     234    public void createTransportRoute(TransportRoute tr) {
    252235        em.persist(tr);
    253236    }
    254237
    255238    @Override
    256     public void deleteTransportRoute(long transportRouteId) {
    257         TransportRoute tr = findTransportRouteById(transportRouteId);
     239    public void deleteTransportRoute(TransportRoute tr) {
    258240        em.remove(tr);
    259241    }
    260242
    261243    @Override
    262     public void editTransportRoute(long transportRouteId, TransportAvailible parentRoute, String from, String to, double price, Date departure, Date arrival, int freeSpace, int order) {
    263         TransportRoute tr = findTransportRouteById(transportRouteId);
    264         tr.setParentRoute(parentRoute);
    265         tr.setFrom(from);
    266         tr.setTo(to);
    267         tr.setPrice(price);
    268         tr.setDeparture(departure);
    269         tr.setArrival(arrival);
    270         tr.setFreeSpace(freeSpace);
    271         tr.setOrder(order);
     244    public void editTransportRoute(TransportRoute tr) {
    272245        em.persist(tr);
    273246
    274247    }
    275248
     249    @Override
     250    public List<TransportReservation> findTransportReservationByTransportId(Transport t) {
     251        return em.createQuery("SELECT tr from TransportReservation tr where tr.transportRoute.parentRoute.transport= :transport")
     252                .setParameter("transport", t)
     253                .getResultList();
     254    }
     255
    276256
    277257}

  • src/main/java/com/tourMate/dao/impl/UsersDaoImpl.java

    r5528b99 r07f4e8b  
    2828    @Override
    2929    public void createUser(String name, String surname, String email, Date birthDate, String address, String contact) {
    30         Role r = em.find(Role.class, 1);
     30        Role r = em.find(Role.class, 2);
    3131        User user = new User(name, surname, email, passwordEncoder.encode("password"), birthDate, address, contact, r);
    3232        em.persist(user);
    … …  
    7474    }
    7575
     76    @Override
     77    public List<User> getUnapprovedUsers() {
     78        return em.createQuery("select u from User u where not u.enabled").getResultList();
     79    }
     80
     81    @Override
     82    @Transactional
     83    public void approveUserProfile(User u) {
     84        u.setEnabled(true);
     85        em.persist(u);
     86    }
     87
     88    @Override
     89    public Role findById(Long id) {
     90        return em.find(Role.class, id);
     91    }
     92
     93    @Override
     94    @Transactional
     95    public void updateUser(User s) {
     96        em.persist(s);
     97    }
    7698
    7799

  • src/main/java/com/tourMate/dto/HotelReservationUserDto.java

    r5528b99 r07f4e8b  
    77
    88public class HotelReservationUserDto {
     9    private Long reservationId;
    910    private User user;
    1011    private HotelRoom hotelRoom;
    … …  
    2021    private Boolean reviewed;
    2122
    22     public HotelReservationUserDto(User user, HotelRoom hotelRoom, Date dateFrom, Date dateTo, Integer numBeds, String hotelName, String hotelLocation, String hotelAddress, Long hotelId, Boolean reviewed) {
     23    public HotelReservationUserDto(Long reservationId, User user, HotelRoom hotelRoom, Date dateFrom, Date dateTo, Integer numBeds, String hotelName, String hotelLocation, String hotelAddress, Long hotelId, Boolean reviewed) {
     24        this.reservationId = reservationId;
    2325        this.user = user;
    2426        this.hotelRoom = hotelRoom;
    … …  
    3133        this.hotelId = hotelId;
    3234        this.reviewed = reviewed;
     35    }
     36
     37    public Long getReservationId() {
     38        return reservationId;
    3339    }
    3440

  • src/main/java/com/tourMate/dto/RestaurantDto.java

    r5528b99 r07f4e8b  
    55import java.util.ArrayList;
    66import java.util.Collection;
     7import java.util.List;
    78
    89public class RestaurantDto {
    … …  
    1415    private String restaurantEdbs;
    1516    private Collection<Menu> menus = new ArrayList<Menu>();
     17    private Collection<MenuImages> menuImages;
    1618    private Collection<RestaurantsAvailible> tables;
    1719    private Collection<Reviews> reviews;
    1820    private double averageScore;
    1921    private Collection<RestaurantImages> images;
    20     public RestaurantDto(long restaurantID, String restaurantName, String restaurantLocation, String cousineType, String restaurantDescription, String restaurantEdbs, Collection<Menu> menus, Collection<RestaurantsAvailible> tables, Collection<Reviews> reviews, double averageScore, Collection<RestaurantImages> images) {
     22
     23    public RestaurantDto(long restaurantID, String restaurantName, String restaurantLocation, String cousineType, String restaurantDescription, String restaurantEdbs, Collection<Menu> menus, Collection<RestaurantsAvailible> tables, Collection<Reviews> reviews, double averageScore, Collection<RestaurantImages> images, Collection<MenuImages> menuImages) {
    2124        this.restaurantID = restaurantID;
    2225        this.restaurantName = restaurantName;
    … …  
    3033        this.averageScore = averageScore;
    3134        this.images = images;
     35        this.menuImages = menuImages;
     36    }
     37    public Collection<MenuImages> getMenuImages() {
     38        return menuImages;
    3239    }
    3340
    … …  
    119126        this.images = images;
    120127    }
     128
    121129}

  • src/main/java/com/tourMate/dto/RestaurantReservationUserDto.java

    r5528b99 r07f4e8b  
    88
    99public class RestaurantReservationUserDto {
     10    private Long reservationId;
    1011    private User user;
    1112    private RestaurantsTable restaurantsTable;
    … …  
    2122    private Boolean reviewed;
    2223
    23     public RestaurantReservationUserDto(User user, RestaurantsTable restaurantsTable, Date dateFrom, Date dateTo, Integer numPeople, String restaurantName, String restaurantLocation, String restaurantAddress, Long restaurantId, Boolean reviewed) {
     24    public RestaurantReservationUserDto(Long reservationId, User user, RestaurantsTable restaurantsTable, Date dateFrom, Date dateTo, Integer numPeople, String restaurantName, String restaurantLocation, String restaurantAddress, Long restaurantId, Boolean reviewed) {
     25        this.reservationId = reservationId;
    2426        this.user = user;
    2527        this.restaurantsTable = restaurantsTable;
    … …  
    3234        this.restaurantId = restaurantId;
    3335        this.reviewed = reviewed;
     36    }
     37
     38    public Long getReservationId() {
     39        return reservationId;
    3440    }
    3541

  • src/main/java/com/tourMate/dto/RouteListingDto.java

    r5528b99 r07f4e8b  
    1818    private Date time;
    1919    private Collection<String> routes;
     20    private Double maxPrice;
    2021
    21     public RouteListingDto(long transportAvailibleId, String from, String to, Date date, int freeSpace, Date time, Collection<TransportRoute> routes) {
     22    public RouteListingDto(long transportAvailibleId, String from, String to, Date date, int freeSpace, Date time, Collection<TransportRoute> routes, Double maxPrice) {
    2223        this.transportAvailibleId = transportAvailibleId;
    2324        this.from = from;
    … …  
    2728        this.time = time;
    2829        this.routes = routes.stream().map(x -> x.getFrom()).distinct().skip(1).toList();
     30        this.maxPrice = maxPrice;
    2931    }
    3032
    … …  
    8486        this.routes = routes;
    8587    }
     88
     89    public Double getMaxPrice() {
     90        return maxPrice;
     91    }
    8692}

  • src/main/java/com/tourMate/dto/TransportDto.java

    r5528b99 r07f4e8b  
    1616    private User owner;
    1717    private String carPlate;
     18    private Double maxPrice;
    1819    private Collection<RouteListingDto> availableRoutes;
    1920
    20     public TransportDto(long transportID, String transportName, String carBrand, String carType, int carManufacturedYear, int noPassengers, int noBags, long EMBG, User owner, String carPlate, Collection<RouteListingDto> availableRoutes) {
     21    public TransportDto(long transportID, String transportName, String carBrand, String carType, int carManufacturedYear, int noPassengers, int noBags, long EMBG, User owner, String carPlate, Collection<RouteListingDto> availableRoutes, Double maxPrice) {
    2122        this.transportID = transportID;
    2223        this.transportName = transportName;
    … …  
    3031        this.carPlate = carPlate;
    3132        this.availableRoutes = availableRoutes;
     33        this.maxPrice = maxPrice;
    3234    }
    3335

  • src/main/java/com/tourMate/dto/TransportReservationUserDto.java

    r5528b99 r07f4e8b  
    1010
    1111public class TransportReservationUserDto {
     12    private Long reservationId;
    1213    private User user;
    1314    private TransportRoute transportRoute;
    … …  
    1920    private Boolean reviewed;
    2021
    21     public TransportReservationUserDto(User user, TransportRoute transportRoute, Long transportId, Integer numPeople, String carBrand, String carType, User owner, Boolean reviewed) {
     22    public TransportReservationUserDto(Long reservationId, User user, TransportRoute transportRoute, Long transportId, Integer numPeople, String carBrand, String carType, User owner, Boolean reviewed) {
     23        this.reservationId = reservationId;
    2224        this.user = user;
    2325        this.transportRoute = transportRoute;
    … …  
    2830        this.owner = owner;
    2931        this.reviewed = reviewed;
     32    }
     33    public Long getReservationId() {
     34        return reservationId;
    3035    }
    3136

  • src/main/java/com/tourMate/entities/Business.java

    r5528b99 r07f4e8b  
    8888    }
    8989
    90     @OneToOne(fetch = FetchType.LAZY)
     90    @OneToOne(fetch = FetchType.EAGER)
    9191    @JoinColumn(name = "owner_id", unique = false, nullable = false, foreignKey = @ForeignKey(name = "fk_ref_od_biznis_kon_korisnik"))
    9292    public User getUser() {
    … …  
    107107        this.approved = approved;
    108108    }
     109
    109110}

  • src/main/java/com/tourMate/entities/HotelRoom.java

    r5528b99 r07f4e8b  
    1 <<<<<<< HEAD
    21package com.tourMate.entities;
    32
    … …  
    160159    }
    161160}
    162 =======
    163 package com.tourMate.entities;
    164 
    165 import jakarta.persistence.*;
    166 import com.fasterxml.jackson.annotation.JsonIgnore;
    167 
    168 import javax.validation.constraints.NotNull;
    169 
    170 @Entity
    171 @Table(name="hotel_rooms", schema = "public")
    172 public class HotelRoom {
    173     private long hotelRoomId;
    174     @JsonIgnore
    175     private Hotels hotel;
    176     private String hotelRoomDescription;
    177     @Enumerated(EnumType.STRING)
    178     private String hotelRoomName;
    179     private double price;
    180     private Boolean kitchenAvailable;
    181     private Boolean airConditioning;
    182     private Boolean balcony;
    183 
    184     public HotelRoom(long hotelRoomId, Hotels hotel, String hotelRoomDescription, String hotelRoomName, double price, Boolean kitchenAvailable, Boolean airConditioning, Boolean balcony) {
    185         this.hotelRoomId = hotelRoomId;
    186         this.hotel = hotel;
    187         this.hotelRoomDescription = hotelRoomDescription;
    188         this.hotelRoomName = hotelRoomName;
    189         this.price = price;
    190         this.kitchenAvailable = kitchenAvailable;
    191         this.airConditioning = airConditioning;
    192         this.balcony = balcony;
    193     }
    194 
    195     public HotelRoom(Hotels hotel, String hotelRoomDescription, String type,
    196                      Boolean kitchenAvailable, Boolean airConditioning, Boolean balcony, double price) {
    197         this.hotel = hotel;
    198         this.hotelRoomDescription = hotelRoomDescription;
    199         this.hotelRoomName = type;
    200         this.kitchenAvailable = kitchenAvailable;
    201         this.airConditioning = airConditioning;
    202         this.balcony = balcony;
    203         this.price = price;
    204     }
    205 
    206     public HotelRoom(String hotelRoomDescription, String type,
    207                      Boolean kitchenAvailable, Boolean airConditioning, Boolean balcony, double price) {
    208         this.hotel = hotel;
    209         this.hotelRoomDescription = hotelRoomDescription;
    210         this.hotelRoomName = type;
    211         this.kitchenAvailable = kitchenAvailable;
    212         this.airConditioning = airConditioning;
    213         this.balcony = balcony;
    214         this.price = price;
    215     }
    216 
    217     public HotelRoom() {
    218 
    219     }
    220 
    221     @Id
    222     @GeneratedValue(strategy = GenerationType.IDENTITY)
    223     @Column(name = "room_id",unique = true,nullable = false)
    224     public long getHotelRoomId() {
    225         return hotelRoomId;
    226     }
    227 
    228     public void setHotelRoomId(long hotelRoomId) {
    229         this.hotelRoomId = hotelRoomId;
    230     }
    231 
    232     @ManyToOne(fetch = FetchType.LAZY)
    233     @JoinColumn(name = "hotel_id", unique = false, nullable = false, foreignKey = @ForeignKey(name = "fk_ref_od_room_kon_hotel"))
    234     public Hotels getHotel() {
    235         return hotel;
    236     }
    237 
    238     public void setHotel(Hotels hotelId) {
    239         this.hotel = hotelId;
    240     }
    241 
    242     @Column(name="hotel_room_description",unique = false,nullable = false)
    243     @NotNull
    244     public String getHotelRoomDescription() {
    245         return hotelRoomDescription;
    246     }
    247 
    248     public void setHotelRoomDescription(String hotelRoomDescription) {
    249         this.hotelRoomDescription = hotelRoomDescription;
    250     }
    251 
    252     @Column(name="hotel_room_price",unique = false,nullable = false)
    253     @NotNull
    254     public double getPrice() {
    255         return price;
    256     }
    257 
    258     @Column(name="hotel_room_name",unique = false,nullable = false)
    259     @NotNull
    260     public String getHotelRoomName() {
    261         return hotelRoomName;
    262     }
    263 
    264 
    265     public void setHotelRoomName(String name) {
    266         this.hotelRoomName = name;
    267     }
    268     public void setPrice(double type) {
    269         this.price = type;
    270     }
    271     @Column(name="hotel_room_kitchen",unique = false,nullable = false)
    272     @NotNull
    273     public Boolean getKitchenAvailable() {
    274         return kitchenAvailable;
    275     }
    276 
    277     public void setKitchenAvailable(Boolean kitchenAvailable) {
    278         this.kitchenAvailable = kitchenAvailable;
    279     }
    280     @Column(name="hotel_room_ac",unique = false,nullable = false)
    281     @NotNull
    282     public Boolean getAirConditioning() {
    283         return airConditioning;
    284     }
    285 
    286     public void setAirConditioning(Boolean airConditioning) {
    287         this.airConditioning = airConditioning;
    288     }
    289     @Column(name="hotel_room_balcony",unique = false,nullable = false)
    290     @NotNull
    291     public Boolean getBalcony() {
    292         return balcony;
    293     }
    294 
    295     public void setBalcony(Boolean balcony) {
    296         this.balcony = balcony;
    297     }
    298 }
    299 >>>>>>> parent of ac19a0c (authContext impl, admin panel impl, search bar fixes, reservations listings impl)

  • src/main/java/com/tourMate/entities/HotelRoomReservations.java

    r5528b99 r07f4e8b  
    4343    }
    4444
    45     @ManyToOne(fetch = FetchType.LAZY)
     45    @ManyToOne(fetch = FetchType.EAGER)
    4646    @JoinColumn(name = "room_id", unique = false, nullable = false, foreignKey = @ForeignKey(name = "fk_ref_od_roomres_kon_room"))
    4747    public HotelRoom getHotelRoom() {
    … …  
    5959    }
    6060
    61     @OneToOne(fetch = FetchType.LAZY)
     61    @OneToOne(fetch = FetchType.EAGER)
    6262    @JoinColumn(name = "user_id", unique = false, nullable = false, foreignKey = @ForeignKey(name = "fk_ref_od_roomres_kon_user"))
    6363    public User getUser() {

  • src/main/java/com/tourMate/entities/RestaurantImages.java

    r5528b99 r07f4e8b  
    3131    }
    3232
    33     @ManyToOne(fetch = FetchType.LAZY)
     33    @ManyToOne(fetch = FetchType.EAGER)
    3434    @JoinColumn(name="restaurant_id",unique = false,nullable = false,foreignKey = @ForeignKey(name = "fk_ref_od_restimg_kon_restoran"))
    3535    public Restaurant getRestaurant() {

  • src/main/java/com/tourMate/entities/RestaurantReservations.java

    r5528b99 r07f4e8b  
    8282    }
    8383
    84     @ManyToOne(fetch = FetchType.LAZY)
     84    @ManyToOne(fetch = FetchType.EAGER)
    8585    @JoinColumn(name = "user_id", unique = false, nullable = false, foreignKey = @ForeignKey(name = "fk_ref_od_rezervacija_restoran_kon_korisnik"))
    8686    public User getUser() {

  • src/main/java/com/tourMate/entities/Reviews.java

    r5528b99 r07f4e8b  
    7575
    7676    @ManyToOne(fetch = FetchType.LAZY)
    77     @JoinColumn(name = "hotel_id", unique = false, nullable = false, foreignKey = @ForeignKey(name = "fk_ref_od_review_kon_hotel"))
     77    @JoinColumn(name = "hotel_id", unique = false, nullable = true, foreignKey = @ForeignKey(name = "fk_ref_od_review_kon_hotel"))
    7878    public Hotels getHotel () {
    7979        return hotel;
    … …  
    8585
    8686    @ManyToOne(fetch = FetchType.LAZY)
    87     @JoinColumn(name = "restaurant_id", unique = false, nullable = false, foreignKey = @ForeignKey(name = "fk_ref_od_review_kon_restorani"))
     87    @JoinColumn(name = "restaurant_id", unique = false, nullable = true, foreignKey = @ForeignKey(name = "fk_ref_od_review_kon_restorani"))
    8888    public Restaurant getRestaurant () {
    8989        return restaurant;
    … …  
    9595
    9696    @ManyToOne(fetch = FetchType.LAZY)
    97     @JoinColumn(name = "transport_id", unique = false, nullable = false, foreignKey = @ForeignKey(name = "fk_ref_od_review_kon_transport"))
     97    @JoinColumn(name = "transport_id", unique = false, nullable = true, foreignKey = @ForeignKey(name = "fk_ref_od_review_kon_transport"))
    9898    public Transport getTransport () {
    9999        return transport;

  • src/main/java/com/tourMate/entities/User.java

    r5528b99 r07f4e8b  
    5252    private Role role;
    5353    @Column(name = "locked", unique = false, nullable = false)
    54     boolean locked;
     54    boolean locked = false;
    5555
    5656    @Column(name = "enabled", unique = false, nullable = false)
    … …  
    9696    }
    9797
     98    public boolean isLocked() {
     99        return locked;
     100    }
    98101
    99102    public long getUserID() {
    … …  
    162165    @Override
    163166    public boolean isAccountNonLocked() {
    164         return true;
     167        return locked;
    165168    }
    166169

  • src/main/java/com/tourMate/services/BusinessManager.java

    r5528b99 r07f4e8b  
    88    public void createBusiness(Business business, long userId);
    99    public List<Business> getUnapprovedBusinessesOfUser(long userId);
    10     public void deleteBusiness(long businessId);
    11     public List<Business> getCreatedBusinesses();
     10
     11    void deleteBusiness(long businessId);
     12
     13    public List<Business> getUnapprovedBusinesses();
     14    public void approveBusiness(Long businessId);
    1215    public Business findBusinessById (long businessId);
    13     public void editBusiness(long businessId, String name, String phone, String address, String edbs, User user, boolean approved);
    1416    public boolean hasBusiness(long userId);
     17
     18    void editBusiness(long businessId, String name, String phone, String address, String edbs, User user, boolean approved);
    1519}

  • src/main/java/com/tourMate/services/HotelManager.java

    r5528b99 r07f4e8b  
    22
    33import com.tourMate.dto.HotelDto;
     4import com.tourMate.dto.HotelReservationDto;
     5import com.tourMate.dto.HotelReservationUserDto;
    46import com.tourMate.entities.*;
    5 import org.springframework.web.multipart.MultipartFile;
    67
    78import java.util.Date;
    89import java.util.List;
    9 import java.util.Map;
    1010
    1111public interface HotelManager {
    … …  
    2424    public List<HotelRoom> getRoomsOfHotel (long hotelId);
    2525    public HotelRoom findRoomById (long hotelRoomId);
    26 <<<<<<< HEAD
    2726    public List<HotelRoomImages> getRoomImages(Long hotelRoom);
    2827    public void createRoom(Hotels hotel, String hotelRoomDescription, String hotelRoomName, Boolean kitchenAvailable, Boolean airConditioning, Boolean balcony, double price, int numOfBeds);
    29 =======
    30     public List<HotelRoomImages> getRoomImages(HotelRoom hotelRoom);
    31     public void createRoom(Hotels hotel, String hotelRoomDescription, String hotelRoomName, Boolean kitchenAvailable, Boolean airConditioning, Boolean balcony, double price);
    32 >>>>>>> parent of ac19a0c (authContext impl, admin panel impl, search bar fixes, reservations listings impl)
    3328    public void editRoom(long hotelRoomId, Hotels hotel, String hotelRoomDescription, String hotelRoomName, Boolean kitchenAvailable, Boolean airConditioning, Boolean balcony, double price);
    3429    public void deleteRoom(long hotelRoomId);
    35     public List<HotelRoomAvailable> getRoomsAvailable(Long id);
    3630    public void createRoomAvailible(HotelRoom hotelRoom, Date dateFrom, Date dateTo, int numberOfBeds);
    3731    public void editRoomAvailible(long hotelRoomAvailableId, HotelRoom hotelRoom, Date dateFrom, Date dateTo, int numberOfBeds);
    … …  
    4034    public HotelRoomAvailable findAvailibleRoomById(long hotelRoomAvailableId);
    4135    public List<HotelRoomAvailable> getRoomsAvailibility();
     36    public List<HotelRoomAvailable> getRoomsAvailableById(Long id);
    4237    public List<HotelRoomAvailable> getRoomsAvailibilityByHotel(Hotels hotel);
    43     public List<HotelDto> getRoomsAvailibilityByDateAndLocation(String hotelLocation, Date dateFrom, Date dateTo, int numberOfBeds);
     38    public List<HotelDto> getRoomsAvailibilityByDateAndLocation(String hotelLocation, Date dateFrom, Date dateTo, int numberOfBeds, Boolean flexible);
    4439    public void createReservation(Long userId, Long hotelRoomId, Long hotelRoomAvailableId, Date dateFrom, Date dateTo, Integer numberOfBeds);
    4540    public void editReservation(long hotelRoomReservedId, User user, HotelRoom hotelRoom, Date dateFrom, Date dateTo, Integer numberOfBeds);
    4641    public void deleteReservation(long hotelRoomReservedId);
     42    public List<HotelReservationDto> findVaidReseravtionsByHotel(Long hotelId);
     43    public List<HotelReservationUserDto> findValidHotelReservationsByUser(Long userId);
    4744    public HotelRoomReservations findReservationById(long hotelRoomReservedId);
    4845    public List<HotelRoomReservations> findReservationByUser(User user);
    … …  
    5451
    5552    void addRoomImage(Long id, List<String> filesToAdd);
     53    void setReservationReviewed(Long reservationId);
    5654}

  • src/main/java/com/tourMate/services/RestaurantManager.java

    r5528b99 r07f4e8b  
    22
    33import com.tourMate.dto.RestaurantDto;
     4import com.tourMate.dto.RestaurantReservationDto;
    45import com.tourMate.dto.RestaurantReservationUserDto;
    56import com.tourMate.entities.*;
    … …  
    1011public interface RestaurantManager {
    1112    public void createRestaurant(Restaurant restaurant, long userId);
    12     public void deleteRestaurant(long restaurantID);
     13
    1314    public void addMenuToRestaurant(long restaurantId, Menu menu);
     15
    1416    public List<Restaurant> getRestaurantsByUser(long userId);
    15     void deleteHotel(long restaurantID);
     17    public void deleteRestaurant(Long restaurantID);
     18
     19    void deleteRestaurant(long restaurantID);
    1620
    1721    public List<Restaurant> getRestaurants();
    18     public Restaurant findRestaurantByID (long restaurantID);
     22
     23    public Restaurant findRestaurantByID(long restaurantID);
     24
    1925    public void addRestaurantImage(Long restaurant, List<String> url);
     26
    2027    public void removeRestaurantImage(long restaurantImageId);
     28
    2129    public RestaurantImages findRestaurantImageById(long restaurantImageId);
    2230
    2331    public List<RestaurantImages> getRestaurantImages(long restaurantID);
     32
    2433    public void editRestaurant(long restaurantID, String restaurantName, String restaurantLocation, String cousineType, String restaurantDescription, String restaurantEdbs, User restaurantOwner);
     34
     35    void editReservation(long restaurantsTableId, RestaurantsTable rt, Date hourFrom, Date hourTo, int noSeats, User user);
     36
    2537    public List<RestaurantsTable> getRestaurantTables(long restaurantID);
    26     public List<RestaurantDto> getTablesByDateAndLocation(String restaurantLocation, Date hourFrom, Date hourTo, int noSeats );
     38
     39    public List<RestaurantDto> getTablesByDateAndLocation(String restaurantLocation, Date hourFrom, Date hourTo, int noSeats);
     40
    2741    public RestaurantsTable findTableById(long tableId);
     42
    2843    public void createTable(Long restaurantId, int noSeats);
     44
    2945    public void editTable(Restaurant restaurant, long tableId, int noSeats);
     46
    3047    public void deleteTable(long tableId);
    3148
    32     public void createTableAvailable(Long rt, Date hourFrom, Date hourTo);
     49    public void createTableAvailable(Long rt, Date hourFrom, Date hourTo, int numTables);
    3350
    3451    public void editTableAvailable(long tableId, Restaurant restaurant, int noSeats);
     52
    3553    public void deleteTableAvailable(long tableId);
    36     public List<RestaurantsTable> getTablesAvailability();
     54
    3755    public List<RestaurantsAvailible> getTablesAvailabilityById(Long id);
    38     public void createReservation(Restaurant restaurant, int noSeats);
     56
     57    RestaurantsAvailible findAvailableReservationByID(long tableId);
    3958
    4059    void createReservation(RestaurantsTable rt, Date dateFrom, Date dateTo, User user);
    4160
    42     public void editReservation(long tableId, Restaurant restaurant, int noSeats);
    4361    public void deleteReservation(long tableId);
     62
    4463    public RestaurantReservations findReservationByID(long tableId);
    45     public List<RestaurantReservations> findAvailableReservationByID();
    4664
    47     List<RestaurantReservations> findAvailableReservationByID(long reservationId);
     65//    List<RestaurantReservations> findAvailableReservationByID(long reservationId);
    4866
    4967    public List<RestaurantReservations> findReservationByUser(User user);
    50     public List<RestaurantReservations> findReservationByRestaurant(Restaurant restaurant);
     68
     69    public List<RestaurantReservationDto> findReservationByRestaurant(Long restaurant);
     70
    5171    public List<RestaurantReservations> getReservations();
     72
    5273    public List<Restaurant> searchByRestaurantName(String restaurantName);
     74
    5375    public List<Restaurant> searchByRestaurantLocation(String restaurantLocation);
     76
    5477    public List<RestaurantsTable> searchByNoSeats(int noSeats);
    5578
    … …  
    6184
    6285    List<RestaurantReservationUserDto> findPastRestaurantReservationsByUser(Long userId);
     86
     87    List<MenuImages> getMenuImages(Long id);
     88
     89    void addMenuImage(Long restaurant, List<String> url);
     90
     91    Menu findMenuById(Long menuId);
     92
     93    void setReservationReviewed(Long reservationId);
     94
     95    List<MenuImages> getMenuImagesByRestaurant(long restaurantId);
    6396}

  • src/main/java/com/tourMate/services/ReviewManager.java

    r5528b99 r07f4e8b  
    99public interface ReviewManager{
    1010
    11     public void createReview(String title, int numStar, String description, Long hotel, Long restaurant, Long transport);
     11    public void createReview(String title, int numStar, String description, Long hotel, Long restaurant, Long transport, Long reservationId);
    1212    public void deleteReview(long id);
    1313    public Reviews findReviewById(long id);

  • src/main/java/com/tourMate/services/TransportManager.java

    r5528b99 r07f4e8b  
    1313public interface TransportManager {
    1414
    15     public void createTransport(String transportName, String carBrand, String carType, int carManufacturedYear, int noPassengers, int noBags, long EMBG, User owner, String carPlate);
     15    public void createTransport(String transportName, String carBrand, String carType, int carManufacturedYear, int noPassengers, int noBags, long EMBG, Long userId, String carPlate);
    1616
    1717    public void deleteTransport(long transportId);
    … …  
    3030    public TransportReservation findTransportReservationByID(long reservationID);
    3131
     32    List<TransportReservation> findTransportReservationByTransportId(long reservationID);
     33
    3234    public List<TransportReservation> getTransportReservations();
    3335
    … …  
    3537    public Transport getTransportById(long transportId);
    3638
    37 <<<<<<< HEAD
    3839    List<Reviews> getReviewsForTransport(long transportId);
    3940
    4041    public List<TransportListingDto> getTransportsAvailableByFilters (String from, String to, Date date, int numPassengers);
    41 =======
    42     public List<TransportListingDto> getTransportsAvailableByFilters (String from, String to, Date date);
    43 >>>>>>> parent of ac19a0c (authContext impl, admin panel impl, search bar fixes, reservations listings impl)
    4442
    4543    public List<TransportReservation> getTransportsReservationsByUserID(long userID);
    … …  
    4846
    4947    public void createTransportAvailable(Transport transport, String departureLocation, String arrivalLocation, Date date, Integer noSeats, Date departureHour, Collection<TransportRoute> routes);
    50 
    51     public void editTransportReservation(Transport transport, long reservationID, String departureLocation, String arrivalLocation, Date date, Integer noSeats, User user, Date departureHour);
    52 
    5348    public void editTransportAvailable(Transport transport, long availableID, String departureLocation, String arrivalLocation, Date date, Integer noSeats, Date departureHour);
    5449
    … …  
    6762
    6863    List<TransportReservationUserDto> findPastTransportReservationsByUser(Long userId);
     64
     65    void setReservationReviewed(Long reservationId);
    6966}
    7067

  • src/main/java/com/tourMate/services/UsersManager.java

    r5528b99 r07f4e8b  
    1616
    1717    public void editUser(long userID, String name, String surname, String email, Date birthDate, String address, String contact);
     18    public List<User> getUnapprovedUsers();
     19    public void approveUserProfile(long userId);
     20
     21    void unlock(Long id);
    1822}

  • src/main/java/com/tourMate/services/impl/BusinessManagerImpl.java

    r5528b99 r07f4e8b  
    22
    33import com.tourMate.dao.BusinessDao;
     4import com.tourMate.dao.UsersDao;
    45import com.tourMate.entities.Business;
     6import com.tourMate.entities.Role;
    57import com.tourMate.entities.User;
    68import com.tourMate.services.BusinessManager;
     9import com.tourMate.services.UsersManager;
    710import org.springframework.beans.factory.annotation.Autowired;
    811import org.springframework.stereotype.Service;
    … …  
    1619    @Autowired
    1720    BusinessDao businessDao;
     21    @Autowired
     22    UsersDao usersDao;
     23    @Autowired
     24    UsersManager usersManager;
    1825
    1926    @Override
    2027    public void createBusiness(Business business, long userId) {
    21         businessDao.createBusiness(business, userId);
     28        User u = usersManager.findUserByID(userId);
     29        business.setUser(u);
     30        businessDao.createBusiness(business);
    2231    }
    2332
    2433    @Override
    2534    public List<Business> getUnapprovedBusinessesOfUser(long userId) {
    26         return businessDao.getUnapprovedBusinessesOfUser(userId);
     35        User u = usersManager.findUserByID(userId);
     36        return businessDao.getUnapprovedBusinessesOfUser(u);
    2737    }
    2838
    2939    @Override
    3040    public void deleteBusiness(long businessId) {
    31         businessDao.deleteBusiness(businessId);
     41        Business business = businessDao.findBusinessById(businessId);
     42        businessDao.deleteBusiness(business);
    3243
    3344    }
    3445
    3546    @Override
    36     public boolean hasBusiness(long userId){
    37         return businessDao.hasBusiness(userId);
     47    public List<Business> getUnapprovedBusinesses() {
     48        return businessDao.getUnapprovedBusinesses();
    3849    }
    3950
    4051    @Override
    41     public List<Business> getCreatedBusinesses() {
    42         return businessDao.getCreatedBusinesses();
     52    public void approveBusiness(Long businessId) {
     53        Business b = findBusinessById(businessId);
     54        b.setApproved(true);
     55        businessDao.approveBusiness(b);
     56        changeUserRoleBusiness(b.getUser().getUserID());
     57    }
     58
     59    private void changeUserRoleBusiness(Long userId)
     60    {
     61        User u = usersDao.findUserByID(userId);
     62        Role r = usersDao.findById(3L);
     63        u.setRole(r);
     64        usersDao.updateUser(u);
     65    }
     66
     67    @Override
     68    public boolean hasBusiness(long userId){
     69        User u = usersManager.findUserByID(userId);
     70        return businessDao.hasBusiness(u);
    4371    }
    4472
    … …  
    5078    @Override
    5179    public void editBusiness(long businessId, String name, String phone, String address, String edbs, User user, boolean approved) {
    52         businessDao.editBusiness(businessId, name, phone, address, edbs, user, approved);
     80        Business business = findBusinessById(businessId);
     81        business.setName(name);
     82        business.setPhone(phone);
     83        business.setAddress(address);
     84        business.setEdbs(edbs);
     85        business.setUser(user);
     86        business.setApproved(approved);
     87        businessDao.editBusiness(business);
    5388    }
    5489

  • src/main/java/com/tourMate/services/impl/HotelManagerImpl.java

    r5528b99 r07f4e8b  
    44import com.tourMate.dao.UsersDao;
    55import com.tourMate.dto.HotelDto;
     6import com.tourMate.dto.HotelReservationDto;
     7import com.tourMate.dto.HotelReservationUserDto;
    68import com.tourMate.entities.*;
    79import com.tourMate.services.HotelManager;
     10import com.tourMate.services.UsersManager;
    811import org.springframework.beans.factory.annotation.Autowired;
    912import org.springframework.stereotype.Service;
    10 import org.springframework.web.multipart.MultipartFile;
    1113
    1214import java.time.Duration;
    13 import java.util.Collection;
    1415import java.util.Date;
    1516import java.util.List;
    … …  
    2425    @Autowired
    2526    UsersDao usersDao;
    26 
     27    @Autowired
     28    UsersManager usersManager;
    2729
    2830    @Override
    … …  
    3335    @Override
    3436    public void createHotel(Hotels hotels, long userId) {
    35         hotelDao.createHotel(hotels, userId);
     37        User u = usersManager.findUserByID(userId);
     38        hotels.setOwner(u);
     39        hotelDao.createHotel(hotels);
    3640    }
    3741
    … …  
    3943    @Override
    4044    public List<Hotels> getHotels() {
    41         List<Hotels> hoteli = hotelDao.getHotels();
    4245        return hotelDao.getHotels();
    4346    }
    … …  
    4548    @Override
    4649    public List<Hotels> getHotelsForUser(long userId) {
    47         return hotelDao.getHotelsForUser(userId);
     50        User u = usersManager.findUserByID(userId);
     51        return hotelDao.getHotelsForUser(u);
    4852    }
    4953
    … …  
    5559    @Override
    5660    public void editHotel(long hotelId, String hotelName, String hotelDescripiton, String hotelLocation, String hotelEDBS, Boolean parking, Boolean petFriendly, Boolean internetAvailable) {
    57         hotelDao.editHotel(hotelId, hotelName, hotelDescripiton, hotelLocation, hotelEDBS, parking, petFriendly, internetAvailable);
     61        Hotels hotel = hotelDao.findHotelByID(hotelId);
     62        hotel.setHotelName(hotelName);
     63        hotel.setHotelDescripiton(hotelDescripiton);
     64        hotel.setHotelLocation(hotelLocation);
     65        hotel.setHotelEDBS(hotelEDBS);
     66        hotel.setParking(parking);
     67        hotel.setPetFriendly(petFriendly);
     68        hotel.setInternetAvailable(internetAvailable);
     69        hotelDao.editHotel(hotel);
    5870    }
    5971
    6072    @Override
    6173    public void deleteHotel(long hotelId) {
    62         hotelDao.deleteHotel(hotelId);
     74        Hotels h = findHotelByID(hotelId);
     75        hotelDao.deleteHotel(h);
    6376    }
    6477
    … …  
    7689    @Override
    7790    public List<HotelRoom> getRoomsOfHotel(long hotelId) {
    78         return hotelDao.getRoomsOfHotel(hotelId);
     91        Hotels h = findHotelByID(hotelId);
     92        return hotelDao.getRoomsOfHotel(h);
    7993    }
    8094
    … …  
    99113    @Override
    100114    public void deleteHotelImage(long hotelImageId){
    101         hotelDao.deleteHotelImage(hotelImageId);
     115        HotelsImages hotelsImages = findHotelImageById(hotelImageId);
     116        hotelDao.deleteHotelImage(hotelsImages);
    102117    }
    103118
    … …  
    108123
    109124    @Override
    110     public void createRoom(Hotels hotel, String hotelRoomDescription, String hotelRoomName, Boolean kitchenAvailable, Boolean airConditioning, Boolean balcony, double price) {
    111         hotelDao.createRoom(hotel, hotelRoomDescription, hotelRoomName, kitchenAvailable, airConditioning, balcony, price);
     125    public void createRoom(Hotels hotel, String hotelRoomDescription, String hotelRoomName, Boolean kitchenAvailable, Boolean airConditioning, Boolean balcony, double price, int numOfBeds) {
     126        HotelRoom hotelRoom = new HotelRoom(hotel, hotelRoomDescription, hotelRoomName, kitchenAvailable, airConditioning, balcony, price, numOfBeds);
     127        hotelDao.createRoom(hotelRoom);
    112128    }
    113129
    114130    @Override
    115131    public void editRoom(long hotelRoomId, Hotels hotel, String hotelRoomDescription, String hotelRoomName, Boolean kitchenAvailable, Boolean airConditioning, Boolean balcony, double price) {
    116         hotelDao.editRoom(hotelRoomId, hotel, hotelRoomDescription, hotelRoomName, kitchenAvailable, airConditioning, balcony, price);
     132        HotelRoom hr = findRoomById(hotelRoomId);
     133        hr.setHotel(hotel);
     134        hr.setHotelRoomDescription(hotelRoomDescription);
     135        hr.setHotelRoomName(hotelRoomName);
     136        hr.setKitchenAvailable(kitchenAvailable);
     137        hr.setAirConditioning(airConditioning);
     138        hr.setBalcony(balcony);
     139        hr.setPrice(price);
     140        hotelDao.editRoom(hr);
    117141    }
    118142
    119143    @Override
    120144    public void deleteRoom(long hotelRoomId) {
    121         hotelDao.deleteRoom(hotelRoomId);
    122     }
    123 
    124     @Override
    125     public List<HotelRoomAvailable> getRoomsAvailable(Long id) {
     145        HotelRoom hr = findRoomById(hotelRoomId);
     146        hotelDao.deleteRoom(hr);
     147    }
     148
     149
     150    @Override
     151    public List<HotelRoomAvailable> getRoomsAvailableById(Long id) {
    126152        return hotelDao.getRoomsAvailable(id);
    127153    }
    … …  
    129155    @Override
    130156    public void createRoomAvailible(HotelRoom hotelRoom, Date dateFrom, Date dateTo, int numberOfBeds) {
    131         hotelDao.createRoomAvailible(hotelRoom, dateFrom, dateTo, numberOfBeds);
     157        HotelRoomAvailable hra = new HotelRoomAvailable(hotelRoom, dateFrom, dateTo, numberOfBeds);
     158        hotelDao.createRoomAvailible(hra);
    132159    }
    133160
    134161    @Override
    135162    public void editRoomAvailible(long hotelRoomAvailableId, HotelRoom hotelRoom, Date dateFrom, Date dateTo, int numberOfBeds) {
    136         hotelDao.editRoomAvailible(hotelRoomAvailableId, hotelRoom, dateFrom, dateTo, numberOfBeds);
     163        HotelRoomAvailable hr = findAvailibleRoomById(hotelRoomAvailableId);
     164        hr.setHotelRoom(hotelRoom);
     165        hr.setDateFrom(dateFrom);
     166        hr.setDateTo(dateTo);
     167        hr.setNumberOfBeds(numberOfBeds);
     168        hotelDao.editRoomAvailible(hr);
    137169    }
    138170
    … …  
    142174        roomAvailable.setNumberOfBeds(numberOfBeds-1);
    143175        HotelRoom room = hotelDao.findRoomById(hotelRoomId);
    144         hotelDao.createRoomAvailible(room, roomAvailable.getDateFrom(), from, 1);
    145         hotelDao.createRoomAvailible(room, to, roomAvailable.getDateTo(), 1);
     176        HotelRoomAvailable hra = new HotelRoomAvailable(room,roomAvailable.getDateFrom(),from,1);
     177        hotelDao.createRoomAvailible(hra);
     178        HotelRoomAvailable hra1 = new HotelRoomAvailable(room,to,roomAvailable.getDateTo(),1);
     179        hotelDao.createRoomAvailible(hra1);
    146180    }
    147181
    148182    @Override
    149183    public void deleteRoomAvailible(long hotelRoomAvailableId) {
    150         hotelDao.deleteRoomAvailible(hotelRoomAvailableId);
     184        HotelRoomAvailable hra = findAvailibleRoomById(hotelRoomAvailableId);
     185        hotelDao.deleteRoomAvailible(hra);
    151186    }
    152187
    … …  
    167202
    168203    @Override
    169     public List<HotelDto> getRoomsAvailibilityByDateAndLocation(String hotelLocation, Date dateFrom, Date dateTo, int numberOfBeds) {
     204    public List<HotelDto> getRoomsAvailibilityByDateAndLocation(String hotelLocation, Date dateFrom, Date dateTo, int numberOfBeds, Boolean flexible) {
    170205        long numberOfNights = Duration.between(dateFrom.toInstant(), dateTo.toInstant()).toDays();
    171         List<HotelRoomAvailable> roomsAvailible = hotelDao.getRoomsAvailibilityByDateAndLocation(hotelLocation, dateFrom, dateTo, numberOfBeds);
     206        List<HotelRoomAvailable> roomsAvailible = hotelDao.getRoomsAvailibilityByDateAndLocation(hotelLocation, dateFrom, dateTo, numberOfBeds, flexible);
    172207        Map<Hotels, List<HotelRoomAvailable>> roomsByHotels = roomsAvailible.stream().collect(Collectors.groupingBy(x -> x.getHotelRoom().getHotel()));
    173208        List<HotelDto> hotelsList = roomsByHotels.keySet().stream()
    … …  
    195230        HotelRoom room = hotelDao.findRoomById(hotelRoomId);
    196231        User user = usersDao.findUserByID(userId);
    197         hotelDao.createReservation(user, room, dateFrom, dateTo, numberOfBeds);
     232        HotelRoomReservations r = new HotelRoomReservations(user, room, dateFrom, dateTo, numberOfBeds);
    198233        editRoomAvailibleReservation(hotelRoomAvailableId, hotelRoomId, dateFrom, dateTo, numberOfBeds);
     234        hotelDao.createReservation(r);
     235
    199236    }
    200237
    201238    @Override
    202239    public void editReservation(long hotelRoomReservedId, User user, HotelRoom hotelRoom, Date dateFrom, Date dateTo, Integer numberOfBeds) {
    203         hotelDao.editReservation(hotelRoomReservedId, user, hotelRoom, dateFrom, dateTo, numberOfBeds);
     240        HotelRoomReservations hr = findReservationById(hotelRoomReservedId);
     241        hr.setUser(user);
     242        hr.setHotelRoom(hotelRoom);
     243        hr.setDateFrom(dateFrom);
     244        hr.setDateTo(dateTo);
     245        hr.setNumberOfBeds(numberOfBeds);
     246        hotelDao.editReservation(hr);
    204247    }
    205248
    206249    @Override
    207250    public void deleteReservation(long hotelRoomReservedId) {
    208         hotelDao.deleteReservation(hotelRoomReservedId);
    209     }
    210 
    211     @Override
    212 <<<<<<< HEAD
     251        HotelRoomReservations r = findReservationById(hotelRoomReservedId);
     252        HotelRoomAvailable hra = new HotelRoomAvailable(r.getHotelRoom(), r.getDateFrom(), r.getDateTo(), r.getNumberOfBeds());
     253        hotelDao.createRoomAvailible(hra);
     254        hotelDao.deleteReservation(r);
     255    }
     256
     257    @Override
    213258    public List<HotelReservationDto> findVaidReseravtionsByHotel(Long hotelId) {
    214259        Hotels hotel = findHotelByID(hotelId);
    … …  
    230275        List<HotelRoomReservations> reservations = hotelDao.findReservationByUser(u);
    231276        return reservations.stream().map(x -> new HotelReservationUserDto(
     277                x.getHotelRoomReservedId(),
    232278                x.getUser(),
    233279                x.getHotelRoom(),
    … …  
    244290
    245291    @Override
    246 =======
    247 >>>>>>> parent of ac19a0c (authContext impl, admin panel impl, search bar fixes, reservations listings impl)
    248292    public HotelRoomReservations findReservationById(long hotelRoomReservedId) {
    249293        return hotelDao.findReservationById(hotelRoomReservedId);
    … …  
    276320        List<HotelRoomReservations> reservations = hotelDao.findPastReservationByUser(u);
    277321        return reservations.stream().map(x -> new HotelReservationUserDto(
     322                x.getHotelRoomReservedId(),
    278323                x.getUser(),
    279324                x.getHotelRoom(),
    … …  
    294339        filesToAdd.stream().map(file -> new HotelRoomImages(hr, file)).forEach(x -> hotelDao.addRoomImage(x));
    295340    }
     341
     342    @Override
     343    public void setReservationReviewed(Long reservationId) {
     344        HotelRoomReservations hotelRoomReservations = findReservationById(reservationId);
     345        hotelRoomReservations.setReviewed(true);
     346        hotelDao.saveReservation(hotelRoomReservations);
     347    }
    296348}

  • src/main/java/com/tourMate/services/impl/ImageManagerImpl.java

    r5528b99 r07f4e8b  
    5656            hotelManager.addRoomImage(id, filesToAdd);
    5757        }
     58        else if(type.equals("menu"))
     59        {
     60            restaurantManager.addMenuImage(id, filesToAdd);
     61        }
    5862
    5963        return filesToAdd;

  • src/main/java/com/tourMate/services/impl/MenuManagerImpl.java

    r5528b99 r07f4e8b  
    1717    @Override
    1818    public void createMenu(String name, String ingredients, double price) {
    19         menuDao.createMenu(name, ingredients, price);
     19        menuDao.createMenu(new Menu(name, ingredients, price));
    2020    }
    2121
    2222    @Override
    2323    public void deleteMenu(long menuId) {
    24         menuDao.deleteMenu(menuId);
     24        Menu menu = findMenuById(menuId);
     25        menuDao.deleteMenu(menu);
    2526    }
    2627
    … …  
    3738    @Override
    3839    public void editMenu(long menuId, String name, String ingredients, double price) {
    39         menuDao.editMenu(menuId, name, ingredients, price);
     40        Menu menu = findMenuById(menuId);
     41        menu.setName(name);
     42        menu.setIngredients(ingredients);
     43        menu.setPrice(price);
     44        menuDao.editMenu(menu);
    4045    }
    4146}

  • src/main/java/com/tourMate/services/impl/RestaurantManagerImpl.java

    r5528b99 r07f4e8b  
    33import com.tourMate.dao.RestaurantDao;
    44import com.tourMate.dto.RestaurantDto;
     5import com.tourMate.dto.RestaurantReservationDto;
    56import com.tourMate.dto.RestaurantReservationUserDto;
    67import com.tourMate.services.RestaurantManager;
    … …  
    2223    @Autowired
    2324    UsersManager usersManager;
     25
    2426    @Override
    2527    public void createRestaurant(Restaurant restaurant, long userId) {
    26         restaurantDao.createRestaurant(restaurant, userId);
    27     }
    28 
    29 
     28        User u = usersManager.findUserByID(userId);
     29        Restaurant r = new Restaurant(restaurant.getRestaurantName(), restaurant.getRestaurantLocation(), restaurant.getCousineType(), restaurant.getRestaurantDescription(), restaurant.getRestaurantEdbs(), u);
     30        restaurantDao.createRestaurant(r);
     31    }
     32
     33    @Override
     34    public void deleteRestaurant(Long restaurantID) {
     35        Restaurant r = findRestaurantByID(restaurantID);
     36        restaurantDao.deleteRestaurant(r);
     37    }
     38
     39    @Override
     40    public void addMenuToRestaurant(long restaurantId, Menu menu) {
     41        Restaurant r = findRestaurantByID(restaurantId);
     42        menu.setRestaurant(r);
     43        restaurantDao.addMenuToRestaurant(menu);
     44    }
     45
     46    @Override
     47    public List<Restaurant> getRestaurantsByUser(long userId) {
     48        User u = usersManager.findUserByID(userId);
     49        return restaurantDao.getRestaurantsByUser(u);
     50    }
    3051
    3152    @Override
    3253    public void deleteRestaurant(long restaurantID) {
    33         restaurantDao.deleteRestaurant(restaurantID);
    34     }
    35 
    36     @Override
    37     public void addMenuToRestaurant(long restaurantId, Menu menu) {
    38         restaurantDao.addMenuToRestaurant(restaurantId, menu);
    39     }
    40 
    41     @Override
    42     public List<Restaurant> getRestaurantsByUser(long userId) {
    43         return restaurantDao.getRestaurantsByUser(userId);
    44     }
    45 
    46     @Override
    47     public void deleteHotel(long restaurantID) {
    48         restaurantDao.deleteRestaurant(restaurantID);
     54        Restaurant r = findRestaurantByID(restaurantID);
     55        restaurantDao.deleteRestaurant(r);
    4956    }
    5057
    … …  
    6774    @Override
    6875    public void removeRestaurantImage(long restaurantImageId) {
    69         restaurantDao.removeRestaurantImage(restaurantImageId);
     76        RestaurantImages restaurantImage = findRestaurantImageById(restaurantImageId);
     77        restaurantDao.removeRestaurantImage(restaurantImage);
    7078    }
    7179
    … …  
    8189
    8290    @Override
    83     public List<RestaurantDto> getTablesByDateAndLocation(String restaurantLocation, Date hourFrom, Date hourTo, int noSeats){
     91    public List<RestaurantDto> getTablesByDateAndLocation(String restaurantLocation, Date hourFrom, Date hourTo, int noSeats) {
    8492        List<RestaurantsAvailible> restaurantsAvailibles = restaurantDao.getTablesByDateAndLocation(restaurantLocation, hourFrom, hourTo, noSeats);
    8593        Map<Restaurant, List<RestaurantsAvailible>> tablesByRestaurants = restaurantsAvailibles.stream().collect(Collectors.groupingBy(x -> x.getRestaurantTable().getRestaurant()));
    … …  
    96104                        getReviewsForRestaurant(x.getRestaurantID()),
    97105                        getReviewsForRestaurant(x.getRestaurantID()).stream().mapToDouble(Reviews::getNumStar).average().orElse(0),
    98                         getRestaurantImages(x.getRestaurantID())
     106                        getRestaurantImages(x.getRestaurantID()),
     107                        getMenuImagesByRestaurant(x.getRestaurantID())
    99108                )).toList();
    100109        return restaurantsList;
    … …  
    103112    @Override
    104113    public void editRestaurant(long restaurantID, String restaurantName, String restaurantLocation, String cousineType, String restaurantDescription, String restaurantEdbs, User restaurantOwner) {
    105         restaurantDao.editRestaurant(restaurantID, restaurantName, restaurantLocation, cousineType, restaurantDescription, restaurantEdbs, restaurantOwner);
     114        Restaurant res = findRestaurantByID(restaurantID);
     115        res.setRestaurantName(restaurantName);
     116        res.setRestaurantLocation(restaurantLocation);
     117        res.setRestaurantEdbs(restaurantEdbs);
     118        res.setRestaurantDescription(restaurantDescription);
     119        res.setRestaurantOwner(restaurantOwner);
     120        res.setCousineType(cousineType);
     121        restaurantDao.createRestaurant(res);
     122    }
     123
     124    @Override
     125    public void editReservation(long restaurantsTableId, RestaurantsTable rt, Date hourFrom, Date hourTo, int noSeats, User user){
     126        RestaurantReservations r = findReservationByID(restaurantsTableId);
     127        r.setTable(rt);
     128        r.setTimeFrom(hourFrom);
     129        r.setTimeTo(hourTo);
     130        r.setNoSeats(noSeats);
     131        r.setUser(user);
     132        restaurantDao.saveReservation(r);
    106133    }
    107134
    … …  
    119146    public void createTable(Long restaurantId, int noSeats) {
    120147        Restaurant r = restaurantDao.findRestaurantByID(restaurantId);
    121         restaurantDao.createTable(r, noSeats);
     148        RestaurantsTable restaurantsTable = new RestaurantsTable(r, noSeats);
     149        restaurantDao.saveTable(restaurantsTable);
    122150    }
    123151
    124152    @Override
    125153    public void editTable(Restaurant restaurant, long tableId, int noSeats) {
    126         restaurantDao.editTable(restaurant, tableId, noSeats);
     154        RestaurantsTable resTable = findTableById(tableId);
     155        resTable.setRestaurant(restaurant);
     156        resTable.setNoSeats(noSeats);
     157        restaurantDao.saveTable(resTable);
    127158    }
    128159
    129160    @Override
    130161    public void deleteTable(long tableId) {
    131         restaurantDao.deleteTable(tableId);
    132     }
    133 
    134     @Override
    135     public void createTableAvailable(Long rt, Date hourFrom, Date hourTo) {
     162        RestaurantsTable rt = findTableById(tableId);
     163        restaurantDao.deleteTable(rt);
     164    }
     165
     166    @Override
     167    public void createTableAvailable(Long rt, Date hourFrom, Date hourTo, int numTables) {
    136168        RestaurantsTable rtabl = findTableById(rt);
    137         restaurantDao.createTableAvailable(rtabl, hourFrom, hourTo);
    138     }
    139 
    140     @Override
    141     public List<RestaurantsAvailible> getTablesAvailabilityById(Long id)
    142     {
     169        RestaurantsAvailible ra = new RestaurantsAvailible(rtabl, hourFrom, hourTo, numTables);
     170        restaurantDao.saveTableAvailable(ra);
     171    }
     172
     173    @Override
     174    public List<RestaurantsAvailible> getTablesAvailabilityById(Long id) {
    143175        return restaurantDao.getTablesAvailabilityById(id);
    144176    }
    … …  
    146178    @Override
    147179    public void editTableAvailable(long tableId, Restaurant restaurant, int noSeats) {
    148         restaurantDao.editTableAvailable(tableId, restaurant, noSeats);
     180        RestaurantsTable rt = findTableById(tableId);
     181        rt.setRestaurant(restaurant);
     182        rt.setNoSeats(noSeats);
     183        restaurantDao.saveTable(rt);
    149184    }
    150185
    151186    @Override
    152187    public void deleteTableAvailable(long tableId) {
    153         restaurantDao.deleteTableAvailable(tableId);
    154     }
    155 
    156     @Override
    157     public List<RestaurantsTable> getTablesAvailability() {
    158         return null;
    159     }
    160 
    161     @Override
    162     public void createReservation(Restaurant restaurant, int noSeats) {
    163 
     188        RestaurantsAvailible ra = findAvailableReservationByID(tableId);
     189        restaurantDao.deleteTableAvailable(ra);
     190    }
     191
     192    @Override
     193    public RestaurantsAvailible findAvailableReservationByID(long tableId){
     194        return restaurantDao.findAvailableReservationByID(tableId);
    164195    }
    165196
    … …  
    170201    }
    171202
    172     @Override
    173     public void editReservation(long tableId, Restaurant restaurant, int noSeats) {
    174         //restaurantDao.editReservation(tableId, restaurant, noSeats);
    175     }
    176203
    177204    @Override
    178205    public void deleteReservation(long tableId) {
    179         restaurantDao.deleteReservation(tableId);
     206        RestaurantReservations r = findReservationByID(tableId);
     207        RestaurantsAvailible ra = new RestaurantsAvailible(r.getTable(), r.getTimeFrom(), r.getTimeTo(), r.getNoSeats());
     208        restaurantDao.saveTableAvailable(ra);
     209        restaurantDao.deleteReservation(r);
    180210    }
    181211
    182212    @Override
    183213    public RestaurantReservations findReservationByID(long tableId) {
    184         //return restaurantDao.findReservationByID(tableId);
    185         return null;
    186     }
    187 
    188     @Override
    189     public List<RestaurantReservations> findAvailableReservationByID() {
    190         return null;
    191     }
    192 
    193     @Override
    194     public List<RestaurantReservations> findAvailableReservationByID(long reservationId) {
    195         return null;
    196         // return restaurantDao.findAvailableReservationByID(reservationId);
     214        return restaurantDao.findReservationByID(tableId);
     215        //return null;
    197216    }
    198217
    … …  
    203222
    204223    @Override
    205     public List<RestaurantReservations> findReservationByRestaurant(Restaurant restaurant) {
    206         return restaurantDao.findReservationByRestaurant(restaurant);
     224    public List<RestaurantReservationDto> findReservationByRestaurant(Long restaurant) {
     225        Restaurant r = findRestaurantByID(restaurant);
     226        List<RestaurantReservations> res = restaurantDao.findReservationByRestaurant(r);
     227        return res.stream().map(x -> new RestaurantReservationDto(
     228                x.getUser(),
     229                x.getTable(),
     230                x.getTimeFrom(),
     231                x.getTimeTo()
     232        )).collect(Collectors.toList());
    207233    }
    208234
    … …  
    251277    }
    252278
    253     public void editTableAvailability(RestaurantsAvailible restaurantsAvailible, RestaurantsTable table, Date dateFrom, Date dateTo)
    254     {
     279    public void editTableAvailability(RestaurantsAvailible restaurantsAvailible, RestaurantsTable table, Date dateFrom, Date dateTo) {
    255280        restaurantsAvailible.setNumTables(restaurantsAvailible.getNumTables() - 1);
    256         restaurantDao.createTableAvailable(table, restaurantsAvailible.getHourFrom(), dateFrom, 1);
    257         restaurantDao.createTableAvailable(table, dateTo, restaurantsAvailible.getHourTo(), 1);
     281        RestaurantsAvailible ra1 = new RestaurantsAvailible(table, restaurantsAvailible.getHourFrom(), dateFrom, 1);
     282        RestaurantsAvailible ra2 = new RestaurantsAvailible(table, dateTo, restaurantsAvailible.getHourTo(), 1);
     283
     284        restaurantDao.saveTableAvailable(ra1);
     285        restaurantDao.saveTableAvailable(ra2);
    258286    }
    259287
    … …  
    263291        List<RestaurantReservations> reservations = restaurantDao.findReservationByUser(u);
    264292        return reservations.stream().map(x -> new RestaurantReservationUserDto(
     293                x.getReservationId(),
    265294                x.getUser(),
    266295                x.getTable(),
    … …  
    281310        List<RestaurantReservations> reservations = restaurantDao.findPastReservationsByUser(u);
    282311        return reservations.stream().map(x -> new RestaurantReservationUserDto(
     312                x.getReservationId(),
    283313                x.getUser(),
    284314                x.getTable(),
    … …  
    293323        )).toList();
    294324    }
     325
     326    @Override
     327    public List<MenuImages> getMenuImages(Long id) {
     328        return restaurantDao.getMenuImages(id);
     329    }
     330
     331    @Override
     332    public void addMenuImage(Long menuId, List<String> url) {
     333        Menu r = restaurantDao.findMenuId(menuId);
     334        url.stream().map(file -> new MenuImages(r, file)).forEach(x -> restaurantDao.addMenuImage(x));
     335    }
     336
     337    @Override
     338    public Menu findMenuById(Long menuId) {
     339        return restaurantDao.findMenuId(menuId);
     340    }
     341
     342    @Override
     343    public void setReservationReviewed(Long reservationId) {
     344        RestaurantReservations restaurantReservations = findReservationByID(reservationId);
     345        restaurantReservations.setReviewed(true);
     346        restaurantDao.saveReservation(restaurantReservations);
     347    }
     348
     349    @Override
     350    public List<MenuImages> getMenuImagesByRestaurant(long restaurantId) {
     351        Restaurant r = findRestaurantByID(restaurantId);
     352        return restaurantDao.getMenuImagesByRestaurant(r);
     353    }
    295354}

  • src/main/java/com/tourMate/services/impl/ReviewManagerImpl.java

    r5528b99 r07f4e8b  
    33import com.tourMate.dao.ReviewDao;
    44import com.tourMate.dao.ReviewManager;
    5 import com.tourMate.entities.Hotels;
    6 import com.tourMate.entities.Restaurant;
    7 import com.tourMate.entities.Reviews;
    8 import com.tourMate.entities.Transport;
     5import com.tourMate.entities.*;
    96import com.tourMate.services.HotelManager;
    107import com.tourMate.services.RestaurantManager;
    … …  
    2926
    3027    @Override
    31     public void createReview(String title, int numStar, String description, Long hotel, Long restaurant, Long transport) {
     28    public void createReview(String title, int numStar, String description, Long hotel, Long restaurant, Long transport, Long reservationId) {
    3229        Hotels h = null;
    3330        Restaurant r = null;
    … …  
    3633        {
    3734            h = hotelManager.findHotelByID(hotel);
     35            hotelManager.setReservationReviewed(reservationId);
    3836        }
    3937        if(restaurant != null)
    4038        {
    4139            r = restaurantManager.findRestaurantByID(restaurant);
     40            restaurantManager.setReservationReviewed(reservationId);
    4241        }
    4342        if(transport != null)
    4443        {
    4544            t = transportManager.getTransportById(transport);
     45            transportManager.setReservationReviewed(reservationId);
    4646        }
    4747        Reviews review = new Reviews (title, numStar, description, h, r, t);
    … …  
    5151    @Override
    5252    public void deleteReview(long id) {
    53         reviewDao.deleteReview(id);
     53        Reviews review = findReviewById(id);
     54        reviewDao.deleteReview(review);
    5455    }
    5556
    … …  
    6162    @Override
    6263    public void editReview(long id, String title, String description, int numStar, Hotels hotel, Restaurant restaurant, Transport transport) {
    63         reviewDao.editReview(id, title, description, numStar, hotel, restaurant, transport);
     64        Reviews review = findReviewById(id);
     65        review.setDescription(description);
     66        review.setHotel(hotel);
     67        review.setRestaurant(restaurant);
     68        review.setTitle(title);
     69        review.setNumStar(numStar);
     70        review.setTransport(transport);
     71        reviewDao.editReview(review);
    6472    }
    6573

  • src/main/java/com/tourMate/services/impl/TransportManagerImpl.java

    r5528b99 r07f4e8b  
    2424    UsersManager usersManager;
    2525
    26     @Override
    27     public void createTransport(String transportName, String carBrand, String carType, int carManufacturedYear, int noPassengers, int noBags, long EMBG, User owner, String carPlate) {
    28         transportDao.createTransport(transportName, carBrand, carType, carManufacturedYear, noPassengers, noBags, EMBG, owner, carPlate);
     26
     27    @Override
     28    public void createTransport(String transportName, String carBrand, String carType, int carManufacturedYear, int noPassengers, int noBags, long EMBG, Long userId, String carPlate) {
     29        User u = usersManager.findUserByID(userId);
     30        Transport t=new Transport(transportName,carBrand,carType,carManufacturedYear,noPassengers,noBags,EMBG,u,carPlate);
     31        transportDao.createTransport(t);
    2932    }
    3033
    3134    @Override
    3235    public void deleteTransport(long transportId) {
    33         transportDao.deleteTransport(transportId);
     36        Transport t=getTransportById(transportId);
     37        transportDao.deleteTransport(t);
    3438    }
    3539
    … …  
    4145    @Override
    4246    public List<TransportDto> getTransportsByUser(long userId) {
    43         return transportDao.getTransportsByUser(userId);
     47        User u = usersManager.findUserByID(userId);
     48        return transportDao.getTransportsByUser(u);
    4449    }
    4550
    4651    @Override
    4752    public List<RouteListingDto> getRoutesForTransport(long transportId) {
    48         return transportDao.getRoutesForTransport(transportId);
     53        Transport t = getTransportById(transportId);
     54        return transportDao.getRoutesForTransport(t);
    4955    }
    5056
    … …  
    6167    @Override
    6268    public void editTransport(long transportID, String transportName, String carBrand, String carType, int carManufacturedYear, int noPassengers, int noBags, long EMBG, User owner, String carPlate) {
    63         transportDao.editTransport(transportID, transportName, carBrand, carType, carManufacturedYear, noPassengers, noBags, EMBG, owner, carPlate);
     69        Transport t=getTransportById(transportID);
     70        t.setTransportName(transportName);
     71        t.setCarBrand(carBrand);
     72        t.setCarType(carType);
     73        t.setCarManufacturedYear(carManufacturedYear);
     74        t.setNoPassengers(noPassengers);
     75        t.setNoBags(noBags);
     76        t.setEMBG(EMBG);
     77        t.setOwner(owner);
     78        t.setCarPlate(carPlate);
     79        transportDao.editTransport(t);
    6480    }
    6581
    … …  
    7894
    7995    @Override
     96    public List<TransportReservation> findTransportReservationByTransportId(long reservationID) {
     97        Transport t = getTransportById(reservationID);
     98        return transportDao.findTransportReservationByTransportId(t);
     99    }
     100
     101    @Override
    80102    public List<TransportReservation> getTransportReservations() {
    81103        return transportDao.getTransportReservations();
    … …  
    93115
    94116    @Override
    95 <<<<<<< HEAD
    96117    public List<Reviews> getReviewsForTransport(long transportId) {
    97118        Transport transport = getTransportById(transportId);
    … …  
    102123    public List<TransportListingDto> getTransportsAvailableByFilters(String from, String to, Date date, int numPassengers) {
    103124        List<TransportRoute> transportAvailable = transportDao.getTransportsAvailableByFilters(from, to, date, numPassengers);
    104 =======
    105     public List<TransportListingDto> getTransportsAvailableByFilters(String from, String to, Date date) {
    106         List<TransportRoute> transportAvailable = transportDao.getTransportsAvailableByFilters(from, to, date);
    107 >>>>>>> parent of ac19a0c (authContext impl, admin panel impl, search bar fixes, reservations listings impl)
    108125        Map<TransportAvailible, List<TransportRoute>> transportsByTransporter = transportAvailable.stream().collect(Collectors.groupingBy(x -> x.getParentRoute()));
    109126        List<TransportListingDto> transportList = transportsByTransporter.keySet().stream().toList().stream()
    … …  
    136153    @Override
    137154    public void createTransportAvailable(Transport transport, String departureLocation, String arrivalLocation, Date date, Integer noSeats, Date departureHour, Collection<TransportRoute> routes) {
    138         transportDao.createTransportAvailable(transport, departureLocation, arrivalLocation, date, noSeats, departureHour, routes);
    139     }
    140 
    141     @Override
    142     public void editTransportReservation(Transport transport, long reservationID, String departureLocation, String arrivalLocation, Date date, Integer noSeats, User user, Date departureHour) {
    143         transportDao.editTransportReservation(transport, reservationID, departureLocation, arrivalLocation, date, noSeats, user, departureHour);
     155        TransportAvailible ta=new TransportAvailible(transport,departureLocation,arrivalLocation,date,noSeats,departureHour);
     156        transportDao.createTransportAvailable(ta);
     157        routes.forEach(x -> {
     158            TransportRoute tr = new TransportRoute(ta, x.getFrom(), x.getTo(), x.getPrice(), x.getDeparture(), x.getArrival(), x.getFreeSpace(), x.getOrder());
     159            transportDao.createTransportRoute(tr);
     160        });
    144161    }
    145162
    146163    @Override
    147164    public void editTransportAvailable(Transport transport, long availableID, String departureLocation, String arrivalLocation, Date date, Integer noSeats, Date departureHour) {
    148         transportDao.editTransportAvailable(transport, availableID, departureLocation, arrivalLocation, date, noSeats, departureHour);
     165        TransportAvailible ta=findTransportAvailableByID(availableID);
     166        ta.setTransport(transport);
     167        ta.setFrom(departureLocation);
     168        ta.setTo(arrivalLocation);
     169        ta.setDate(date);
     170        ta.setFreeSpace(noSeats);
     171        ta.setTime(departureHour);
     172        transportDao.editTransportAvailable(ta);
    149173    }
    150174
    151175    @Override
    152176    public void deleteTransportReservation(long reservationID) {
    153         transportDao.deleteTransportReservation(reservationID);
     177        TransportReservation tr=findTransportReservationByID(reservationID);
     178        transportDao.deleteTransportReservation(tr);
    154179    }
    155180
    156181    @Override
    157182    public void deleteTransportAvailable(long availableID) {
    158         transportDao.deleteTransportAvailable(availableID);
     183        TransportAvailible ta=findTransportAvailableByID(availableID);
     184        transportDao.deleteTransportAvailable(ta);
    159185    }
    160186
    161187    @Override
    162188    public void createTransportRoute(TransportAvailible parentRoute, String from, String to, double price, Date departure, Date arrival, int freeSpace, int order) {
    163         transportDao.createTransportRoute(parentRoute, from, to, price, departure, arrival, freeSpace, order);
     189        TransportRoute tr = new TransportRoute(parentRoute, from, to, price, departure, arrival, freeSpace, order);
     190
     191        transportDao.createTransportRoute(tr);
    164192    }
    165193
    166194    @Override
    167195    public void deleteTransportRoute(long transportRouteId) {
    168         transportDao.deleteTransportRoute(transportRouteId);
     196        TransportRoute tr = transportDao.findTransportRouteById(transportRouteId);
     197        transportDao.deleteTransportRoute(tr);
    169198    }
    170199
    171200    @Override
    172201    public void editTransportRoute(long transportRouteId, TransportAvailible parentRoute, String from, String to, double price, Date departure, Date arrival, int freeSpace, int order) {
    173         transportDao.editTransportRoute(transportRouteId, parentRoute, from, to, price, departure, arrival, freeSpace, order);
     202        TransportRoute tr = transportDao.findTransportRouteById(transportRouteId);
     203        tr.setParentRoute(parentRoute);
     204        tr.setFrom(from);
     205        tr.setTo(to);
     206        tr.setPrice(price);
     207        tr.setDeparture(departure);
     208        tr.setArrival(arrival);
     209        tr.setFreeSpace(freeSpace);
     210        tr.setOrder(order);
     211        transportDao.editTransportRoute(tr);
    174212    }
    175213
    … …  
    179217        List<TransportReservation> reservations = transportDao.findReservationByUser(u);
    180218        return reservations.stream().map(x -> new TransportReservationUserDto(
     219                x.getReservationID(),
    181220                x.getUser(),
    182221                x.getTransportRoute(),
    … …  
    195234        List<TransportReservation> reservations = transportDao.findPastReservationByUser(u);
    196235        return reservations.stream().map(x -> new TransportReservationUserDto(
     236                x.getReservationID(),
    197237                x.getUser(),
    198238                x.getTransportRoute(),
    … …  
    206246    }
    207247
     248    @Override
     249    public void setReservationReviewed(Long reservationId) {
     250        TransportReservation transportReservation = findTransportReservationByID(reservationId);
     251        transportReservation.setReviewed(true);
     252        transportDao.saveReservation(transportReservation);
     253    }
     254
    208255}
    209256

  • src/main/java/com/tourMate/services/impl/UsersManagerImpl.java

    r5528b99 r07f4e8b  
    4545
    4646    @Override
     47    public List<User> getUnapprovedUsers() {
     48        return usersDao.getUnapprovedUsers();
     49    }
     50
     51    @Override
     52    public void approveUserProfile(long userId) {
     53        User u = findUserByID(userId);
     54        usersDao.approveUserProfile(u);
     55    }
     56
     57    @Override
     58    public void unlock(Long id) {
     59        User u = findUserByID(id);
     60        u.setLocked(!u.isLocked());
     61        u.setEnabled(true);
     62        usersDao.updateUser(u);
     63    }
     64
     65    @Override
    4766    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
    4867        return usersDao.findUserByUsername(username);
Note: See TracChangeset for help on using the changeset viewer.