Implement CRUD operations for Reservation

src/main/java/com/marketingconfort/mobiloca/constants/Message.java

@@ -2,4 +2,6 @@ package com.marketingconfort.mobiloca.constants;
 
 public class Message {
     public static final String CONTRACT_NOT_FOUND = "Contract not found";
+    public static final String RESERVATION_NOT_FOUND = "Reservation not found with ID: ";
+
 }

src/main/java/com/marketingconfort/mobiloca/constants/Paths.java

@@ -7,5 +7,27 @@ public class Paths {
     public static final String ALL_CONTRACTS = "";
     public static final String CONTRACT_BY_ID = "/{id}";
     public static final String UPDATE_CONTRACT_STATUS = "/update-status/{id}";
+
+    public static final String GLOBAL_RESERVATION_BASE = BASE_URL + "/global-reservation";
+    public static final String SINGLE_RESERVATION_BASE = BASE_URL + "/single-reservation";
+    public static final String ALL_RESERVATIONS = "";
+    public static final String RESERVATION_BY_ID = "/{id}";
+    public static final String RESERVATIONS_BY_CLIENT = "/client/{clientId}";
+    public static final String RESERVATION_BY_NUMBER = "/number/{reservationNumber}";
+    public static final String RESERVATIONS_BY_TYPE = "/type/{type}";
+    public static final String RESERVATIONS_BY_DATE_RANGE = "/date-range";
+    public static final String CHANGE_RESERVATION_TYPE = "/{id}/type";
+    public static final String ADD_SINGLE_RESERVATION = "/{id}/add-single";
+    public static final String RESERVATION_STATS = "/{id}/stats";
+    public static final String RESERVATION_TOTAL = "/{id}/total";
+    public static final String RESERVATIONS_BY_VEHICLE = "/vehicle/{vehicleId}";
+    public static final String RESERVATIONS_BY_STATUS = "/status/{status}";
+    public static final String RESERVATIONS_BY_PICKUP_DATE_RANGE = "/pickup-date-range";
+    public static final String RESERVATIONS_BY_AGENCIES = "/agencies";
+    public static final String CHANGE_RESERVATION_STATUS = "/{id}/status";
+    public static final String UPDATE_INSURANCE = "/{id}/insurance";
+    public static final String RESERVATION_DURATION = "/{id}/duration";
+    public static final String CHECK_AVAILABILITY = "/check-availability";
+    public static final String RESERVATION_TOTAL_COST = "/{id}/total-cost";
 }
 

src/main/java/com/marketingconfort/mobiloca/controller/GlobalReservationController.java

