Merge branch 'feature/MLC-342' into 'develop'

MLC-342 / Cancellation management backend

Closes MLC-342

See merge request !7

CHANGELOG.md

@@ -5,4 +5,5 @@
 - MLC-260/add cancellationReason and creationdate and update contractController
 - MLC-260/resolve the comment and remove the unnecessary variable creation
 - MLC-260/Removing the debug log and change the name from saved to savedContract
-- MLC-331/Implement full CRUD operations for Reservation
\ No newline at end of file
+- MLC-331/Implement full CRUD operations for Reservation
+- MLC-342/Cancellation management backend
\ No newline at end of file

pom.xml

@@ -33,7 +33,7 @@
 		<dependency>
 			<groupId>com.marketingconfort</groupId>
 			<artifactId>mobiloca-common</artifactId>
-			<version>0.0.29-RELEASE</version>
+			<version>0.0.35-RELEASE</version>
 		</dependency>
 		<dependency>
 			<groupId>org.modelmapper</groupId>

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

@@ -12,4 +12,5 @@ public class Message {
     public static final String RESERVATION_SET_TO_CONFIRMED = "Reservation set to confirmed with ID: ";
     public static final String RESERVATION_SET_TO_COMPLETED = "Reservation set to completed with ID: ";
     public static final String AGENCY_SERVICE_ERROR = "Error occurred while calling agency service: ";
+    public static final String CANCELLATION_ID_NOT_FOUND ="Cancellation with ID not found : ";
 }

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

@@ -37,5 +37,16 @@ public class Paths {
 
     // ========Agency Api========
     public static final String GET_AGENCY_NAME_BY_ID = "/{id}/name";
+
+    // ========Cancellation========
+    public static final String CANCELLATION_REQUEST_BASE = BASE_URL + "/cancellations";
+    public static final String COUNT_BY_STATUS = "/status";
+    public static final String COUNT_ALL = "";
+    public static final String CANCELLATION_REASONS_STATS = "/stats";
+    public static final String CANCELLATION_REQUEST_GET_ALL = "/all";
+    public static final String CANCELLATION_REQUEST_GET_BY_ID = "/{id}";
+    public static final String CANCELLATION_REQUEST_DELETE_BY_ID = "/delete/{id}";
+    public static final String CANCELLATION_REQUEST_UPDATE_STATUS_BY_ID= "/update-status/{id}";
+    public static final String CANCELLATION_REQUEST_EXPORT = "/export";
 }
 

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

