commit v1

Dockerfile

@@ -0,0 +1,13 @@
+# Step 1: Use an official OpenJDK base image from Docker Hub
+FROM openjdk:17-jdk-alpine
+# Step 2: Set the working directory inside the container
+WORKDIR /app
+
+# Step 3: Copy the Spring Boot JAR file into the container
+COPY build/libs/API-PLR-0.0.1-SNAPSHOT.jar /app/app.jar
+
+# Step 4: Expose the port your application runs on
+EXPOSE 8080
+
+# Step 5: Define the command to run your Spring Boot application
+CMD ["java", "-jar", "/app/app.jar"]

build.gradle

@@ -26,11 +26,20 @@ repositories {
 dependencies {
     implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
     implementation 'org.springframework.boot:spring-boot-starter-web'
+    implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.8.5'
     compileOnly 'org.projectlombok:lombok'
     runtimeOnly 'org.postgresql:postgresql'
     annotationProcessor 'org.projectlombok:lombok'
+    developmentOnly 'org.springframework.boot:spring-boot-devtools'
+    developmentOnly 'org.springframework.boot:spring-boot-docker-compose'
+    implementation 'org.springframework.boot:spring-boot-starter-validation'
     testImplementation 'org.springframework.boot:spring-boot-starter-test'
     testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
+    //
+    implementation('org.springframework.boot:spring-boot-starter-security')
+    implementation('io.jsonwebtoken:jjwt-api:0.11.5')
+    implementation('io.jsonwebtoken:jjwt-impl:0.11.5')
+    implementation('io.jsonwebtoken:jjwt-jackson:0.11.5')
 }
 
 tasks.named('test') {

deployToVPS.sh

@@ -0,0 +1 @@
+scp -P 22 build/libs/API-PLR-0.0.1-SNAPSHOT.jar dsit@192.168.1.235:/home/docker/api/

docker-compose.yml

@@ -0,0 +1,32 @@
+version: '3.8'
+services:
+  api_app:
+    build: .
+    platform: linux/x86_64
+    image: pmu_api:1
+    container_name: api_app
+    ports:
+      - 8183:8080
+    restart: on-failure
+    depends_on:
+      - api_db
+    networks:
+      - api
+  api_db:
+    image: postgres
+    container_name: api_db
+    ports:
+      - 5555:5432
+    volumes:
+      - db_api:/var/lib/postgresql/data
+    environment:
+      - POSTGRES_USER=postgres
+      - POSTGRES_PASSWORD=password
+      - POSTGRES_DBNAME="api"
+    restart: always
+    networks:
+      - api
+volumes:
+  db_api:
+networks:
+  api:

src/main/java/com/pmumali/api/ApiKey.java

@@ -0,0 +1,28 @@
+package com.pmumali.api;
+
+import jakarta.persistence.*;
+import lombok.*;
+
+import java.time.LocalDateTime;
+
+@Entity
+@Table(name = "api_keys")
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class ApiKey {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(unique = true, nullable = false, length = 128)
+    private String keyValue;
+
+    @Column(nullable = false)
+    private Boolean active;
+
+    @Column(nullable = false)
+    private LocalDateTime createdAt;
+}

src/main/java/com/pmumali/api/ApiKeyController.java

@@ -0,0 +1,27 @@
+package com.pmumali.api;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.UUID;
+
+@RestController
+@RequestMapping("/admin/api-keys")
+@RequiredArgsConstructor
+public class ApiKeyController {
+
+    private final ApiKeyService apiKeyService;
+
+    @PostMapping("/create")
+    public ApiKey createApiKey() {
+        String generatedKey = UUID.randomUUID().toString().replace("-", "");
+        return apiKeyService.createKey(generatedKey);
+    }
+
+   // @PutMapping("/deactivate/{id}")
+    public String deactivateApiKey(@PathVariable Long id) {
+        apiKeyService.deactivateKey(id);
+        return "API Key désactivée avec succès";
+    }
+}
+

src/main/java/com/pmumali/api/ApiKeyFilter.java

@@ -0,0 +1,34 @@
+package com.pmumali.api;
+
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+import org.springframework.web.filter.OncePerRequestFilter;
+
+import java.io.IOException;
+
+@Component
+@RequiredArgsConstructor
+public class ApiKeyFilter extends OncePerRequestFilter {
+
+    private final ApiKeyService apiKeyService;
+
+    @Override
+    protected void doFilterInternal(HttpServletRequest request,
+                                    HttpServletResponse response,
+                                    FilterChain filterChain) throws ServletException, IOException {
+        String requestApiKey = request.getHeader("x-api-key");
+
+    /*    if (requestApiKey == null || !apiKeyService.isValid(requestApiKey)) {
+            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
+            response.getWriter().write("Invalid or missing API Key");
+            return;
+        }*/
+
+        filterChain.doFilter(request, response);
+    }
+}
+

src/main/java/com/pmumali/api/ApiKeyRepository.java

@@ -0,0 +1,10 @@
+package com.pmumali.api;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.Optional;
+
+public interface ApiKeyRepository extends JpaRepository<ApiKey, Long> {
+    Optional<ApiKey> findByKeyValueAndActiveTrue(String keyValue);
+}
+

src/main/java/com/pmumali/api/ApiKeyService.java

@@ -0,0 +1,34 @@
+package com.pmumali.api;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.Optional;
+
+@Service
+@RequiredArgsConstructor
+public class ApiKeyService {
+
+    private final ApiKeyRepository apiKeyRepository;
+
+    public boolean isValid(String key) {
+        return apiKeyRepository.findByKeyValueAndActiveTrue(key).isPresent();
+    }
+
+    public ApiKey createKey(String key) {
+        ApiKey apiKey = ApiKey.builder()
+                .keyValue(key)
+                .active(true)
+                .createdAt(java.time.LocalDateTime.now())
+                .build();
+        return apiKeyRepository.save(apiKey);
+    }
+
+    public void deactivateKey(Long id) {
+        apiKeyRepository.findById(id).ifPresent(apiKey -> {
+            apiKey.setActive(false);
+            apiKeyRepository.save(apiKey);
+        });
+    }
+}
+

src/main/java/com/pmumali/ch10_multi/controller/ControleurMulti.java

@@ -31,7 +31,7 @@ public class ControleurMulti {
         }
     }
 
-    @PostMapping("/calculer-paiements")
+  //  @PostMapping("/calculer-paiements")
     public ResponseEntity<List<ReponsePaiementMulti>> calculerPaiements(@RequestBody RequeteResultatMulti requete) {
         try {
             List<ReponsePaiementMulti> paiements = serviceMulti.calculerPaiements(requete);
@@ -41,7 +41,7 @@ public class ControleurMulti {
         }
     }
 
-    @GetMapping("/calcul-combinaison")
+  //  @GetMapping("/calcul-combinaison")
     public ResponseEntity<CalculCombinaisonMulti> calculerCombinaison(
             @RequestParam TypeMulti typeMulti,
             @RequestParam TypeFormuleMulti typeFormule,
@@ -56,7 +56,7 @@ public class ControleurMulti {
         }
     }
 
-    @PostMapping("/cagnotte/{cagnotteId}/utiliser")
+  //  @PostMapping("/cagnotte/{cagnotteId}/utiliser")
     public ResponseEntity<Void> utiliserCagnotte(
             @PathVariable Long cagnotteId,
             @RequestParam Long courseId) {
@@ -68,22 +68,22 @@ public class ControleurMulti {
         }
     }
 
-    @GetMapping("/cagnottes/disponibles")
+   // @GetMapping("/cagnottes/disponibles")
     public ResponseEntity<List<CagnotteMulti>> getCagnottesDisponibles() {
         return ResponseEntity.ok(cagnotteRepository.findByUtilisee(false));
     }
 
-    @GetMapping("/paris/course/{courseId}")
+   // @GetMapping("/paris/course/{courseId}")
     public ResponseEntity<List<PariMulti>> getParisCourse(@PathVariable Long courseId) {
         return ResponseEntity.ok(pariRepository.findByCourseId(courseId));
     }
 
-    @GetMapping("/paiements/pari/{pariId}")
+  //  @GetMapping("/paiements/pari/{pariId}")
     public ResponseEntity<List<PaiementMulti>> getPaiementsPari(@PathVariable Long pariId) {
         return ResponseEntity.ok(paiementRepository.findByPariId(pariId));
     }
 
-    @GetMapping("/statistiques/course/{courseId}")
+  //  @GetMapping("/statistiques/course/{courseId}")
     public ResponseEntity<Map<TypeMulti, Long>> getStatistiquesParis(@PathVariable Long courseId) {
         Map<TypeMulti, Long> stats = new HashMap<>();
         for (TypeMulti type : TypeMulti.values()) {

src/main/java/com/pmumali/ch10_multi/model/ChevalMulti.java

@@ -9,12 +9,18 @@ import lombok.*;
 @AllArgsConstructor
 @Builder
 @Table(name = "cheval")
-public class Cheval {
+public class ChevalMulti {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
 
     private String nom;
     private Integer numero;
+
+    @Column(name = "non_partant")
     private Boolean nonPartant;
+
+    @ManyToOne
+    @JoinColumn(name = "course_id")
+    private CourseMulti course;
 }

src/main/java/com/pmumali/ch10_multi/model/CourseMulti.java

@@ -12,18 +12,19 @@ import java.util.List;
 @AllArgsConstructor
 @Builder
 @Table(name = "course")
-public class Course {
+public class CourseMulti {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
 
     private String nom;
+    @Column(name = "heure_course")
     private LocalDateTime heureCourse;
     private Integer nombreChevauxPartants;
 
     @OneToMany
-    private List<Cheval> chevaux;
+    private List<ChevalMulti> chevaux;
 
     @Enumerated(EnumType.STRING)
-    private StatutCourse statut;
+    private StatutCourseMulti statut;
 }

src/main/java/com/pmumali/ch10_multi/model/PaiementMulti.java

@@ -20,8 +20,10 @@ public class PaiementMulti {
     private PariMulti pari;
 
     private Double montant;
+    @Column(name = "heure_paiement")
     private LocalDateTime heurePaiement;
 
     @Enumerated(EnumType.STRING)
+    @Column(name = "type_paiement")
     private TypePaiementMulti typePaiement;
 }

src/main/java/com/pmumali/ch10_multi/model/PariMulti.java

@@ -18,10 +18,10 @@ public class PariMulti {
     private Long id;
 
     @ManyToOne
-    private Course course;
+    private CourseMulti course;
 
     @ManyToMany
-    private List<Cheval> chevauxSelectionnes;
+    private List<ChevalMulti> chevauxSelectionnes;
 
     private Double mise;
     private LocalDateTime heurePari;
@@ -33,7 +33,7 @@ public class PariMulti {
     private TypeFormuleMulti typeFormule;
 
     @ManyToOne
-    private Parieur parieur;
+    private ParieurMulti parieur;
 
     private Integer nombreChevauxBase;
 }

src/main/java/com/pmumali/ch10_multi/model/ParieurMulti.java

@@ -9,12 +9,13 @@ import lombok.*;
 @AllArgsConstructor
 @Builder
 @Table(name = "parieur")
-public class Parieur {
+public class ParieurMulti {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
 
     private String nom;
     private String identification;
+    @Column(name = "mise_totale")
     private Double miseTotale;
 }

src/main/java/com/pmumali/ch10_multi/model/ResultatCalculRapportMulti.java

@@ -3,7 +3,7 @@ package com.pmumali.ch10_multi.model;
 import lombok.Data;
 
 @Data
-public class ResultatCalculRapport {
+public class ResultatCalculRapportMulti {
     private Double rapportBase;
     private Double rapportMulti4;
     private Double rapportMulti5;

src/main/java/com/pmumali/ch10_multi/model/ResultatCourseMulti.java

@@ -11,31 +11,35 @@ import java.util.List;
 @AllArgsConstructor
 @Builder
 @Table(name = "resultat_course")
-public class ResultatCourse {
+public class ResultatCourseMulti {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
 
     @ManyToOne
-    private Course course;
+    private CourseMulti course;
 
     @ManyToMany
-    private List<Cheval> premiers;
+    private List<ChevalMulti> premiers;
 
     @ManyToMany
-    private List<Cheval> seconds;
+    private List<ChevalMulti> seconds;
 
     @ManyToMany
-    private List<Cheval> troisiemes;
+    private List<ChevalMulti> troisiemes;
 
     @ManyToMany
-    private List<Cheval> quatriemes;
+    private List<ChevalMulti> quatriemes;
 
     @ManyToMany
-    private List<Cheval> ordreArrivee;
+    private List<ChevalMulti> ordreArrivee;
 
+    @Column(name = "recette_nette")
     private Double recetteNette;
+    @Column(name = "montant_rembourse")
     private Double montantRembourse;
+    @Column(name = "prelevements_legaux")
     private Double prelevementsLegaux;
+    @Column(name = "masse_apartager")
     private Double masseAPartager;
 }

src/main/java/com/pmumali/ch10_multi/model/StatutCourseMulti.java

@@ -1,5 +1,5 @@
 package com.pmumali.ch10_multi.model;
 
-public enum StatutCourse {
+public enum StatutCourseMulti {
     PROGRAMMEE, EN_COURS, TERMINEE, ANNULEE
 }

src/main/java/com/pmumali/ch10_multi/repository/ChevalMultiRepository.java

@@ -0,0 +1,11 @@
+package com.pmumali.ch10_multi.repository;
+
+import com.pmumali.ch10_multi.model.ChevalMulti;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.List;
+
+public interface ChevalMultiRepository extends JpaRepository<ChevalMulti, Long> {
+    List<ChevalMulti> findByNonPartant(Boolean nonPartant);
+    List<ChevalMulti> findByIdIn(List<Long> ids);
+}

src/main/java/com/pmumali/ch10_multi/repository/ChevalRepository.java

@@ -1,11 +0,0 @@
-package com.pmumali.ch10_multi.repository;
-
-import com.pmumali.ch10_multi.model.Cheval;
-import org.springframework.data.jpa.repository.JpaRepository;
-
-import java.util.List;
-
-public interface ChevalRepository extends JpaRepository<Cheval, Long> {
-    List<Cheval> findByNonPartant(Boolean nonPartant);
-    List<Cheval> findByIdIn(List<Long> ids);
-}

src/main/java/com/pmumali/ch10_multi/repository/CourseMultiRepository.java

@@ -0,0 +1,12 @@
+package com.pmumali.ch10_multi.repository;
+
+import com.pmumali.ch10_multi.model.CourseMulti;
+import com.pmumali.ch10_multi.model.StatutCourseMulti;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.List;
+
+public interface CourseMultiRepository extends JpaRepository<CourseMulti, Long> {
+    List<CourseMulti> findByStatut(StatutCourseMulti statut);
+    List<CourseMulti> findByNombreChevauxPartantsGreaterThanEqual(Integer nombre);
+}

src/main/java/com/pmumali/ch10_multi/repository/CourseRepository.java

@@ -1,12 +0,0 @@
-package com.pmumali.ch10_multi.repository;
-
-import com.pmumali.ch10_multi.model.Course;
-import com.pmumali.ch10_multi.model.StatutCourse;
-import org.springframework.data.jpa.repository.JpaRepository;
-
-import java.util.List;
-
-public interface CourseRepository extends JpaRepository<Course, Long> {
-    List<Course> findByStatut(StatutCourse statut);
-    List<Course> findByNombreChevauxPartantsGreaterThanEqual(Integer nombre);
-}

src/main/java/com/pmumali/ch10_multi/repository/ParieurMultiRepository.java

@@ -0,0 +1,10 @@
+package com.pmumali.ch10_multi.repository;
+
+import com.pmumali.ch10_multi.model.ParieurMulti;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.List;
+
+public interface ParieurMultiRepository extends JpaRepository<ParieurMulti, Long> {
+    List<ParieurMulti> findByNomContaining(String nom);
+}

src/main/java/com/pmumali/ch10_multi/repository/ParieurRepository.java

@@ -1,10 +0,0 @@
-package com.pmumali.ch10_multi.repository;
-
-import com.pmumali.ch10_multi.model.Parieur;
-import org.springframework.data.jpa.repository.JpaRepository;
-
-import java.util.List;
-
-public interface ParieurRepository extends JpaRepository<Parieur, Long> {
-    List<Parieur> findByNomContaining(String nom);
-}

src/main/java/com/pmumali/ch10_multi/repository/ResultatCourseMultiRepository.java

@@ -0,0 +1,8 @@
+package com.pmumali.ch10_multi.repository;
+
+import com.pmumali.ch10_multi.model.ResultatCourseMulti;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface ResultatCourseMultiRepository extends JpaRepository<ResultatCourseMulti, Long> {
+    ResultatCourseMulti findByCourseId(Long courseId);
+}

src/main/java/com/pmumali/ch10_multi/repository/ResultatCourseRepository.java

@@ -1,8 +0,0 @@
-package com.pmumali.ch10_multi.repository;
-
-import com.pmumali.ch10_multi.model.ResultatCourse;
-import org.springframework.data.jpa.repository.JpaRepository;
-
-public interface ResultatCourseRepository extends JpaRepository<ResultatCourse, Long> {
-    ResultatCourse findByCourseId(Long courseId);
-}

src/main/java/com/pmumali/ch10_multi/service/ServiceMulti.java

@@ -16,12 +16,12 @@ import java.util.stream.Collectors;
 public class ServiceMulti {
 
     private final PariMultiRepository pariRepository;
-    private final CourseRepository courseRepository;
+    private final CourseMultiRepository courseRepository;
-    private final ChevalRepository chevalRepository;
+    private final ChevalMultiRepository chevalRepository;
     private final PaiementMultiRepository paiementRepository;
-    private final ResultatCourseRepository resultatRepository;
+    private final ResultatCourseMultiRepository resultatRepository;
     private final CagnotteMultiRepository cagnotteRepository;
-    private final ParieurRepository parieurRepository;
+    private final ParieurMultiRepository parieurRepository;
 
     private static final Double MISE_BASE = 500.0;
     private static final Double MISE_MAX = 200 * MISE_BASE;
@@ -50,7 +50,7 @@ public class ServiceMulti {
             throw new IllegalArgumentException("La mise doit être au moins " + MISE_BASE + " FCFA");
         }
 
-        Course course = courseRepository.findById(requete.getCourseId())
+        CourseMulti course = courseRepository.findById(requete.getCourseId())
                 .orElseThrow(() -> new RuntimeException("Course non trouvée"));
 
         // Vérification du nombre minimum de chevaux
@@ -58,19 +58,19 @@ public class ServiceMulti {
             throw new IllegalArgumentException("La course doit avoir au moins " + NOMBRE_CHEVAUX_MINIMUM + " chevaux partants");
         }
 
-        List<Cheval> chevaux = chevalRepository.findAllById(requete.getChevalIds());
+        List<ChevalMulti> chevaux = chevalRepository.findAllById(requete.getChevalIds());
 
         // Validation du nombre de chevaux selon le type MULTI
         validerNombreChevaux(requete.getTypeMulti(), chevaux.size());
 
         // Vérification des non-partants
-        long nonPartants = chevaux.stream().filter(Cheval::getNonPartant).count();
+        long nonPartants = chevaux.stream().filter(ChevalMulti::getNonPartant).count();
         validerNonPartants(requete.getTypeMulti(), nonPartants);
 
         // Limitation de mise selon l'article 2
         Double miseEffective = Math.min(requete.getMise(), MISE_MAX);
 
-        Parieur parieur = parieurRepository.findById(requete.getParieurId())
+        ParieurMulti parieur = parieurRepository.findById(requete.getParieurId())
                 .orElseThrow(() -> new RuntimeException("Parieur non trouvé"));
 
         PariMulti pari = PariMulti.builder()
@@ -123,7 +123,7 @@ public class ServiceMulti {
 
     @Transactional
     public List<ReponsePaiementMulti> calculerPaiements(RequeteResultatMulti requete) {
-        ResultatCourse resultat = creerResultat(requete);
+        ResultatCourseMulti resultat = creerResultat(requete);
         List<PariMulti> paris = pariRepository.findByCourseId(requete.getCourseId());
         List<ReponsePaiementMulti> paiements = new ArrayList<>();
 
@@ -168,9 +168,9 @@ public class ServiceMulti {
         return paiements;
     }
 
-    private ReponsePaiementMulti calculerPaiementPari(PariMulti pari, ResultatCourse resultat, Double masseAPartager) {
+    private ReponsePaiementMulti calculerPaiementPari(PariMulti pari, ResultatCourseMulti resultat, Double masseAPartager) {
-        List<Cheval> chevauxPari = pari.getChevauxSelectionnes();
+        List<ChevalMulti> chevauxPari = pari.getChevauxSelectionnes();
-        long nonPartants = chevauxPari.stream().filter(Cheval::getNonPartant).count();
+        long nonPartants = chevauxPari.stream().filter(ChevalMulti::getNonPartant).count();
 
         // Article 4: Gestion des non-partants et transformations
         if (doitEtreRembourse(pari.getTypeMulti(), nonPartants)) {
@@ -180,7 +180,7 @@ public class ServiceMulti {
 
         // Transformer les paris avec non-partants (Article 4)
         TypeMulti typeTransforme = transformerPari(pari.getTypeMulti(), nonPartants);
-        List<Cheval> chevauxParticipants = chevauxPari.stream()
+        List<ChevalMulti> chevauxParticipants = chevauxPari.stream()
                 .filter(cheval -> !cheval.getNonPartant())
                 .collect(Collectors.toList());
 
@@ -228,7 +228,7 @@ public class ServiceMulti {
         }
     }
 
-    private boolean estCombinaisonGagnante(List<Cheval> chevauxPari, ResultatCourse resultat) {
+    private boolean estCombinaisonGagnante(List<ChevalMulti> chevauxPari, ResultatCourseMulti resultat) {
         // Vérifier si au moins 4 chevaux sont dans les 4 premiers
         long countDansTop4 = chevauxPari.stream()
                 .filter(cheval -> estDansTop4(cheval, resultat))
@@ -236,14 +236,14 @@ public class ServiceMulti {
         return countDansTop4 >= 4;
     }
 
-    private boolean estDansTop4(Cheval cheval, ResultatCourse resultat) {
+    private boolean estDansTop4(ChevalMulti cheval, ResultatCourseMulti resultat) {
         return estDansListe(cheval, resultat.getPremiers()) ||
                 estDansListe(cheval, resultat.getSeconds()) ||
                 estDansListe(cheval, resultat.getTroisiemes()) ||
                 estDansListe(cheval, resultat.getQuatriemes());
     }
 
-    private boolean estDansListe(Cheval cheval, List<Cheval> liste) {
+    private boolean estDansListe(ChevalMulti cheval, List<ChevalMulti> liste) {
         return liste != null && liste.contains(cheval);
     }
 
@@ -520,7 +520,7 @@ public class ServiceMulti {
     }
 
     // Gestion des dead-heat (Article 3)
-    private TypeDeadHeat detecterDeadHeat(ResultatCourse resultat) {
+    private TypeDeadHeat detecterDeadHeat(ResultatCourseMulti resultat) {
         if (resultat.getPremiers().size() >= 4) return TypeDeadHeat.QUATRE_PREMIERS_OU_PLUS;
         if (resultat.getPremiers().size() >= 3 && resultat.getQuatriemes().size() >= 1)
             return TypeDeadHeat.TROIS_PREMIERS_UN_QUATRIEME;
@@ -540,7 +540,7 @@ public class ServiceMulti {
         return null;
     }
 
-    private List<ReponsePaiementMulti> gererDeadHeat(ResultatCourse resultat, TypeDeadHeat typeDeadHeat) {
+    private List<ReponsePaiementMulti> gererDeadHeat(ResultatCourseMulti resultat, TypeDeadHeat typeDeadHeat) {
         List<PariMulti> paris = pariRepository.findByCourseId(resultat.getCourse().getId());
         List<ReponsePaiementMulti> paiements = new ArrayList<>();
         Double masseAPartager = resultat.getMasseAPartager();
@@ -556,7 +556,7 @@ public class ServiceMulti {
         return paiements;
     }
 
-    private ReponsePaiementMulti calculerPaiementDeadHeat(PariMulti pari, ResultatCourse resultat,
+    private ReponsePaiementMulti calculerPaiementDeadHeat(PariMulti pari, ResultatCourseMulti resultat,
                                                           Double masseAPartager, TypeDeadHeat typeDeadHeat) {
         // Implémentation spécifique pour chaque type de dead-heat
         switch (typeDeadHeat) {
@@ -581,9 +581,9 @@ public class ServiceMulti {
         }
     }
 
-    private ReponsePaiementMulti gererDeadHeatQuatrePremiers(PariMulti pari, ResultatCourse resultat, Double masseAPartager) {
+    private ReponsePaiementMulti gererDeadHeatQuatrePremiers(PariMulti pari, ResultatCourseMulti resultat, Double masseAPartager) {
         // Article 3a: Dead-heat de 4+ chevaux premiers
-        List<Cheval> chevauxPari = pari.getChevauxSelectionnes();
+        List<ChevalMulti> chevauxPari = pari.getChevauxSelectionnes();
 
         // Vérifier si tous les chevaux du pari sont parmi les premiers
         if (chevauxPari.stream().allMatch(cheval -> estDansListe(cheval, resultat.getPremiers()))) {
@@ -596,9 +596,9 @@ public class ServiceMulti {
         return null;
     }
 
-    private ReponsePaiementMulti gererDeadHeatTroisPremiersUnQuatrieme(PariMulti pari, ResultatCourse resultat, Double masseAPartager) {
+    private ReponsePaiementMulti gererDeadHeatTroisPremiersUnQuatrieme(PariMulti pari, ResultatCourseMulti resultat, Double masseAPartager) {
         // Article 3b: Dead-heat de 3 premiers + 1+ quatrième
-        List<Cheval> chevauxPari = pari.getChevauxSelectionnes();
+        List<ChevalMulti> chevauxPari = pari.getChevauxSelectionnes();
 
         boolean troisPremiersOk = chevauxPari.subList(0, 3).stream()
                 .allMatch(cheval -> estDansListe(cheval, resultat.getPremiers()));
@@ -615,40 +615,40 @@ public class ServiceMulti {
     }
 
     // Implémentations similaires pour les autres types de dead-heat...
-    private ReponsePaiementMulti gererDeadHeatDeuxPremiersDeuxTroisiemes(PariMulti pari, ResultatCourse resultat, Double masseAPartager) {
+    private ReponsePaiementMulti gererDeadHeatDeuxPremiersDeuxTroisiemes(PariMulti pari, ResultatCourseMulti resultat, Double masseAPartager) {
         // Article 3c: Implémentation spécifique
         return calculerPaiementGeneriqueDeadHeat(pari, resultat, masseAPartager, 2.0);
     }
 
-    private ReponsePaiementMulti gererDeadHeatDeuxPremiersUnTroisiemeUnQuatrieme(PariMulti pari, ResultatCourse resultat, Double masseAPartager) {
+    private ReponsePaiementMulti gererDeadHeatDeuxPremiersUnTroisiemeUnQuatrieme(PariMulti pari, ResultatCourseMulti resultat, Double masseAPartager) {
         // Article 3d: Implémentation spécifique
         return calculerPaiementGeneriqueDeadHeat(pari, resultat, masseAPartager, 4.0);
     }
 
-    private ReponsePaiementMulti gererDeadHeatTroisSeconds(PariMulti pari, ResultatCourse resultat, Double masseAPartager) {
+    private ReponsePaiementMulti gererDeadHeatTroisSeconds(PariMulti pari, ResultatCourseMulti resultat, Double masseAPartager) {
         // Article 3e: Implémentation spécifique
         return calculerPaiementGeneriqueDeadHeat(pari, resultat, masseAPartager, 2.0);
     }
 
-    private ReponsePaiementMulti gererDeadHeatDeuxSecondsUnQuatrieme(PariMulti pari, ResultatCourse resultat, Double masseAPartager) {
+    private ReponsePaiementMulti gererDeadHeatDeuxSecondsUnQuatrieme(PariMulti pari, ResultatCourseMulti resultat, Double masseAPartager) {
         // Article 3f: Implémentation spécifique
         return calculerPaiementGeneriqueDeadHeat(pari, resultat, masseAPartager, 4.0);
     }
 
-    private ReponsePaiementMulti gererDeadHeatDeuxTroisiemes(PariMulti pari, ResultatCourse resultat, Double masseAPartager) {
+    private ReponsePaiementMulti gererDeadHeatDeuxTroisiemes(PariMulti pari, ResultatCourseMulti resultat, Double masseAPartager) {
         // Article 3g: Implémentation spécifique
         return calculerPaiementGeneriqueDeadHeat(pari, resultat, masseAPartager, 4.0);
     }
 
-    private ReponsePaiementMulti gererDeadHeatDeuxQuatriemes(PariMulti pari, ResultatCourse resultat, Double masseAPartager) {
+    private ReponsePaiementMulti gererDeadHeatDeuxQuatriemes(PariMulti pari, ResultatCourseMulti resultat, Double masseAPartager) {
         // Article 3h: Implémentation spécifique
         return calculerPaiementGeneriqueDeadHeat(pari, resultat, masseAPartager, 4.0);
     }
 
-    private ReponsePaiementMulti calculerPaiementGeneriqueDeadHeat(PariMulti pari, ResultatCourse resultat,
+    private ReponsePaiementMulti calculerPaiementGeneriqueDeadHeat(PariMulti pari, ResultatCourseMulti resultat,
                                                                    Double masseAPartager, Double coefficient) {
         // Méthode générique pour les dead-heat avec coefficient spécifique
-        List<Cheval> chevauxPari = pari.getChevauxSelectionnes();
+        List<ChevalMulti> chevauxPari = pari.getChevauxSelectionnes();
 
         if (chevauxPari.stream().allMatch(cheval ->
                 estDansListe(cheval, resultat.getPremiers()) ||
@@ -676,14 +676,14 @@ public class ServiceMulti {
         return resultat;
     }
 
-    private int compterCombinaisonsGagnantesDeadHeat(ResultatCourse resultat) {
+    private int compterCombinaisonsGagnantesDeadHeat(ResultatCourseMulti resultat) {
         // Comptage simplifié des combinaisons gagnantes
         // Implémentation réelle dépendrait de la structure exacte du dead-heat
         return 1;
     }
 
     // Gestion de la cagnotte (Articles 9 et 10)
-    private void transfererEnCagnotte(ResultatCourse resultat) {
+    private void transfererEnCagnotte(ResultatCourseMulti resultat) {
         CagnotteMulti cagnotte = CagnotteMulti.builder()
                 .montant(resultat.getMasseAPartager())
                 .dateCreation(LocalDateTime.now())
@@ -707,7 +707,7 @@ public class ServiceMulti {
         cagnotteRepository.save(cagnotte);
 
         // Ajouter le montant à la masse à partager de la course
-        ResultatCourse resultat = resultatRepository.findByCourseId(courseId);
+        ResultatCourseMulti resultat = resultatRepository.findByCourseId(courseId);
         if (resultat != null) {
             resultat.setMasseAPartager(resultat.getMasseAPartager() + cagnotte.getMontant());
             resultatRepository.save(resultat);
@@ -715,18 +715,18 @@ public class ServiceMulti {
     }
 
     // Méthodes utilitaires
-    private Double calculerMasseAPartager(ResultatCourse resultat) {
+    private Double calculerMasseAPartager(ResultatCourseMulti resultat) {
         // Article 5: MAP = RNET - MREMB - PRELEV
         return resultat.getRecetteNette() -
                 resultat.getMontantRembourse() -
                 resultat.getPrelevementsLegaux();
     }
 
-    private ResultatCourse creerResultat(RequeteResultatMulti requete) {
+    private ResultatCourseMulti creerResultat(RequeteResultatMulti requete) {
-        Course course = courseRepository.findById(requete.getCourseId())
+        CourseMulti course = courseRepository.findById(requete.getCourseId())
                 .orElseThrow(() -> new RuntimeException("Course non trouvée"));
 
-        return ResultatCourse.builder()
+        return ResultatCourseMulti.builder()
                 .course(course)
                 .premiers(chevalRepository.findAllById(requete.getPremiersIds()))
                 .seconds(chevalRepository.findAllById(requete.getSecondsIds()))
@@ -752,7 +752,7 @@ public class ServiceMulti {
     // Méthodes supplémentaires pour la gestion des cas particuliers (Article 9)
     @Transactional
     public List<ReponsePaiementMulti> gererCasParticuliers(RequeteResultatMulti requete) {
-        ResultatCourse resultat = creerResultat(requete);
+        ResultatCourseMulti resultat = creerResultat(requete);
         List<PariMulti> paris = pariRepository.findByCourseId(requete.getCourseId());
 
         // Article 9: Cas où il n'y a aucune mise sur la combinaison gagnante
@@ -763,7 +763,7 @@ public class ServiceMulti {
         return calculerPaiements(requete);
     }
 
-    private boolean existeParisGagnants(List<PariMulti> paris, ResultatCourse resultat) {
+    private boolean existeParisGagnants(List<PariMulti> paris, ResultatCourseMulti resultat) {
         for (PariMulti pari : paris) {
             if (estCombinaisonGagnante(pari.getChevauxSelectionnes(), resultat)) {
                 return true;
@@ -772,7 +772,7 @@ public class ServiceMulti {
         return false;
     }
 
-    private List<ReponsePaiementMulti> appliquerReglesDegradation(ResultatCourse resultat, List<PariMulti> paris) {
+    private List<ReponsePaiementMulti> appliquerReglesDegradation(ResultatCourseMulti resultat, List<PariMulti> paris) {
         // Article 9: Application des règles de dégradation
         List<ReponsePaiementMulti> paiements = new ArrayList<>();
         Double masseAPartager = resultat.getMasseAPartager();
@@ -794,10 +794,10 @@ public class ServiceMulti {
         return paiements;
     }
 
-    private ReponsePaiementMulti calculerPaiementDegrade(PariMulti pari, ResultatCourse resultat,
+    private ReponsePaiementMulti calculerPaiementDegrade(PariMulti pari, ResultatCourseMulti resultat,
                                                          Double masseAPartager, int niveauDegradation) {
         // Implémentation des règles de dégradation selon l'article 9
-        List<Cheval> chevauxPari = pari.getChevauxSelectionnes();
+        List<ChevalMulti> chevauxPari = pari.getChevauxSelectionnes();
 
         // Vérifier différents patterns de dégradation
         boolean estGagnant = false;
@@ -826,15 +826,15 @@ public class ServiceMulti {
         return null;
     }
 
-    private boolean estPatternDegrade(List<Cheval> chevauxPari, ResultatCourse resultat,
+    private boolean estPatternDegrade(List<ChevalMulti> chevauxPari, ResultatCourseMulti resultat,
                                       int pos1, int pos2, int pos3, int pos4) {
         // Vérifier un pattern spécifique de dégradation
         if (resultat.getOrdreArrivee().size() < 5) return false;
 
-        Cheval cheval1 = resultat.getOrdreArrivee().get(pos1);
+        ChevalMulti cheval1 = resultat.getOrdreArrivee().get(pos1);
-        Cheval cheval2 = resultat.getOrdreArrivee().get(pos2);
+        ChevalMulti cheval2 = resultat.getOrdreArrivee().get(pos2);
-        Cheval cheval3 = resultat.getOrdreArrivee().get(pos3);
+        ChevalMulti cheval3 = resultat.getOrdreArrivee().get(pos3);
-        Cheval cheval4 = resultat.getOrdreArrivee().get(pos4);
+        ChevalMulti cheval4 = resultat.getOrdreArrivee().get(pos4);
 
         return chevauxPari.contains(cheval1) &&
                 chevauxPari.contains(cheval2) &&
@@ -858,7 +858,7 @@ public class ServiceMulti {
     }
 
     public Double getMasseAPartagerCourse(Long courseId) {
-        ResultatCourse resultat = resultatRepository.findByCourseId(courseId);
+        ResultatCourseMulti resultat = resultatRepository.findByCourseId(courseId);
         return resultat != null ? resultat.getMasseAPartager() : 0.0;
     }
 

src/main/java/com/pmumali/ch11_quinteplus/InitData.java

@@ -1,9 +1,9 @@
 package com.pmumali.ch11_quinteplus;
 
-import com.pmumali.ch11_quinteplus.model.Cheval;
+import com.pmumali.ch11_quinteplus.model.ChevalQuintePlus;
-import com.pmumali.ch11_quinteplus.model.Course;
+import com.pmumali.ch11_quinteplus.model.CourseQuintePlus;
-import com.pmumali.ch11_quinteplus.repository.ChevalRepository;
+import com.pmumali.ch11_quinteplus.repository.ChevalQuintePlusRepository;
-import com.pmumali.ch11_quinteplus.repository.CourseRepository;
+import com.pmumali.ch11_quinteplus.repository.CourseQuintePlusRepository;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.CommandLineRunner;
 import org.springframework.stereotype.Component;
@@ -14,54 +14,54 @@ import java.util.Arrays;
 public class InitData implements CommandLineRunner {
 
     @Autowired
-    private CourseRepository repositoryCourse;
+    private CourseQuintePlusRepository repositoryCourse;
 
     @Autowired
-    private ChevalRepository repositoryCheval;
+    private ChevalQuintePlusRepository repositoryCheval;
 
     @Override
     public void run(String... args) throws Exception {
         // Création d'une course de test
-        Course course = new Course();
+  /*      CourseQuintePlus course = new CourseQuintePlus();
         course.setNom("Course du 15 août");
         course.setDate(LocalDateTime.now().plusDays(1));
         course.setLieu("Hippodrome de Bamako");
         course.setEstTerminee(false);
 
-        Course courseSauvee = repositoryCourse.save(course);
+        CourseQuintePlus courseSauvee = repositoryCourse.save(course);
 
         // Création de chevaux de test
-        Cheval cheval1 = new Cheval();
+        ChevalQuintePlus cheval1 = new ChevalQuintePlus();
         cheval1.setNom("Foudre");
         cheval1.setNumero(1);
-        cheval1.setEstNonPartant(false);
+        cheval1.setNonPartant(false);
         cheval1.setCourse(courseSauvee);
 
-        Cheval cheval2 = new Cheval();
+        ChevalQuintePlus cheval2 = new ChevalQuintePlus();
         cheval2.setNom("Éclair");
         cheval2.setNumero(2);
-        cheval2.setEstNonPartant(false);
+        cheval2.setNonPartant(false);
         cheval2.setCourse(courseSauvee);
 
-        Cheval cheval3 = new Cheval();
+        ChevalQuintePlus cheval3 = new ChevalQuintePlus();
         cheval3.setNom("Tonnerre");
         cheval3.setNumero(3);
-        cheval3.setEstNonPartant(false);
+        cheval3.setNonPartant(false);
         cheval3.setCourse(courseSauvee);
 
-        Cheval cheval4 = new Cheval();
+        ChevalQuintePlus cheval4 = new ChevalQuintePlus();
         cheval4.setNom("Vent");
         cheval4.setNumero(4);
-        cheval4.setEstNonPartant(false);
+        cheval4.setNonPartant(false);
         cheval4.setCourse(courseSauvee);
 
-        Cheval cheval5 = new Cheval();
+        ChevalQuintePlus cheval5 = new ChevalQuintePlus();
         cheval5.setNom("Pluie");
         cheval5.setNumero(5);
-        cheval5.setEstNonPartant(false);
+        cheval5.setNonPartant(false);
         cheval5.setCourse(courseSauvee);
 
-        repositoryCheval.saveAll(Arrays.asList(cheval1, cheval2, cheval3, cheval4, cheval5));
+        repositoryCheval.saveAll(Arrays.asList(cheval1, cheval2, cheval3, cheval4, cheval5));*/
     }
 }
 

src/main/java/com/pmumali/ch11_quinteplus/controller/ControleurCagnotteQuintePlus.java

@@ -2,31 +2,31 @@ package com.pmumali.ch11_quinteplus.controller;
 
 
 
-import com.pmumali.ch11_quinteplus.model.Cagnotte;
+import com.pmumali.ch11_quinteplus.model.CagnotteQuintePlus;
-import com.pmumali.ch11_quinteplus.service.ServiceCagnotte;
+import com.pmumali.ch11_quinteplus.service.ServiceCagnotteQuintePlus;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 import java.util.List;
 
 @RestController
-@RequestMapping("/api/cagnotte")
+@RequestMapping("/api/quinteplus/cagnotte")
-public class ControleurCagnotte {
+public class ControleurCagnotteQuintePlus {
 
     @Autowired
-    private ServiceCagnotte serviceCagnotte;
+    private ServiceCagnotteQuintePlus serviceCagnotte;
 
-    @GetMapping("/montant")
+  //  @GetMapping("/montant")
     public ResponseEntity<Double> getMontantCagnotteActive() {
         return ResponseEntity.ok(serviceCagnotte.getMontantCagnotteActive());
     }
 
-    @GetMapping("/historique")
+  //  @GetMapping("/historique")
-    public ResponseEntity<List<Cagnotte>> getHistoriqueCagnottes() {
+    public ResponseEntity<List<CagnotteQuintePlus>> getHistoriqueCagnottes() {
         return ResponseEntity.ok(serviceCagnotte.getHistoriqueCagnottes());
     }
 
-    @PostMapping("/gerer-cas-particuliers")
+  //  @PostMapping("/gerer-cas-particuliers")
     public ResponseEntity<String> gererCasParticuliers() {
         serviceCagnotte.gererCasParticuliersCagnotte();
         return ResponseEntity.ok("Cas particuliers de cagnotte gérés avec succès");

src/main/java/com/pmumali/ch11_quinteplus/controller/ControleurCourse.java

@@ -1,55 +0,0 @@
-package com.pmumali.ch11_quinteplus.controller;
-
-import com.pmumali.ch11_quinteplus.model.Course;
-import com.pmumali.ch11_quinteplus.service.ServiceCourse;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.*;
-
-import java.util.List;
-
-@RestController
-@RequestMapping("/api/courses")
-public class ControleurCourse {
-
-    @Autowired
-    private ServiceCourse serviceCourse;
-
-    @PostMapping
-    public ResponseEntity<Course> creerCourse(@RequestBody Course course) {
-        return ResponseEntity.ok(serviceCourse.creerCourse(course));
-    }
-
-    @GetMapping
-    public ResponseEntity<List<Course>> obtenirToutesCourses() {
-        return ResponseEntity.ok(serviceCourse.obtenirToutesCourses());
-    }
-
-    @GetMapping("/{id}")
-    public ResponseEntity<Course> obtenirCourseParId(@PathVariable Long id) {
-        Course course = serviceCourse.obtenirCourseParId(id);
-        return course != null ? ResponseEntity.ok(course) : ResponseEntity.notFound().build();
-    }
-
-    @GetMapping("/terminees")
-    public ResponseEntity<List<Course>> obtenirCoursesTerminees() {
-        return ResponseEntity.ok(serviceCourse.obtenirCoursesTerminees());
-    }
-
-    @GetMapping("/avenir")
-    public ResponseEntity<List<Course>> obtenirCoursesAVenir() {
-        return ResponseEntity.ok(serviceCourse.obtenirCoursesAVenir());
-    }
-
-    @PutMapping("/{id}")
-    public ResponseEntity<Course> mettreAJourCourse(@PathVariable Long id, @RequestBody Course course) {
-        Course courseMaj = serviceCourse.mettreAJourCourse(id, course);
-        return courseMaj != null ? ResponseEntity.ok(courseMaj) : ResponseEntity.notFound().build();
-    }
-
-    @DeleteMapping("/{id}")
-    public ResponseEntity<?> supprimerCourse(@PathVariable Long id) {
-        boolean supprime = serviceCourse.supprimerCourse(id);
-        return supprime ? ResponseEntity.ok().build() : ResponseEntity.notFound().build();
-    }
-}

src/main/java/com/pmumali/ch11_quinteplus/controller/ControleurCourseQuintePlus.java

@@ -0,0 +1,55 @@
+package com.pmumali.ch11_quinteplus.controller;
+
+import com.pmumali.ch11_quinteplus.model.CourseQuintePlus;
+import com.pmumali.ch11_quinteplus.service.ServiceCourseQuintePlus;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/quinteplus/courses")
+public class ControleurCourseQuintePlus {
+
+    @Autowired
+    private ServiceCourseQuintePlus serviceCourse;
+
+  //  @PostMapping
+    public ResponseEntity<CourseQuintePlus> creerCourse(@RequestBody CourseQuintePlus course) {
+        return ResponseEntity.ok(serviceCourse.creerCourse(course));
+    }
+
+  //  @GetMapping
+    public ResponseEntity<List<CourseQuintePlus>> obtenirToutesCourses() {
+        return ResponseEntity.ok(serviceCourse.obtenirToutesCourses());
+    }
+
+   // @GetMapping("/{id}")
+    public ResponseEntity<CourseQuintePlus> obtenirCourseParId(@PathVariable Long id) {
+        CourseQuintePlus course = serviceCourse.obtenirCourseParId(id);
+        return course != null ? ResponseEntity.ok(course) : ResponseEntity.notFound().build();
+    }
+
+  //  @GetMapping("/terminees")
+    public ResponseEntity<List<CourseQuintePlus>> obtenirCoursesTerminees() {
+        return ResponseEntity.ok(serviceCourse.obtenirCoursesTerminees());
+    }
+
+  //  @GetMapping("/avenir")
+    public ResponseEntity<List<CourseQuintePlus>> obtenirCoursesAVenir() {
+        return ResponseEntity.ok(serviceCourse.obtenirCoursesAVenir());
+    }
+
+  //  @PutMapping("/{id}")
+    public ResponseEntity<CourseQuintePlus> mettreAJourCourse(@PathVariable Long id, @RequestBody CourseQuintePlus course) {
+        CourseQuintePlus courseMaj = serviceCourse.mettreAJourCourse(id, course);
+        return courseMaj != null ? ResponseEntity.ok(courseMaj) : ResponseEntity.notFound().build();
+    }
+
+  //  @DeleteMapping("/{id}")
+    public ResponseEntity<?> supprimerCourse(@PathVariable Long id) {
+        boolean supprime = serviceCourse.supprimerCourse(id);
+        return supprime ? ResponseEntity.ok().build() : ResponseEntity.notFound().build();
+    }
+}

src/main/java/com/pmumali/ch11_quinteplus/controller/ControleurGains.java

@@ -1,29 +0,0 @@
-package com.pmumali.ch11_quinteplus.controller;
-
-import com.pmumali.ch11_quinteplus.model.Gains;
-import com.pmumali.ch11_quinteplus.model.Resultat;
-import com.pmumali.ch11_quinteplus.service.ServiceGains;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.*;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
-
-@RestController
-@RequestMapping("/api/gains")
-public class ControleurGains {
-
-    @Autowired
-    private ServiceGains serviceGains;
-
-    @PostMapping("/calculer/{courseId}")
-    public ResponseEntity<Gains> calculerGains(@PathVariable Long courseId, @RequestBody Resultat resultat) {
-        return ResponseEntity.ok(serviceGains.calculerGains(courseId, resultat));
-    }
-
-    @GetMapping("/course/{courseId}")
-    public ResponseEntity<Gains> obtenirGainsParCourse(@PathVariable Long courseId) {
-        Gains gains = serviceGains.obtenirGainsParCourse(courseId);
-        return gains != null ? ResponseEntity.ok(gains) : ResponseEntity.notFound().build();
-    }
-}

src/main/java/com/pmumali/ch11_quinteplus/controller/ControleurGainsQuintePlus.java

@@ -0,0 +1,29 @@
+package com.pmumali.ch11_quinteplus.controller;
+
+import com.pmumali.ch11_quinteplus.model.GainsQuintePlus;
+import com.pmumali.ch11_quinteplus.model.ResultatQuintePlus;
+import com.pmumali.ch11_quinteplus.service.ServiceGainsQuintePlus;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/api/quinteplus/gains")
+public class ControleurGainsQuintePlus {
+
+    @Autowired
+    private ServiceGainsQuintePlus serviceGains;
+
+  //  @PostMapping("/calculer/{courseId}")
+    public ResponseEntity<GainsQuintePlus> calculerGains(@PathVariable Long courseId, @RequestBody ResultatQuintePlus resultat) {
+        return ResponseEntity.ok(serviceGains.calculerGains(courseId, resultat));
+    }
+
+  //  @GetMapping("/course/{courseId}")
+    public ResponseEntity<GainsQuintePlus> obtenirGainsParCourse(@PathVariable Long courseId) {
+        GainsQuintePlus gains = serviceGains.obtenirGainsParCourse(courseId);
+        return gains != null ? ResponseEntity.ok(gains) : ResponseEntity.notFound().build();
+    }
+}

src/main/java/com/pmumali/ch11_quinteplus/controller/ControleurPari.java

@@ -1,51 +0,0 @@
-package com.pmumali.ch11_quinteplus.controller;
-
-import com.pmumali.ch11_quinteplus.model.Pari;
-import com.pmumali.ch11_quinteplus.service.ServicePari;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.*;
-
-import java.util.List;
-
-@RestController
-@RequestMapping("/api/paris")
-public class ControleurPari {
-
-    @Autowired
-    private ServicePari servicePari;
-
-    @PostMapping
-    public ResponseEntity<Pari> placerPari(@RequestBody Pari pari) {
-        return ResponseEntity.ok(servicePari.placerPari(pari));
-    }
-
-    @GetMapping("/course/{courseId}")
-    public ResponseEntity<List<Pari>> obtenirParisParCourse(@PathVariable Long courseId) {
-        return ResponseEntity.ok(servicePari.obtenirParisParCourse(courseId));
-    }
-
-    @GetMapping("/parieur/{nomParieur}")
-    public ResponseEntity<List<Pari>> obtenirParisParParieur(@PathVariable String nomParieur) {
-        return ResponseEntity.ok(servicePari.obtenirParisParParieur(nomParieur));
-    }
-
-    @GetMapping("/{id}")
-    public ResponseEntity<Pari> obtenirPariParId(@PathVariable Long id) {
-        Pari pari = servicePari.obtenirPariParId(id);
-        return pari != null ? ResponseEntity.ok(pari) : ResponseEntity.notFound().build();
-    }
-
-    @PutMapping("/{id}")
-    public ResponseEntity<Pari> mettreAJourPari(@PathVariable Long id, @RequestBody Pari pari) {
-        Pari pariMaj = servicePari.mettreAJourPari(id, pari);
-        return pariMaj != null ? ResponseEntity.ok(pariMaj) : ResponseEntity.notFound().build();
-    }
-
-    @DeleteMapping("/{id}")
-    public ResponseEntity<?> supprimerPari(@PathVariable Long id) {
-        boolean supprime = servicePari.supprimerPari(id);
-        return supprime ? ResponseEntity.ok().build() : ResponseEntity.notFound().build();
-    }
-}
-

src/main/java/com/pmumali/ch11_quinteplus/controller/ControleurPariQuintePlus.java

@@ -0,0 +1,51 @@
+package com.pmumali.ch11_quinteplus.controller;
+
+import com.pmumali.ch11_quinteplus.model.PariQuintePlus;
+import com.pmumali.ch11_quinteplus.service.ServicePariQuintePlus;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/quinteplus")
+public class ControleurPariQuintePlus {
+
+    @Autowired
+    private ServicePariQuintePlus servicePari;
+
+    @PostMapping("/pari")
+    public ResponseEntity<PariQuintePlus> placerPari(@RequestBody PariQuintePlus pari) {
+        return ResponseEntity.ok(servicePari.placerPari(pari));
+    }
+
+ //   @GetMapping("/course/{courseId}")
+    public ResponseEntity<List<PariQuintePlus>> obtenirParisParCourse(@PathVariable Long courseId) {
+        return ResponseEntity.ok(servicePari.obtenirParisParCourse(courseId));
+    }
+
+  //  @GetMapping("/parieur/{nomParieur}")
+    public ResponseEntity<List<PariQuintePlus>> obtenirParisParParieur(@PathVariable String nomParieur) {
+        return ResponseEntity.ok(servicePari.obtenirParisParParieur(nomParieur));
+    }
+
+  //  @GetMapping("/{id}")
+    public ResponseEntity<PariQuintePlus> obtenirPariParId(@PathVariable Long id) {
+        PariQuintePlus pari = servicePari.obtenirPariParId(id);
+        return pari != null ? ResponseEntity.ok(pari) : ResponseEntity.notFound().build();
+    }
+
+   // @PutMapping("/{id}")
+    public ResponseEntity<PariQuintePlus> mettreAJourPari(@PathVariable Long id, @RequestBody PariQuintePlus pari) {
+        PariQuintePlus pariMaj = servicePari.mettreAJourPari(id, pari);
+        return pariMaj != null ? ResponseEntity.ok(pariMaj) : ResponseEntity.notFound().build();
+    }
+
+  //  @DeleteMapping("/{id}")
+    public ResponseEntity<?> supprimerPari(@PathVariable Long id) {
+        boolean supprime = servicePari.supprimerPari(id);
+        return supprime ? ResponseEntity.ok().build() : ResponseEntity.notFound().build();
+    }
+}
+

src/main/java/com/pmumali/ch11_quinteplus/model/CagnotteQuintePlus.java

@@ -1,12 +1,18 @@
 package com.pmumali.ch11_quinteplus.model;
 
 import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 import java.time.LocalDateTime;
 
 @Data
-public class Cagnotte {
+@Entity
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "cagnotte_quinteplus")
+public class CagnotteQuintePlus {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
@@ -18,15 +24,15 @@ public class Cagnotte {
 
     @ManyToOne
     @JoinColumn(name = "course_source_id")
-    private Course courseSource;
+    private CourseQuintePlus courseSource;
 
     @ManyToOne
     @JoinColumn(name = "course_destination_id")
-    private Course courseDestination;
+    private CourseQuintePlus courseDestination;
 
     private String typeCagnotte; // ORDRE_EXACT, ORDRE_INEXACT, COMBINEE
 
-    public Cagnotte(double montant, Course courseSource, String typeCagnotte) {
+    public CagnotteQuintePlus(double montant, CourseQuintePlus courseSource, String typeCagnotte) {
         this.montant = montant;
         this.courseSource = courseSource;
         this.typeCagnotte = typeCagnotte;

src/main/java/com/pmumali/ch11_quinteplus/model/ChevalQuintePlus.java

@@ -8,16 +8,17 @@ import lombok.*;
 @NoArgsConstructor
 @AllArgsConstructor
 @Table(name = "cheval")
-public class Cheval {
+public class ChevalQuintePlus {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
 
     private String nom;
     private int numero;
-    private boolean estNonPartant;
+    @Column(name = "non_partant")
+    private boolean nonPartant;
 
     @ManyToOne
     @JoinColumn(name = "course_id")
-    private Course course;
+    private CourseQuintePlus course;
 }

src/main/java/com/pmumali/ch11_quinteplus/model/CourseDtoQuintePlus.java

@@ -6,7 +6,7 @@ import java.time.LocalDateTime;
 import java.util.List;
 
 @Data
-public class CourseDto {
+public class CourseDtoQuintePlus {
     private Long id;
     private String nom;
     private LocalDateTime date;

src/main/java/com/pmumali/ch11_quinteplus/model/CourseQuintePlus.java

@@ -14,19 +14,20 @@ import java.util.List;
 @NoArgsConstructor
 @AllArgsConstructor
 @Table(name = "course")
-public class Course {
+public class CourseQuintePlus {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
 
     private String nom;
+    @Column(name = "heure_course")
     private LocalDateTime date;
     private String lieu;
     private boolean estTerminee;
 
     @OneToMany(mappedBy = "course", cascade = CascadeType.ALL)
-    private List<Cheval> chevaux;
+    private List<ChevalQuintePlus> chevaux;
 
     @OneToOne(mappedBy = "course", cascade = CascadeType.ALL)
-    private Resultat resultat;
+    private ResultatQuintePlus resultat;
 }

src/main/java/com/pmumali/ch11_quinteplus/model/GainsDtoQuintePlus.java

@@ -5,7 +5,7 @@ import lombok.Data;
 import java.time.LocalDateTime;
 
 @Data
-public class GainsDto {
+public class GainsDtoQuintePlus {
     private Long id;
     private Long courseId;
     private double masseOrdreExact;

src/main/java/com/pmumali/ch11_quinteplus/model/GainsQuintePlus.java

@@ -10,14 +10,14 @@ import java.time.LocalDateTime;
 @NoArgsConstructor
 @AllArgsConstructor
 @Table(name = "gains")
-public class Gains {
+public class GainsQuintePlus {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
 
     @ManyToOne
     @JoinColumn(name = "course_id")
-    private Course course;
+    private CourseQuintePlus course;
 
     private double masseOrdreExact;
     private double masseOrdreInexact;

src/main/java/com/pmumali/ch11_quinteplus/model/PariDtoQuintePlus.java

@@ -6,7 +6,7 @@ import java.time.LocalDateTime;
 import java.util.List;
 
 @Data
-public class PariDto {
+public class PariDtoQuintePlus {
     private Long id;
     private String nomParieur;
     private LocalDateTime datePari;

src/main/java/com/pmumali/ch11_quinteplus/model/PariQuintePlus.java

@@ -11,7 +11,7 @@ import java.util.List;
 @NoArgsConstructor
 @AllArgsConstructor
 @Table(name = "pari")
-public class Pari {
+public class PariQuintePlus {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
@@ -22,14 +22,14 @@ public class Pari {
 
     @ManyToOne
     @JoinColumn(name = "course_id")
-    private Course course;
+    private CourseQuintePlus course;
 
     @ElementCollection
     private List<Long> chevauxSelectionnes;
 
     @ElementCollection
     private List<Integer> ordrePredit;
-
+    @Column(name = "type_pari")
     private String typePari;
 
     private boolean estPaye;

src/main/java/com/pmumali/ch11_quinteplus/model/ResultatQuintePlus.java

@@ -9,15 +9,15 @@ import java.util.List;
 @Data
 @NoArgsConstructor
 @AllArgsConstructor
-@Table(name = "resultat")
+@Table(name = "resultat_course")
-public class Resultat {
+public class ResultatQuintePlus {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
 
     @OneToOne
     @JoinColumn(name = "course_id")
-    private Course course;
+    private CourseQuintePlus course;
 
     @ElementCollection
     private List<Long> idsChevauxOrdreArrivee;

src/main/java/com/pmumali/ch11_quinteplus/repository/CagnotteQuintePlusRepository.java

@@ -0,0 +1,14 @@
+package com.pmumali.ch11_quinteplus.repository;
+
+import com.pmumali.ch11_quinteplus.model.CagnotteQuintePlus;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+import java.util.List;
+
+@Repository
+public interface CagnotteQuintePlusRepository extends JpaRepository<CagnotteQuintePlus, Long> {
+    List<CagnotteQuintePlus> findByStatut(String statut);
+    List<CagnotteQuintePlus> findByCourseSourceId(Long courseId);
+    List<CagnotteQuintePlus> findByCourseDestinationId(Long courseId);
+    List<CagnotteQuintePlus> findByTypeCagnotte(String typeCagnotte);
+}

src/main/java/com/pmumali/ch11_quinteplus/repository/CagnotteRepository.java

@@ -1,14 +0,0 @@
-package com.pmumali.ch11_quinteplus.repository;
-
-import com.pmumali.ch11_quinteplus.model.Cagnotte;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
-import java.util.List;
-
-@Repository
-public interface CagnotteRepository extends JpaRepository<Cagnotte, Long> {
-    List<Cagnotte> findByStatut(String statut);
-    List<Cagnotte> findByCourseSourceId(Long courseId);
-    List<Cagnotte> findByCourseDestinationId(Long courseId);
-    List<Cagnotte> findByTypeCagnotte(String typeCagnotte);
-}

src/main/java/com/pmumali/ch11_quinteplus/repository/ChevalQuintePlusRepository.java

@@ -0,0 +1,12 @@
+package com.pmumali.ch11_quinteplus.repository;
+
+import com.pmumali.ch11_quinteplus.model.ChevalQuintePlus;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface ChevalQuintePlusRepository extends JpaRepository<ChevalQuintePlus, Long> {
+    List<ChevalQuintePlus> findByCourseId(Long courseId);
+}

src/main/java/com/pmumali/ch11_quinteplus/repository/ChevalRepository.java

@@ -1,12 +0,0 @@
-package com.pmumali.ch11_quinteplus.repository;
-
-import com.pmumali.ch11_quinteplus.model.Cheval;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
-
-import java.util.List;
-
-@Repository
-public interface ChevalRepository extends JpaRepository<Cheval, Long> {
-    List<Cheval> findByCourseId(Long courseId);
-}

src/main/java/com/pmumali/ch11_quinteplus/repository/CourseQuintePlusRepository.java

@@ -0,0 +1,11 @@
+package com.pmumali.ch11_quinteplus.repository;
+
+import com.pmumali.ch11_quinteplus.model.CourseQuintePlus;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+import java.util.List;
+
+@Repository
+public interface CourseQuintePlusRepository extends JpaRepository<CourseQuintePlus, Long> {
+    List<CourseQuintePlus> findByEstTerminee(boolean estTerminee);
+}

src/main/java/com/pmumali/ch11_quinteplus/repository/CourseRepository.java

@@ -1,11 +0,0 @@
-package com.pmumali.ch11_quinteplus.repository;
-
-import com.pmumali.ch11_quinteplus.model.Course;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
-import java.util.List;
-
-@Repository
-public interface CourseRepository extends JpaRepository<Course, Long> {
-    List<Course> findByEstTerminee(boolean estTerminee);
-}

src/main/java/com/pmumali/ch11_quinteplus/repository/GainsQuintePlusRepository.java

@@ -0,0 +1,10 @@
+package com.pmumali.ch11_quinteplus.repository;
+
+import com.pmumali.ch11_quinteplus.model.GainsQuintePlus;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface GainsQuintePlusRepository extends JpaRepository<GainsQuintePlus, Long> {
+    GainsQuintePlus findByCourseId(Long courseId);
+}

src/main/java/com/pmumali/ch11_quinteplus/repository/GainsRepository.java

@@ -1,10 +0,0 @@
-package com.pmumali.ch11_quinteplus.repository;
-
-import com.pmumali.ch11_quinteplus.model.Gains;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
-
-@Repository
-public interface GainsRepository extends JpaRepository<Gains, Long> {
-    Gains findByCourseId(Long courseId);
-}

src/main/java/com/pmumali/ch11_quinteplus/repository/PariQuintePlusRepository.java

@@ -0,0 +1,13 @@
+package com.pmumali.ch11_quinteplus.repository;
+
+import com.pmumali.ch11_quinteplus.model.PariQuintePlus;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface PariQuintePlusRepository extends JpaRepository<PariQuintePlus, Long> {
+    List<PariQuintePlus> findByCourseId(Long courseId);
+    List<PariQuintePlus> findByNomParieur(String nomParieur);
+}

src/main/java/com/pmumali/ch11_quinteplus/repository/PariRepository.java

@@ -1,13 +0,0 @@
-package com.pmumali.ch11_quinteplus.repository;
-
-import com.pmumali.ch11_quinteplus.model.Pari;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
-
-import java.util.List;
-
-@Repository
-public interface PariRepository extends JpaRepository<Pari, Long> {
-    List<Pari> findByCourseId(Long courseId);
-    List<Pari> findByNomParieur(String nomParieur);
-}

src/main/java/com/pmumali/ch11_quinteplus/repository/ResultatQuintePlusRepository.java

@@ -0,0 +1,9 @@
+package com.pmumali.ch11_quinteplus.repository;
+
+import com.pmumali.ch11_quinteplus.model.ResultatQuintePlus;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface ResultatQuintePlusRepository extends JpaRepository<ResultatQuintePlus,Long> {
+
+    ResultatQuintePlus findByCourseId(Long courseId);
+}

src/main/java/com/pmumali/ch11_quinteplus/repository/ResultatRepository.java

@@ -1,9 +0,0 @@
-package com.pmumali.ch11_quinteplus.repository;
-
-import com.pmumali.ch11_quinteplus.model.Resultat;
-import org.springframework.data.jpa.repository.JpaRepository;
-
-public interface ResultatRepository extends JpaRepository<Resultat,Long> {
-
-    Resultat  findByCourseId(Long courseId);
-}

src/main/java/com/pmumali/ch11_quinteplus/service/ServiceCagnotteQuintePlus.java

@@ -1,9 +1,9 @@
 package com.pmumali.ch11_quinteplus.service;
 
 import com.pmumali.ch11_quinteplus.model.*;
-import com.pmumali.ch11_quinteplus.repository.CagnotteRepository;
+import com.pmumali.ch11_quinteplus.repository.CagnotteQuintePlusRepository;
-import com.pmumali.ch11_quinteplus.repository.CourseRepository;
+import com.pmumali.ch11_quinteplus.repository.CourseQuintePlusRepository;
-import com.pmumali.ch11_quinteplus.repository.GainsRepository;
+import com.pmumali.ch11_quinteplus.repository.GainsQuintePlusRepository;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -15,24 +15,24 @@ import java.util.stream.Collectors;
 
 @Service
 @Transactional
-public class ServiceCagnotte {
+public class ServiceCagnotteQuintePlus {
 
     @Autowired
-    private CagnotteRepository cagnotteRepository;
+    private CagnotteQuintePlusRepository cagnotteRepository;
 
     @Autowired
-    private CourseRepository repositoryCourse;
+    private CourseQuintePlusRepository repositoryCourse;
 
     @Autowired
-    private GainsRepository repositoryGains;
+    private GainsQuintePlusRepository repositoryGains;
 
     // Méthode principale pour gérer la cagnotte selon l'article 9
-    public void gererCagnotte(Gains gains, List<Pari> paris, Resultat resultat) {
+    public void gererCagnotte(GainsQuintePlus gains, List<PariQuintePlus> paris, ResultatQuintePlus resultat) {
-        Course course = gains.getCourse();
+        CourseQuintePlus course = gains.getCourse();
 
         // Vérifier s'il n'y a aucun gagnant dans une catégorie
-        List<Pari> gagnantsOrdreExact = determinerGagnantsOrdreExact(paris, resultat);
+        List<PariQuintePlus> gagnantsOrdreExact = determinerGagnantsOrdreExact(paris, resultat);
-        List<Pari> gagnantsOrdreInexact = determinerGagnantsOrdreInexact(paris, resultat);
+        List<PariQuintePlus> gagnantsOrdreInexact = determinerGagnantsOrdreInexact(paris, resultat);
 
         double montantCagnotte = 0.0;
         boolean cagnotteOrdreExact = false;
@@ -57,7 +57,7 @@ public class ServiceCagnotte {
         // Si une cagnotte doit être créée
         if (montantCagnotte > 0) {
             String typeCagnotte = determinerTypeCagnotte(cagnotteOrdreExact, cagnotteOrdreInexact);
-            Cagnotte cagnotte = new Cagnotte(montantCagnotte, course, typeCagnotte);
+            CagnotteQuintePlus cagnotte = new CagnotteQuintePlus(montantCagnotte, course, typeCagnotte);
             cagnotteRepository.save(cagnotte);
 
             // Mettre à jour le gain avec le montant de la cagnotte
@@ -79,15 +79,15 @@ public class ServiceCagnotte {
     }
 
     // Méthode pour reporter les cagnottes vers la prochaine course
-    public void reporterCagnottesVersProchaineCourse(Course courseActuelle) {
+    public void reporterCagnottesVersProchaineCourse(CourseQuintePlus courseActuelle) {
         // Trouver toutes les cagnottes actives
-        List<Cagnotte> cagnottesActives = cagnotteRepository.findByStatut("ACTIVE");
+        List<CagnotteQuintePlus> cagnottesActives = cagnotteRepository.findByStatut("ACTIVE");
 
         // Trouver la prochaine course
-        Course prochaineCourse = trouverProchaineCourse(courseActuelle);
+        CourseQuintePlus prochaineCourse = trouverProchaineCourse(courseActuelle);
 
         if (prochaineCourse != null) {
-            for (Cagnotte cagnotte : cagnottesActives) {
+            for (CagnotteQuintePlus cagnotte : cagnottesActives) {
                 // Article 9b: Reporter la cagnotte vers la prochaine course
                 cagnotte.setCourseDestination(prochaineCourse);
                 cagnotte.setDateDerniereModification(LocalDateTime.now());
@@ -95,7 +95,7 @@ public class ServiceCagnotte {
             }
         } else {
             // Article 9d: Si pas de course la semaine suivante, reporter à la prochaine disponible
-            for (Cagnotte cagnotte : cagnottesActives) {
+            for (CagnotteQuintePlus cagnotte : cagnottesActives) {
                 cagnotte.setStatut("REPORTEE");
                 cagnotte.setDateDerniereModification(LocalDateTime.now());
                 cagnotteRepository.save(cagnotte);
@@ -104,13 +104,13 @@ public class ServiceCagnotte {
     }
 
     // Méthode pour appliquer les cagnottes reportées à une course
-    public void appliquerCagnottesReportees(Course course) {
+    public void appliquerCagnottesReportees(CourseQuintePlus course) {
         // Trouver toutes les cagnottes reportées pour cette course
-        List<Cagnotte> cagnottesReportees = cagnotteRepository.findByCourseDestinationId(course.getId());
+        List<CagnotteQuintePlus> cagnottesReportees = cagnotteRepository.findByCourseDestinationId(course.getId());
 
         double montantTotalCagnotte = 0.0;
 
-        for (Cagnotte cagnotte : cagnottesReportees) {
+        for (CagnotteQuintePlus cagnotte : cagnottesReportees) {
             if ("REPORTEE".equals(cagnotte.getStatut())) {
                 montantTotalCagnotte += cagnotte.getMontant();
 
@@ -123,10 +123,10 @@ public class ServiceCagnotte {
 
         // Appliquer la cagnotte à la masse à partager de la course
         if (montantTotalCagnotte > 0) {
-            Optional<Gains> gainsOpt = Optional.ofNullable(repositoryGains.findByCourseId(course.getId()));
+            Optional<GainsQuintePlus> gainsOpt = Optional.ofNullable(repositoryGains.findByCourseId(course.getId()));
 
             if (gainsOpt.isPresent()) {
-                Gains gains = gainsOpt.get();
+                GainsQuintePlus gains = gainsOpt.get();
 
                 // Article 9b: Ajouter la cagnotte à la masse à partager de l'ordre exact
                 gains.setMasseOrdreExact(gains.getMasseOrdreExact() + montantTotalCagnotte);
@@ -138,11 +138,11 @@ public class ServiceCagnotte {
     }
 
     // Méthode pour trouver la prochaine course après une date donnée
-    private Course trouverProchaineCourse(Course courseActuelle) {
+    private CourseQuintePlus trouverProchaineCourse(CourseQuintePlus courseActuelle) {
-        List<Course> toutesCourses = repositoryCourse.findAll();
+        List<CourseQuintePlus> toutesCourses = repositoryCourse.findAll();
-        Course prochaineCourse = null;
+        CourseQuintePlus prochaineCourse = null;
 
-        for (Course course : toutesCourses) {
+        for (CourseQuintePlus course : toutesCourses) {
             if (course.getDate().isAfter(courseActuelle.getDate()) &&
                     (prochaineCourse == null || course.getDate().isBefore(prochaineCourse.getDate()))) {
                 prochaineCourse = course;
@@ -157,16 +157,16 @@ public class ServiceCagnotte {
         // Article 9c: Si plusieurs cagnottes sont constituées dans l'intervalle,
         // elles sont toutes ajoutées à la masse à partager de la prochaine course
 
-        List<Cagnotte> cagnottesActives = cagnotteRepository.findByStatut("ACTIVE");
+        List<CagnotteQuintePlus> cagnottesActives = cagnotteRepository.findByStatut("ACTIVE");
 
         if (cagnottesActives.size() > 1) {
             // Trouver la prochaine course
-            Course prochaineCourse = trouverProchaineCourseParDate(LocalDateTime.now());
+            CourseQuintePlus prochaineCourse = trouverProchaineCourseParDate(LocalDateTime.now());
 
             if (prochaineCourse != null) {
                 double montantTotal = 0.0;
 
-                for (Cagnotte cagnotte : cagnottesActives) {
+                for (CagnotteQuintePlus cagnotte : cagnottesActives) {
                     montantTotal += cagnotte.getMontant();
                     cagnotte.setCourseDestination(prochaineCourse);
                     cagnotte.setStatut("UTILISEE");
@@ -180,11 +180,11 @@ public class ServiceCagnotte {
         }
     }
 
-    private Course trouverProchaineCourseParDate(LocalDateTime date) {
+    private CourseQuintePlus trouverProchaineCourseParDate(LocalDateTime date) {
-        List<Course> toutesCourses = repositoryCourse.findAll();
+        List<CourseQuintePlus> toutesCourses = repositoryCourse.findAll();
-        Course prochaineCourse = null;
+        CourseQuintePlus prochaineCourse = null;
 
-        for (Course course : toutesCourses) {
+        for (CourseQuintePlus course : toutesCourses) {
             if (course.getDate().isAfter(date) &&
                     (prochaineCourse == null || course.getDate().isBefore(prochaineCourse.getDate()))) {
                 prochaineCourse = course;
@@ -194,17 +194,17 @@ public class ServiceCagnotte {
         return prochaineCourse;
     }
 
-    private void appliquerCagnotteACourse(Course course, double montant) {
+    private void appliquerCagnotteACourse(CourseQuintePlus course, double montant) {
-        Optional<Gains> gainsOpt = Optional.ofNullable(repositoryGains.findByCourseId(course.getId()));
+        Optional<GainsQuintePlus> gainsOpt = Optional.ofNullable(repositoryGains.findByCourseId(course.getId()));
 
         if (gainsOpt.isPresent()) {
-            Gains gains = gainsOpt.get();
+            GainsQuintePlus gains = gainsOpt.get();
             gains.setMasseOrdreExact(gains.getMasseOrdreExact() + montant);
             gains.setMasseCagnotte(montant);
             repositoryGains.save(gains);
         } else {
             // Créer un gains pour la course si il n'existe pas encore
-            Gains gains = new Gains();
+            GainsQuintePlus gains = new GainsQuintePlus();
             gains.setCourse(course);
             gains.setMasseOrdreExact(montant);
             gains.setMasseCagnotte(montant);
@@ -215,33 +215,33 @@ public class ServiceCagnotte {
 
     // Méthode pour obtenir le montant total de la cagnotte active
     public double getMontantCagnotteActive() {
-        List<Cagnotte> cagnottesActives = cagnotteRepository.findByStatut("ACTIVE");
+        List<CagnotteQuintePlus> cagnottesActives = cagnotteRepository.findByStatut("ACTIVE");
-        return cagnottesActives.stream().mapToDouble(Cagnotte::getMontant).sum();
+        return cagnottesActives.stream().mapToDouble(CagnotteQuintePlus::getMontant).sum();
     }
 
     // Méthode pour obtenir l'historique des cagnottes
-    public List<Cagnotte> getHistoriqueCagnottes() {
+    public List<CagnotteQuintePlus> getHistoriqueCagnottes() {
         return cagnotteRepository.findAll();
     }
 
     // Méthodes utilitaires pour déterminer les gagnants
-    private List<Pari> determinerGagnantsOrdreExact(List<Pari> paris, Resultat resultat) {
+    private List<PariQuintePlus> determinerGagnantsOrdreExact(List<PariQuintePlus> paris, ResultatQuintePlus resultat) {
         return paris.stream()
                 .filter(pari -> estOrdreExact(pari, resultat))
                 .collect(Collectors.toList());
     }
 
-    private List<Pari> determinerGagnantsOrdreInexact(List<Pari> paris, Resultat resultat) {
+    private List<PariQuintePlus> determinerGagnantsOrdreInexact(List<PariQuintePlus> paris, ResultatQuintePlus resultat) {
         return paris.stream()
                 .filter(pari -> estOrdreInexact(pari, resultat))
                 .collect(Collectors.toList());
     }
 
-    private boolean estOrdreExact(Pari pari, Resultat resultat) {
+    private boolean estOrdreExact(PariQuintePlus pari, ResultatQuintePlus resultat) {
         return pari.getOrdrePredit().equals(resultat.getIdsChevauxOrdreArrivee());
     }
 
-    private boolean estOrdreInexact(Pari pari, Resultat resultat) {
+    private boolean estOrdreInexact(PariQuintePlus pari, ResultatQuintePlus resultat) {
         List<Long> chevauxArrivee = resultat.getIdsChevauxOrdreArrivee();
         List<Long> chevauxPari = pari.getChevauxSelectionnes();
 

src/main/java/com/pmumali/ch11_quinteplus/service/ServiceCourseQuintePlus.java

@@ -1,8 +1,8 @@
 package com.pmumali.ch11_quinteplus.service;
 
-import com.pmumali.ch11_quinteplus.model.Course;
+import com.pmumali.ch11_quinteplus.model.CourseQuintePlus;
-import com.pmumali.ch11_quinteplus.repository.ChevalRepository;
+import com.pmumali.ch11_quinteplus.repository.ChevalQuintePlusRepository;
-import com.pmumali.ch11_quinteplus.repository.CourseRepository;
+import com.pmumali.ch11_quinteplus.repository.CourseQuintePlusRepository;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
@@ -10,36 +10,36 @@ import java.util.List;
 
 
 @Service
-public class ServiceCourse {
+public class ServiceCourseQuintePlus {
 
     @Autowired
-    private CourseRepository repositoryCourse;
+    private CourseQuintePlusRepository repositoryCourse;
 
     @Autowired
-    private ChevalRepository repositoryCheval;
+    private ChevalQuintePlusRepository repositoryCheval;
 
-    public Course creerCourse(Course course) {
+    public CourseQuintePlus creerCourse(CourseQuintePlus course) {
         return repositoryCourse.save(course);
     }
 
-    public List<Course> obtenirToutesCourses() {
+    public List<CourseQuintePlus> obtenirToutesCourses() {
         return repositoryCourse.findAll();
     }
 
-    public Course obtenirCourseParId(Long id) {
+    public CourseQuintePlus obtenirCourseParId(Long id) {
         return repositoryCourse.findById(id).orElse(null);
     }
 
-    public List<Course> obtenirCoursesTerminees() {
+    public List<CourseQuintePlus> obtenirCoursesTerminees() {
         return repositoryCourse.findByEstTerminee(true);
     }
 
-    public List<Course> obtenirCoursesAVenir() {
+    public List<CourseQuintePlus> obtenirCoursesAVenir() {
         return repositoryCourse.findByEstTerminee(false);
     }
 
-    public Course mettreAJourCourse(Long id, Course detailsCourse) {
+    public CourseQuintePlus mettreAJourCourse(Long id, CourseQuintePlus detailsCourse) {
-        Course course = repositoryCourse.findById(id).orElse(null);
+        CourseQuintePlus course = repositoryCourse.findById(id).orElse(null);
         if (course != null) {
             course.setNom(detailsCourse.getNom());
             course.setDate(detailsCourse.getDate());

src/main/java/com/pmumali/ch11_quinteplus/service/ServiceGainsQuintePlus.java

@@ -1,9 +1,9 @@
 package com.pmumali.ch11_quinteplus.service;
 
-import com.pmumali.ch11_quinteplus.model.Course;
+import com.pmumali.ch11_quinteplus.model.CourseQuintePlus;
 import com.pmumali.ch11_quinteplus.model.*;
-import com.pmumali.ch11_quinteplus.model.Resultat;
+import com.pmumali.ch11_quinteplus.model.ResultatQuintePlus;
-import com.pmumali.ch11_quinteplus.repository.GainsRepository;
+import com.pmumali.ch11_quinteplus.repository.GainsQuintePlusRepository;
 import com.pmumali.ch11_quinteplus.repository.*;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
@@ -15,40 +15,40 @@ import java.util.stream.Collectors;
 
 @Service
 @Transactional
-public class ServiceGains {
+public class ServiceGainsQuintePlus {
 
     @Autowired
-    private PariRepository repositoryPari;
+    private PariQuintePlusRepository repositoryPari;
 
     @Autowired
-    private GainsRepository repositoryGains;
+    private GainsQuintePlusRepository repositoryGains;
 
     @Autowired
-    private CourseRepository repositoryCourse;
+    private CourseQuintePlusRepository repositoryCourse;
 
     @Autowired
-    private ChevalRepository repositoryCheval;
+    private ChevalQuintePlusRepository repositoryCheval;
 
     @Autowired
-    private ResultatRepository repositoryResultat;
+    private ResultatQuintePlusRepository repositoryResultat;
 
     @Autowired
-    private ServiceCagnotte serviceCagnotte;
+    private ServiceCagnotteQuintePlus serviceCagnotte;
 
     private static final double MISE_DE_BASE = 500.0;
     private static final double RAPPORT_MINIMUM = 1.1;
 
-    public Gains calculerGains(Long courseId, Resultat resultat) {
+    public GainsQuintePlus calculerGains(Long courseId, ResultatQuintePlus resultat) {
-        Course course = repositoryCourse.findById(courseId)
+        CourseQuintePlus course = repositoryCourse.findById(courseId)
                 .orElseThrow(() -> new RuntimeException("Course non trouvée"));
 
         // Appliquer les cagnottes reportées avant le calcul
         appliquerCagnottesAvantCalcul(course);
 
-        List<Pari> tousParis = repositoryPari.findByCourseId(courseId);
+        List<PariQuintePlus> tousParis = repositoryPari.findByCourseId(courseId);
 
         // Calcul de la recette nette (Article 5)
-        double totalMises = tousParis.stream().mapToDouble(Pari::getMise).sum();
+        double totalMises = tousParis.stream().mapToDouble(PariQuintePlus::getMise).sum();
         double recetteNette = totalMises;
 
         // Calcul des remboursements (Article 4)
@@ -66,7 +66,7 @@ public class ServiceGains {
         double masseBonus4 = masseAPartager * 0.25;
 
         // Calcul des rapports
-        Gains gains = new Gains();
+        GainsQuintePlus gains = new GainsQuintePlus();
         gains.setCourse(course);
         gains.setMasseOrdreExact(masseOrdreExact);
         gains.setMasseOrdreInexact(masseOrdreInexact);
@@ -85,10 +85,10 @@ public class ServiceGains {
         return repositoryGains.save(gains);
     }
 
-    private double calculerRemboursements(List<Pari> paris, Resultat resultat) {
+    private double calculerRemboursements(List<PariQuintePlus> paris, ResultatQuintePlus resultat) {
         double remboursements = 0.0;
 
-        for (Pari pari : paris) {
+        for (PariQuintePlus pari : paris) {
             int nombreNonPartants = compterNonPartants(pari);
             if (nombreNonPartants >= 2) {
                 // Article 4a: Remboursement si 2 chevaux ou plus non partants
@@ -107,18 +107,18 @@ public class ServiceGains {
         return remboursements;
     }
 
-    private int compterNonPartants(Pari pari) {
+    private int compterNonPartants(PariQuintePlus pari) {
         int compte = 0;
-        List<Cheval> chevaux = repositoryCheval.findAllById(pari.getChevauxSelectionnes());
+        List<ChevalQuintePlus> chevaux = repositoryCheval.findAllById(pari.getChevauxSelectionnes());
-        for (Cheval cheval : chevaux) {
+        for (ChevalQuintePlus cheval : chevaux) {
-            if (cheval.isEstNonPartant()) {
+            if (cheval.isNonPartant()) {
                 compte++;
             }
         }
         return compte;
     }
 
-    private boolean sontQuatrePremiers(Pari pari, Resultat resultat) {
+    private boolean sontQuatrePremiers(PariQuintePlus pari, ResultatQuintePlus resultat) {
         // Vérifier si au moins 4 chevaux du pari sont dans les 4 premiers
         if (resultat.getIdsChevauxOrdreArrivee().size() < 4) {
             return false;
@@ -134,24 +134,24 @@ public class ServiceGains {
         return compte >= 4;
     }
 
-    private void calculerDetailsGains(Gains gains, List<Pari> paris, Resultat resultat) {
+    private void calculerDetailsGains(GainsQuintePlus gains, List<PariQuintePlus> paris, ResultatQuintePlus resultat) {
         // Compter les paris gagnants pour chaque type de gain
-        List<Pari> parisOrdreExact = determinerGagnantsOrdreExact(paris, resultat);
+        List<PariQuintePlus> parisOrdreExact = determinerGagnantsOrdreExact(paris, resultat);
-        List<Pari> parisOrdreInexact = determinerGagnantsOrdreInexact(paris, resultat);
+        List<PariQuintePlus> parisOrdreInexact = determinerGagnantsOrdreInexact(paris, resultat);
-        List<Pari> parisBonus4 = determinerGagnantsBonus4(paris, resultat);
+        List<PariQuintePlus> parisBonus4 = determinerGagnantsBonus4(paris, resultat);
 
         // Gérer les cas de dead-heat
         if (resultat.isADeadHeat()) {
             Map<String, Object> resultatsDeadHeat = gererDeadHeat(resultat, paris);
-            parisOrdreExact = (List<Pari>) resultatsDeadHeat.get("parisOrdreExact");
+            parisOrdreExact = (List<PariQuintePlus>) resultatsDeadHeat.get("parisOrdreExact");
-            parisOrdreInexact = (List<Pari>) resultatsDeadHeat.get("parisOrdreInexact");
+            parisOrdreInexact = (List<PariQuintePlus>) resultatsDeadHeat.get("parisOrdreInexact");
-            parisBonus4 = (List<Pari>) resultatsDeadHeat.get("parisBonus4");
+            parisBonus4 = (List<PariQuintePlus>) resultatsDeadHeat.get("parisBonus4");
         }
 
         // Calcul des dividendes
-        double totalMisesOrdreExact = parisOrdreExact.stream().mapToDouble(Pari::getMise).sum();
+        double totalMisesOrdreExact = parisOrdreExact.stream().mapToDouble(PariQuintePlus::getMise).sum();
-        double totalMisesOrdreInexact = parisOrdreInexact.stream().mapToDouble(Pari::getMise).sum();
+        double totalMisesOrdreInexact = parisOrdreInexact.stream().mapToDouble(PariQuintePlus::getMise).sum();
-        double totalMisesBonus4 = parisBonus4.stream().mapToDouble(Pari::getMise).sum();
+        double totalMisesBonus4 = parisBonus4.stream().mapToDouble(PariQuintePlus::getMise).sum();
 
         if (totalMisesOrdreExact > 0) {
             gains.setDividendeOrdreExact(gains.getMasseOrdreExact() / totalMisesOrdreExact);
@@ -177,30 +177,30 @@ public class ServiceGains {
         marquerParisPayes(parisOrdreExact);
     }
 
-    private List<Pari> determinerGagnantsOrdreExact(List<Pari> paris, Resultat resultat) {
+    private List<PariQuintePlus> determinerGagnantsOrdreExact(List<PariQuintePlus> paris, ResultatQuintePlus resultat) {
         return paris.stream()
                 .filter(pari -> estOrdreExact(pari, resultat))
                 .collect(Collectors.toList());
     }
 
-    private List<Pari> determinerGagnantsOrdreInexact(List<Pari> paris, Resultat resultat) {
+    private List<PariQuintePlus> determinerGagnantsOrdreInexact(List<PariQuintePlus> paris, ResultatQuintePlus resultat) {
         return paris.stream()
                 .filter(pari -> estOrdreInexact(pari, resultat))
                 .collect(Collectors.toList());
     }
 
-    private List<Pari> determinerGagnantsBonus4(List<Pari> paris, Resultat resultat) {
+    private List<PariQuintePlus> determinerGagnantsBonus4(List<PariQuintePlus> paris, ResultatQuintePlus resultat) {
         return paris.stream()
                 .filter(pari -> estBonus4(pari, resultat))
                 .collect(Collectors.toList());
     }
 
-    private boolean estOrdreExact(Pari pari, Resultat resultat) {
+    private boolean estOrdreExact(PariQuintePlus pari, ResultatQuintePlus resultat) {
         // Vérifier si l'ordre prédit correspond exactement à l'ordre d'arrivée
         return pari.getOrdrePredit().equals(resultat.getIdsChevauxOrdreArrivee());
     }
 
-    private boolean estOrdreInexact(Pari pari, Resultat resultat) {
+    private boolean estOrdreInexact(PariQuintePlus pari, ResultatQuintePlus resultat) {
         List<Long> chevauxArrivee = resultat.getIdsChevauxOrdreArrivee();
         List<Long> chevauxPari = pari.getChevauxSelectionnes();
 
@@ -209,7 +209,7 @@ public class ServiceGains {
                 !pari.getOrdrePredit().equals(chevauxArrivee);
     }
 
-    private boolean estBonus4(Pari pari, Resultat resultat) {
+    private boolean estBonus4(PariQuintePlus pari, ResultatQuintePlus resultat) {
         if (resultat.getIdsChevauxOrdreArrivee().size() < 4) {
             return false;
         }
@@ -225,11 +225,11 @@ public class ServiceGains {
         return compte >= 4;
     }
 
-    private void marquerParisPayes(List<Pari> paris) {
+    private void marquerParisPayes(List<PariQuintePlus> paris) {
-        for (Pari pari : paris) {
+        for (PariQuintePlus pari : paris) {
             if (!pari.isEstPaye()) {
                 // Vérifier si le pari est gagnant
-                Resultat resultat = repositoryResultat.findByCourseId(pari.getCourse().getId());
+                ResultatQuintePlus resultat = repositoryResultat.findByCourseId(pari.getCourse().getId());
                 if (estOrdreExact(pari, resultat) || estOrdreInexact(pari, resultat) || estBonus4(pari, resultat)) {
                     pari.setEstPaye(true);
                     repositoryPari.save(pari);
@@ -238,32 +238,32 @@ public class ServiceGains {
         }
     }
 
-    private Map<String, Object> gererDeadHeat(Resultat resultat, List<Pari> paris) {
+    private Map<String, Object> gererDeadHeat(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
         Map<String, Object> resultatsDeadHeat = new HashMap<>();
 
         // Déterminer le type de dead-heat et appliquer les règles appropriées
         String typeDeadHeat = determinerTypeDeadHeat(resultat);
         resultatsDeadHeat.put("typeDeadHeat", typeDeadHeat);
 
-        List<Pari> parisOrdreExact = new ArrayList<>();
+        List<PariQuintePlus> parisOrdreExact = new ArrayList<>();
-        List<Pari> parisOrdreInexact = new ArrayList<>();
+        List<PariQuintePlus> parisOrdreInexact = new ArrayList<>();
-        List<Pari> parisBonus4 = new ArrayList<>();
+        List<PariQuintePlus> parisBonus4 = new ArrayList<>();
 
         switch (typeDeadHeat) {
             case "CINQ_PREMIERS":
-                Map<String, List<Pari>> resultats = traiterDeadHeatCinqPremiers(resultat, paris);
+                Map<String, List<PariQuintePlus>> resultats = traiterDeadHeatCinqPremiers(resultat, paris);
                 parisOrdreExact = resultats.get("ordreExact");
                 parisOrdreInexact = resultats.get("ordreInexact");
                 break;
 
             case "QUATRE_PREMIERS_UN_CINQUIEME":
-                Map<String, List<Pari>> resultats2 = traiterDeadHeatQuatrePremiersUnCinquieme(resultat, paris);
+                Map<String, List<PariQuintePlus>> resultats2 = traiterDeadHeatQuatrePremiersUnCinquieme(resultat, paris);
                 parisOrdreExact = resultats2.get("ordreExact");
                 parisOrdreInexact = resultats2.get("ordreInexact");
                 break;
 
             case "TROIS_PREMIERS_DEUX_QUATRIEMES":
-                Map<String, List<Pari>> resultats3 = traiterDeadHeatTroisPremiersDeuxQuatriemes(resultat, paris);
+                Map<String, List<PariQuintePlus>> resultats3 = traiterDeadHeatTroisPremiersDeuxQuatriemes(resultat, paris);
                 parisOrdreExact = resultats3.get("ordreExact");
                 parisOrdreInexact = resultats3.get("ordreInexact");
                 break;
@@ -284,7 +284,7 @@ public class ServiceGains {
         return resultatsDeadHeat;
     }
 
-    private String determinerTypeDeadHeat(Resultat resultat) {
+    private String determinerTypeDeadHeat(ResultatQuintePlus resultat) {
         // Implémentation de la logique pour déterminer le type de dead-heat
         // Basé sur les positions avec dead-heat
 
@@ -312,16 +312,16 @@ public class ServiceGains {
     }
 
     // Implémentations des différents cas de dead-heat (Article 3)
-    private Map<String, List<Pari>> traiterDeadHeatCinqPremiers(Resultat resultat, List<Pari> paris) {
+    private Map<String, List<PariQuintePlus>> traiterDeadHeatCinqPremiers(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
-        Map<String, List<Pari>> resultats = new HashMap<>();
+        Map<String, List<PariQuintePlus>> resultats = new HashMap<>();
-        List<Pari> ordreExact = new ArrayList<>();
+        List<PariQuintePlus> ordreExact = new ArrayList<>();
-        List<Pari> ordreInexact = new ArrayList<>();
+        List<PariQuintePlus> ordreInexact = new ArrayList<>();
 
         // Article 3a: Dead-heat de cinq chevaux ou plus classés à la première place
         // Tous les paris avec 5 chevaux parmi les premiers sont gagnants
         List<Long> chevauxPremiers = obtenirChevauxParPosition(resultat, 1);
 
-        for (Pari pari : paris) {
+        for (PariQuintePlus pari : paris) {
             if (chevauxPremiers.containsAll(pari.getChevauxSelectionnes())) {
                 if (estOrdreExact(pari, resultat)) {
                     ordreExact.add(pari);
@@ -336,16 +336,16 @@ public class ServiceGains {
         return resultats;
     }
 
-    private Map<String, List<Pari>> traiterDeadHeatQuatrePremiersUnCinquieme(Resultat resultat, List<Pari> paris) {
+    private Map<String, List<PariQuintePlus>> traiterDeadHeatQuatrePremiersUnCinquieme(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
-        Map<String, List<Pari>> resultats = new HashMap<>();
+        Map<String, List<PariQuintePlus>> resultats = new HashMap<>();
-        List<Pari> ordreExact = new ArrayList<>();
+        List<PariQuintePlus> ordreExact = new ArrayList<>();
-        List<Pari> ordreInexact = new ArrayList<>();
+        List<PariQuintePlus> ordreInexact = new ArrayList<>();
 
         // Article 3b: Dead-heat de quatre chevaux classés à la première place et un ou plusieurs classés cinquième
         List<Long> chevauxPremiers = obtenirChevauxParPosition(resultat, 1);
         List<Long> chevauxCinquiemes = obtenirChevauxParPosition(resultat, 5);
 
-        for (Pari pari : paris) {
+        for (PariQuintePlus pari : paris) {
             // Vérifier si le pari contient les 4 premiers et un cinquième
             if (chevauxPremiers.containsAll(pari.getChevauxSelectionnes().subList(0, 4)) &&
                     chevauxCinquiemes.contains(pari.getChevauxSelectionnes().get(4))) {
@@ -363,16 +363,16 @@ public class ServiceGains {
         return resultats;
     }
 
-    private Map<String, List<Pari>> traiterDeadHeatTroisPremiersDeuxQuatriemes(Resultat resultat, List<Pari> paris) {
+    private Map<String, List<PariQuintePlus>> traiterDeadHeatTroisPremiersDeuxQuatriemes(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
-        Map<String, List<Pari>> resultats = new HashMap<>();
+        Map<String, List<PariQuintePlus>> resultats = new HashMap<>();
-        List<Pari> ordreExact = new ArrayList<>();
+        List<PariQuintePlus> ordreExact = new ArrayList<>();
-        List<Pari> ordreInexact = new ArrayList<>();
+        List<PariQuintePlus> ordreInexact = new ArrayList<>();
 
         // Article 3c: Dead-heat de trois chevaux classés à la première place et deux chevaux classés à la quatrième place
         List<Long> chevauxPremiers = obtenirChevauxParPosition(resultat, 1);
         List<Long> chevauxQuatriemes = obtenirChevauxParPosition(resultat, 4);
 
-        for (Pari pari : paris) {
+        for (PariQuintePlus pari : paris) {
             // Vérifier si le pari contient les 3 premiers et 2 quatrièmes
             if (chevauxPremiers.containsAll(pari.getChevauxSelectionnes().subList(0, 3)) &&
                     chevauxQuatriemes.containsAll(pari.getChevauxSelectionnes().subList(3, 5))) {
@@ -389,8 +389,8 @@ public class ServiceGains {
         resultats.put("ordreInexact", ordreInexact);
         return resultats;
     }
-    private Map<String, List<Pari>> traiterDeadHeatTroisPremiersUnQuatriemeUnCinquieme(Resultat resultat, List<Pari> paris) {
+    private Map<String, List<PariQuintePlus>> traiterDeadHeatTroisPremiersUnQuatriemeUnCinquieme(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
-        Map<String, List<Pari>> resultats = new HashMap<>();
+        Map<String, List<PariQuintePlus>> resultats = new HashMap<>();
         resultats.put("ordreExact", new ArrayList<>());
         resultats.put("ordreInexact", new ArrayList<>());
         resultats.put("bonus4", new ArrayList<>());
@@ -400,7 +400,7 @@ public class ServiceGains {
         List<Long> chevauxQuatriemes = obtenirChevauxParPosition(resultat, 4);
         List<Long> chevauxCinquiemes = obtenirChevauxParPosition(resultat, 5);
 
-        for (Pari pari : paris) {
+        for (PariQuintePlus pari : paris) {
             List<Long> chevauxPari = pari.getChevauxSelectionnes();
 
             // Vérifier si le pari contient 3 premiers, 1 quatrième et 1 cinquième
@@ -419,8 +419,8 @@ public class ServiceGains {
         return resultats;
     }
 
-    private Map<String, List<Pari>> traiterDeadHeatDeuxPremiersTroisTroisiemes(Resultat resultat, List<Pari> paris) {
+    private Map<String, List<PariQuintePlus>> traiterDeadHeatDeuxPremiersTroisTroisiemes(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
-        Map<String, List<Pari>> resultats = new HashMap<>();
+        Map<String, List<PariQuintePlus>> resultats = new HashMap<>();
         resultats.put("ordreExact", new ArrayList<>());
         resultats.put("ordreInexact", new ArrayList<>());
         resultats.put("bonus4", new ArrayList<>());
@@ -429,7 +429,7 @@ public class ServiceGains {
         List<Long> chevauxPremiers = obtenirChevauxParPosition(resultat, 1);
         List<Long> chevauxTroisiemes = obtenirChevauxParPosition(resultat, 3);
 
-        for (Pari pari : paris) {
+        for (PariQuintePlus pari : paris) {
             List<Long> chevauxPari = pari.getChevauxSelectionnes();
 
             // Vérifier si le pari contient 2 premiers et 3 troisièmes
@@ -447,8 +447,8 @@ public class ServiceGains {
         return resultats;
     }
 
-    private Map<String, List<Pari>> traiterDeadHeatDeuxPremiersDeuxTroisiemesUnCinquieme(Resultat resultat, List<Pari> paris) {
+    private Map<String, List<PariQuintePlus>> traiterDeadHeatDeuxPremiersDeuxTroisiemesUnCinquieme(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
-        Map<String, List<Pari>> resultats = new HashMap<>();
+        Map<String, List<PariQuintePlus>> resultats = new HashMap<>();
         resultats.put("ordreExact", new ArrayList<>());
         resultats.put("ordreInexact", new ArrayList<>());
         resultats.put("bonus4", new ArrayList<>());
@@ -458,7 +458,7 @@ public class ServiceGains {
         List<Long> chevauxTroisiemes = obtenirChevauxParPosition(resultat, 3);
         List<Long> chevauxCinquiemes = obtenirChevauxParPosition(resultat, 5);
 
-        for (Pari pari : paris) {
+        for (PariQuintePlus pari : paris) {
             List<Long> chevauxPari = pari.getChevauxSelectionnes();
 
             // Vérifier si le pari contient 2 premiers, 2 troisièmes et 1 cinquième
@@ -477,8 +477,8 @@ public class ServiceGains {
         return resultats;
     }
 
-    private Map<String, List<Pari>> traiterDeadHeatDeuxPremiersUnTroisiemeDeuxQuatriemes(Resultat resultat, List<Pari> paris) {
+    private Map<String, List<PariQuintePlus>> traiterDeadHeatDeuxPremiersUnTroisiemeDeuxQuatriemes(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
-        Map<String, List<Pari>> resultats = new HashMap<>();
+        Map<String, List<PariQuintePlus>> resultats = new HashMap<>();
         resultats.put("ordreExact", new ArrayList<>());
         resultats.put("ordreInexact", new ArrayList<>());
         resultats.put("bonus4", new ArrayList<>());
@@ -488,7 +488,7 @@ public class ServiceGains {
         List<Long> chevauxTroisiemes = obtenirChevauxParPosition(resultat, 3);
         List<Long> chevauxQuatriemes = obtenirChevauxParPosition(resultat, 4);
 
-        for (Pari pari : paris) {
+        for (PariQuintePlus pari : paris) {
             List<Long> chevauxPari = pari.getChevauxSelectionnes();
 
             // Vérifier si le pari contient 2 premiers, 1 troisième et 2 quatrièmes
@@ -508,8 +508,8 @@ public class ServiceGains {
     }
 
 
-    private Map<String, List<Pari>> traiterDeadHeatDeuxPremiersUnTroisiemeUnQuatriemeUnCinquieme(Resultat resultat, List<Pari> paris) {
+    private Map<String, List<PariQuintePlus>> traiterDeadHeatDeuxPremiersUnTroisiemeUnQuatriemeUnCinquieme(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
-        Map<String, List<Pari>> resultats = new HashMap<>();
+        Map<String, List<PariQuintePlus>> resultats = new HashMap<>();
         resultats.put("ordreExact", new ArrayList<>());
         resultats.put("ordreInexact", new ArrayList<>());
         resultats.put("bonus4", new ArrayList<>());
@@ -520,7 +520,7 @@ public class ServiceGains {
         List<Long> chevauxQuatriemes = obtenirChevauxParPosition(resultat, 4);
         List<Long> chevauxCinquiemes = obtenirChevauxParPosition(resultat, 5);
 
-        for (Pari pari : paris) {
+        for (PariQuintePlus pari : paris) {
             List<Long> chevauxPari = pari.getChevauxSelectionnes();
 
             // Vérifier si le pari contient 2 premiers, 1 troisième, 1 quatrième et 1 cinquième
@@ -540,8 +540,8 @@ public class ServiceGains {
         return resultats;
     }
 
-    private Map<String, List<Pari>> traiterDeadHeatQuatreDeuxiemes(Resultat resultat, List<Pari> paris) {
+    private Map<String, List<PariQuintePlus>> traiterDeadHeatQuatreDeuxiemes(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
-        Map<String, List<Pari>> resultats = new HashMap<>();
+        Map<String, List<PariQuintePlus>> resultats = new HashMap<>();
         resultats.put("ordreExact", new ArrayList<>());
         resultats.put("ordreInexact", new ArrayList<>());
         resultats.put("bonus4", new ArrayList<>());
@@ -553,7 +553,7 @@ public class ServiceGains {
         // Toutes les combinaisons de 4 chevaux parmi les deuxièmes
         List<List<Long>> combinaisons = genererCombinaisons(chevauxDeuxiemes, 4);
 
-        for (Pari pari : paris) {
+        for (PariQuintePlus pari : paris) {
             for (List<Long> combinaison : combinaisons) {
                 List<Long> combinaisonComplete = new ArrayList<>();
                 combinaisonComplete.add(chevauxPremier.get(0)); // Le cheval premier
@@ -573,8 +573,8 @@ public class ServiceGains {
         return resultats;
     }
 
-    private Map<String, List<Pari>> traiterDeadHeatTroisDeuxiemesUnCinquieme(Resultat resultat, List<Pari> paris) {
+    private Map<String, List<PariQuintePlus>> traiterDeadHeatTroisDeuxiemesUnCinquieme(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
-        Map<String, List<Pari>> resultats = new HashMap<>();
+        Map<String, List<PariQuintePlus>> resultats = new HashMap<>();
         resultats.put("ordreExact", new ArrayList<>());
         resultats.put("ordreInexact", new ArrayList<>());
         resultats.put("bonus4", new ArrayList<>());
@@ -584,7 +584,7 @@ public class ServiceGains {
         List<Long> chevauxDeuxiemes = obtenirChevauxParPosition(resultat, 2);
         List<Long> chevauxCinquiemes = obtenirChevauxParPosition(resultat, 5);
 
-        for (Pari pari : paris) {
+        for (PariQuintePlus pari : paris) {
             List<Long> chevauxPari = pari.getChevauxSelectionnes();
 
             // Vérifier si le pari contient le premier, 3 deuxièmes et 1 cinquième
@@ -603,8 +603,8 @@ public class ServiceGains {
         return resultats;
     }
 
-    private Map<String, List<Pari>> traiterDeadHeatDeuxDeuxiemesDeuxQuatriemes(Resultat resultat, List<Pari> paris) {
+    private Map<String, List<PariQuintePlus>> traiterDeadHeatDeuxDeuxiemesDeuxQuatriemes(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
-        Map<String, List<Pari>> resultats = new HashMap<>();
+        Map<String, List<PariQuintePlus>> resultats = new HashMap<>();
         resultats.put("ordreExact", new ArrayList<>());
         resultats.put("ordreInexact", new ArrayList<>());
         resultats.put("bonus4", new ArrayList<>());
@@ -614,7 +614,7 @@ public class ServiceGains {
         List<Long> chevauxDeuxiemes = obtenirChevauxParPosition(resultat, 2);
         List<Long> chevauxQuatriemes = obtenirChevauxParPosition(resultat, 4);
 
-        for (Pari pari : paris) {
+        for (PariQuintePlus pari : paris) {
             List<Long> chevauxPari = pari.getChevauxSelectionnes();
 
             // Vérifier si le pari contient le premier, 2 deuxièmes et 2 quatrièmes
@@ -633,8 +633,8 @@ public class ServiceGains {
         return resultats;
     }
 
-    private Map<String, List<Pari>> traiterDeadHeatDeuxDeuxiemesUnQuatriemeUnCinquieme(Resultat resultat, List<Pari> paris) {
+    private Map<String, List<PariQuintePlus>> traiterDeadHeatDeuxDeuxiemesUnQuatriemeUnCinquieme(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
-        Map<String, List<Pari>> resultats = new HashMap<>();
+        Map<String, List<PariQuintePlus>> resultats = new HashMap<>();
         resultats.put("ordreExact", new ArrayList<>());
         resultats.put("ordreInexact", new ArrayList<>());
         resultats.put("bonus4", new ArrayList<>());
@@ -645,7 +645,7 @@ public class ServiceGains {
         List<Long> chevauxQuatriemes = obtenirChevauxParPosition(resultat, 4);
         List<Long> chevauxCinquiemes = obtenirChevauxParPosition(resultat, 5);
 
-        for (Pari pari : paris) {
+        for (PariQuintePlus pari : paris) {
             List<Long> chevauxPari = pari.getChevauxSelectionnes();
 
             // Vérifier si le pari contient le premier, 2 deuxièmes, 1 quatrième et 1 cinquième
@@ -665,8 +665,8 @@ public class ServiceGains {
         return resultats;
     }
 
-    private Map<String, List<Pari>> traiterDeadHeatTroisTroisiemes(Resultat resultat, List<Pari> paris) {
+    private Map<String, List<PariQuintePlus>> traiterDeadHeatTroisTroisiemes(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
-        Map<String, List<Pari>> resultats = new HashMap<>();
+        Map<String, List<PariQuintePlus>> resultats = new HashMap<>();
         resultats.put("ordreExact", new ArrayList<>());
         resultats.put("ordreInexact", new ArrayList<>());
         resultats.put("bonus4", new ArrayList<>());
@@ -679,7 +679,7 @@ public class ServiceGains {
         // Toutes les combinaisons de 3 chevaux parmi les troisièmes
         List<List<Long>> combinaisons = genererCombinaisons(chevauxTroisiemes, 3);
 
-        for (Pari pari : paris) {
+        for (PariQuintePlus pari : paris) {
             for (List<Long> combinaison : combinaisons) {
                 List<Long> combinaisonComplete = new ArrayList<>();
                 combinaisonComplete.add(chevauxPremier.get(0)); // Le cheval premier
@@ -700,8 +700,8 @@ public class ServiceGains {
         return resultats;
     }
 
-    private Map<String, List<Pari>> traiterDeadHeatDeuxTroisiemesUnCinquieme(Resultat resultat, List<Pari> paris) {
+    private Map<String, List<PariQuintePlus>> traiterDeadHeatDeuxTroisiemesUnCinquieme(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
-        Map<String, List<Pari>> resultats = new HashMap<>();
+        Map<String, List<PariQuintePlus>> resultats = new HashMap<>();
         resultats.put("ordreExact", new ArrayList<>());
         resultats.put("ordreInexact", new ArrayList<>());
         resultats.put("bonus4", new ArrayList<>());
@@ -712,7 +712,7 @@ public class ServiceGains {
         List<Long> chevauxTroisiemes = obtenirChevauxParPosition(resultat, 3);
         List<Long> chevauxCinquiemes = obtenirChevauxParPosition(resultat, 5);
 
-        for (Pari pari : paris) {
+        for (PariQuintePlus pari : paris) {
             List<Long> chevauxPari = pari.getChevauxSelectionnes();
 
             // Vérifier si le pari contient le premier, le deuxième, 2 troisièmes et 1 cinquième
@@ -732,8 +732,8 @@ public class ServiceGains {
         return resultats;
     }
 
-    private Map<String, List<Pari>> traiterDeadHeatDeuxQuatriemes(Resultat resultat, List<Pari> paris) {
+    private Map<String, List<PariQuintePlus>> traiterDeadHeatDeuxQuatriemes(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
-        Map<String, List<Pari>> resultats = new HashMap<>();
+        Map<String, List<PariQuintePlus>> resultats = new HashMap<>();
         resultats.put("ordreExact", new ArrayList<>());
         resultats.put("ordreInexact", new ArrayList<>());
         resultats.put("bonus4", new ArrayList<>());
@@ -747,7 +747,7 @@ public class ServiceGains {
         // Toutes les combinaisons de 2 chevaux parmi les quatrièmes
         List<List<Long>> combinaisons = genererCombinaisons(chevauxQuatriemes, 2);
 
-        for (Pari pari : paris) {
+        for (PariQuintePlus pari : paris) {
             for (List<Long> combinaison : combinaisons) {
                 List<Long> combinaisonComplete = new ArrayList<>();
                 combinaisonComplete.add(chevauxPremier.get(0)); // Le cheval premier
@@ -769,8 +769,8 @@ public class ServiceGains {
         return resultats;
     }
 
-    private Map<String, List<Pari>> traiterDeadHeatDeuxCinquiemes(Resultat resultat, List<Pari> paris) {
+    private Map<String, List<PariQuintePlus>> traiterDeadHeatDeuxCinquiemes(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
-        Map<String, List<Pari>> resultats = new HashMap<>();
+        Map<String, List<PariQuintePlus>> resultats = new HashMap<>();
         resultats.put("ordreExact", new ArrayList<>());
         resultats.put("ordreInexact", new ArrayList<>());
         resultats.put("bonus4", new ArrayList<>());
@@ -782,7 +782,7 @@ public class ServiceGains {
         List<Long> chevauxQuatrieme = obtenirChevauxParPosition(resultat, 4);
         List<Long> chevauxCinquiemes = obtenirChevauxParPosition(resultat, 5);
 
-        for (Pari pari : paris) {
+        for (PariQuintePlus pari : paris) {
             List<Long> chevauxPari = pari.getChevauxSelectionnes();
 
             // Vérifier si le pari contient les 4 premiers et 1 cinquième
@@ -803,7 +803,7 @@ public class ServiceGains {
         return resultats;
     }
 
-    private List<Long> obtenirChevauxParPosition(Resultat resultat, int position) {
+    private List<Long> obtenirChevauxParPosition(ResultatQuintePlus resultat, int position) {
         // Implémentation simplifiée: retourne les chevaux à une position donnée
         // Dans une implémentation réelle, il faudrait gérer les dead-heats
 
@@ -834,7 +834,7 @@ public class ServiceGains {
         }
     }
 
-    private void calculerDividendesDeadHeat(Gains gains, List<Pari> parisOrdreExact, List<Pari> parisOrdreInexact, List<Pari> parisBonus4) {
+    private void calculerDividendesDeadHeat(GainsQuintePlus gains, List<PariQuintePlus> parisOrdreExact, List<PariQuintePlus> parisOrdreInexact, List<PariQuintePlus> parisBonus4) {
         // Calcul des dividendes pour les cas de dead-heat
         // Répartition égale de la masse entre les combinaisons payables
 
@@ -855,11 +855,11 @@ public class ServiceGains {
         }
     }
 
-    private void calculerDividendesNormaux(Gains gains, List<Pari> parisOrdreExact, List<Pari> parisOrdreInexact, List<Pari> parisBonus4) {
+    private void calculerDividendesNormaux(GainsQuintePlus gains, List<PariQuintePlus> parisOrdreExact, List<PariQuintePlus> parisOrdreInexact, List<PariQuintePlus> parisBonus4) {
         // Calcul des dividendes pour les cas normaux (sans dead-heat)
-        double totalMisesOrdreExact = parisOrdreExact.stream().mapToDouble(Pari::getMise).sum();
+        double totalMisesOrdreExact = parisOrdreExact.stream().mapToDouble(PariQuintePlus::getMise).sum();
-        double totalMisesOrdreInexact = parisOrdreInexact.stream().mapToDouble(Pari::getMise).sum();
+        double totalMisesOrdreInexact = parisOrdreInexact.stream().mapToDouble(PariQuintePlus::getMise).sum();
-        double totalMisesBonus4 = parisBonus4.stream().mapToDouble(Pari::getMise).sum();
+        double totalMisesBonus4 = parisBonus4.stream().mapToDouble(PariQuintePlus::getMise).sum();
 
         if (totalMisesOrdreExact > 0) {
             gains.setDividendeOrdreExact(gains.getMasseOrdreExact() / totalMisesOrdreExact);
@@ -873,7 +873,7 @@ public class ServiceGains {
             gains.setDividendeBonus4(gains.getMasseBonus4() / totalMisesBonus4);
         }
     }
-    private void appliquerReglesProportionMinimum(Gains gains, List<Pari> paris, Resultat resultat) {
+    private void appliquerReglesProportionMinimum(GainsQuintePlus gains, List<PariQuintePlus> paris, ResultatQuintePlus resultat) {
         // Application de l'article 6 - Proportion minimum des rapports
 
         // Règle 6a: Rapport ordre exact doit être au moins 25 fois le rapport ordre inexact
@@ -961,29 +961,29 @@ public class ServiceGains {
 
 
 
-    private void gererCagnotte(Gains gains, List<Pari> paris, Resultat resultat) {
+    private void gererCagnotte(GainsQuintePlus gains, List<PariQuintePlus> paris, ResultatQuintePlus resultat) {
         serviceCagnotte.gererCagnotte(gains, paris, resultat);
     }
 
     // Ajouter cette méthode pour appliquer les cagnottes reportées avant le calcul des gains
-    public void appliquerCagnottesAvantCalcul(Course course) {
+    public void appliquerCagnottesAvantCalcul(CourseQuintePlus course) {
         serviceCagnotte.appliquerCagnottesReportees(course);
     }
-    public Gains obtenirGainsParCourse(Long courseId) {
+    public GainsQuintePlus obtenirGainsParCourse(Long courseId) {
         return repositoryGains.findByCourseId(courseId);
     }
 
-    public List<Gains> obtenirTousGains() {
+    public List<GainsQuintePlus> obtenirTousGains() {
         return repositoryGains.findAll();
     }
 
     // Méthode pour calculer les gains d'un pari spécifique
-    public double calculerGainsParieur(Pari pari, Gains gains) {
+    public double calculerGainsParieur(PariQuintePlus pari, GainsQuintePlus gains) {
         double gainsParieur = 0.0;
 
         if (pari.isEstPaye()) {
             // Vérifier le type de gain
-            Resultat resultat = repositoryResultat.findByCourseId(pari.getCourse().getId());
+            ResultatQuintePlus resultat = repositoryResultat.findByCourseId(pari.getCourse().getId());
 
             if (estOrdreExact(pari, resultat)) {
                 gainsParieur = pari.getMise() * gains.getDividendeOrdreExact();
@@ -1003,14 +1003,14 @@ public class ServiceGains {
     public Map<String, Object> genererRapportGains(Long courseId) {
         Map<String, Object> rapport = new HashMap<>();
 
-        Gains gains = obtenirGainsParCourse(courseId);
+        GainsQuintePlus gains = obtenirGainsParCourse(courseId);
         if (gains == null) {
             rapport.put("erreur", "Aucun gain calculé pour cette course");
             return rapport;
         }
 
-        Course course = gains.getCourse();
+        CourseQuintePlus course = gains.getCourse();
-        List<Pari> tousParis = repositoryPari.findByCourseId(courseId);
+        List<PariQuintePlus> tousParis = repositoryPari.findByCourseId(courseId);
 
         rapport.put("course", course.getNom());
         rapport.put("date", course.getDate());
@@ -1023,10 +1023,10 @@ public class ServiceGains {
         rapport.put("masseCagnotte", gains.getMasseCagnotte());
 
         // Compter les gagnants par catégorie
-        Resultat resultat = repositoryResultat.findByCourseId(courseId);
+        ResultatQuintePlus resultat = repositoryResultat.findByCourseId(courseId);
-        List<Pari> gagnantsOrdreExact = determinerGagnantsOrdreExact(tousParis, resultat);
+        List<PariQuintePlus> gagnantsOrdreExact = determinerGagnantsOrdreExact(tousParis, resultat);
-        List<Pari> gagnantsOrdreInexact = determinerGagnantsOrdreInexact(tousParis, resultat);
+        List<PariQuintePlus> gagnantsOrdreInexact = determinerGagnantsOrdreInexact(tousParis, resultat);
-        List<Pari> gagnantsBonus4 = determinerGagnantsBonus4(tousParis, resultat);
+        List<PariQuintePlus> gagnantsBonus4 = determinerGagnantsBonus4(tousParis, resultat);
 
         rapport.put("nombreGagnantsOrdreExact", gagnantsOrdreExact.size());
         rapport.put("nombreGagnantsOrdreInexact", gagnantsOrdreInexact.size());

src/main/java/com/pmumali/ch11_quinteplus/service/ServicePariQuintePlus.java

@@ -1,40 +1,39 @@
 package com.pmumali.ch11_quinteplus.service;
 
 
-import com.pmumali.ch11_quinteplus.model.Cheval;
+import com.pmumali.ch11_quinteplus.model.ChevalQuintePlus;
-import com.pmumali.ch11_quinteplus.model.Pari;
+import com.pmumali.ch11_quinteplus.model.PariQuintePlus;
-import com.pmumali.ch11_quinteplus.model.Resultat;
+import com.pmumali.ch11_quinteplus.model.ResultatQuintePlus;
-import com.pmumali.ch11_quinteplus.repository.ChevalRepository;
+import com.pmumali.ch11_quinteplus.repository.ChevalQuintePlusRepository;
-import com.pmumali.ch11_quinteplus.repository.CourseRepository;
+import com.pmumali.ch11_quinteplus.repository.CourseQuintePlusRepository;
-import com.pmumali.ch11_quinteplus.repository.GainsRepository;
+import com.pmumali.ch11_quinteplus.repository.GainsQuintePlusRepository;
-import com.pmumali.ch11_quinteplus.repository.PariRepository;
+import com.pmumali.ch11_quinteplus.repository.PariQuintePlusRepository;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.util.*;
-import java.util.stream.Collectors;
 
 @Service
 @Transactional
-public class ServicePari {
+public class ServicePariQuintePlus {
 
     @Autowired
-    private PariRepository repositoryPari;
+    private PariQuintePlusRepository repositoryPari;
 
     @Autowired
-    private CourseRepository repositoryCourse;
+    private CourseQuintePlusRepository repositoryCourse;
 
     @Autowired
-    private ChevalRepository repositoryCheval;
+    private ChevalQuintePlusRepository repositoryCheval;
 
     @Autowired
-    private GainsRepository repositoryGains;
+    private GainsQuintePlusRepository repositoryGains;
 
     private static final double MISE_DE_BASE = 500.0;
     private static final double MISE_MAXIMALE = 20 * MISE_DE_BASE;
 
-    public Pari placerPari(Pari pari) {
+    public PariQuintePlus placerPari(PariQuintePlus pari) {
         // Vérification de la limite d'enjeu (Article 2)
         if (pari.getMise() > MISE_MAXIMALE) {
             pari.setMise(MISE_MAXIMALE);
@@ -49,7 +48,7 @@ public class ServicePari {
         return repositoryPari.save(pari);
     }
 
-    private boolean estPariValide(Pari pari) {
+    private boolean estPariValide(PariQuintePlus pari) {
         // Vérifier que le pari a exactement 5 chevaux sélectionnés
         if (pari.getChevauxSelectionnes() == null || pari.getChevauxSelectionnes().size() != 5) {
             return false;
@@ -61,7 +60,7 @@ public class ServicePari {
         }
 
         // Vérifier que tous les chevaux sélectionnés existent
-        List<Cheval> chevaux = repositoryCheval.findAllById(pari.getChevauxSelectionnes());
+        List<ChevalQuintePlus> chevaux = repositoryCheval.findAllById(pari.getChevauxSelectionnes());
         if (chevaux.size() != 5) {
             return false;
         }
@@ -74,20 +73,20 @@ public class ServicePari {
         return true;
     }
 
-    public List<Pari> obtenirParisParCourse(Long courseId) {
+    public List<PariQuintePlus> obtenirParisParCourse(Long courseId) {
         return repositoryPari.findByCourseId(courseId);
     }
 
-    public List<Pari> obtenirParisParParieur(String nomParieur) {
+    public List<PariQuintePlus> obtenirParisParParieur(String nomParieur) {
         return repositoryPari.findByNomParieur(nomParieur);
     }
 
-    public Pari obtenirPariParId(Long id) {
+    public PariQuintePlus obtenirPariParId(Long id) {
         return repositoryPari.findById(id).orElse(null);
     }
 
-    public Pari mettreAJourPari(Long id, Pari detailsPari) {
+    public PariQuintePlus mettreAJourPari(Long id, PariQuintePlus detailsPari) {
-        Pari pari = repositoryPari.findById(id).orElse(null);
+        PariQuintePlus pari = repositoryPari.findById(id).orElse(null);
         if (pari != null) {
             pari.setNomParieur(detailsPari.getNomParieur());
             pari.setMise(detailsPari.getMise());
@@ -108,7 +107,7 @@ public class ServicePari {
     }
 
     // Méthodes pour gérer les dead-heats (Article 3)
-    public Map<String, Object> gererDeadHeat(Resultat resultat, List<Pari> paris) {
+    public Map<String, Object> gererDeadHeat(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
         Map<String, Object> resultatsDeadHeat = new HashMap<>();
 
         if (!resultat.isADeadHeat()) {
@@ -176,7 +175,7 @@ public class ServicePari {
         return resultatsDeadHeat;
     }
 
-    private String determinerTypeDeadHeat(Resultat resultat) {
+    private String determinerTypeDeadHeat(ResultatQuintePlus resultat) {
         // Implémentation de la logique pour déterminer le type de dead-heat
         // Basé sur les positions avec dead-heat
 
@@ -200,7 +199,7 @@ public class ServicePari {
     }
 
     // Implémentations des différents cas de dead-heat (Article 3)
-    private List<Map<String, Object>> traiterDeadHeatCinqPremiers(Resultat resultat, List<Pari> paris) {
+    private List<Map<String, Object>> traiterDeadHeatCinqPremiers(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
         List<Map<String, Object>> combinaisonsPayables = new ArrayList<>();
 
         // Article 3a: Dead-heat de cinq chevaux ou plus classés à la première place
@@ -223,7 +222,7 @@ public class ServicePari {
         return combinaisonsPayables;
     }
 
-    private List<Map<String, Object>> traiterDeadHeatQuatrePremiersUnCinquieme(Resultat resultat, List<Pari> paris) {
+    private List<Map<String, Object>> traiterDeadHeatQuatrePremiersUnCinquieme(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
         List<Map<String, Object>> combinaisonsPayables = new ArrayList<>();
 
         // Article 3b: Dead-heat de quatre chevaux classés à la première place et un ou plusieurs classés cinquième
@@ -247,7 +246,7 @@ public class ServicePari {
         return combinaisonsPayables;
     }
 
-    private List<Map<String, Object>> traiterDeadHeatTroisPremiersDeuxQuatriemes(Resultat resultat, List<Pari> paris) {
+    private List<Map<String, Object>> traiterDeadHeatTroisPremiersDeuxQuatriemes(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
         List<Map<String, Object>> combinaisonsPayables = new ArrayList<>();
 
         // Article 3c: Dead-heat de trois chevaux classés à la première place et deux chevaux classés à la quatrième place
@@ -274,73 +273,73 @@ public class ServicePari {
     }
 
     // Méthodes pour les autres cas de dead-heat (à implémenter selon l'article 3)
-    private List<Map<String, Object>> traiterDeadHeatTroisPremiersUnQuatriemeUnCinquieme(Resultat resultat, List<Pari> paris) {
+    private List<Map<String, Object>> traiterDeadHeatTroisPremiersUnQuatriemeUnCinquieme(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
         // Article 3d: Implémentation à compléter
         return new ArrayList<>();
     }
 
-    private List<Map<String, Object>> traiterDeadHeatDeuxPremiersTroisTroisiemes(Resultat resultat, List<Pari> paris) {
+    private List<Map<String, Object>> traiterDeadHeatDeuxPremiersTroisTroisiemes(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
         // Article 3e: Implémentation à compléter
         return new ArrayList<>();
     }
 
-    private List<Map<String, Object>> traiterDeadHeatDeuxPremiersDeuxTroisiemesUnCinquieme(Resultat resultat, List<Pari> paris) {
+    private List<Map<String, Object>> traiterDeadHeatDeuxPremiersDeuxTroisiemesUnCinquieme(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
         // Article 3f: Implémentation à compléter
         return new ArrayList<>();
     }
 
-    private List<Map<String, Object>> traiterDeadHeatDeuxPremiersUnTroisiemeDeuxQuatriemes(Resultat resultat, List<Pari> paris) {
+    private List<Map<String, Object>> traiterDeadHeatDeuxPremiersUnTroisiemeDeuxQuatriemes(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
         // Article 3g: Implémentation à compléter
         return new ArrayList<>();
     }
 
-    private List<Map<String, Object>> traiterDeadHeatDeuxPremiersUnTroisiemeUnQuatriemeUnCinquieme(Resultat resultat, List<Pari> paris) {
+    private List<Map<String, Object>> traiterDeadHeatDeuxPremiersUnTroisiemeUnQuatriemeUnCinquieme(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
         // Article 3h: Implémentation à compléter
         return new ArrayList<>();
     }
 
-    private List<Map<String, Object>> traiterDeadHeatQuatreDeuxiemes(Resultat resultat, List<Pari> paris) {
+    private List<Map<String, Object>> traiterDeadHeatQuatreDeuxiemes(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
         // Article 3i: Implémentation à compléter
         return new ArrayList<>();
     }
 
-    private List<Map<String, Object>> traiterDeadHeatTroisDeuxiemesUnCinquieme(Resultat resultat, List<Pari> paris) {
+    private List<Map<String, Object>> traiterDeadHeatTroisDeuxiemesUnCinquieme(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
         // Article 3j: Implémentation à compléter
         return new ArrayList<>();
     }
 
-    private List<Map<String, Object>> traiterDeadHeatDeuxDeuxiemesDeuxQuatriemes(Resultat resultat, List<Pari> paris) {
+    private List<Map<String, Object>> traiterDeadHeatDeuxDeuxiemesDeuxQuatriemes(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
         // Article 3k: Implémentation à compléter
         return new ArrayList<>();
     }
 
-    private List<Map<String, Object>> traiterDeadHeatDeuxDeuxiemesUnQuatriemeUnCinquieme(Resultat resultat, List<Pari> paris) {
+    private List<Map<String, Object>> traiterDeadHeatDeuxDeuxiemesUnQuatriemeUnCinquieme(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
         // Article 3l: Implémentation à compléter
         return new ArrayList<>();
     }
 
-    private List<Map<String, Object>> traiterDeadHeatTroisTroisiemes(Resultat resultat, List<Pari> paris) {
+    private List<Map<String, Object>> traiterDeadHeatTroisTroisiemes(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
         // Article 3m: Implémentation à compléter
         return new ArrayList<>();
     }
 
-    private List<Map<String, Object>> traiterDeadHeatDeuxTroisiemesUnCinquieme(Resultat resultat, List<Pari> paris) {
+    private List<Map<String, Object>> traiterDeadHeatDeuxTroisiemesUnCinquieme(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
         // Article 3n: Implémentation à compléter
         return new ArrayList<>();
     }
 
-    private List<Map<String, Object>> traiterDeadHeatDeuxQuatriemes(Resultat resultat, List<Pari> paris) {
+    private List<Map<String, Object>> traiterDeadHeatDeuxQuatriemes(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
         // Article 3o: Implémentation à compléter
         return new ArrayList<>();
     }
 
-    private List<Map<String, Object>> traiterDeadHeatDeuxCinquiemes(Resultat resultat, List<Pari> paris) {
+    private List<Map<String, Object>> traiterDeadHeatDeuxCinquiemes(ResultatQuintePlus resultat, List<PariQuintePlus> paris) {
         // Article 3p: Implémentation à compléter
         return new ArrayList<>();
     }
 
     // Méthodes utilitaires pour les dead-heats
-    private List<Long> obtenirChevauxParPosition(Resultat resultat, int position) {
+    private List<Long> obtenirChevauxParPosition(ResultatQuintePlus resultat, int position) {
         // Implémentation simplifiée: retourne les chevaux à une position donnée
         // Dans une implémentation réelle, il faudrait gérer les dead-heats
 
@@ -508,12 +507,12 @@ public class ServicePari {
     }
 
     // Méthodes pour gérer les non-partants (Article 4)
-    public Map<String, Object> traiterNonPartants(List<Pari> paris, Resultat resultat) {
+    public Map<String, Object> traiterNonPartants(List<PariQuintePlus> paris, ResultatQuintePlus resultat) {
         Map<String, Object> resultats = new HashMap<>();
-        List<Pari> parisARembourser = new ArrayList<>();
+        List<PariQuintePlus> parisARembourser = new ArrayList<>();
-        List<Pari> parisBonus4 = new ArrayList<>();
+        List<PariQuintePlus> parisBonus4 = new ArrayList<>();
 
-        for (Pari pari : paris) {
+        for (PariQuintePlus pari : paris) {
             int nombreNonPartants = compterNonPartants(pari);
 
             if (nombreNonPartants >= 2) {
@@ -536,18 +535,18 @@ public class ServicePari {
         return resultats;
     }
 
-    private int compterNonPartants(Pari pari) {
+    private int compterNonPartants(PariQuintePlus pari) {
         int compte = 0;
-        List<Cheval> chevaux = repositoryCheval.findAllById(pari.getChevauxSelectionnes());
+        List<ChevalQuintePlus> chevaux = repositoryCheval.findAllById(pari.getChevauxSelectionnes());
-        for (Cheval cheval : chevaux) {
+        for (ChevalQuintePlus cheval : chevaux) {
-            if (cheval.isEstNonPartant()) {
+            if (cheval.isNonPartant()) {
                 compte++;
             }
         }
         return compte;
     }
 
-    private boolean sontQuatrePremiers(Pari pari, Resultat resultat) {
+    private boolean sontQuatrePremiers(PariQuintePlus pari, ResultatQuintePlus resultat) {
         // Vérifier si au moins 4 chevaux du pari sont dans les 4 premiers
         List<Long> quatrePremiers = resultat.getIdsChevauxOrdreArrivee().subList(0, Math.min(4, resultat.getIdsChevauxOrdreArrivee().size()));
         List<Long> chevauxPari = pari.getChevauxSelectionnes();
@@ -559,22 +558,22 @@ public class ServicePari {
         return compte >= 4;
     }
 
-    private double calculerMontantRemboursements(List<Pari> paris) {
+    private double calculerMontantRemboursements(List<PariQuintePlus> paris) {
         return paris.stream()
-                .mapToDouble(Pari::getMise)
+                .mapToDouble(PariQuintePlus::getMise)
                 .sum();
     }
 
     // Méthode pour déterminer les gagnants d'une course
-    public Map<String, Object> determinerGagnants(Long courseId, Resultat resultat) {
+    public Map<String, Object> determinerGagnants(Long courseId, ResultatQuintePlus resultat) {
         Map<String, Object> resultats = new HashMap<>();
-        List<Pari> tousParis = repositoryPari.findByCourseId(courseId);
+        List<PariQuintePlus> tousParis = repositoryPari.findByCourseId(courseId);
 
-        List<Pari> gagnantsOrdreExact = new ArrayList<>();
+        List<PariQuintePlus> gagnantsOrdreExact = new ArrayList<>();
-        List<Pari> gagnantsOrdreInexact = new ArrayList<>();
+        List<PariQuintePlus> gagnantsOrdreInexact = new ArrayList<>();
-        List<Pari> gagnantsBonus4 = new ArrayList<>();
+        List<PariQuintePlus> gagnantsBonus4 = new ArrayList<>();
 
-        for (Pari pari : tousParis) {
+        for (PariQuintePlus pari : tousParis) {
             if (estGagnantOrdreExact(pari, resultat)) {
                 gagnantsOrdreExact.add(pari);
             } else if (estGagnantOrdreInexact(pari, resultat)) {
@@ -591,12 +590,12 @@ public class ServicePari {
         return resultats;
     }
 
-    private boolean estGagnantOrdreExact(Pari pari, Resultat resultat) {
+    private boolean estGagnantOrdreExact(PariQuintePlus pari, ResultatQuintePlus resultat) {
         // Vérifier si l'ordre prédit correspond exactement à l'ordre d'arrivée
         return pari.getOrdrePredit().equals(resultat.getIdsChevauxOrdreArrivee());
     }
 
-    private boolean estGagnantOrdreInexact(Pari pari, Resultat resultat) {
+    private boolean estGagnantOrdreInexact(PariQuintePlus pari, ResultatQuintePlus resultat) {
         // Vérifier si les 5 chevaux sont dans les 5 premiers mais pas dans le bon ordre
         List<Long> cinqPremiers = resultat.getIdsChevauxOrdreArrivee().subList(0, Math.min(5, resultat.getIdsChevauxOrdreArrivee().size()));
         List<Long> chevauxPari = pari.getChevauxSelectionnes();
@@ -605,7 +604,7 @@ public class ServicePari {
                 !pari.getOrdrePredit().equals(resultat.getIdsChevauxOrdreArrivee());
     }
 
-    private boolean estGagnantBonus4(Pari pari, Resultat resultat) {
+    private boolean estGagnantBonus4(PariQuintePlus pari, ResultatQuintePlus resultat) {
         // Vérifier si au moins 4 chevaux du pari sont dans les 4 premiers
         List<Long> quatrePremiers = resultat.getIdsChevauxOrdreArrivee().subList(0, Math.min(4, resultat.getIdsChevauxOrdreArrivee().size()));
         List<Long> chevauxPari = pari.getChevauxSelectionnes();

src/main/java/com/pmumali/ch1_simple/controller/ChevalController.java

@@ -1,33 +0,0 @@
-package com.pmumali.ch1_simple.controller;
-
-import com.pmumali.ch1_simple.model.Cheval;
-import com.pmumali.ch1_simple.service.ChevalService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.*;
-
-import java.util.List;
-
-@RestController
-@RequestMapping("/api/chevaux")
-public class ChevalController {
-
-    @Autowired
-    private ChevalService chevalService;
-
-    @PostMapping
-    public ResponseEntity<Cheval> ajouterCheval(@RequestBody Cheval cheval) {
-        return ResponseEntity.ok(chevalService.ajouterCheval(cheval));
-    }
-
-    @GetMapping("/course/{courseId}")
-    public ResponseEntity<List<Cheval>> obtenirChevauxParCourse(@PathVariable Long courseId) {
-        return ResponseEntity.ok(chevalService.obtenirChevauxParCourse(courseId));
-    }
-
-    @GetMapping("/ecurie/{nomEcurie}")
-    public ResponseEntity<List<Cheval>> obtenirChevauxParEcurie(@PathVariable String nomEcurie) {
-        return ResponseEntity.ok(chevalService.obtenirChevauxParEcurie(nomEcurie));
-    }
-}
-

src/main/java/com/pmumali/ch1_simple/controller/ChevalSimpleController.java

@@ -0,0 +1,34 @@
+package com.pmumali.ch1_simple.controller;
+
+import com.pmumali.ch1_simple.model.ChevalSimple;
+import com.pmumali.ch1_simple.service.ChevalSimpleService;
+import com.pmumali.common.model.Cheval;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/simple/cheval")
+public class ChevalSimpleController {
+
+    @Autowired
+    private ChevalSimpleService chevalService;
+
+   // @PostMapping
+    public ResponseEntity<ChevalSimple> ajouterCheval(@RequestBody ChevalSimple cheval) {
+        return ResponseEntity.ok(chevalService.ajouterCheval(cheval));
+    }
+
+   // @GetMapping("/course/{courseId}")
+    public ResponseEntity<List<ChevalSimple>> obtenirChevauxParCourse(@PathVariable Long courseId) {
+        return ResponseEntity.ok(chevalService.obtenirChevauxParCourse(courseId));
+    }
+
+   // @GetMapping("/ecurie/{nomEcurie}")
+    public ResponseEntity<List<ChevalSimple>> obtenirChevauxParEcurie(@PathVariable String nomEcurie) {
+        return ResponseEntity.ok(chevalService.obtenirChevauxParEcurie(nomEcurie));
+    }
+}
+

src/main/java/com/pmumali/ch1_simple/controller/CourseController.java

@@ -1,43 +0,0 @@
-package com.pmumali.ch1_simple.controller;
-
-import com.pmumali.ch1_simple.model.Course;
-import com.pmumali.ch1_simple.service.CourseService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.*;
-import java.util.List;
-
-@RestController
-@RequestMapping("/api/courses")
-public class CourseController {
-
-    @Autowired
-    private CourseService courseService;
-
-    @PostMapping
-    public ResponseEntity<Course> creerCourse(@RequestBody Course course) {
-        return ResponseEntity.ok(courseService.creerCourse(course));
-    }
-
-    @GetMapping
-    public ResponseEntity<List<Course>> obtenirToutesCourses() {
-        return ResponseEntity.ok(courseService.obtenirToutesCourses());
-    }
-
-    @GetMapping("/{id}")
-    public ResponseEntity<Course> obtenirCourseParId(@PathVariable Long id) {
-        Course course = courseService.obtenirCourseParId(id);
-        return course != null ? ResponseEntity.ok(course) : ResponseEntity.notFound().build();
-    }
-
-    @GetMapping("/terminees")
-    public ResponseEntity<List<Course>> obtenirCoursesTerminees() {
-        return ResponseEntity.ok(courseService.obtenirCoursesTerminees());
-    }
-
-    @GetMapping("/avenir")
-    public ResponseEntity<List<Course>> obtenirCoursesAVenir() {
-        return ResponseEntity.ok(courseService.obtenirCoursesAVenir());
-    }
-}
-

src/main/java/com/pmumali/ch1_simple/controller/CourseSimpleController.java

@@ -0,0 +1,44 @@
+package com.pmumali.ch1_simple.controller;
+
+import com.pmumali.ch1_simple.model.CourseSimple;
+
+import com.pmumali.ch1_simple.service.CourseSimpleService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/simple/courses")
+public class CourseSimpleController {
+
+    @Autowired
+    private CourseSimpleService courseService;
+
+   // @PostMapping
+    public ResponseEntity<CourseSimple> creerCourse(@RequestBody CourseSimple course) {
+        return ResponseEntity.ok(courseService.creerCourse(course));
+    }
+
+   // @GetMapping
+    public ResponseEntity<List<CourseSimple>> obtenirToutesCourses() {
+        return ResponseEntity.ok(courseService.obtenirToutesCourses());
+    }
+
+  //  @GetMapping("/{id}")
+    public ResponseEntity<CourseSimple> obtenirCourseParId(@PathVariable Long id) {
+        CourseSimple course = courseService.obtenirCourseParId(id);
+        return course != null ? ResponseEntity.ok(course) : ResponseEntity.notFound().build();
+    }
+
+   // @GetMapping("/terminees")
+    public ResponseEntity<List<CourseSimple>> obtenirCoursesTerminees() {
+        return ResponseEntity.ok(courseService.obtenirCoursesTerminees());
+    }
+
+  //  @GetMapping("/avenir")
+    public ResponseEntity<List<CourseSimple>> obtenirCoursesAVenir() {
+        return ResponseEntity.ok(courseService.obtenirCoursesAVenir());
+    }
+}
+

src/main/java/com/pmumali/ch1_simple/controller/GainsController.java

@@ -1,28 +0,0 @@
-package com.pmumali.ch1_simple.controller;
-
-import com.pmumali.ch1_simple.model.Gains;
-import com.pmumali.ch1_simple.model.ResultatCourse;
-import com.pmumali.ch1_simple.service.GainsService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.*;
-
-@RestController
-@RequestMapping("/api/gains")
-public class GainsController {
-
-    @Autowired
-    private GainsService gainsService;
-
-    @PostMapping("/calculer/{courseId}")
-    public ResponseEntity<Gains> calculerGains(@PathVariable Long courseId, @RequestBody ResultatCourse resultat) {
-        return ResponseEntity.ok(gainsService.calculerGains(courseId, resultat));
-    }
-
-    @GetMapping("/course/{courseId}")
-    public ResponseEntity<Gains> obtenirGainsParCourse(@PathVariable Long courseId) {
-        Gains gains = gainsService.obtenirGainsParCourse(courseId);
-        return gains != null ? ResponseEntity.ok(gains) : ResponseEntity.notFound().build();
-    }
-}
-

src/main/java/com/pmumali/ch1_simple/controller/GainsSimpleController.java

@@ -0,0 +1,28 @@
+package com.pmumali.ch1_simple.controller;
+
+import com.pmumali.ch1_simple.model.GainsSimple;
+import com.pmumali.ch1_simple.model.ResultatCourseSimple;
+import com.pmumali.ch1_simple.service.GainsSimpleService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@RequestMapping("/api/simple/gains")
+public class GainsSimpleController {
+
+    @Autowired
+    private GainsSimpleService gainsService;
+
+  //  @PostMapping("/calculer/{courseId}")
+    public ResponseEntity<GainsSimple> calculerGains(@PathVariable Long courseId, @RequestBody ResultatCourseSimple resultat) {
+        return ResponseEntity.ok(gainsService.calculerGains(courseId, resultat));
+    }
+
+  //  @GetMapping("/course/{courseId}")
+    public ResponseEntity<GainsSimple> obtenirGainsParCourse(@PathVariable Long courseId) {
+        GainsSimple gains = gainsService.obtenirGainsParCourse(courseId);
+        return gains != null ? ResponseEntity.ok(gains) : ResponseEntity.notFound().build();
+    }
+}
+

src/main/java/com/pmumali/ch1_simple/controller/PariSimpleController.java

@@ -9,29 +9,29 @@ import org.springframework.web.bind.annotation.*;
 import java.util.List;
 
 @RestController
-@RequestMapping("/api/paris")
+@RequestMapping("/api/simple")
-public class PariController {
+public class PariSimpleController {
 
     @Autowired
     private PariSimpleService pariService;
 
-    @PostMapping
+    @PostMapping("/pari")
     public ResponseEntity<PariSimple> placerPari(@RequestBody PariSimple pari) {
         return ResponseEntity.ok(pariService.placerPari(pari));
     }
 
-    @GetMapping("/course/{courseId}")
+  //  @GetMapping("/course/{courseId}")
     public ResponseEntity<List<PariSimple>> obtenirParisParCourse(@PathVariable Long courseId) {
         return ResponseEntity.ok(pariService.obtenirParisParCourse(courseId));
     }
 
-    @GetMapping("/course/{courseId}/type/{typePari}")
+  //  @GetMapping("/course/{courseId}/type/{typePari}")
     public ResponseEntity<List<PariSimple>> obtenirParisParCourseEtType(
             @PathVariable Long courseId, @PathVariable String typePari) {
         return ResponseEntity.ok(pariService.obtenirParisParCourseEtType(courseId, typePari));
     }
 
-    @GetMapping("/cheval/{chevalId}")
+  //  @GetMapping("/cheval/{chevalId}")
     public ResponseEntity<List<PariSimple>> obtenirParisParCheval(@PathVariable Long chevalId) {
         return ResponseEntity.ok(pariService.obtenirParisParCheval(chevalId));
     }

src/main/java/com/pmumali/ch1_simple/model/ChevalSimple.java

@@ -1,25 +1,34 @@
 package com.pmumali.ch1_simple.model;
 
+import com.pmumali.common.model.Cheval;
+import com.pmumali.common.model.Course;
+import com.pmumali.common.util.CollectionTransformer;
 import jakarta.persistence.*;
 import lombok.*;
 
+import java.util.List;
+
+
 @Entity
 @Data
 @NoArgsConstructor
 @AllArgsConstructor
 @Table(name = "cheval")
-public class Cheval {
+public class ChevalSimple extends Cheval {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
 
     private String nom;
     private int numero;
-    private boolean estNonPartant;
+    @Column(name = "non_partant")
+    private boolean nonPartant;
     private String nomEcurie;
 
     @ManyToOne
     @JoinColumn(name = "course_id")
-    private Course course;
+    private CourseSimple course;
+
+
 }
 

src/main/java/com/pmumali/ch1_simple/model/CourseSimple.java

@@ -1,5 +1,6 @@
 package com.pmumali.ch1_simple.model;
 
+import com.pmumali.common.model.Course;
 import jakarta.persistence.*;
 import lombok.Data;
 import lombok.NoArgsConstructor;
@@ -13,20 +14,18 @@ import java.util.List;
 @NoArgsConstructor
 @AllArgsConstructor
 @Table(name = "course")
-public class Course {
+public class CourseSimple extends Course {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
-
     private String nom;
-    private LocalDateTime date;
+    @Column(name = "heure_course")
+    private LocalDateTime heureCourse;
     private String lieu;
     private int nombreChevauxInscrits;
     private boolean estTerminee;
-
+    private boolean estAnnulee;
-    @OneToMany(mappedBy = "course", cascade = CascadeType.ALL)
-    private List<Cheval> chevaux;
 
     @OneToOne(mappedBy = "course", cascade = CascadeType.ALL)
-    private ResultatCourse resultat;
+    private ResultatCourseSimple resultat;
 }

src/main/java/com/pmumali/ch1_simple/model/GainsSimple.java

@@ -10,14 +10,14 @@ import java.time.LocalDateTime;
 @NoArgsConstructor
 @AllArgsConstructor
 @Table(name = "gains")
-public class Gains {
+public class GainsSimple {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
 
     @ManyToOne
     @JoinColumn(name = "course_id")
-    private Course course;
+    private CourseSimple course;
 
     private double masseGagnant;
     private double massePlace;

src/main/java/com/pmumali/ch1_simple/model/PariSimple.java

@@ -1,31 +1,35 @@
 package com.pmumali.ch1_simple.model;
 
+import com.pmumali.ch2_jumelegagnant.model.CourseJumeleGagnant;
+import com.pmumali.common.model.Pari;
 import jakarta.persistence.*;
 import lombok.*;
 
 import java.time.LocalDateTime;
 
+
 @Entity
 @Data
 @NoArgsConstructor
 @AllArgsConstructor
-@Table(name = "pari_simple")
+@Table(name = "pari")
-public class PariSimple {
+public class PariSimple extends Pari {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
-
+    @Column(name = "type_pari")
     private String typePari; // GAGNANT ou PLACE
     private double mise = 500.0;
     private LocalDateTime datePari;
 
+    private boolean estPaye;
+    private boolean estRembourse;
+
     @ManyToOne
     @JoinColumn(name = "cheval_id")
-    private Cheval cheval;
+    private ChevalSimple cheval;
 
     @ManyToOne
     @JoinColumn(name = "course_id")
-    private Course course;
+    private CourseSimple course;
-
-    private boolean estPaye;
 }

src/main/java/com/pmumali/ch1_simple/model/ResultatCourse.java

@@ -1,32 +0,0 @@
-package com.pmumali.ch1_simple.model;
-
-import jakarta.persistence.*;
-import lombok.*;
-
-import java.util.List;
-
-@Entity
-@Data
-@NoArgsConstructor
-@AllArgsConstructor
-@Table(name = "resultat_course")
-public class ResultatCourse {
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
-
-    @OneToOne
-    @JoinColumn(name = "course_id")
-    private Course course;
-
-    @ElementCollection
-    private List<Long> chevauxPremiers; // Pour gérer les dead-heats
-
-    @ElementCollection
-    private List<Long> chevauxDeuxiemes; // Pour gérer les dead-heats
-
-    @ElementCollection
-    private List<Long> chevauxTroisiemes; // Pour gérer les dead-heats
-
-    private boolean aDeadHeat;
-}

src/main/java/com/pmumali/ch1_simple/model/ResultatCourseSimple.java

@@ -0,0 +1,24 @@
+package com.pmumali.ch1_simple.model;
+
+import com.pmumali.ch2_jumelegagnant.model.CourseJumeleGagnant;
+import com.pmumali.common.model.Resultat;
+import jakarta.persistence.*;
+import lombok.*;
+
+import java.util.List;
+
+@Entity
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "resultat_course")
+public class ResultatCourseSimple extends Resultat {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @OneToOne
+    @JoinColumn(name = "course_id")
+    private CourseSimple course;
+
+}

src/main/java/com/pmumali/ch1_simple/repository/ChevalRepository.java

@@ -1,13 +0,0 @@
-package com.pmumali.ch1_simple.repository;
-
-import com.pmumali.ch1_simple.model.Cheval;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
-
-import java.util.List;
-
-@Repository
-public interface ChevalRepository extends JpaRepository<Cheval, Long> {
-    List<Cheval> findByCourseId(Long courseId);
-    List<Cheval> findByNomEcurie(String nomEcurie);
-}

src/main/java/com/pmumali/ch1_simple/repository/ChevalSimpleRepository.java

@@ -0,0 +1,14 @@
+package com.pmumali.ch1_simple.repository;
+
+import com.pmumali.ch1_simple.model.ChevalSimple;
+import com.pmumali.common.model.Cheval;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface ChevalSimpleRepository extends JpaRepository<ChevalSimple, Long> {
+    List<ChevalSimple> findByCourseId(Long courseId);
+    List<ChevalSimple> findByNomEcurie(String nomEcurie);
+}

src/main/java/com/pmumali/ch1_simple/repository/CourseRepository.java

@@ -1,11 +0,0 @@
-package com.pmumali.ch1_simple.repository;
-
-import com.pmumali.ch1_simple.model.Course;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
-import java.util.List;
-
-@Repository
-public interface CourseRepository extends JpaRepository<Course, Long> {
-    List<Course> findByEstTerminee(boolean estTerminee);
-}

src/main/java/com/pmumali/ch1_simple/repository/CourseSimpleRepository.java

@@ -0,0 +1,11 @@
+package com.pmumali.ch1_simple.repository;
+
+import com.pmumali.ch1_simple.model.CourseSimple;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+import java.util.List;
+
+@Repository
+public interface CourseSimpleRepository extends JpaRepository<CourseSimple, Long> {
+    List<CourseSimple> findByEstTerminee(boolean estTerminee);
+}

src/main/java/com/pmumali/ch1_simple/repository/GainsRepository.java

@@ -1,10 +0,0 @@
-package com.pmumali.ch1_simple.repository;
-
-import com.pmumali.ch1_simple.model.Gains;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
-
-@Repository
-public interface GainsRepository extends JpaRepository<Gains, Long> {
-    Gains findByCourseId(Long courseId);
-}

src/main/java/com/pmumali/ch1_simple/repository/GainsSimpleRepository.java

@@ -0,0 +1,10 @@
+package com.pmumali.ch1_simple.repository;
+
+import com.pmumali.ch1_simple.model.GainsSimple;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface GainsSimpleRepository extends JpaRepository<GainsSimple, Long> {
+    GainsSimple findByCourseId(Long courseId);
+}

src/main/java/com/pmumali/ch1_simple/repository/ResultatCourseRepository.java

@@ -1,10 +0,0 @@
-package com.pmumali.ch1_simple.repository;
-
-import com.pmumali.ch1_simple.model.ResultatCourse;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
-
-@Repository
-public interface ResultatCourseRepository extends JpaRepository<ResultatCourse, Long> {
-    ResultatCourse findByCourseId(Long courseId);
-}

src/main/java/com/pmumali/ch1_simple/repository/ResultatCourseSimpleRepository.java

@@ -0,0 +1,10 @@
+package com.pmumali.ch1_simple.repository;
+
+import com.pmumali.ch1_simple.model.ResultatCourseSimple;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface ResultatCourseSimpleRepository extends JpaRepository<ResultatCourseSimple, Long> {
+    ResultatCourseSimple findByCourseId(Long courseId);
+}

src/main/java/com/pmumali/ch1_simple/service/ChevalService.java

@@ -1,27 +0,0 @@
-package com.pmumali.ch1_simple.service;
-
-import com.pmumali.ch1_simple.model.Cheval;
-import com.pmumali.ch1_simple.repository.ChevalRepository;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-
-import java.util.List;
-
-@Service
-public class ChevalService {
-
-    @Autowired
-    private ChevalRepository chevalRepository;
-
-    public Cheval ajouterCheval(Cheval cheval) {
-        return chevalRepository.save(cheval);
-    }
-
-    public List<Cheval> obtenirChevauxParCourse(Long courseId) {
-        return chevalRepository.findByCourseId(courseId);
-    }
-
-    public List<Cheval> obtenirChevauxParEcurie(String nomEcurie) {
-        return chevalRepository.findByNomEcurie(nomEcurie);
-    }
-}

src/main/java/com/pmumali/ch1_simple/service/ChevalSimpleService.java

@@ -0,0 +1,28 @@
+package com.pmumali.ch1_simple.service;
+
+import com.pmumali.ch1_simple.model.ChevalSimple;
+import com.pmumali.ch1_simple.repository.ChevalSimpleRepository;
+import com.pmumali.common.model.Cheval;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+public class ChevalSimpleService {
+
+    @Autowired
+    private ChevalSimpleRepository chevalRepository;
+
+    public ChevalSimple ajouterCheval(ChevalSimple cheval) {
+        return chevalRepository.save(cheval);
+    }
+
+    public List<ChevalSimple> obtenirChevauxParCourse(Long courseId) {
+        return chevalRepository.findByCourseId(courseId);
+    }
+
+    public List<ChevalSimple> obtenirChevauxParEcurie(String nomEcurie) {
+        return chevalRepository.findByNomEcurie(nomEcurie);
+    }
+}

src/main/java/com/pmumali/ch1_simple/service/CourseSimpleService.java

@@ -1,8 +1,8 @@
 package com.pmumali.ch1_simple.service;
 
 
-import com.pmumali.ch1_simple.model.Course;
+import com.pmumali.ch1_simple.model.CourseSimple;
-import com.pmumali.ch1_simple.repository.CourseRepository;
+import com.pmumali.ch1_simple.repository.CourseSimpleRepository;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
@@ -10,28 +10,28 @@ import java.util.*;
 
 
 @Service
-public class CourseService {
+public class CourseSimpleService {
 
     @Autowired
-    private CourseRepository courseRepository;
+    private CourseSimpleRepository courseRepository;
 
-    public Course creerCourse(Course course) {
+    public CourseSimple creerCourse(CourseSimple course) {
         return courseRepository.save(course);
     }
 
-    public List<Course> obtenirToutesCourses() {
+    public List<CourseSimple> obtenirToutesCourses() {
         return courseRepository.findAll();
     }
 
-    public Course obtenirCourseParId(Long id) {
+    public CourseSimple obtenirCourseParId(Long id) {
         return courseRepository.findById(id).orElse(null);
     }
 
-    public List<Course> obtenirCoursesTerminees() {
+    public List<CourseSimple> obtenirCoursesTerminees() {
         return courseRepository.findByEstTerminee(true);
     }
 
-    public List<Course> obtenirCoursesAVenir() {
+    public List<CourseSimple> obtenirCoursesAVenir() {
         return courseRepository.findByEstTerminee(false);
     }
 }

src/main/java/com/pmumali/ch1_simple/service/GainsSimpleService.java

@@ -14,28 +14,28 @@ import java.util.stream.Collectors;
 
 @Service
 @Transactional
-public class GainsService {
+public class GainsSimpleService {
 
     @Autowired
     private PariSimpleRepository pariRepository;
 
     @Autowired
-    private GainsRepository gainsRepository;
+    private GainsSimpleRepository gainsRepository;
 
     @Autowired
-    private CourseRepository courseRepository;
+    private CourseSimpleRepository courseRepository;
 
     @Autowired
-    private ChevalRepository chevalRepository;
+    private ChevalSimpleRepository chevalRepository;
 
     @Autowired
-    private ResultatCourseRepository resultatRepository;
+    private ResultatCourseSimpleRepository resultatRepository;
 
     private static final double RAPPORT_MINIMUM = 1.1;
     private static final double PRELEVEMENTS = 0.15; // 15% de prélèvements
 
-    public Gains calculerGains(Long courseId, ResultatCourse resultat) {
+    public GainsSimple calculerGains(Long courseId, ResultatCourseSimple resultat) {
-        Course course = courseRepository.findById(courseId)
+        CourseSimple course = courseRepository.findById(courseId)
                 .orElseThrow(() -> new RuntimeException("Course non trouvée"));
 
         List<PariSimple> tousParis = pariRepository.findByCourseId(courseId);
@@ -64,7 +64,7 @@ public class GainsService {
         double massePlace = masseAPartager * (parisPlace.stream().mapToDouble(PariSimple::getMise).sum() / totalMises);
 
         // Calcul des rapports
-        Gains gains = new Gains();
+        GainsSimple gains = new GainsSimple();
         gains.setCourse(course);
         gains.setMasseGagnant(masseGagnant);
         gains.setMassePlace(massePlace);
@@ -83,7 +83,7 @@ public class GainsService {
         double remboursements = 0.0;
 
         for (PariSimple pari : paris) {
-            if (pari.getCheval().isEstNonPartant()) {
+            if (pari.getCheval().isNonPartant()) {
                 remboursements += pari.getMise();
                 pari.setEstPaye(true); // Marquer comme remboursé
             }
@@ -92,7 +92,7 @@ public class GainsService {
         return remboursements;
     }
 
-    private void calculerDetailsGains(Gains gains, ResultatCourse resultat,
+    private void calculerDetailsGains(GainsSimple gains, ResultatCourseSimple resultat,
                                       List<PariSimple> parisGagnant, List<PariSimple> parisPlace) {
         // Calcul des rapports GAGNANT
         if (resultat.isADeadHeat()) {
@@ -113,7 +113,7 @@ public class GainsService {
         gains.setRapportPlace(Math.max(gains.getRapportPlace(), RAPPORT_MINIMUM));
     }
 
-    private void calculerRapportsGagnantNormal(Gains gains, ResultatCourse resultat, List<PariSimple> parisGagnant) {
+    private void calculerRapportsGagnantNormal(GainsSimple gains, ResultatCourseSimple resultat, List<PariSimple> parisGagnant) {
         // Article 5a: Cas d'arrivée normale - Calcul du rapport "gagnant"
         if (resultat.getChevauxPremiers().isEmpty()) {
             gains.setRapportGagnant(0.0);
@@ -122,7 +122,7 @@ public class GainsService {
 
         // Gestion des écuries (Article 2)
         Long chevalGagnantId = resultat.getChevauxPremiers().get(0);
-        Cheval chevalGagnant = chevalRepository.findById(chevalGagnantId).orElse(null);
+        ChevalSimple chevalGagnant = chevalRepository.findById(chevalGagnantId).orElse(null);
 
         if (chevalGagnant == null) {
             gains.setRapportGagnant(0.0);
@@ -130,14 +130,14 @@ public class GainsService {
         }
 
         // Trouver tous les chevaux de la même écurie
-        List<Cheval> chevauxEcurie = Collections.singletonList(chevalGagnant);
+        List<ChevalSimple> chevauxEcurie = Collections.singletonList(chevalGagnant);
         if (chevalGagnant.getNomEcurie() != null) {
             chevauxEcurie = chevalRepository.findByNomEcurie(chevalGagnant.getNomEcurie());
         }
 
         // Calculer le total des mises sur les chevaux de l'écurie
         double totalMisesEcurie = 0.0;
-        for (Cheval cheval : chevauxEcurie) {
+        for (ChevalSimple cheval : chevauxEcurie) {
             double misesCheval = parisGagnant.stream()
                     .filter(p -> p.getCheval().getId().equals(cheval.getId()))
                     .mapToDouble(PariSimple::getMise)
@@ -152,7 +152,7 @@ public class GainsService {
         }
     }
 
-    private void calculerRapportsGagnantDeadHeat(Gains gains, ResultatCourse resultat, List<PariSimple> parisGagnant) {
+    private void calculerRapportsGagnantDeadHeat(GainsSimple gains, ResultatCourseSimple resultat, List<PariSimple> parisGagnant) {
         // Article 5a: Cas d'arrivée "dead-heat" - Calcul des rapports "gagnant"
         if (resultat.getChevauxPremiers().isEmpty()) {
             gains.setRapportGagnant(0.0);
@@ -204,7 +204,7 @@ public class GainsService {
         }
     }
 
-    private void calculerRapportsPlaceNormal(Gains gains, ResultatCourse resultat, List<PariSimple> parisPlace) {
+    private void calculerRapportsPlaceNormal(GainsSimple gains, ResultatCourseSimple resultat, List<PariSimple> parisPlace) {
         // Article 5b: Cas d'arrivée normale - Calcul du rapport "placé"
         int nombreChevauxInscrits = gains.getCourse().getNombreChevauxInscrits();
         List<Long> chevauxPayables = new ArrayList<>();
@@ -271,7 +271,7 @@ public class GainsService {
         }
     }
 
-    private void calculerRapportsPlaceDeadHeat(Gains gains, ResultatCourse resultat, List<PariSimple> parisPlace) {
+    private void calculerRapportsPlaceDeadHeat(GainsSimple gains, ResultatCourseSimple resultat, List<PariSimple> parisPlace) {
         // Article 5b et 5c: Cas d'arrivée "dead-heat" - Calcul des rapports "placé"
         int nombreChevauxInscrits = gains.getCourse().getNombreChevauxInscrits();
 
@@ -335,7 +335,7 @@ public class GainsService {
         }
     }
 
-    private List<Long> determinerChevauxPayablesPlace(ResultatCourse resultat, int nombreChevauxInscrits) {
+    private List<Long> determinerChevauxPayablesPlace(ResultatCourseSimple resultat, int nombreChevauxInscrits) {
         List<Long> chevauxPayables = new ArrayList<>();
 
         // Article 3: Déterminer les chevaux payables selon le nombre de partants
@@ -353,7 +353,7 @@ public class GainsService {
         return chevauxPayables;
     }
 
-    private double appliquerReglesPlaceMoinsHuit(ResultatCourse resultat, double beneficeARepartir) {
+    private double appliquerReglesPlaceMoinsHuit(ResultatCourseSimple resultat, double beneficeARepartir) {
         // Article 5c: Règles pour les courses de moins de 8 chevaux avec dead-heat
         int nbPremiers = resultat.getChevauxPremiers().size();
         int nbDeuxiemes = resultat.getChevauxDeuxiemes().size();
@@ -371,7 +371,7 @@ public class GainsService {
         return beneficeARepartir;
     }
 
-    private double appliquerReglesPlaceHuitPlus(ResultatCourse resultat, double beneficeARepartir) {
+    private double appliquerReglesPlaceHuitPlus(ResultatCourseSimple resultat, double beneficeARepartir) {
         // Article 5c: Règles pour les courses de 8 chevaux et plus avec dead-heat
         int nbPremiers = resultat.getChevauxPremiers().size();
         int nbDeuxiemes = resultat.getChevauxDeuxiemes().size();
@@ -401,7 +401,7 @@ public class GainsService {
         return beneficeARepartir;
     }
 
-    private void gererCagnotte(Gains gains, ResultatCourse resultat,
+    private void gererCagnotte(GainsSimple gains, ResultatCourseSimple resultat,
                                List<PariSimple> parisGagnant, List<PariSimple> parisPlace) {
         // Article 6 et 7: Gestion de la cagnotte (tirelire)
         double montantCagnotte = 0.0;
@@ -473,7 +473,7 @@ public class GainsService {
         // TODO: Implémenter la logique de report de la cagnotte selon l'article 7
     }
 
-    public Gains obtenirGainsParCourse(Long courseId) {
+    public GainsSimple obtenirGainsParCourse(Long courseId) {
         return gainsRepository.findByCourseId(courseId);
     }
 }

src/main/java/com/pmumali/ch1_simple/service/PariSimpleService.java

@@ -1,9 +1,9 @@
 package com.pmumali.ch1_simple.service;
 
-import com.pmumali.ch1_simple.model.Course;
+import com.pmumali.ch1_simple.model.CourseSimple;
 import com.pmumali.ch1_simple.model.PariSimple;
-import com.pmumali.ch1_simple.repository.ChevalRepository;
+import com.pmumali.ch1_simple.repository.ChevalSimpleRepository;
-import com.pmumali.ch1_simple.repository.CourseRepository;
+import com.pmumali.ch1_simple.repository.CourseSimpleRepository;
 import com.pmumali.ch1_simple.repository.PariSimpleRepository;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
@@ -17,16 +17,16 @@ public class PariSimpleService {
     private PariSimpleRepository pariRepository;
 
     @Autowired
-    private CourseRepository courseRepository;
+    private CourseSimpleRepository courseRepository;
 
     @Autowired
-    private ChevalRepository chevalRepository;
+    private ChevalSimpleRepository chevalRepository;
 
     private static final double MISE_DE_BASE = 500.0;
 
     public PariSimple placerPari(PariSimple pari) {
         // Vérifier que le type de pari est valide pour la course
-        Course course = pari.getCourse();
+        CourseSimple course = (CourseSimple) pari.getCourse();
         if ("GAGNANT".equals(pari.getTypePari()) && course.getNombreChevauxInscrits() < 2) {
             throw new IllegalArgumentException("Pari GAGNANT impossible: moins de 2 chevaux");
         }

src/main/java/com/pmumali/ch2_jumelegagnant/controller/ChevalController.java

@@ -1,32 +0,0 @@
-package com.pmumali.ch2_jumelegagnant.controller;
-
-import com.pmumali.ch2_jumelegagnant.model.Cheval;
-import com.pmumali.ch2_jumelegagnant.service.ChevalService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.*;
-
-import java.util.List;
-
-@RestController
-@RequestMapping("/api/chevaux")
-public class ChevalController {
-
-    @Autowired
-    private ChevalService chevalService;
-
-    @PostMapping
-    public ResponseEntity<Cheval> ajouterCheval(@RequestBody Cheval cheval) {
-        return ResponseEntity.ok(chevalService.ajouterCheval(cheval));
-    }
-
-    @GetMapping("/course/{courseId}")
-    public ResponseEntity<List<Cheval>> obtenirChevauxParCourse(@PathVariable Long courseId) {
-        return ResponseEntity.ok(chevalService.obtenirChevauxParCourse(courseId));
-    }
-
-    @GetMapping("/non-partants")
-    public ResponseEntity<List<Cheval>> obtenirChevauxNonPartants() {
-        return ResponseEntity.ok(chevalService.obtenirChevauxNonPartants());
-    }
-}

src/main/java/com/pmumali/ch2_jumelegagnant/controller/ChevalJumeleGagnantController.java

@@ -0,0 +1,32 @@
+package com.pmumali.ch2_jumelegagnant.controller;
+
+import com.pmumali.ch2_jumelegagnant.model.ChevalJumeleGagnant;
+import com.pmumali.ch2_jumelegagnant.service.ChevalJumeleGagnantService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/jumelegagnant/chevaux")
+public class ChevalJumeleGagnantController {
+
+    @Autowired
+    private ChevalJumeleGagnantService chevalService;
+
+  //  @PostMapping
+    public ResponseEntity<ChevalJumeleGagnant> ajouterCheval(@RequestBody ChevalJumeleGagnant cheval) {
+        return ResponseEntity.ok(chevalService.ajouterCheval(cheval));
+    }
+
+  //  @GetMapping("/course/{courseId}")
+    public ResponseEntity<List<ChevalJumeleGagnant>> obtenirChevauxParCourse(@PathVariable Long courseId) {
+        return ResponseEntity.ok(chevalService.obtenirChevauxParCourse(courseId));
+    }
+
+  //  @GetMapping("/non-partants")
+    public ResponseEntity<List<ChevalJumeleGagnant>> obtenirChevauxNonPartants() {
+        return ResponseEntity.ok(chevalService.obtenirChevauxNonPartants());
+    }
+}

src/main/java/com/pmumali/ch2_jumelegagnant/controller/CourseController.java

@@ -1,48 +0,0 @@
-package com.pmumali.ch2_jumelegagnant.controller;
-
-import com.pmumali.ch2_jumelegagnant.model.Course;
-import com.pmumali.ch2_jumelegagnant.service.CourseService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.*;
-import java.util.List;
-
-@RestController
-@RequestMapping("/api/courses")
-public class CourseController {
-
-    @Autowired
-    private CourseService courseService;
-
-    @PostMapping
-    public ResponseEntity<Course> creerCourse(@RequestBody Course course) {
-        return ResponseEntity.ok(courseService.creerCourse(course));
-    }
-
-    @GetMapping
-    public ResponseEntity<List<Course>> obtenirToutesCourses() {
-        return ResponseEntity.ok(courseService.obtenirToutesCourses());
-    }
-
-    @GetMapping("/{id}")
-    public ResponseEntity<Course> obtenirCourseParId(@PathVariable Long id) {
-        Course course = courseService.obtenirCourseParId(id);
-        return course != null ? ResponseEntity.ok(course) : ResponseEntity.notFound().build();
-    }
-
-    @GetMapping("/terminees")
-    public ResponseEntity<List<Course>> obtenirCoursesTerminees() {
-        return ResponseEntity.ok(courseService.obtenirCoursesTerminees());
-    }
-
-    @GetMapping("/avenir")
-    public ResponseEntity<List<Course>> obtenirCoursesAVenir() {
-        return ResponseEntity.ok(courseService.obtenirCoursesAVenir());
-    }
-
-    @GetMapping("/annulees")
-    public ResponseEntity<List<Course>> obtenirCoursesAnnulees() {
-        return ResponseEntity.ok(courseService.obtenirCoursesAnnulees());
-    }
-}
-

src/main/java/com/pmumali/ch2_jumelegagnant/controller/CourseJumeleGagnantController.java

@@ -0,0 +1,49 @@
+package com.pmumali.ch2_jumelegagnant.controller;
+
+import com.pmumali.ch2_jumelegagnant.model.CourseJumeleGagnant;
+import com.pmumali.ch2_jumelegagnant.service.CourseJumeleGagnantService;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/jumelegagnant/courses")
+public class CourseJumeleGagnantController {
+
+    @Autowired
+    private CourseJumeleGagnantService courseService;
+
+   // @PostMapping
+    public ResponseEntity<CourseJumeleGagnant> creerCourse(@RequestBody CourseJumeleGagnant course) {
+        return ResponseEntity.ok(courseService.creerCourse(course));
+    }
+
+  //  @GetMapping
+    public ResponseEntity<List<CourseJumeleGagnant>> obtenirToutesCourses() {
+        return ResponseEntity.ok(courseService.obtenirToutesCourses());
+    }
+
+  //  @GetMapping("/{id}")
+    public ResponseEntity<CourseJumeleGagnant> obtenirCourseParId(@PathVariable Long id) {
+        CourseJumeleGagnant course = courseService.obtenirCourseParId(id);
+        return course != null ? ResponseEntity.ok(course) : ResponseEntity.notFound().build();
+    }
+
+   // @GetMapping("/terminees")
+    public ResponseEntity<List<CourseJumeleGagnant>> obtenirCoursesTerminees() {
+        return ResponseEntity.ok(courseService.obtenirCoursesTerminees());
+    }
+
+  //  @GetMapping("/avenir")
+    public ResponseEntity<List<CourseJumeleGagnant>> obtenirCoursesAVenir() {
+        return ResponseEntity.ok(courseService.obtenirCoursesAVenir());
+    }
+
+   // @GetMapping("/annulees")
+    public ResponseEntity<List<CourseJumeleGagnant>> obtenirCoursesAnnulees() {
+        return ResponseEntity.ok(courseService.obtenirCoursesAnnulees());
+    }
+}
+

src/main/java/com/pmumali/ch2_jumelegagnant/controller/GainsController.java

@@ -1,27 +0,0 @@
-package com.pmumali.ch2_jumelegagnant.controller;
-
-import com.pmumali.ch2_jumelegagnant.model.Gains;
-import com.pmumali.ch2_jumelegagnant.model.ResultatCourse;
-import com.pmumali.ch2_jumelegagnant.service.GainsService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.*;
-
-@RestController
-@RequestMapping("/api/gains")
-public class GainsController {
-
-    @Autowired
-    private GainsService gainsService;
-
-    @PostMapping("/calculer/{courseId}")
-    public ResponseEntity<Gains> calculerGains(@PathVariable Long courseId, @RequestBody ResultatCourse resultat) {
-        return ResponseEntity.ok(gainsService.calculerGains(courseId, resultat));
-    }
-
-    @GetMapping("/course/{courseId}")
-    public ResponseEntity<Gains> obtenirGainsParCourse(@PathVariable Long courseId) {
-        Gains gains = gainsService.obtenirGainsParCourse(courseId);
-        return gains != null ? ResponseEntity.ok(gains) : ResponseEntity.notFound().build();
-    }
-}

src/main/java/com/pmumali/ch2_jumelegagnant/controller/GainsJumeleGagnantController.java

@@ -0,0 +1,27 @@
+package com.pmumali.ch2_jumelegagnant.controller;
+
+import com.pmumali.ch2_jumelegagnant.model.GainsJumeleGagnant;
+import com.pmumali.ch2_jumelegagnant.model.ResultatCourseJumeleGagnant;
+import com.pmumali.ch2_jumelegagnant.service.GainsJumeleGagnantService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@RequestMapping("/api/jumelegagnant/gains")
+public class GainsJumeleGagnantController {
+
+    @Autowired
+    private GainsJumeleGagnantService gainsService;
+
+  //  @PostMapping("/calculer/{courseId}")
+    public ResponseEntity<GainsJumeleGagnant> calculerGains(@PathVariable Long courseId, @RequestBody ResultatCourseJumeleGagnant resultat) {
+        return ResponseEntity.ok(gainsService.calculerGains(courseId, resultat));
+    }
+
+   // @GetMapping("/course/{courseId}")
+    public ResponseEntity<GainsJumeleGagnant> obtenirGainsParCourse(@PathVariable Long courseId) {
+        GainsJumeleGagnant gains = gainsService.obtenirGainsParCourse(courseId);
+        return gains != null ? ResponseEntity.ok(gains) : ResponseEntity.notFound().build();
+    }
+}

src/main/java/com/pmumali/ch2_jumelegagnant/controller/PariJumeleController.java

@@ -9,33 +9,33 @@ import org.springframework.web.bind.annotation.*;
 import java.util.List;
 
 @RestController
-@RequestMapping("/api/paris-jumele")
+@RequestMapping("/api/jumelegagnant")
 public class PariJumeleController {
 
     @Autowired
     private PariJumeleService pariService;
 
-    @PostMapping
+    @PostMapping("/pari")
     public ResponseEntity<PariJumeleGagnant> placerPari(@RequestBody PariJumeleGagnant pari) {
         return ResponseEntity.ok(pariService.placerPari(pari));
     }
 
-    @GetMapping("/course/{courseId}")
+  //  @GetMapping("/course/{courseId}")
     public ResponseEntity<List<PariJumeleGagnant>> obtenirParisParCourse(@PathVariable Long courseId) {
         return ResponseEntity.ok(pariService.obtenirParisParCourse(courseId));
     }
 
-    @GetMapping("/cheval/{chevalId}")
+   // @GetMapping("/cheval/{chevalId}")
     public ResponseEntity<List<PariJumeleGagnant>> obtenirParisParCheval(@PathVariable Long chevalId) {
         return ResponseEntity.ok(pariService.obtenirParisParCheval(chevalId));
     }
 
-    @GetMapping("/calculer-formule-combinee/{nombreChevaux}")
+   // @GetMapping("/calculer-formule-combinee/{nombreChevaux}")
     public ResponseEntity<Double> calculerCoutFormuleCombinee(@PathVariable int nombreChevaux) {
         return ResponseEntity.ok(pariService.calculerCoutFormuleCombinee(nombreChevaux));
     }
 
-    @GetMapping("/calculer-formule-champ")
+   // @GetMapping("/calculer-formule-champ")
     public ResponseEntity<Double> calculerCoutFormuleChamp(
             @RequestParam int nombreChevauxPartants,
             @RequestParam int nombreChevauxSelectionnes,

src/main/java/com/pmumali/ch2_jumelegagnant/model/ChevalJumeleGagnant.java

@@ -1,23 +1,28 @@
 package com.pmumali.ch2_jumelegagnant.model;
 
+import com.pmumali.common.model.Cheval;
 import jakarta.persistence.*;
 import lombok.*;
 
+
 @Entity
 @Data
 @NoArgsConstructor
 @AllArgsConstructor
 @Table(name = "cheval")
-public class Cheval {
+public class ChevalJumeleGagnant extends Cheval {
+
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
 
     private String nom;
     private int numero;
-    private boolean estNonPartant;
+    @Column(name = "non_partant")
+    private boolean nonPartant;
+    private String nomEcurie;
 
     @ManyToOne
     @JoinColumn(name = "course_id")
-    private Course course;
+    private CourseJumeleGagnant course;
 }

src/main/java/com/pmumali/ch2_jumelegagnant/model/CourseJumeleGagnant.java

@@ -1,5 +1,7 @@
 package com.pmumali.ch2_jumelegagnant.model;
 
+import com.pmumali.common.model.Cheval;
+import com.pmumali.common.model.Course;
 import jakarta.persistence.*;
 import lombok.*;
 import lombok.NoArgsConstructor;
@@ -8,26 +10,27 @@ import lombok.AllArgsConstructor;
 import java.time.LocalDateTime;
 import java.util.List;
 
+
 @Entity
 @Data
 @NoArgsConstructor
 @AllArgsConstructor
 @Table(name = "course")
-public class Course {
+public class CourseJumeleGagnant extends Course {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
-
     private String nom;
-    private LocalDateTime date;
+    @Column(name = "heure_course")
+    private LocalDateTime heureCourse;
     private String lieu;
     private int nombreChevauxInscrits;
     private boolean estTerminee;
     private boolean estAnnulee;
 
     @OneToMany(mappedBy = "course", cascade = CascadeType.ALL)
-    private List<Cheval> chevaux;
+    private List<ChevalJumeleGagnant> chevaux;
 
     @OneToOne(mappedBy = "course", cascade = CascadeType.ALL)
-    private ResultatCourse resultat;
+    private ResultatCourseJumeleGagnant resultat;
 }

src/main/java/com/pmumali/ch2_jumelegagnant/model/GainsJumeleGagnant.java

@@ -11,14 +11,14 @@ import java.util.List;
 @NoArgsConstructor
 @AllArgsConstructor
 @Table(name = "gains")
-public class Gains {
+public class GainsJumeleGagnant {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
 
     @ManyToOne
     @JoinColumn(name = "course_id")
-    private Course course;
+    private CourseJumeleGagnant course;
 
     private double masseAPartager;
     private double montantCagnotte;

src/main/java/com/pmumali/ch2_jumelegagnant/model/PariJumeleGagnant.java

@@ -1,36 +1,40 @@
 package com.pmumali.ch2_jumelegagnant.model;
 
+import com.pmumali.common.model.Pari;
 import jakarta.persistence.*;
 import lombok.*;
 
 import java.time.LocalDateTime;
 
+
 @Entity
 @Data
 @NoArgsConstructor
 @AllArgsConstructor
-@Table(name = "pari_jumele_gagnant")
+@Table(name = "pari")
-public class PariJumeleGagnant {
+public class PariJumeleGagnant extends Pari {
+
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
-
+    @Column(name = "type_pari")
-    private String typePari; // UNITAIRE, COMBINE, CHAMP_TOTAL, CHAMP_PARTIEL
+    private String typePari; // GAGNANT ou PLACE
     private double mise = 500.0;
     private LocalDateTime datePari;
 
+    private boolean estPaye;
+    private boolean estRembourse;
+
     @ManyToOne
     @JoinColumn(name = "cheval1_id")
-    private Cheval cheval1;
+    private ChevalJumeleGagnant cheval1;
 
     @ManyToOne
     @JoinColumn(name = "cheval2_id")
-    private Cheval cheval2;
+    private ChevalJumeleGagnant cheval2;
 
     @ManyToOne
     @JoinColumn(name = "course_id")
-    private Course course;
+    private CourseJumeleGagnant course;
 
-    private boolean estPaye;
-    private boolean estRembourse;
 }

src/main/java/com/pmumali/ch2_jumelegagnant/model/ResultatCourseJumeleGagnant.java

@@ -1,29 +1,25 @@
 package com.pmumali.ch2_jumelegagnant.model;
 
+import com.pmumali.common.model.Resultat;
 import jakarta.persistence.*;
 import lombok.*;
 
 import java.util.List;
 
+
 @Entity
 @Data
 @NoArgsConstructor
 @AllArgsConstructor
 @Table(name = "resultat_course")
-public class ResultatCourse {
+public class ResultatCourseJumeleGagnant extends Resultat {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
 
     @OneToOne
     @JoinColumn(name = "course_id")
-    private Course course;
+    private CourseJumeleGagnant course;
 
-    @ElementCollection
-    private List<Long> chevauxPremiers; // Pour gérer les dead-heats
 
-    @ElementCollection
-    private List<Long> chevauxDeuxiemes; // Pour gérer les dead-heats
-
-    private boolean aDeadHeat;
 }

src/main/java/com/pmumali/ch2_jumelegagnant/repository/ChevalJumeleGagnantRepository.java

@@ -0,0 +1,13 @@
+package com.pmumali.ch2_jumelegagnant.repository;
+
+import com.pmumali.ch2_jumelegagnant.model.ChevalJumeleGagnant;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface ChevalJumeleGagnantRepository extends JpaRepository<ChevalJumeleGagnant, Long> {
+    List<ChevalJumeleGagnant> findByCourseId(Long courseId);
+    List<ChevalJumeleGagnant> findByNonPartant(boolean nonPartant);
+}

src/main/java/com/pmumali/ch2_jumelegagnant/repository/ChevalRepository.java

@@ -1,13 +0,0 @@
-package com.pmumali.ch2_jumelegagnant.repository;
-
-import com.pmumali.ch2_jumelegagnant.model.Cheval;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
-
-import java.util.List;
-
-@Repository
-public interface ChevalRepository extends JpaRepository<Cheval, Long> {
-    List<Cheval> findByCourseId(Long courseId);
-    List<Cheval> findByEstNonPartant(boolean estNonPartant);
-}