+package com.marketingconfort.mobiloca.controller;
+
+import com.marketingconfort.mobiloca.common.Reservation.enums.ReservationType;
+import com.marketingconfort.mobiloca.common.Reservation.enums.SingleReservationStatus;
+import com.marketingconfort.mobiloca.common.Reservation.models.GlobalReservation;
+import com.marketingconfort.mobiloca.common.Reservation.models.SingleReservation;
+import com.marketingconfort.mobiloca.constants.Paths;
+import com.marketingconfort.mobiloca.dto.GlobalReservationDTO;
+import com.marketingconfort.mobiloca.dto.SingleReservationDTO;
+import com.marketingconfort.mobiloca.mapper.GlobalReservationMapper;
+import com.marketingconfort.mobiloca.mapper.SingleReservationMapper;
+import com.marketingconfort.mobiloca.service.GlobalReservationService;
+import com.marketingconfort.mobiloca.service.SingleReservationService;
+import com.marketingconfort.starter.core.exceptions.FunctionalException;
+import lombok.RequiredArgsConstructor;
+import org.modelmapper.ModelMapper;
+import org.springframework.format.annotation.DateTimeFormat;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.time.LocalDate;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@RestController
+@RequestMapping(Paths.GLOBAL_RESERVATION_BASE)
+@RequiredArgsConstructor
+public class GlobalReservationController {
+    private final GlobalReservationService globalReservationService;
+    private final GlobalReservationMapper globalReservationMapper;
+
+    @GetMapping(Paths.ALL_RESERVATIONS)
+    public ResponseEntity<List<GlobalReservationDTO>> getAllGlobalReservations() {
+        List<GlobalReservationDTO> reservations = globalReservationService.getAllGlobalReservations()
+                .stream()
+                .map(globalReservationMapper::toDto)
+                .collect(Collectors.toList());
+        return ResponseEntity.ok(reservations);
+    }
+
+    @GetMapping(Paths.RESERVATION_BY_ID)
+    public ResponseEntity<GlobalReservationDTO> getGlobalReservationById(@PathVariable Long id) throws FunctionalException {
+        return ResponseEntity.ok(globalReservationMapper.toDto(
+                globalReservationService.getGlobalReservationById(id).orElseThrow()));
+    }
+
+    @GetMapping(Paths.RESERVATIONS_BY_CLIENT)
+    public ResponseEntity<List<GlobalReservationDTO>> getReservationsByClientId(@PathVariable Long clientId) {
+        List<GlobalReservationDTO> reservations = globalReservationService.getReservationsByClientId(clientId)
+                .stream()
+                .map(globalReservationMapper::toDto)
+                .collect(Collectors.toList());
+        return ResponseEntity.ok(reservations);
+    }
+
+    @GetMapping(Paths.RESERVATION_BY_NUMBER)
+    public ResponseEntity<GlobalReservationDTO> getReservationByNumber(@PathVariable String reservationNumber) throws FunctionalException {
+        return ResponseEntity.ok(globalReservationMapper.toDto(
+                globalReservationService.getReservationByNumber(reservationNumber).orElseThrow()));
+    }
+
+    @GetMapping(Paths.RESERVATIONS_BY_TYPE)
+    public ResponseEntity<List<GlobalReservationDTO>> getReservationsByType(@PathVariable ReservationType type) {
+        List<GlobalReservationDTO> reservations = globalReservationService.getReservationsByType(type)
+                .stream()
+                .map(globalReservationMapper::toDto)
+                .collect(Collectors.toList());
+        return ResponseEntity.ok(reservations);
+    }
+
+    @GetMapping(Paths.RESERVATIONS_BY_DATE_RANGE)
+    public ResponseEntity<List<GlobalReservationDTO>> getReservationsByDateRange(
+            @RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate startDate,
+            @RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate endDate) {
+        List<GlobalReservationDTO> reservations = globalReservationService.getReservationsByDateRange(startDate, endDate)
+                .stream()
+                .map(globalReservationMapper::toDto)
+                .collect(Collectors.toList());
+        return ResponseEntity.ok(reservations);
+    }
+
+    @PostMapping(Paths.ALL_RESERVATIONS)
+    public ResponseEntity<GlobalReservationDTO> createGlobalReservation(@RequestBody GlobalReservationDTO globalReservationDTO) throws FunctionalException {
+        GlobalReservation globalReservation = globalReservationService.createGlobalReservation(globalReservationDTO);
+        return ResponseEntity.ok(globalReservationMapper.toDto(globalReservation));
+    }
+
+    @PostMapping(Paths.RESERVATION_BY_ID)
+    public ResponseEntity<GlobalReservationDTO> updateGlobalReservation(
+            @PathVariable Long id, @RequestBody GlobalReservationDTO globalReservationDTO) throws FunctionalException {
+        GlobalReservation globalReservation = globalReservationService.updateGlobalReservation(id, globalReservationDTO);
+        return ResponseEntity.ok(globalReservationMapper.toDto(globalReservation));
+    }
+
+    @PostMapping(Paths.CHANGE_RESERVATION_TYPE)
+    public ResponseEntity<GlobalReservationDTO> changeReservationType(
+            @PathVariable Long id, @RequestParam ReservationType type) throws FunctionalException {
+        GlobalReservation globalReservation = globalReservationService.changeReservationType(id, type);
+        return ResponseEntity.ok(globalReservationMapper.toDto(globalReservation));
+    }
+
+    @PostMapping(Paths.ADD_SINGLE_RESERVATION)
+    public ResponseEntity<GlobalReservationDTO> addSingleReservation(
+            @PathVariable Long id, @RequestBody SingleReservationDTO singleReservationDTO) throws FunctionalException {
+        SingleReservation singleReservation = new SingleReservationMapper(new ModelMapper()).toEntity(singleReservationDTO);
+        GlobalReservation globalReservation = globalReservationService.addSingleReservation(id, singleReservation);
+        return ResponseEntity.ok(globalReservationMapper.toDto(globalReservation));
+    }
+
+    @PostMapping(Paths.RESERVATION_BY_ID + "/delete")
+    public ResponseEntity<Void> deleteGlobalReservation(@PathVariable Long id) throws FunctionalException {
+        globalReservationService.deleteGlobalReservation(id);
+        return ResponseEntity.noContent().build();
+    }
+
+    @GetMapping(Paths.RESERVATION_TOTAL)
+    public ResponseEntity<Double> calculateTotalPaid(@PathVariable Long id) throws FunctionalException {
+        return ResponseEntity.ok(globalReservationService.calculateTotalPaid(id));
+    }
+}
\ No newline at end of file

src/main/java/com/marketingconfort/mobiloca/controller/SingleReservationController.java