+package com.marketingconfort.mobiloca.controller;
+
+import com.marketingconfort.mobiloca.common.Reservation.enums.StatusCancellation;
+import com.marketingconfort.mobiloca.constants.Paths;
+import com.marketingconfort.mobiloca.dto.CancellationDTO;
+import com.marketingconfort.mobiloca.service.CancellationRequestService;
+import com.marketingconfort.mobiloca.utils.CsvExport;
+import com.marketingconfort.starter.core.exceptions.FunctionalException;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+
+
+@RestController
+@RequestMapping(Paths.CANCELLATION_REQUEST_BASE)
+@RequiredArgsConstructor
+public class CancellationRequestController {
+
+    private final CancellationRequestService cancellationRequestService;
+
+    @GetMapping(Paths.COUNT_BY_STATUS)
+    public Map<String, Long> getCancellationCountsByStatus() {
+        long treated = cancellationRequestService.countByStatus(StatusCancellation.TREATED);
+        long pending = cancellationRequestService.countByStatus(StatusCancellation.PENDING);
+        Map<String, Long> result = new HashMap<>();
+        result.put("treated", treated);
+        result.put("pending", pending);
+        return result;
+    }
+
+    @GetMapping(Paths.COUNT_ALL)
+    public ResponseEntity<Long> getCancellationCounts() {
+        return ResponseEntity.ok(cancellationRequestService.countAllCancellations());
+    }
+
+    @GetMapping(Paths.CANCELLATION_REASONS_STATS)
+    public ResponseEntity<Map<String, Object>> getCancellationStats() {
+        Map<String, Object> data = new HashMap<>();
+        data.put("total", cancellationRequestService.countAllCancellations());
+        data.put("treated", cancellationRequestService.countByStatus(StatusCancellation.TREATED));
+        data.put("pending", cancellationRequestService.countByStatus(StatusCancellation.PENDING));
+        data.put("reasons", cancellationRequestService.getCancellationsByReason());
+
+        return ResponseEntity.ok(data);
+    }
+
+    @GetMapping(Paths.CANCELLATION_REQUEST_GET_ALL)
+    public ResponseEntity<Page<CancellationDTO>> getAllCancellations(
+            @RequestParam(defaultValue = "0") int page,
+            @RequestParam(defaultValue = "10") int size,
+            @RequestParam(defaultValue = "cancellationNumber") String sortBy,
+            @RequestParam(defaultValue = "asc") String sortDirection,
+            @RequestParam(required = false) String cancellationNumberSearch,
+            @RequestParam(required = false) String reservationNumberSearch,
+            @RequestParam(required = false) String clientSearch,
+            @RequestParam(required = false) String statusSearch,
+            @RequestParam(required = false) String priceSearch,
+            @RequestParam(required = false) Double minAmount,
+            @RequestParam(required = false) Double maxAmount
+    )throws  FunctionalException  {
+            Page<CancellationDTO> cancellations = cancellationRequestService.getAllCancellations(
+                    page,
+                    size,
+                    sortBy,
+                    sortDirection,
+                    cancellationNumberSearch,
+                    reservationNumberSearch,
+                    clientSearch,
+                    statusSearch,
+                    priceSearch,
+                    minAmount, maxAmount
+            );
+            return ResponseEntity.ok(cancellations);
+
+    }
+
+    @GetMapping(Paths.CANCELLATION_REQUEST_GET_BY_ID)
+    public ResponseEntity<CancellationDTO> getCancellationDetails(@PathVariable Long id) throws FunctionalException {
+        CancellationDTO dto = cancellationRequestService.getCancellationDetails(id);
+        return ResponseEntity.ok(dto);
+    }
+
+    @DeleteMapping(Paths.CANCELLATION_REQUEST_DELETE_BY_ID)
+    public ResponseEntity<Void> deleteCancellation(@PathVariable Long id) throws FunctionalException {
+        cancellationRequestService.deleteCancellationById(id);
+        return ResponseEntity.noContent().build();
+    }
+
+    @GetMapping(Paths.CANCELLATION_REQUEST_UPDATE_STATUS_BY_ID)
+    public ResponseEntity<CancellationDTO> updateCancellationStatusToTreated(@PathVariable Long id) throws FunctionalException {
+        CancellationDTO dto = cancellationRequestService.updateCancellationStatus(id, StatusCancellation.TREATED);
+        return ResponseEntity.ok(dto);
+    }
+    @PostMapping(Paths.CANCELLATION_REQUEST_EXPORT)
+    public void exportCsv(
+            @RequestParam(required = false) String cancellationNumberSearch,
+            @RequestParam(required = false) String reservationNumberSearch,
+            @RequestParam(required = false) String clientSearch,
+            @RequestParam(required = false) String statusSearch,
+            @RequestParam(required = false) String priceSearch,
+            HttpServletResponse response
+    ) throws IOException, FunctionalException {
+        List<CancellationDTO> list = cancellationRequestService.getAllCancellationsForExport(
+                cancellationNumberSearch,
+                reservationNumberSearch,
+                clientSearch,
+                statusSearch,
+                priceSearch
+        );
+
+        CsvExport.exportCancellationsToCsv(response, list);
+    }
+}

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

@@ -3,9 +3,11 @@ package com.marketingconfort.mobiloca.controller;
 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.common.User.dtos.AgencyDTO;
 import com.marketingconfort.mobiloca.constants.Paths;
 import com.marketingconfort.mobiloca.dto.GlobalReservationDTO;
 import com.marketingconfort.mobiloca.dto.SingleReservationDTO;
+import com.marketingconfort.mobiloca.externalServices.Implementations.AgencyServiceImpl;
 import com.marketingconfort.mobiloca.mapper.GlobalReservationMapper;
 import com.marketingconfort.mobiloca.mapper.SingleReservationMapper;
 import com.marketingconfort.mobiloca.service.GlobalReservationService;