+package com.marketingconfort.mobiloca.controller;
+
+import com.marketingconfort.mobiloca.common.Reservation.enums.ReservationType;
+import com.marketingconfort.mobiloca.common.Reservation.enums.SingleReservationStatus;
+import com.marketingconfort.mobiloca.common.Reservation.models.SingleReservation;
+import com.marketingconfort.mobiloca.constants.Paths;
+import com.marketingconfort.mobiloca.dto.GlobalReservationDTO;
+import com.marketingconfort.mobiloca.dto.SingleReservationDTO;
+import com.marketingconfort.mobiloca.mapper.GlobalReservationMapper;
+import com.marketingconfort.mobiloca.mapper.SingleReservationMapper;
+import com.marketingconfort.mobiloca.service.GlobalReservationService;
+import com.marketingconfort.mobiloca.service.SingleReservationService;
+import com.marketingconfort.starter.core.exceptions.FunctionalException;
+import lombok.RequiredArgsConstructor;
+import org.springframework.format.annotation.DateTimeFormat;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.time.LocalDate;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@RestController
+@RequestMapping(Paths.SINGLE_RESERVATION_BASE)
+@RequiredArgsConstructor
+public class SingleReservationController {
+    private final SingleReservationService singleReservationService;
+    private final SingleReservationMapper singleReservationMapper;
+
+    @GetMapping(Paths.ALL_RESERVATIONS)
+    public ResponseEntity<List<SingleReservationDTO>> getAllSingleReservations() {
+        List<SingleReservationDTO> reservations = singleReservationService.getAllSingleReservations()
+                .stream()
+                .map(singleReservationMapper::toDto)
+                .collect(Collectors.toList());
+        return ResponseEntity.ok(reservations);
+    }
+
+    @GetMapping(Paths.RESERVATION_BY_ID)
+    public ResponseEntity<SingleReservationDTO> getSingleReservationById(@PathVariable Long id) throws FunctionalException {
+        return ResponseEntity.ok(singleReservationMapper.toDto(
+                singleReservationService.getSingleReservationById(id).orElseThrow()));
+    }
+
+    @GetMapping(Paths.RESERVATIONS_BY_VEHICLE)
+    public ResponseEntity<List<SingleReservationDTO>> getReservationsByVehicleId(@PathVariable Long vehicleId) {
+        List<SingleReservationDTO> reservations = singleReservationService.getReservationsByVehicleId(vehicleId)
+                .stream()
+                .map(singleReservationMapper::toDto)
+                .collect(Collectors.toList());
+        return ResponseEntity.ok(reservations);
+    }
+
+    @GetMapping(Paths.RESERVATIONS_BY_STATUS)
+    public ResponseEntity<List<SingleReservationDTO>> getReservationsByStatus(@PathVariable SingleReservationStatus status) {
+        List<SingleReservationDTO> reservations = singleReservationService.getReservationsByStatus(status)
+                .stream()
+                .map(singleReservationMapper::toDto)
+                .collect(Collectors.toList());
+        return ResponseEntity.ok(reservations);
+    }
+
+    @GetMapping(Paths.RESERVATIONS_BY_PICKUP_DATE_RANGE)
+    public ResponseEntity<List<SingleReservationDTO>> getReservationsByPickupDateRange(
+            @RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate startDate,
+            @RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate endDate) {
+        List<SingleReservationDTO> reservations = singleReservationService.getReservationsByPickupDateRange(startDate, endDate)
+                .stream()
+                .map(singleReservationMapper::toDto)
+                .collect(Collectors.toList());
+        return ResponseEntity.ok(reservations);
+    }
+
+    @GetMapping(Paths.RESERVATIONS_BY_AGENCIES)
+    public ResponseEntity<List<SingleReservationDTO>> getReservationsByAgencies(
+            @RequestParam Long departureAgency, @RequestParam Long returnAgency) {
+        List<SingleReservationDTO> reservations = singleReservationService.getReservationsByAgencies(departureAgency, returnAgency)
+                .stream()
+                .map(singleReservationMapper::toDto)
+                .collect(Collectors.toList());
+        return ResponseEntity.ok(reservations);
+    }
+
+    @PostMapping(Paths.ALL_RESERVATIONS)
+    public ResponseEntity<SingleReservationDTO> createSingleReservation(@RequestBody SingleReservationDTO singleReservationDTO) throws FunctionalException {
+        SingleReservation singleReservation = singleReservationService.createSingleReservation(singleReservationDTO);
+        return ResponseEntity.ok(singleReservationMapper.toDto(singleReservation));
+    }
+
+    @PostMapping(Paths.RESERVATION_BY_ID)
+    public ResponseEntity<SingleReservationDTO> updateSingleReservation(
+            @PathVariable Long id, @RequestBody SingleReservationDTO singleReservationDTO) throws FunctionalException {
+        SingleReservation singleReservation = singleReservationService.updateSingleReservation(id, singleReservationDTO);
+        return ResponseEntity.ok(singleReservationMapper.toDto(singleReservation));
+    }
+
+    @PostMapping(Paths.CHANGE_RESERVATION_STATUS)
+    public ResponseEntity<SingleReservationDTO> changeReservationStatus(
+            @PathVariable Long id, @RequestParam SingleReservationStatus status) throws FunctionalException {
+        SingleReservation singleReservation = singleReservationService.changeReservationStatus(id, status);
+        return ResponseEntity.ok(singleReservationMapper.toDto(singleReservation));
+    }
+
+    @PostMapping(Paths.UPDATE_INSURANCE)
+    public ResponseEntity<SingleReservationDTO> updateInsuranceOption(
+            @PathVariable Long id, @RequestParam Boolean insurance) throws FunctionalException {
+        SingleReservation singleReservation = singleReservationService.updateInsuranceOption(id, insurance);
+        return ResponseEntity.ok(singleReservationMapper.toDto(singleReservation));
+    }
+
+    @PostMapping(Paths.RESERVATION_BY_ID + "/delete")
+    public ResponseEntity<Void> deleteSingleReservation(@PathVariable Long id) throws FunctionalException {
+        singleReservationService.deleteSingleReservation(id);
+        return ResponseEntity.noContent().build();
+    }
+
+    @GetMapping(Paths.RESERVATION_DURATION)
+    public ResponseEntity<Integer> calculateRentalDuration(@PathVariable Long id) throws FunctionalException {
+        return ResponseEntity.ok(singleReservationService.calculateRentalDuration(id));
+    }
+
+    @GetMapping(Paths.CHECK_AVAILABILITY)
+    public ResponseEntity<Boolean> checkVehicleAvailability(
+            @RequestParam Long vehicleId,
+            @RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate startDate,
+            @RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate endDate) throws FunctionalException {
+        return ResponseEntity.ok(singleReservationService.checkVehicleAvailability(vehicleId, startDate, endDate));
+    }
+
+    @GetMapping(Paths.RESERVATION_TOTAL_COST)
+    public ResponseEntity<Double> calculateTotalCost(@PathVariable Long id) throws FunctionalException {
+        return ResponseEntity.ok(singleReservationService.calculateTotalCost(id));
+    }
+}
\ No newline at end of file

src/main/java/com/marketingconfort/mobiloca/dto/GlobalReservationDTO.java

+package com.marketingconfort.mobiloca.dto;
+
+import com.marketingconfort.mobiloca.common.Reservation.enums.ReservationType;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.time.LocalDate;
+import java.util.List;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+public class GlobalReservationDTO {
+    private Long id;
+    private String reservationNumber;
+    private Long clientId;
+    private LocalDate createdAt;
+    private ReservationType type;
+    private Double totalAmount;
+    private List<SingleReservationDTO> singleReservations;
+}

src/main/java/com/marketingconfort/mobiloca/dto/SingleReservationDTO.java

 package com.marketingconfort.mobiloca.dto;
 
+import com.marketingconfort.mobiloca.common.Reservation.enums.SingleReservationStatus;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
 
 import java.time.LocalDate;
+
 @Getter
 @Setter
-@AllArgsConstructor
 @NoArgsConstructor
-
+@AllArgsConstructor
 public class SingleReservationDTO {
-    private Long id;
+    private Long unitReservationId;
+    private String reservationNumber;
+    private Long vehicleId;
     private LocalDate pickupDate;
     private LocalDate returnDate;
-
+    private Long departureAgency;
+    private Long returnAgency;
+    private Boolean insurance;
+    private SingleReservationStatus status;
+    private Long globalReservationId;
 }

src/main/java/com/marketingconfort/mobiloca/mapper/GlobalReservationMapper.java

+package com.marketingconfort.mobiloca.mapper;
+
+import com.marketingconfort.mobiloca.common.Reservation.models.GlobalReservation;
+import com.marketingconfort.mobiloca.dto.GlobalReservationDTO;
+import lombok.AllArgsConstructor;
+import org.modelmapper.ModelMapper;
+import org.springframework.stereotype.Component;
+
+@Component
+@AllArgsConstructor
+public class GlobalReservationMapper {
+    private final ModelMapper modelMapper;
+
+    public GlobalReservationDTO toDto(GlobalReservation globalReservation) {
+        return modelMapper.map(globalReservation, GlobalReservationDTO.class);
+    }
+
+    public GlobalReservation toEntity(GlobalReservationDTO dto) {
+        return modelMapper.map(dto, GlobalReservation.class);
+    }
+}
\ No newline at end of file

src/main/java/com/marketingconfort/mobiloca/mapper/SingleReservationMapper.java

+package com.marketingconfort.mobiloca.mapper;
+
+import com.marketingconfort.mobiloca.common.Reservation.models.SingleReservation;
+import com.marketingconfort.mobiloca.dto.SingleReservationDTO;
+import lombok.AllArgsConstructor;
+import org.modelmapper.ModelMapper;
+import org.springframework.stereotype.Component;
+@Component
+@AllArgsConstructor
+public class SingleReservationMapper {
+    private final ModelMapper modelMapper;
+
+    public SingleReservationDTO toDto(SingleReservation singleReservation) {
+        return modelMapper.map(singleReservation, SingleReservationDTO.class);
+    }
+
+    public SingleReservation toEntity(SingleReservationDTO dto) {
+        return modelMapper.map(dto, SingleReservation.class);
+    }
+}
\ No newline at end of file

src/main/java/com/marketingconfort/mobiloca/repository/GlobalReservationRepository.java