@@ -29,6 +31,7 @@ public class GlobalReservationController {
     private final GlobalReservationService globalReservationService;
     private final GlobalReservationMapper globalReservationMapper;
     private final ReservationStatusScheduler scheduler;
+    private final AgencyServiceImpl agencyService;
 
     @PostMapping(Paths.CREATE_RESERVATION)
     public ResponseEntity<GlobalReservationDTO> createGlobalReservation(@RequestBody GlobalReservationDTO globalReservationDTO) throws FunctionalException {
@@ -147,4 +150,7 @@ public class GlobalReservationController {
     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/dto/CancellationDTO.java

+package com.marketingconfort.mobiloca.dto;
+
+
+import com.marketingconfort.mobiloca.common.Reservation.dto.ClientDTO;
+import com.marketingconfort.mobiloca.common.Reservation.enums.StatusCancellation;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class CancellationDTO {
+    private Long id;
+    private String cancellationNumber;
+    private ClientDTO client;
+    private String cancellationDetails;
+    private StatusCancellation status;
+    private SingleReservationCancellationDTO singleReservation;
+}

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

+package com.marketingconfort.mobiloca.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+public class SingleReservationCancellationDTO {
+    private Long id;
+    private String reservationNumber;
+    private Double amountPaid;
+
+}

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

@@ -13,6 +13,7 @@ public class ContractMapper {
     private final ModelMapper modelMapper;
 
     public ContractDTO toDto(Contract contract) {
+
         return modelMapper.map(contract, ContractDTO.class);
     }
 

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

+package com.marketingconfort.mobiloca.repository;
+
+import com.marketingconfort.mobiloca.common.Reservation.enums.StatusCancellation;
+import com.marketingconfort.mobiloca.common.Reservation.models.CancellationRequest;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface CancellationRequestRepository extends JpaRepository<CancellationRequest, Long>, JpaSpecificationExecutor<CancellationRequest> {
+    Long countByStatus(StatusCancellation status);
+
+    @Query("SELECT c.cancellationReason, COUNT(c) FROM CancellationRequest c GROUP BY c.cancellationReason")
+    List<Object[]> countByCancellationReason();
+
+
+}

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

+package com.marketingconfort.mobiloca.service;
+
+import com.marketingconfort.mobiloca.common.Reservation.enums.StatusCancellation;
+import com.marketingconfort.mobiloca.dto.CancellationDTO;
+import com.marketingconfort.starter.core.exceptions.FunctionalException;
+import org.springframework.data.domain.Page;
+
+import java.util.List;
+import java.util.Map;
+
+public interface CancellationRequestService {
+    Long countByStatus(StatusCancellation status);
+
+    Long countAllCancellations();
+
+    Map<String, Long> getCancellationsByReason();
+
+    Page<CancellationDTO> getAllCancellations(
+            int page,
+            int size,
+            String sortBy,
+            String sortDirection,
+            String cancellationNumberSearch,
+            String reservationNumberSearch,
+            String clientSearch,
+            String statusSearch,
+            String priceSearch,
+            Double minAmount,
+            Double maxAmount
+    ) throws FunctionalException;
+
+    CancellationDTO getCancellationDetails(Long cancellationId) throws FunctionalException;
+
+    void deleteCancellationById(Long cancellationId) throws FunctionalException;
+
+    CancellationDTO updateCancellationStatus(Long cancellationId, StatusCancellation status) throws FunctionalException;
+
+    List<CancellationDTO> getAllCancellationsForExport(
+            String cancellationNumberSearch,
+            String reservationNumberSearch,
+            String clientSearch,
+            String statusSearch,
+            String priceSearch
+    ) throws FunctionalException;
+}

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

+package com.marketingconfort.mobiloca.service.impl;
+
+import com.marketingconfort.mobiloca.common.Reservation.dto.ClientDTO;
+import com.marketingconfort.mobiloca.common.Reservation.enums.CancellationReasonType;
+import com.marketingconfort.mobiloca.common.Reservation.enums.StatusCancellation;
+import com.marketingconfort.mobiloca.common.Reservation.models.CancellationRequest;
+import com.marketingconfort.mobiloca.common.Reservation.models.GlobalReservation;
+import com.marketingconfort.mobiloca.common.Reservation.models.SingleReservation;
+import com.marketingconfort.mobiloca.dto.CancellationDTO;
+import com.marketingconfort.mobiloca.constants.Message;
+import com.marketingconfort.mobiloca.dto.SingleReservationCancellationDTO;
+import com.marketingconfort.mobiloca.dto.SingleReservationDTO;
+import com.marketingconfort.mobiloca.externalServices.ClientService;
+import com.marketingconfort.mobiloca.repository.CancellationRequestRepository;
+import com.marketingconfort.mobiloca.service.CancellationRequestService;
+import com.marketingconfort.starter.core.exceptions.FunctionalException;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.*;
+
+@Service
+@RequiredArgsConstructor
+public class CancellationRequestImpl implements CancellationRequestService {
+
+    private final CancellationRequestRepository cancellationRepository;
+    private final ClientService clientService;
+
+    public Long countByStatus(StatusCancellation status) {
+        return cancellationRepository.countByStatus(status);
+    }
+
+    public Long countAllCancellations() {
+        return cancellationRepository.count();
+    }
+
+    public Map<String, Long> getCancellationsByReason() {
+        List<Object[]> results = cancellationRepository.countByCancellationReason();
+        Map<String, Long> map = new HashMap<>();
+        for (Object[] row : results) {
+            String reason = row[0] != null ? ((CancellationReasonType) row[0]).name() : null;
+            Long count = (Long) row[1];
+
+            map.put(Objects.requireNonNullElse(reason, "Inconnue"), count);
+        }
+        return map;
+    }
+
+
+
+    public Page<CancellationDTO> getAllCancellations(int page, int size, String sortBy, String sortDirection, String cancellationNumberSearch, String reservationNumberSearch, String clientSearch, String statusSearch, String priceSearch, Double minAmount, Double maxAmount) throws FunctionalException {
+
+        Pageable pageable = PageRequest.of(page, size);
+
+        Specification<CancellationRequest> spec = Specification.where(null);
+
+        if (cancellationNumberSearch != null && !cancellationNumberSearch.isBlank()) {
+            spec = spec.and((root, query, cb) -> cb.like(cb.lower(root.get("cancellationNumber")), "%" + cancellationNumberSearch.toLowerCase() + "%"));
+        }
+
+        if (statusSearch != null && !statusSearch.isBlank()) {
+            String upperStatus = statusSearch.toUpperCase();
+
+            if (!upperStatus.equals("PENDING") && !upperStatus.equals("TREATED")) {
+                throw new FunctionalException("Invalid status: must be PENDING or TREATED.");
+            }
+
+            StatusCancellation statusEnum = StatusCancellation.valueOf(upperStatus);
+            spec = spec.and((root, query, cb) -> cb.equal(root.get("status"), statusEnum));
+        }
+
+        Page<CancellationRequest> cancellationRequests = cancellationRepository.findAll(spec, pageable);
+
+        List<CancellationDTO> result = new ArrayList<>();
+
+        for (CancellationRequest cancellationRequest : cancellationRequests) {
+            SingleReservation reservation = cancellationRequest.getSingleReservation();
+            ClientDTO client = clientService.getClient(cancellationRequest.getClientId());
+
+            boolean match = true;
+
+            if (clientSearch != null && !clientSearch.isBlank()) {
+                String fullName = (client.firstname() + " " + client.lastname()).toLowerCase();
+                if (!fullName.contains(clientSearch.toLowerCase())) {
+                    match = false;
+                }
+            }
+
+            if (reservationNumberSearch != null && !reservationNumberSearch.isBlank()) {
+                if (reservation == null || reservation.getReservationNumber() == null || !reservation.getReservationNumber().toLowerCase().contains(reservationNumberSearch.toLowerCase())) {
+                    match = false;
+                }
+            }
+
+            if (priceSearch != null && !priceSearch.isBlank()) {
+                try {
+                    double amount = reservation != null ? reservation.getAmountPaid() : 0.0;
+                    if (Double.parseDouble(priceSearch) != amount) {
+                        match = false;
+                    }
+                } catch (NumberFormatException e) {
+                    match = false;
+                }
+            }
+
+            if (minAmount != null || maxAmount != null) {
+                double amount = reservation != null ? reservation.getAmountPaid() : 0.0;
+                if ((minAmount != null && amount < minAmount) || (maxAmount != null && amount > maxAmount)) {
+                    match = false;
+                }
+            }
+
+            if (match) {
+                CancellationDTO dto = new CancellationDTO();
+                dto.setId(cancellationRequest.getCancellationId());
+                dto.setCancellationNumber(cancellationRequest.getCancellationNumber());
+                dto.setStatus(cancellationRequest.getStatus());
+                dto.setCancellationDetails(cancellationRequest.getCancellationDetails());
+                dto.setClient(client); // ✅ full client DTO
+
+                if (reservation != null) {
+                    SingleReservationCancellationDTO reservationDTO = new SingleReservationCancellationDTO();
+                    reservationDTO.setId(reservation.getUnitReservationId());
+                    reservationDTO.setReservationNumber(reservation.getReservationNumber());
+                    reservationDTO.setAmountPaid(reservation.getAmountPaid());
+
+                    dto.setSingleReservation(reservationDTO); // ✅ full reservation DTO
+                }
+
+                result.add(dto);
+            }
+        }
+
+        Comparator<CancellationDTO> comparator = Comparator.comparing(CancellationDTO::getCancellationNumber, String.CASE_INSENSITIVE_ORDER);
+
+        if ("client".equalsIgnoreCase(sortBy)) {
+            comparator = Comparator.comparing(dto -> {
+                ClientDTO c = dto.getClient();
+                return (c != null) ? (c.firstname() + " " + c.lastname()).toLowerCase() : "";
+            }, String.CASE_INSENSITIVE_ORDER);
+        } else if ("reservationNumber".equalsIgnoreCase(sortBy)) {
+            comparator = Comparator.comparing(dto -> {
+                var res = dto.getSingleReservation();
+                return (res != null && res.getReservationNumber() != null) ? res.getReservationNumber() : "";
+            }, String.CASE_INSENSITIVE_ORDER);
+        } else if ("price".equalsIgnoreCase(sortBy)) {
+            comparator = Comparator.comparing(dto -> {
+                var res = dto.getSingleReservation();
+                return (res != null && res.getAmountPaid() != null) ? res.getAmountPaid() : 0.0;
+            });
+        } else if ("status".equalsIgnoreCase(sortBy)) {
+            comparator = Comparator.comparing(dto -> dto.getStatus() != null ? dto.getStatus().name() : "", String.CASE_INSENSITIVE_ORDER);
+        }
+
+        if ("desc".equalsIgnoreCase(sortDirection)) {
+            comparator = comparator.reversed();
+        }
+
+        result.sort(comparator);
+
+        int start = (int) pageable.getOffset();
+        int end = Math.min(start + pageable.getPageSize(), result.size());
+        List<CancellationDTO> pagedResult = result.subList(start, end);
+
+        return new PageImpl<>(pagedResult, pageable, result.size());
+    }
+
+    public CancellationDTO getCancellationDetails(Long cancellationId) throws FunctionalException {
+        CancellationRequest cancellation = cancellationRepository.findById(cancellationId).orElseThrow(() -> new FunctionalException(Message.CANCELLATION_ID_NOT_FOUND + cancellationId));
+
+        ClientDTO client = clientService.getClient(cancellation.getClientId());
+        SingleReservation reservation = cancellation.getSingleReservation();
+
+        CancellationDTO dto = new CancellationDTO();
+        dto.setId(cancellation.getCancellationId());
+        dto.setCancellationNumber(cancellation.getCancellationNumber());
+        dto.setStatus(cancellation.getStatus());
+        dto.setCancellationDetails(cancellation.getCancellationDetails());
+
+        dto.setClient(client);
+
+        if (reservation != null) {
+            SingleReservationCancellationDTO reservationDTO = new SingleReservationCancellationDTO();
+            reservationDTO.setId(reservation.getUnitReservationId());
+            reservationDTO.setReservationNumber(reservation.getReservationNumber());
+            reservationDTO.setAmountPaid(reservation.getAmountPaid());
+
+            dto.setSingleReservation(reservationDTO);
+        }
+
+        return dto;
+    }
+
+
+    @Transactional
+    public void deleteCancellationById(Long cancellationId) throws FunctionalException {
+        CancellationRequest cancellation = cancellationRepository.findById(cancellationId).orElseThrow(() -> new FunctionalException(Message.CANCELLATION_ID_NOT_FOUND + cancellationId));
+
+        cancellationRepository.delete(cancellation);
+    }
+
+    public CancellationDTO updateCancellationStatus(Long cancellationId, StatusCancellation status) throws FunctionalException {
+        CancellationRequest cancellation = cancellationRepository.findById(cancellationId).orElseThrow(() -> new FunctionalException(Message.CANCELLATION_ID_NOT_FOUND + cancellationId));
+        cancellation.setStatus(status);
+        cancellationRepository.save(cancellation);
+        return getCancellationDetails(cancellationId);
+    }
+
+
+    public List<CancellationDTO> getAllCancellationsForExport(String cancellationNumberSearch, String reservationNumberSearch, String clientSearch, String statusSearch, String priceSearch) throws FunctionalException {
+        return getAllCancellations(0, Integer.MAX_VALUE, "cancellationNumber", "asc", cancellationNumberSearch, reservationNumberSearch, clientSearch, statusSearch, priceSearch, null, null).getContent();
+    }
+
+
+}

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

@@ -49,7 +49,7 @@ public class GlobalReservationServiceImpl implements GlobalReservationService {
     public GlobalReservationDTO createReservation(GlobalReservationDTO request) throws FunctionalException {
 
         if (request.getClient() == null || request.getClient().id() == null) {
-            throw new FunctionalException(Message.CONTRACT_NOT_FOUND);
+            throw new FunctionalException(Message.CLIENT_FAILED_TO_GET);
         }
 
         if (request.getSingleReservations() == null || request.getSingleReservations().isEmpty()) {
@@ -89,14 +89,14 @@ public class GlobalReservationServiceImpl implements GlobalReservationService {
             }
 
             List<BuiltInEquipmentDTO> equipments = new ArrayList<>();
-            List<String> equipmentIds = new ArrayList<>();
+            List<Long> equipmentIds = new ArrayList<>();
             if (single.getBuiltInEquipments() != null) {
                 for (BuiltInEquipmentDTO e : single.getBuiltInEquipments()) {
                     BuiltInEquipmentDTO fullEquipment = vehicleService.getEquipmentById(e.id());
                     if (fullEquipment != null) {
                         reservationPrice += fullEquipment.price();
                         equipments.add(fullEquipment);
-                        equipmentIds.add(String.valueOf(fullEquipment.id()));
+                        equipmentIds.add(fullEquipment.id());
                     }
                 }
             }
@@ -150,9 +150,9 @@ public class GlobalReservationServiceImpl implements GlobalReservationService {
 
             List<BuiltInEquipmentDTO> fullEquipments = new ArrayList<>();
             if (savedSingle.getBuiltInEquipementIds() != null) {
-                for (String equipmentId : savedSingle.getBuiltInEquipementIds()) {
+                for (Long equipmentId : savedSingle.getBuiltInEquipementIds()) {
                     try {
-                        Long id = Long.parseLong(equipmentId);
+                        Long id = equipmentId;
                         BuiltInEquipmentDTO equipment = vehicleService.getEquipmentById(id);
                         if (equipment != null) fullEquipments.add(equipment);
                     } catch (NumberFormatException e) {
@@ -203,13 +203,13 @@ public class GlobalReservationServiceImpl implements GlobalReservationService {
             double reservationPrice = (vehicle.getPricePerDay() != null ? vehicle.getPricePerDay() : 0.0) * days;
             if (Boolean.TRUE.equals(single.getInsurance())) reservationPrice += INSURANCE_PRICE;
 
-            List<String> equipmentIds = new ArrayList<>();
+            List<Long> equipmentIds = new ArrayList<>();
             if (single.getBuiltInEquipments() != null) {
                 for (BuiltInEquipmentDTO e : single.getBuiltInEquipments()) {
                     BuiltInEquipmentDTO full = vehicleService.getEquipmentById(e.id());
                     if (full != null) {
                         reservationPrice += full.price();
-                        equipmentIds.add(full.id().toString());
+                        equipmentIds.add(full.id());
                     }
                 }
             }
@@ -256,9 +256,9 @@ public class GlobalReservationServiceImpl implements GlobalReservationService {
 
             List<BuiltInEquipmentDTO> fullEquipments = new ArrayList<>();
             if (savedSingle.getBuiltInEquipementIds() != null) {
-                for (String idStr : savedSingle.getBuiltInEquipementIds()) {
+                for (Long idStr : savedSingle.getBuiltInEquipementIds()) {
                     try {
-                        Long idEq = Long.parseLong(idStr);
+                        Long idEq = idStr;
                         BuiltInEquipmentDTO eq = vehicleService.getEquipmentById(idEq);
                         if (eq != null) fullEquipments.add(eq);
                     } catch (NumberFormatException e) {
@@ -290,9 +290,9 @@ public class GlobalReservationServiceImpl implements GlobalReservationService {
 
             List<BuiltInEquipmentDTO> equipmentList = new ArrayList<>();
             if (single.getBuiltInEquipementIds() != null) {
-                for (String idStr : single.getBuiltInEquipementIds()) {
+                for (Long idStr : single.getBuiltInEquipementIds()) {
                     try {
-                        Long eqId = Long.parseLong(idStr);
+                        Long eqId = idStr;
                         BuiltInEquipmentDTO eq = vehicleService.getEquipmentById(eqId);
                         if (eq != null) equipmentList.add(eq);
                     } catch (NumberFormatException e) {
@@ -355,6 +355,7 @@ public class GlobalReservationServiceImpl implements GlobalReservationService {
         }
 
         Page<GlobalReservation> reservationPage = globalReservationRepository.findAll(spec, Pageable.unpaged());
+
         List<GlobalReservationDTO> result = new ArrayList<>();
 
         for (GlobalReservation reservation : reservationPage.getContent()) {
@@ -386,9 +387,9 @@ public class GlobalReservationServiceImpl implements GlobalReservationService {
 
                 List<BuiltInEquipmentDTO> fullEquipments = new ArrayList<>();
                 if (single.getBuiltInEquipementIds() != null) {
-                    for (String equipmentId : single.getBuiltInEquipementIds()) {
+                    for (Long equipmentId : single.getBuiltInEquipementIds()) {
                         try {
-                            Long id = Long.parseLong(equipmentId);
+                            Long id = equipmentId;
                             BuiltInEquipmentDTO equipment = vehicleService.getEquipmentById(id);
                             if (equipment != null) fullEquipments.add(equipment);
                         } catch (NumberFormatException e) {

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

@@ -59,7 +59,7 @@ public class SingleReservationServiceImpl implements SingleReservationService {
 
         updatedReservation.setUnitReservationId(singleReservation.getUnitReservationId());
         updatedReservation.setGlobalReservation(globalReservation);
-        updatedReservation.setCancellationRequests(singleReservation.getCancellationRequests());
+        updatedReservation.setCancellationRequest(singleReservation.getCancellationRequest());
         updatedReservation.setReview(singleReservation.getReview());
         updatedReservation.setContract(singleReservation.getContract());
         updatedReservation.setDeposits(singleReservation.getDeposits());

src/main/java/com/marketingconfort/mobiloca/utils/CsvExport.java

+package com.marketingconfort.mobiloca.utils;
+
+import com.marketingconfort.mobiloca.dto.CancellationDTO;
+import jakarta.servlet.http.HttpServletResponse;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.util.List;
+
+public class CsvExport {
+    public static void exportCancellationsToCsv(HttpServletResponse response, List<CancellationDTO> cancellations) throws IOException {
+        String currentDate = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
+        String fileName = "cancellations_" + currentDate + ".csv";
+        response.setContentType("text/csv");
+        response.setHeader("Content-Disposition", "attachment; filename=" + fileName);
+
+        PrintWriter writer = response.getWriter();
+        writer.println("N° d'annulation,N° de réservation,Client,Statut,Montant payé");
+
+        for (CancellationDTO dto : cancellations) {
+            writer.printf("%s,%s,%s,%s,%.2f €%n", dto.getCancellationNumber(), dto.getSingleReservation().getReservationNumber() != null ? dto.getSingleReservation().getReservationNumber() : "", dto.getClient().firstname() + " " + dto.getClient().lastname(), dto.getStatus() != null ? dto.getStatus().name() : "", dto.getSingleReservation().getAmountPaid() != null ? dto.getSingleReservation().getAmountPaid() : 0.0);
+        }
+
+        writer.flush();
+    }
+}