+package com.marketingconfort.mobiloca.repository;
+
+import com.marketingconfort.mobiloca.common.Reservation.enums.ReservationType;
+import com.marketingconfort.mobiloca.common.Reservation.models.GlobalReservation;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.time.LocalDate;
+import java.util.List;
+
+@Repository
+public interface GlobalReservationRepository extends JpaRepository<GlobalReservation, Long> {
+    List<GlobalReservation> findByClientId(Long clientId);
+    GlobalReservation findByReservationNumber(String reservationNumber);
+    List<GlobalReservation> findByType(ReservationType type);
+    List<GlobalReservation> findByCreatedAtBetween(LocalDate startDate, LocalDate endDate);
+}
\ No newline at end of file

src/main/java/com/marketingconfort/mobiloca/repository/SingleReservationRepository.java

 package com.marketingconfort.mobiloca.repository;
 
-public interface SingleReservationRepository {
-}
+import com.marketingconfort.mobiloca.common.Reservation.enums.SingleReservationStatus;
+import com.marketingconfort.mobiloca.common.Reservation.models.SingleReservation;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.time.LocalDate;
+import java.util.List;
+
+@Repository
+public interface SingleReservationRepository extends JpaRepository<SingleReservation, Long> {
+    List<SingleReservation> findByVehicleId(Long vehicleId);
+    List<SingleReservation> findByPickupDateBetween(LocalDate startDate, LocalDate endDate);
+    List<SingleReservation> findByStatus(SingleReservationStatus status);
+    List<SingleReservation> findByDepartureAgencyAndReturnAgency(Long departureAgency, Long returnAgency);
+}
\ No newline at end of file

src/main/java/com/marketingconfort/mobiloca/service/GlobalReservationService.java

+package com.marketingconfort.mobiloca.service;
+
+import com.marketingconfort.mobiloca.common.Reservation.enums.ReservationType;
+import com.marketingconfort.mobiloca.common.Reservation.models.GlobalReservation;
+import com.marketingconfort.mobiloca.common.Reservation.models.SingleReservation;
+import com.marketingconfort.mobiloca.dto.GlobalReservationDTO;
+import com.marketingconfort.starter.core.exceptions.FunctionalException;
+
+import java.time.LocalDate;
+import java.util.List;
+import java.util.Optional;
+
+public interface GlobalReservationService {
+    GlobalReservation createGlobalReservation(GlobalReservationDTO globalReservationDTO) throws FunctionalException;
+    GlobalReservation updateGlobalReservation(Long id, GlobalReservationDTO globalReservationDTO) throws FunctionalException;
+    void deleteGlobalReservation(Long id) throws FunctionalException;
+    List<GlobalReservation> getAllGlobalReservations();
+    Optional<GlobalReservation> getGlobalReservationById(Long id) throws FunctionalException;
+    GlobalReservation changeReservationType(Long id, ReservationType type) throws FunctionalException;
+    List<GlobalReservation> getReservationsByClientId(Long clientId);
+    List<GlobalReservation> getReservationsByType(ReservationType type);
+    List<GlobalReservation> getReservationsByDateRange(LocalDate startDate, LocalDate endDate);
+    Optional<GlobalReservation> getReservationByNumber(String reservationNumber) throws FunctionalException;
+    GlobalReservation addSingleReservation(Long globalReservationId, SingleReservation singleReservation) throws FunctionalException;
+    Double calculateTotalPaid(Long globalReservationId) throws FunctionalException;
+}
\ No newline at end of file

src/main/java/com/marketingconfort/mobiloca/service/SingleReservationService.java

 package com.marketingconfort.mobiloca.service;
 
+import com.marketingconfort.mobiloca.common.Reservation.enums.ReservationType;
+import com.marketingconfort.mobiloca.common.Reservation.enums.SingleReservationStatus;
+import com.marketingconfort.mobiloca.common.Reservation.models.SingleReservation;
+import com.marketingconfort.mobiloca.dto.SingleReservationDTO;
+import com.marketingconfort.starter.core.exceptions.FunctionalException;
+
+import java.time.LocalDate;
+import java.util.List;
+import java.util.Optional;
+
 public interface SingleReservationService {
-}
+    SingleReservation createSingleReservation(SingleReservationDTO singleReservationDTO) throws FunctionalException;
+    SingleReservation updateSingleReservation(Long id, SingleReservationDTO singleReservationDTO) throws FunctionalException;
+    void deleteSingleReservation(Long id) throws FunctionalException;
+    List<SingleReservation> getAllSingleReservations();
+    Optional<SingleReservation> getSingleReservationById(Long id) throws FunctionalException;
+    SingleReservation changeReservationStatus(Long id, SingleReservationStatus status) throws FunctionalException;
+    List<SingleReservation> getReservationsByVehicleId(Long vehicleId);
+    List<SingleReservation> getReservationsByPickupDateRange(LocalDate startDate, LocalDate endDate);
+    List<SingleReservation> getReservationsByStatus(SingleReservationStatus status);
+    List<SingleReservation> getReservationsByAgencies(Long departureAgency, Long returnAgency);
+    boolean checkVehicleAvailability(Long vehicleId, LocalDate startDate, LocalDate endDate) throws FunctionalException;
+    int calculateRentalDuration(Long singleReservationId) throws FunctionalException;
+    SingleReservation updateInsuranceOption(Long id, Boolean insurance) throws FunctionalException;
+    SingleReservation associateContract(Long singleReservationId, Long contractId) throws FunctionalException;
+    Double calculateTotalCost(Long singleReservationId) throws FunctionalException;
+}
\ No newline at end of file

src/main/java/com/marketingconfort/mobiloca/service/impl/GlobalReservationServiceImpl.java

+package com.marketingconfort.mobiloca.service.impl;
+
+import com.marketingconfort.mobiloca.common.Reservation.enums.ReservationType;
+import com.marketingconfort.mobiloca.common.Reservation.enums.SingleReservationStatus;
+import com.marketingconfort.mobiloca.common.Reservation.models.Contract;
+import com.marketingconfort.mobiloca.common.Reservation.models.GlobalReservation;
+import com.marketingconfort.mobiloca.common.Reservation.models.SingleReservation;
+import com.marketingconfort.mobiloca.constants.Message;
+import com.marketingconfort.mobiloca.dto.GlobalReservationDTO;
+import com.marketingconfort.mobiloca.dto.SingleReservationDTO;
+import com.marketingconfort.mobiloca.mapper.GlobalReservationMapper;
+import com.marketingconfort.mobiloca.mapper.SingleReservationMapper;
+import com.marketingconfort.mobiloca.repository.ContractRepository;
+import com.marketingconfort.mobiloca.repository.GlobalReservationRepository;
+import com.marketingconfort.mobiloca.repository.SingleReservationRepository;
+import com.marketingconfort.mobiloca.service.ClientService;
+import com.marketingconfort.mobiloca.service.GlobalReservationService;
+import com.marketingconfort.mobiloca.service.SingleReservationService;
+import com.marketingconfort.mobiloca.service.VehicleService;
+import com.marketingconfort.starter.core.exceptions.FunctionalException;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDate;
+import java.time.temporal.ChronoUnit;
+import java.util.List;
+import java.util.Optional;
+
+@Service
+@Slf4j
+@RequiredArgsConstructor
+public class GlobalReservationServiceImpl implements GlobalReservationService {
+    private final GlobalReservationRepository globalReservationRepository;
+    private final SingleReservationRepository singleReservationRepository;
+    private final ClientService clientService;
+    private final GlobalReservationMapper globalReservationMapper;
+
+    @Override
+    @Transactional
+    public GlobalReservation createGlobalReservation(GlobalReservationDTO globalReservationDTO) throws FunctionalException {
+        clientService.getClientById(globalReservationDTO.getClientId());
+        GlobalReservation globalReservation = globalReservationMapper.toEntity(globalReservationDTO);
+        globalReservation.setCreatedAt(LocalDate.now());
+        return globalReservationRepository.save(globalReservation);
+    }
+
+    @Override
+    @Transactional
+    public GlobalReservation updateGlobalReservation(Long id, GlobalReservationDTO globalReservationDTO) throws FunctionalException {
+        GlobalReservation globalReservation = globalReservationRepository.findById(id)
+                .orElseThrow(() -> new FunctionalException(Message.RESERVATION_NOT_FOUND + id));
+        clientService.getClientById(globalReservationDTO.getClientId());
+        globalReservation.setReservationNumber(globalReservationDTO.getReservationNumber());
+        globalReservation.setClientId(globalReservationDTO.getClientId());
+        globalReservation.setType(globalReservationDTO.getType());
+        globalReservation.setTotalAmount(globalReservationDTO.getTotalAmount());
+        return globalReservationRepository.save(globalReservation);
+    }
+
+    @Override
+    @Transactional
+    public void deleteGlobalReservation(Long id) throws FunctionalException {
+        globalReservationRepository.findById(id)
+                .orElseThrow(() -> new FunctionalException(Message.RESERVATION_NOT_FOUND + id));
+        globalReservationRepository.deleteById(id);
+    }
+
+    @Override
+    public List<GlobalReservation> getAllGlobalReservations() {
+        return globalReservationRepository.findAll();
+    }
+
+    @Override
+    public Optional<GlobalReservation> getGlobalReservationById(Long id) throws FunctionalException {
+        return Optional.of(globalReservationRepository.findById(id)
+                .orElseThrow(() -> new FunctionalException(Message.RESERVATION_NOT_FOUND + id)));
+    }
+
+    @Override
+    @Transactional
+    public GlobalReservation changeReservationType(Long id, ReservationType type) throws FunctionalException {
+        GlobalReservation globalReservation = globalReservationRepository.findById(id)
+                .orElseThrow(() -> new FunctionalException(Message.RESERVATION_NOT_FOUND + id));
+        globalReservation.setType(type);
+        return globalReservationRepository.save(globalReservation);
+    }
+
+    @Override
+    public List<GlobalReservation> getReservationsByClientId(Long clientId) {
+        return globalReservationRepository.findByClientId(clientId);
+    }
+
+    @Override
+    public List<GlobalReservation> getReservationsByType(ReservationType type) {
+        return globalReservationRepository.findByType(type);
+    }
+
+    @Override
+    public List<GlobalReservation> getReservationsByDateRange(LocalDate startDate, LocalDate endDate) {
+        return globalReservationRepository.findByCreatedAtBetween(startDate, endDate);
+    }
+
+    @Override
+    public Optional<GlobalReservation> getReservationByNumber(String reservationNumber) throws FunctionalException {
+        GlobalReservation globalReservation = globalReservationRepository.findByReservationNumber(reservationNumber);
+        if (globalReservation == null) {
+            throw new FunctionalException(Message.RESERVATION_NOT_FOUND + reservationNumber);
+        }
+        return Optional.of(globalReservation);
+    }
+
+    @Override
+    @Transactional
+    public GlobalReservation addSingleReservation(Long globalReservationId, SingleReservation singleReservation) throws FunctionalException {
+        GlobalReservation globalReservation = globalReservationRepository.findById(globalReservationId)
+                .orElseThrow(() -> new FunctionalException(Message.RESERVATION_NOT_FOUND + globalReservationId));
+        singleReservation.setGlobalReservation(globalReservation);
+        singleReservationRepository.save(singleReservation);
+        globalReservation.getSingleReservations().add(singleReservation);
+        return globalReservationRepository.save(globalReservation);
+    }
+
+    @Override
+    public Double calculateTotalPaid(Long globalReservationId) throws FunctionalException {
+        GlobalReservation globalReservation = globalReservationRepository.findById(globalReservationId)
+                .orElseThrow(() -> new FunctionalException(Message.RESERVATION_NOT_FOUND + globalReservationId));
+        return globalReservation.getTotalAmount();
+    }
+}
+

src/main/java/com/marketingconfort/mobiloca/service/impl/SingleReservationServiceImpl.java

+package com.marketingconfort.mobiloca.service.impl;
+
+import com.marketingconfort.mobiloca.common.Reservation.enums.ReservationType;
+import com.marketingconfort.mobiloca.common.Reservation.enums.SingleReservationStatus;
+import com.marketingconfort.mobiloca.common.Reservation.models.Contract;
+import com.marketingconfort.mobiloca.common.Reservation.models.GlobalReservation;
+import com.marketingconfort.mobiloca.common.Reservation.models.SingleReservation;
+import com.marketingconfort.mobiloca.constants.Message;
+import com.marketingconfort.mobiloca.dto.GlobalReservationDTO;
+import com.marketingconfort.mobiloca.dto.SingleReservationDTO;
+import com.marketingconfort.mobiloca.mapper.GlobalReservationMapper;
+import com.marketingconfort.mobiloca.mapper.SingleReservationMapper;
+import com.marketingconfort.mobiloca.repository.ContractRepository;
+import com.marketingconfort.mobiloca.repository.GlobalReservationRepository;
+import com.marketingconfort.mobiloca.repository.SingleReservationRepository;
+import com.marketingconfort.mobiloca.service.ClientService;
+import com.marketingconfort.mobiloca.service.GlobalReservationService;
+import com.marketingconfort.mobiloca.service.SingleReservationService;
+import com.marketingconfort.mobiloca.service.VehicleService;
+import com.marketingconfort.starter.core.exceptions.FunctionalException;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDate;
+import java.time.temporal.ChronoUnit;
+import java.util.List;
+import java.util.Optional;
+
+@Service
+@Slf4j
+@RequiredArgsConstructor
+public class SingleReservationServiceImpl implements SingleReservationService {
+    private final SingleReservationRepository singleReservationRepository;
+    private final GlobalReservationRepository globalReservationRepository;
+    private final VehicleService vehicleService;
+    private final ContractRepository contractRepository;
+    private final SingleReservationMapper singleReservationMapper;
+
+    @Override
+    @Transactional
+    public SingleReservation createSingleReservation(SingleReservationDTO singleReservationDTO) throws FunctionalException {
+        vehicleService.getVehicleById(singleReservationDTO.getVehicleId());
+        GlobalReservation globalReservation = globalReservationRepository.findById(singleReservationDTO.getGlobalReservationId())
+                .orElseThrow(() -> new FunctionalException(Message.RESERVATION_NOT_FOUND + singleReservationDTO.getGlobalReservationId()));
+        SingleReservation singleReservation = singleReservationMapper.toEntity(singleReservationDTO);
+        singleReservation.setGlobalReservation(globalReservation);
+        return singleReservationRepository.save(singleReservation);
+    }
+
+    @Override
+    @Transactional
+    public SingleReservation updateSingleReservation(Long id, SingleReservationDTO singleReservationDTO) throws FunctionalException {
+        SingleReservation singleReservation = singleReservationRepository.findById(id)
+                .orElseThrow(() -> new FunctionalException(Message.RESERVATION_NOT_FOUND + id));
+        vehicleService.getVehicleById(singleReservationDTO.getVehicleId());
+        GlobalReservation globalReservation = globalReservationRepository.findById(singleReservationDTO.getGlobalReservationId())
+                .orElseThrow(() -> new FunctionalException(Message.RESERVATION_NOT_FOUND + singleReservationDTO.getGlobalReservationId()));
+
+        SingleReservation updatedReservation = singleReservationMapper.toEntity(singleReservationDTO);
+
+        updatedReservation.setUnitReservationId(singleReservation.getUnitReservationId());
+        updatedReservation.setGlobalReservation(globalReservation);
+        updatedReservation.setCancellationRequests(singleReservation.getCancellationRequests());
+        updatedReservation.setReview(singleReservation.getReview());
+        updatedReservation.setContract(singleReservation.getContract());
+        updatedReservation.setDeposits(singleReservation.getDeposits());
+
+        return singleReservationRepository.save(updatedReservation);
+    }
+
+    @Override
+    @Transactional
+    public void deleteSingleReservation(Long id) throws FunctionalException {
+        singleReservationRepository.findById(id)
+                .orElseThrow(() -> new FunctionalException(Message.RESERVATION_NOT_FOUND + id));
+        singleReservationRepository.deleteById(id);
+    }
+
+    @Override
+    public List<SingleReservation> getAllSingleReservations() {
+        return singleReservationRepository.findAll();
+    }
+
+    @Override
+    public Optional<SingleReservation> getSingleReservationById(Long id) throws FunctionalException {
+        return Optional.of(singleReservationRepository.findById(id)
+                .orElseThrow(() -> new FunctionalException(Message.RESERVATION_NOT_FOUND + id)));
+    }
+
+    @Override
+    @Transactional
+    public SingleReservation changeReservationStatus(Long id, SingleReservationStatus status) throws FunctionalException {
+        SingleReservation singleReservation = singleReservationRepository.findById(id)
+                .orElseThrow(() -> new FunctionalException(Message.RESERVATION_NOT_FOUND + id));
+        singleReservation.setStatus(status);
+        return singleReservationRepository.save(singleReservation);
+    }
+
+    @Override
+    public List<SingleReservation> getReservationsByVehicleId(Long vehicleId) {
+        return singleReservationRepository.findByVehicleId(vehicleId);
+    }
+
+    @Override
+    public List<SingleReservation> getReservationsByPickupDateRange(LocalDate startDate, LocalDate endDate) {
+        return singleReservationRepository.findByPickupDateBetween(startDate, endDate);
+    }
+
+    @Override
+    public List<SingleReservation> getReservationsByStatus(SingleReservationStatus status) {
+        return singleReservationRepository.findByStatus(status);
+    }
+
+    @Override
+    public List<SingleReservation> getReservationsByAgencies(Long departureAgency, Long returnAgency) {
+        return singleReservationRepository.findByDepartureAgencyAndReturnAgency(departureAgency, returnAgency);
+    }
+
+    @Override
+    public boolean checkVehicleAvailability(Long vehicleId, LocalDate startDate, LocalDate endDate) throws FunctionalException {
+        vehicleService.getVehicleById(vehicleId);
+        List<SingleReservation> reservations = singleReservationRepository.findByVehicleId(vehicleId);
+        return reservations.stream().noneMatch(reservation ->
+                !(reservation.getReturnDate().isBefore(startDate) || reservation.getPickupDate().isAfter(endDate)));
+    }
+
+    @Override
+    public int calculateRentalDuration(Long singleReservationId) throws FunctionalException {
+        SingleReservation singleReservation = singleReservationRepository.findById(singleReservationId)
+                .orElseThrow(() -> new FunctionalException(Message.RESERVATION_NOT_FOUND + singleReservationId));
+        return (int) ChronoUnit.DAYS.between(singleReservation.getPickupDate(), singleReservation.getReturnDate());
+    }
+
+    @Override
+    @Transactional
+    public SingleReservation updateInsuranceOption(Long id, Boolean insurance) throws FunctionalException {
+        SingleReservation singleReservation = singleReservationRepository.findById(id)
+                .orElseThrow(() -> new FunctionalException(Message.RESERVATION_NOT_FOUND + id));
+        singleReservation.setInsurance(insurance);
+        return singleReservationRepository.save(singleReservation);
+    }
+
+    @Override
+    @Transactional
+    public SingleReservation associateContract(Long singleReservationId, Long contractId) throws FunctionalException {
+        SingleReservation singleReservation = singleReservationRepository.findById(singleReservationId)
+                .orElseThrow(() -> new FunctionalException(Message.RESERVATION_NOT_FOUND + singleReservationId));
+        Contract contract = contractRepository.findById(contractId)
+                .orElseThrow(() -> new FunctionalException(Message.CONTRACT_NOT_FOUND + contractId));
+        singleReservation.setContract(contract);
+        return singleReservationRepository.save(singleReservation);
+    }
+
+    @Override
+    public Double calculateTotalCost(Long singleReservationId) throws FunctionalException {
+        SingleReservation singleReservation = singleReservationRepository.findById(singleReservationId)
+                .orElseThrow(() -> new FunctionalException(Message.RESERVATION_NOT_FOUND + singleReservationId));
+        return 100.0 * calculateRentalDuration(singleReservationId);
+    }
+}