splitting the services

build.gradle

@@ -41,6 +41,7 @@ dependencies {
     implementation('io.jsonwebtoken:jjwt-jackson:0.11.5')
 
     implementation('org.modelmapper:modelmapper:3.2.0')
+    implementation 'org.springframework.boot:spring-boot-starter-security'
 }
 
 tasks.named('test') {

compose.yaml

@@ -13,7 +13,7 @@ services:
     networks:
       - api
   api_db:
-    image: postgres
+    image: postgres:15
     container_name: api_db
     ports:
       - 5555:5432
@@ -22,7 +22,7 @@ services:
     environment:
       - POSTGRES_USER=postgres
       - POSTGRES_PASSWORD=password
-      - POSTGRES_DBNAME="plr"
+      - POSTGRES_DB="plr"
     restart: always
     networks:
       - api

run.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+set -e 
+./gradlew clean build -x test
+docker-compose up --build -d
+docker logs -f api_app

src/main/java/com/pmu/betengine/BetEngineApplication.java

@@ -2,6 +2,8 @@ package com.pmu.betengine;
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.context.event.ApplicationReadyEvent;
+import org.springframework.context.event.EventListener;
 
 @SpringBootApplication
 public class BetEngineApplication {
@@ -10,4 +12,8 @@ public class BetEngineApplication {
         SpringApplication.run(BetEngineApplication.class, args);
     }
 
+    @EventListener(ApplicationReadyEvent.class)
+    public void onApplicationReady() {
+        System.out.println("******************* PMU Bet Engine is running and connected successfully! *******************");
+    }
 }

src/main/java/com/pmu/betengine/config/CorsConfig.java

@@ -26,4 +26,19 @@ public class CorsConfig {
             }
         };
     }
+
+
+    // @Bean
+    // public WebMvcConfigurer corsConfigurer() {
+    //     return new WebMvcConfigurer() {
+    //         @Override
+    //         public void addCorsMappings(CorsRegistry registry) {
+    //             registry.addMapping("/**")
+    //                     .allowedOrigins("*")             // Same as configuration.addAllowedOrigin("*")
+    //                     .allowedHeaders("*")             // Same as configuration.addAllowedHeader("*")
+    //                     .allowedMethods("*")             // Same as configuration.addAllowedMethod("*")
+    //                     .maxAge(3600);
+    //         }
+    //     };
+    // }
 }

src/main/java/com/pmu/betengine/config/SecurityConfig.java

@@ -7,6 +7,8 @@ import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.security.config.annotation.web.builders.HttpSecurity;
 import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.security.crypto.password.PasswordEncoder;
 import org.springframework.security.web.SecurityFilterChain;
 import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
 
@@ -29,5 +31,10 @@ public class SecurityConfig {
                 .addFilterBefore(apiKeyFilter, UsernamePasswordAuthenticationFilter.class)
                 .build();
     }
+
+    @Bean
+    public PasswordEncoder passwordEncoder() {
+        return new BCryptPasswordEncoder();
+    }
 }
 

src/main/java/com/pmu/betengine/controller/AgentController.java

@@ -0,0 +1,90 @@
+package com.pmu.betengine.controller;
+
+import com.pmu.betengine.model.Agent;
+import com.pmu.betengine.service.AgentService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/v1/agents")
+@CrossOrigin(origins = "*")
+@Tag(name = "Gestion des Agents", description = "Endpoints relatifs aux Agents")
+public class AgentController {
+
+    private final AgentService agentService;
+
+    public AgentController(AgentService agentService) {
+        this.agentService = agentService;
+    }
+
+    @GetMapping
+    @Operation(summary = "Lister tous les Agents")
+    public ResponseEntity<List<Agent>> getAllAgents() {
+        return ResponseEntity.ok(agentService.getAllAgents());
+    }
+
+    @GetMapping("/{id}")
+    @Operation(summary = "Obtenir un Agent par ID")
+    public ResponseEntity<Agent> getAgentById(@PathVariable Long id) {
+        return ResponseEntity.ok(agentService.getAgentById(id));
+    }
+
+    @PostMapping
+    @Operation(summary = "Créer un Agent")
+    public ResponseEntity<Agent> createAgent(@RequestBody Agent agent) {
+        return new ResponseEntity<>(agentService.createAgent(agent), HttpStatus.CREATED);
+    }
+
+    @PutMapping("/{id}")
+    @Operation(summary = "Modifier un Agent")
+    public ResponseEntity<Agent> updateAgent(@PathVariable Long id, @RequestBody Agent agent) {
+        return ResponseEntity.ok(agentService.updateAgent(id, agent));
+    }
+
+    @DeleteMapping("/{id}")
+    @Operation(summary = "Désactiver un Agent")
+    public ResponseEntity<String> deleteAgent(@PathVariable Long id) {
+        return ResponseEntity.ok(agentService.deleteAgent(id));
+    }
+
+    @PutMapping("/toggle-status/{id}")
+    @Operation(summary = "Activer ou désactiver un Agent")
+    public ResponseEntity<Agent> toggleAgentStatus(@PathVariable Long id) {
+        return ResponseEntity.ok(agentService.toggleAgentStatus(id));
+    }
+    
+    @PutMapping("/restore/{id}")
+    public ResponseEntity<Agent> restoreAgent(@PathVariable Long id) {
+        return ResponseEntity.ok(agentService.restoreAgent(id));
+    }
+
+
+    @GetMapping("/code/{code}")
+    @Operation(summary = "Obtenir un Agent par code")
+    public ResponseEntity<Agent> getAgentByCode(@PathVariable String code) {
+        return ResponseEntity.ok(agentService.getAgentByCode(code));
+    }
+
+    @GetMapping("/statut/{statut}")
+    @Operation(summary = "Lister les Agents par statut")
+    public ResponseEntity<List<Agent>> getAgentsByStatut(@PathVariable String statut) {
+        return ResponseEntity.ok(agentService.getAgentsByStatut(statut));
+    }
+
+    @GetMapping("/ville/{ville}")
+    @Operation(summary = "Lister les Agents par ville")
+    public ResponseEntity<List<Agent>> getAgentsByVille(@PathVariable String ville) {
+        return ResponseEntity.ok(agentService.getAgentsByVille(ville));
+    }
+
+    @GetMapping("/search")
+    @Operation(summary = "Rechercher des Agents par nom ou prénom")
+    public ResponseEntity<List<Agent>> searchAgents(@RequestParam String q) {
+        return ResponseEntity.ok(agentService.searchAgentsByName(q));
+    }
+}

src/main/java/com/pmu/betengine/controller/AgentFamilyMemberController.java

@@ -1,76 +1,79 @@
 package com.pmu.betengine.controller;
 
-import com.pmu.betengine.model.dto.AgentFamilyMemberDTO;
-import com.pmu.betengine.model.dto.AgentFamilyMemberRequestDTO;
+import com.pmu.betengine.model.AgentFamilyMember;
 import com.pmu.betengine.service.AgentFamilyMemberService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
-import jakarta.validation.Valid;
-import lombok.AllArgsConstructor;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 
 import java.util.List;
 
-
 @RestController
-@AllArgsConstructor
 @RequestMapping("/api/v1/agent-family-members")
 @CrossOrigin(origins = "*")
 @Tag(name = "Gestion des Membres de famille", description = "Endpoints relatifs à l'objet AgentFamilyMember")
 public class AgentFamilyMemberController {
 
-    private final AgentFamilyMemberService agentFamilyMemberService;
+    private final AgentFamilyMemberService service;
 
-   /* public AgentFamilyMemberController(AgentFamilyMemberService agentFamilyMemberService) {
-        this.agentFamilyMemberService = agentFamilyMemberService;
-    }*/
+    public AgentFamilyMemberController(AgentFamilyMemberService service) {
+        this.service = service;
+    }
 
     @GetMapping
-    public ResponseEntity<List<AgentFamilyMemberDTO>> getAllFamilyMembers() {
-        return ResponseEntity.ok(agentFamilyMemberService.getAllFamilyMembers());
+    @Operation(summary = "Lister tous les membres de famille")
+    public ResponseEntity<List<AgentFamilyMember>> getAllFamilyMembers() {
+        return ResponseEntity.ok(service.getAllFamilyMembers());
     }
 
     @GetMapping("/{id}")
-    public ResponseEntity<AgentFamilyMemberDTO> getFamilyMemberById(@PathVariable Long id) {
-        return ResponseEntity.ok(agentFamilyMemberService.getFamilyMemberById(id));
+    @Operation(summary = "Obtenir un membre de famille par ID")
+    public ResponseEntity<AgentFamilyMember> getFamilyMemberById(@PathVariable Long id) {
+        return ResponseEntity.ok(service.getFamilyMemberById(id));
     }
 
     @PostMapping
-    @Operation(summary = "Ajouter un AgentFamilyMember dans la base")
-    public ResponseEntity<AgentFamilyMemberDTO> createFamilyMember(@Valid @RequestBody AgentFamilyMemberRequestDTO requestDTO) {
-        return new ResponseEntity<>(agentFamilyMemberService.createFamilyMember(requestDTO), HttpStatus.CREATED);
+    @Operation(summary = "Créer un membre de famille")
+    public ResponseEntity<AgentFamilyMember> createFamilyMember(@RequestBody AgentFamilyMember member) {
+        return new ResponseEntity<>(service.createFamilyMember(member), HttpStatus.CREATED);
     }
 
     @PutMapping("/{id}")
-    public ResponseEntity<AgentFamilyMemberDTO> updateFamilyMember(@PathVariable Long id, @Valid @RequestBody AgentFamilyMemberRequestDTO requestDTO) {
-        return ResponseEntity.ok(agentFamilyMemberService.updateFamilyMember(id, requestDTO));
+    @Operation(summary = "Modifier un membre de famille")
+    public ResponseEntity<AgentFamilyMember> updateFamilyMember(@PathVariable Long id,
+                                                                @RequestBody AgentFamilyMember member) {
+        return ResponseEntity.ok(service.updateFamilyMember(id, member));
     }
 
     @DeleteMapping("/{id}")
-    public ResponseEntity<Void> deleteFamilyMember(@PathVariable Long id) {
-        agentFamilyMemberService.deleteFamilyMember(id);
-        return ResponseEntity.noContent().build();
+    @Operation(summary = "Supprimer un membre de famille")
+    public ResponseEntity<String> deleteFamilyMember(@PathVariable Long id) {
+        return ResponseEntity.ok(service.deleteFamilyMember(id));
     }
 
     @GetMapping("/statut/{statut}")
-    public ResponseEntity<List<AgentFamilyMemberDTO>> getFamilyMembersByStatut(@PathVariable String statut) {
-        return ResponseEntity.ok(agentFamilyMemberService.getFamilyMembersByStatut(statut));
+    @Operation(summary = "Lister les membres par statut")
+    public ResponseEntity<List<AgentFamilyMember>> getFamilyMembersByStatut(@PathVariable String statut) {
+        return ResponseEntity.ok(service.getFamilyMembersByStatut(statut));
     }
 
     @GetMapping("/sexe/{sexe}")
-    public ResponseEntity<List<AgentFamilyMemberDTO>> getFamilyMembersBySexe(@PathVariable String sexe) {
-        return ResponseEntity.ok(agentFamilyMemberService.getFamilyMembersBySexe(sexe));
+    @Operation(summary = "Lister les membres par sexe")
+    public ResponseEntity<List<AgentFamilyMember>> getFamilyMembersBySexe(@PathVariable String sexe) {
+        return ResponseEntity.ok(service.getFamilyMembersBySexe(sexe));
     }
 
     @GetMapping("/search")
-    public ResponseEntity<List<AgentFamilyMemberDTO>> searchFamilyMembers(@RequestParam String keyword) {
-        return ResponseEntity.ok(agentFamilyMemberService.searchFamilyMembers(keyword));
+    @Operation(summary = "Rechercher des membres par mot-clé")
+    public ResponseEntity<List<AgentFamilyMember>> searchFamilyMembers(@RequestParam String keyword) {
+        return ResponseEntity.ok(service.searchFamilyMembers(keyword));
     }
 
     @GetMapping("/nom/{nom}")
-    public ResponseEntity<List<AgentFamilyMemberDTO>> getFamilyMembersByNom(@PathVariable String nom) {
-        return ResponseEntity.ok(agentFamilyMemberService.getFamilyMembersByNom(nom));
+    @Operation(summary = "Lister les membres par nom")
+    public ResponseEntity<List<AgentFamilyMember>> getFamilyMembersByNom(@PathVariable String nom) {
+        return ResponseEntity.ok(service.getFamilyMembersByNom(nom));
     }
 }

src/main/java/com/pmu/betengine/controller/AgentLimitController.java

@@ -0,0 +1,78 @@
+package com.pmu.betengine.controller;
+
+import com.pmu.betengine.model.AgentLimit;
+import com.pmu.betengine.service.AgentLimitService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/v1/agent-limits")
+@CrossOrigin(origins = "*")
+@Tag(name = "Gestion des Limites Agents", description = "Endpoints relatifs à l'objet AgentLimit")
+public class AgentLimitController {
+
+    private final AgentLimitService service;
+
+    public AgentLimitController(AgentLimitService service) {
+        this.service = service;
+    }
+
+    @GetMapping
+    @Operation(summary = "Lister toutes les limites d'agents")
+    public ResponseEntity<List<AgentLimit>> getAllAgentLimits() {
+        return ResponseEntity.ok(service.getAllAgentLimits());
+    }
+
+    @GetMapping("/{id}")
+    @Operation(summary = "Obtenir une limite par ID")
+    public ResponseEntity<AgentLimit> getAgentLimitById(@PathVariable Long id) {
+        return ResponseEntity.ok(service.getAgentLimitById(id));
+    }
+
+    @PostMapping
+    @Operation(summary = "Créer une limite d'agent")
+    public ResponseEntity<AgentLimit> createAgentLimit(@RequestBody AgentLimit agentLimit) {
+        return new ResponseEntity<>(service.createAgentLimit(agentLimit), HttpStatus.CREATED);
+    }
+
+    @PutMapping("/{id}")
+    @Operation(summary = "Modifier une limite d'agent")
+    public ResponseEntity<AgentLimit> updateAgentLimit(@PathVariable Long id,
+                                                       @RequestBody AgentLimit agentLimit) {
+        return ResponseEntity.ok(service.updateAgentLimit(id, agentLimit));
+    }
+
+    @DeleteMapping("/{id}")
+    @Operation(summary = "Supprimer une limite d'agent")
+    public ResponseEntity<String> deleteAgentLimit(@PathVariable Long id) {
+        return ResponseEntity.ok(service.deleteAgentLimit(id));
+    }
+
+    @GetMapping("/actif")
+    @Operation(summary = "Lister les limites actives")
+    public ResponseEntity<List<AgentLimit>> getAgentLimitsByActif() {
+        return ResponseEntity.ok(service.getAgentLimitsByActif(true));
+    }
+
+    @GetMapping("/inactif")
+    @Operation(summary = "Lister les limites inactives")
+    public ResponseEntity<List<AgentLimit>> getAgentLimitsByInactif() {
+        return ResponseEntity.ok(service.getAgentLimitsByActif(false));
+    }
+
+    // @GetMapping("/search")
+    // @Operation(summary = "Rechercher les limites par nom")
+    // public ResponseEntity<List<AgentLimit>> searchAgentLimitsByNom(@RequestParam String nom) {
+    //     return ResponseEntity.ok(service.searchAgentLimitsByNom(nom));
+    // }
+    @GetMapping("/search/{nom}")
+    public ResponseEntity<List<AgentLimit>> searchAgentLimitsByNom(@PathVariable String nom) {
+        return ResponseEntity.ok(service.searchAgentLimitsByNom(nom));
+    }
+
+}

src/main/java/com/pmu/betengine/controller/AuthController.java

@@ -0,0 +1,35 @@
+package com.pmu.betengine.controller;
+
+import com.pmu.betengine.model.Agent;
+import com.pmu.betengine.model.AuthRequest;
+import com.pmu.betengine.model.AuthRequestAgent;
+import com.pmu.betengine.model.AuthResponse;
+import com.pmu.betengine.model.User;
+import com.pmu.betengine.service.AuthService;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@RequestMapping("/api/v1/auth")
+@CrossOrigin
+public class AuthController {
+
+    private final AuthService authService;
+
+    public AuthController(AuthService authService) {
+        this.authService = authService;
+    }
+
+    @PostMapping("/login")
+    public ResponseEntity<User> login(@RequestBody AuthRequest request) {
+        User loggedUser = authService.login(request);
+        return ResponseEntity.ok(loggedUser);
+    }
+    
+       // AGENT LOGIN via TPE
+       @PostMapping("/agent/login")
+       public ResponseEntity<Agent> loginAgent(@RequestBody AuthRequestAgent request) {
+           Agent loggedAgent = authService.loginAgentWithPin(request);
+           return ResponseEntity.ok(loggedAgent);
+       }
+}

src/main/java/com/pmu/betengine/controller/ChevalController.java

@@ -4,26 +4,35 @@ import com.pmu.betengine.model.Cheval;
 import com.pmu.betengine.service.ChevalService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
-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/v1/cheval")
-@Tag(name = "Gestion des Chevaux", description = "Endpoints relatifs à l'objet cheval")
+@RequestMapping("/api/v1/chevaux")
+@CrossOrigin(origins = "*")
+@Tag(name = "Gestion des Chevaux", description = "Endpoints relatifs à l'objet Cheval")
 public class ChevalController {
 
-    @Autowired
-    private ChevalService chevalService;
+    private final ChevalService chevalService;
+
+    public ChevalController(ChevalService chevalService) {
+        this.chevalService = chevalService;
+    }
 
     @PostMapping
-    @Operation(summary = "Ajouter un cheval dans la base")
+    @Operation(summary = "Ajouter un cheval")
     public ResponseEntity<Cheval> ajouterCheval(@RequestBody Cheval cheval) {
         return ResponseEntity.ok(chevalService.ajouterCheval(cheval));
     }
 
+    @GetMapping
+    @Operation(summary = "Lister tous les chevaux")
+    public ResponseEntity<List<Cheval>> obtenirTousLesChevaux() {
+        return ResponseEntity.ok(chevalService.obtenirTousLesChevaux());
+    }
+
     @GetMapping("/course/{courseId}")
     @Operation(summary = "Affiche les chevaux d'une Course donnée")
     public ResponseEntity<List<Cheval>> obtenirChevauxParCourse(@PathVariable Long courseId) {
@@ -35,5 +44,17 @@ public class ChevalController {
     public ResponseEntity<List<Cheval>> obtenirChevauxParEcurie(@PathVariable String nomEcurie) {
         return ResponseEntity.ok(chevalService.obtenirChevauxParEcurie(nomEcurie));
     }
+
+    @GetMapping("/numero/{numero}")
+    @Operation(summary = "Obtenir un cheval par numéro")
+    public ResponseEntity<Cheval> obtenirChevalParNumero(@PathVariable int numero) {
+        return ResponseEntity.ok(chevalService.obtenirChevalParNumero(numero));
     }
 
+    @DeleteMapping("/{id}")
+    @Operation(summary = "Supprimer un cheval par ID")
+    public ResponseEntity<String> supprimerCheval(@PathVariable Long id) {
+        chevalService.supprimerCheval(id);
+        return ResponseEntity.ok("Cheval supprimé avec succès.");
+    }
+}

src/main/java/com/pmu/betengine/controller/CourseController.java

@@ -1,91 +1,104 @@
 package com.pmu.betengine.controller;
 
-import com.pmu.betengine.model.Cheval;
 import com.pmu.betengine.model.Course;
-import com.pmu.betengine.model.dto.NewCourse;
-import com.pmu.betengine.model.statut.StatutCourse;
+import com.pmu.betengine.model.NonPartant;
+import com.pmu.betengine.model.SearchParam;
 import com.pmu.betengine.service.CourseService;
 import io.swagger.v3.oas.annotations.Operation;
-import io.swagger.v3.oas.annotations.responses.ApiResponse;
 import io.swagger.v3.oas.annotations.tags.Tag;
-import org.springframework.beans.factory.annotation.Autowired;
+
+import org.springframework.data.domain.Page;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 
-import java.util.ArrayList;
 import java.util.List;
-
-import static com.pmu.betengine.util.ChevalUtil.fromIntegerList;
+import java.util.Map;
 
 @RestController
-@RequestMapping("/api/v1/course")
-@Tag(name = "Gestion des Courses", description = "Endpoints relatifs à l'objet course")
+@RequestMapping("/api/v1/courses")
+@CrossOrigin(origins = "*")
+@Tag(name = "Gestion des Courses", description = "Endpoints relatifs aux Courses")
 public class CourseController {
 
-    @Autowired
-    private CourseService courseService;
+    private final CourseService courseService;
 
-    @PostMapping
-    @Operation(summary = "Création d'une Nouvelle Course")
-    @ApiResponse(responseCode = "201", description = "Course Enregistrée")
-    public ResponseEntity<String> creerCourse(@RequestBody NewCourse course) {
-        Course courseNew =null;
-        try {
-            courseNew = courseService.creerCourse(fromDto(course));
-        }catch (Exception e){
-            e.printStackTrace();
+    public CourseController(CourseService courseService) {
+        this.courseService = courseService;
     }
 
-      if(courseNew!=null && courseNew.getId()!=null)
-
-        return  new ResponseEntity<>("Course ID = "+courseNew.getId(), HttpStatus.CREATED);
-
-      else {
-
-          return  new ResponseEntity<>("Erreur de Création de la Course", HttpStatus.INTERNAL_SERVER_ERROR);
-      }
-
-    }
-
-   // @GetMapping
-    public ResponseEntity<List<Course>> obtenirToutesCourses() {
-        return ResponseEntity.ok(courseService.obtenirToutesCourses());
+    @GetMapping
+    @Operation(summary = "Lister toutes les Courses")
+    public ResponseEntity<List<Course>> getAllCourses() {
+        return ResponseEntity.ok(courseService.getAllCourses());
     }
 
     @GetMapping("/{id}")
-    @Operation(summary = "Obtenir une Course à travers son ID")
-    public ResponseEntity<Course> obtenirCourseParId(@PathVariable Long id) {
-        Course course = courseService.obtenirCourseParId(id);
-        return course != null ? ResponseEntity.ok(course) : ResponseEntity.notFound().build();
+    @Operation(summary = "Obtenir une Course par ID")
+    public ResponseEntity<Course> getCourseById(@PathVariable Long id) {
+        return ResponseEntity.ok(courseService.getCourseById(id));
     }
 
-    @GetMapping("/terminees")
-    @Operation(summary = "Afficher toutes  les courses terminées")
-    public ResponseEntity<List<Course>> obtenirCoursesTerminees() {
-        return ResponseEntity.ok(courseService.obtenirCoursesTerminees());
+    // @GetMapping("/reunion/{reunionId}")
+    // @Operation(summary = "Lister les Courses d'une réunion")
+    // public ResponseEntity<List<Course>> getCoursesByReunion(@PathVariable Long reunionId) {
+    //     return ResponseEntity.ok(courseService.getCoursesByReunionId(reunionId));
+    // }
+
+    @GetMapping("/reunion/{reunionId}")
+    @Operation(summary = "Lister les Courses VALIDATED d'une réunion")
+    public ResponseEntity<List<Course>> getValidatedCoursesByReunion(@PathVariable Long reunionId) {
+        return ResponseEntity.ok(courseService.getCoursesByReunionIdAndStatut(reunionId, "VALIDATED"));
     }
 
-    @GetMapping("/avenir")
-    @Operation(summary = "Afficher les Courses à venir")
-    public ResponseEntity<List<Course>> obtenirCoursesAVenir() {
-        return ResponseEntity.ok(courseService.obtenirCoursesAVenir());
+
+
+    @PostMapping
+    @Operation(summary = "Créer une Course")
+    public ResponseEntity<Course> createCourse(@RequestBody Course course) {
+        return new ResponseEntity<>(courseService.createCourse(course), HttpStatus.CREATED);
     }
 
-    private Course fromDto(NewCourse dto){
-       return  Course.builder()
-                .heureCourse(dto.getHeureCourse())
-                .numero(dto.getNumero())
-                .aDeadHeat(false)
-                .estAnnulee(false)
-                .estTerminee(false)
-                .lieu(dto.getLieu())
-                .reunion(dto.getReunion())
-                .statut(StatutCourse.CREATED)
-              //  .nombreChevauxInscrits(dto.getChevaux() != null ? dto.getChevaux().size() : 0)
-              //  .chevaux(fromIntegerList(dto.getChevaux()))
-                .build();
+    @PutMapping("/{id}")
+    @Operation(summary = "Modifier une Course")
+    public ResponseEntity<Course> updateCourse(@PathVariable Long id, @RequestBody Course course) {
+        return ResponseEntity.ok(courseService.updateCourse(id, course));
     }
 
+    @DeleteMapping("/{id}")
+    @Operation(summary = "Supprimer une Course")
+    public ResponseEntity<Void> deleteCourse(@PathVariable Long id) {
+        courseService.deleteCourse(id);
+        return ResponseEntity.noContent().build();
     }
 
+    @GetMapping("/search")
+    @Operation(summary = "Rechercher des Courses")
+    public ResponseEntity<List<Course>> searchCourses(@RequestParam String q) {
+        return ResponseEntity.ok(courseService.searchCourses(q));
+    }
+
+    @PatchMapping("/{id}/statut")
+    @Operation(summary = "Modifier le statut d'une Course")
+    public ResponseEntity<Course> updateStatut(@PathVariable Long id, @RequestBody Map<String, String> request) {
+        String statut = request.get("statut");
+        return ResponseEntity.ok(courseService.updateStatut(id, statut));
+    }
+
+    @PutMapping("/{courseId}/non-partants")
+    @Operation(summary = "Remplacer la liste des non-partants d'une course")
+    public ResponseEntity<List<String>> replaceCourseNonPartants(
+            @PathVariable Long courseId,
+            @RequestBody List<String> nonPartants) {
+        return ResponseEntity.ok(courseService.replaceCourseNonPartants(courseId, nonPartants));
+    }
+
+    @PostMapping("/searchByParams")
+    @Operation(summary = "Rechercher des Courses avec critères")
+    public ResponseEntity<List<Course>> searchCourses(@RequestBody SearchParam searchParam) {
+        return ResponseEntity.ok(courseService.search(searchParam));
+    }
+
+    
+
+}

src/main/java/com/pmu/betengine/controller/CourseReportDetailRowController.java

@@ -0,0 +1,86 @@
+package com.pmu.betengine.controller;
+
+import com.pmu.betengine.model.CourseReportDetailRow;
+import com.pmu.betengine.service.CourseReportDetailRowService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/v1/course-report-detail-rows")
+@CrossOrigin(origins = "*")
+@Tag(name = "Gestion des détails de rapports de course", description = "Endpoints relatifs à l'objet CourseReportDetailRow")
+public class CourseReportDetailRowController {
+
+    private final CourseReportDetailRowService service;
+
+    public CourseReportDetailRowController(CourseReportDetailRowService service) {
+        this.service = service;
+    }
+
+    @PostMapping
+    @Operation(summary = "Créer un détail de rapport de course")
+    public ResponseEntity<CourseReportDetailRow> create(@RequestBody CourseReportDetailRow row) {
+        return ResponseEntity.ok(service.create(row));
+    }
+
+    @GetMapping("/{id}")
+    @Operation(summary = "Obtenir un détail par ID")
+    public ResponseEntity<CourseReportDetailRow> getById(@PathVariable Long id) {
+        return ResponseEntity.ok(service.getById(id));
+    }
+
+    @GetMapping
+    @Operation(summary = "Lister tous les détails de rapport")
+    public ResponseEntity<List<CourseReportDetailRow>> getAll() {
+        return ResponseEntity.ok(service.getAll());
+    }
+
+    @PutMapping("/{id}")
+    @Operation(summary = "Mettre à jour un détail de rapport")
+    public ResponseEntity<CourseReportDetailRow> update(@PathVariable Long id,
+                                                        @RequestBody CourseReportDetailRow row) {
+        return ResponseEntity.ok(service.update(id, row));
+    }
+
+    @DeleteMapping("/{id}")
+    @Operation(summary = "Supprimer un détail de rapport")
+    public ResponseEntity<String> delete(@PathVariable Long id) {
+        service.delete(id);
+        return ResponseEntity.ok("CourseReportDetailRow supprimé avec succès.");
+    }
+
+    @GetMapping("/detail/{detailId}")
+    @Operation(summary = "Obtenir les détails par detailId")
+    public ResponseEntity<List<CourseReportDetailRow>> getByDetailId(@PathVariable Long detailId) {
+        return ResponseEntity.ok(service.getByDetailId(detailId));
+    }
+
+    @GetMapping("/type-gain/{typeGain}")
+    public ResponseEntity<List<CourseReportDetailRow>> getByTypeGain(@PathVariable String typeGain) {
+        return ResponseEntity.ok(service.getByTypeGain(typeGain));
+    }
+
+    @GetMapping("/type-jeu/{typeJeu}")
+    public ResponseEntity<List<CourseReportDetailRow>> getByTypeJeu(@PathVariable String typeJeu) {
+        return ResponseEntity.ok(service.getByTypeJeu(typeJeu));
+    }
+
+    @GetMapping("/statut/{statut}")
+    public ResponseEntity<List<CourseReportDetailRow>> getByStatut(@PathVariable String statut) {
+        return ResponseEntity.ok(service.getByStatut(statut));
+    }
+
+    @GetMapping("/distributed/{distributed}")
+    public ResponseEntity<List<CourseReportDetailRow>> getByDistributed(@PathVariable Boolean distributed) {
+        return ResponseEntity.ok(service.getByDistributed(distributed));
+    }
+
+    @GetMapping("/externe/{externe}")
+    public ResponseEntity<List<CourseReportDetailRow>> getByExterne(@PathVariable Boolean externe) {
+        return ResponseEntity.ok(service.getByExterne(externe));
+    }
+}

src/main/java/com/pmu/betengine/controller/HippodromeController.java

@@ -1,22 +1,19 @@
 package com.pmu.betengine.controller;
 
-import com.pmu.betengine.model.dto.HippodromeDTO;
-import com.pmu.betengine.model.dto.HippodromeRequestDTO;
+import com.pmu.betengine.model.Hippodrome;
 import com.pmu.betengine.service.HippodromeService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
-import jakarta.validation.Valid;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 
-
 import java.util.List;
 
 @RestController
 @RequestMapping("/api/v1/hippodromes")
 @CrossOrigin(origins = "*")
-@Tag(name = "Gestion des Hippodromes ", description = "Endpoints relatifs à l'objet Hippodrome")
+@Tag(name = "Gestion des Hippodromes", description = "Endpoints relatifs aux Hippodromes")
 public class HippodromeController {
 
     private final HippodromeService hippodromeService;
@@ -26,45 +23,66 @@ public class HippodromeController {
     }
 
     @GetMapping
-    public ResponseEntity<List<HippodromeDTO>> getAllHippodromes() {
+    @Operation(summary = "Lister tous les Hippodromes")
+    public ResponseEntity<List<Hippodrome>> getAllHippodromes() {
         return ResponseEntity.ok(hippodromeService.getAllHippodromes());
     }
 
     @GetMapping("/{id}")
-    public ResponseEntity<HippodromeDTO> getHippodromeById(@PathVariable Long id) {
+    @Operation(summary = "Obtenir un Hippodrome par ID")
+    public ResponseEntity<Hippodrome> getHippodromeById(@PathVariable Long id) {
         return ResponseEntity.ok(hippodromeService.getHippodromeById(id));
     }
 
     @PostMapping
-    @Operation(summary = "Enregistrer Un Hippodrome",
-            description = "Méthode permettant d'enregistrer l'Hippodrome")
-    public ResponseEntity<HippodromeDTO> createHippodrome(@Valid @RequestBody HippodromeRequestDTO requestDTO) {
-        return new ResponseEntity<>(hippodromeService.createHippodrome(requestDTO), HttpStatus.CREATED);
+    @Operation(summary = "Créer un Hippodrome")
+    public ResponseEntity<Hippodrome> createHippodrome(@RequestBody Hippodrome hippodrome) {
+        return new ResponseEntity<>(hippodromeService.createHippodrome(hippodrome), HttpStatus.CREATED);
     }
 
     @PutMapping("/{id}")
-    public ResponseEntity<HippodromeDTO> updateHippodrome(@PathVariable Long id, @Valid @RequestBody HippodromeRequestDTO requestDTO) {
-        return ResponseEntity.ok(hippodromeService.updateHippodrome(id, requestDTO));
+    @Operation(summary = "Modifier un Hippodrome")
+    public ResponseEntity<Hippodrome> updateHippodrome(@PathVariable Long id, @RequestBody Hippodrome hippodrome) {
+        return ResponseEntity.ok(hippodromeService.updateHippodrome(id, hippodrome));
     }
 
-    @DeleteMapping("/{id}")
+    @DeleteMapping("/delete/{id}")
+    @Operation(summary = "Supprimer un Hippodrome")
     public ResponseEntity<Void> deleteHippodrome(@PathVariable Long id) {
         hippodromeService.deleteHippodrome(id);
         return ResponseEntity.noContent().build();
     }
 
+    @PutMapping("/restore/{id}")
+    public ResponseEntity<Hippodrome> restoreHippodrome(@PathVariable Long id) {
+        return ResponseEntity.ok(hippodromeService.restoreHippodrome(id));
+    }
+
+
+    @DeleteMapping("/{id}")
+    @Operation(summary = "Desactiver un Hippodrome")
+    public ResponseEntity<Void> deleteHippodrome2(@PathVariable Long id) {
+        hippodromeService.deleteHippodrome2(id);
+        return ResponseEntity.noContent().build();
+    }
+    
+    
+
     @GetMapping("/ville/{ville}")
-    public ResponseEntity<List<HippodromeDTO>> getHippodromesByVille(@PathVariable String ville) {
+    @Operation(summary = "Lister les Hippodromes par ville")
+    public ResponseEntity<List<Hippodrome>> getHippodromesByVille(@PathVariable String ville) {
         return ResponseEntity.ok(hippodromeService.getHippodromesByVille(ville));
     }
 
     @GetMapping("/actifs")
-    public ResponseEntity<List<HippodromeDTO>> getHippodromesActifs() {
+    @Operation(summary = "Lister les Hippodromes actifs")
+    public ResponseEntity<List<Hippodrome>> getHippodromesActifs() {
         return ResponseEntity.ok(hippodromeService.getHippodromesActifs());
     }
 
-    @GetMapping("/reunion/{reunionId}")
-    public ResponseEntity<HippodromeDTO> getHippodromeByReunion(@PathVariable Long reunionId) {
-        return ResponseEntity.ok(hippodromeService.getHippodromeByReunion(reunionId));
+    @GetMapping("/search")
+    @Operation(summary = "Rechercher des Hippodromes par nom")
+    public ResponseEntity<List<Hippodrome>> searchHippodromes(@RequestParam String nom) {
+        return ResponseEntity.ok(hippodromeService.searchHippodromesByNom(nom));
     }
 }

src/main/java/com/pmu/betengine/controller/MiseController.java

@@ -0,0 +1,55 @@
+package com.pmu.betengine.controller;
+
+import com.pmu.betengine.model.Mise;
+import com.pmu.betengine.service.MiseService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/v1")
+@CrossOrigin(origins = "*")
+@Tag(name = "Gestion des Mises", description = "Endpoints relatifs aux Mises")
+public class MiseController {
+
+    private final MiseService miseService;
+
+    public MiseController(MiseService miseService) {
+        this.miseService = miseService;
+    }
+
+    @GetMapping
+    @Operation(summary = "Lister toutes les Mises")
+    public ResponseEntity<List<Mise>> getAllMises() {
+        return ResponseEntity.ok(miseService.getAll());
+    }
+
+    @GetMapping("/{id}")
+    @Operation(summary = "Obtenir une Mise par ID")
+    public ResponseEntity<Mise> getMiseById(@PathVariable Long id) {
+        return ResponseEntity.ok(miseService.getById(id));
+    }
+
+    @PostMapping
+    @Operation(summary = "Créer une Mise")
+    public ResponseEntity<Mise> createMise(@RequestBody Mise mise) {
+        return new ResponseEntity<>(miseService.create(mise), HttpStatus.CREATED);
+    }
+
+    @PutMapping("/{id}")
+    @Operation(summary = "Modifier une Mise")
+    public ResponseEntity<Mise> updateMise(@PathVariable Long id, @RequestBody Mise mise) {
+        return ResponseEntity.ok(miseService.update(id, mise));
+    }
+
+    @DeleteMapping("/{id}")
+    @Operation(summary = "Supprimer une Mise")
+    public ResponseEntity<Void> deleteMise(@PathVariable Long id) {
+        miseService.delete(id);
+        return ResponseEntity.noContent().build();
+    }
+}

src/main/java/com/pmu/betengine/controller/NonPartantController.java

@@ -0,0 +1,74 @@
+package com.pmu.betengine.controller;
+
+import com.pmu.betengine.model.NonPartant;
+import com.pmu.betengine.service.NonPartantService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.UUID;
+
+@RestController
+@RequestMapping("/api/v1/non-partants")
+@CrossOrigin(origins = "*")
+@Tag(name = "Gestion des Non Partants", description = "Endpoints relatifs aux chevaux non partants")
+public class NonPartantController {
+
+    private final NonPartantService service;
+
+    public NonPartantController(NonPartantService service) {
+        this.service = service;
+    }
+
+    @PostMapping
+    @Operation(summary = "Ajouter un NonPartant")
+    public ResponseEntity<NonPartant> create(@RequestBody NonPartant np) {
+        return new ResponseEntity<>(service.createNonPartant(np), HttpStatus.CREATED);
+    }
+
+    @GetMapping
+    @Operation(summary = "Lister tous les NonPartants")
+    public ResponseEntity<List<NonPartant>> getAll() {
+        return ResponseEntity.ok(service.getAllNonPartants());
+    }
+
+    @GetMapping("/{id}")
+    @Operation(summary = "Obtenir un NonPartant par ID")
+    public ResponseEntity<NonPartant> getById(@PathVariable Long id) {
+        return ResponseEntity.ok(service.getNonPartantById(id));
+    }
+
+    @PutMapping("/{id}")
+    @Operation(summary = "Mettre à jour un NonPartant")
+    public ResponseEntity<NonPartant> update(@PathVariable Long id, @RequestBody NonPartant np) {
+        return ResponseEntity.ok(service.updateNonPartant(id, np));
+    }
+
+    @DeleteMapping("/{id}")
+    @Operation(summary = "Supprimer un NonPartant")
+    public ResponseEntity<String> delete(@PathVariable Long id) {
+        service.deleteNonPartant(id);
+        return ResponseEntity.ok("NonPartant supprimé avec succès.");
+    }
+
+    @GetMapping("/course/{courseId}")
+    @Operation(summary = "Lister les NonPartants d'une course")
+    public ResponseEntity<List<NonPartant>> getByCourse(@PathVariable Long courseId) {
+        return ResponseEntity.ok(service.getByCourseId(courseId));
+    }
+
+    @GetMapping("/search/nom")
+    @Operation(summary = "Rechercher des NonPartants par nom de cheval")
+    public ResponseEntity<List<NonPartant>> searchByNom(@RequestParam String nom) {
+        return ResponseEntity.ok(service.searchByNomCheval(nom));
+    }
+
+    @GetMapping("/search/motif")
+    @Operation(summary = "Rechercher des NonPartants par motif")
+    public ResponseEntity<List<NonPartant>> searchByMotif(@RequestParam String motif) {
+        return ResponseEntity.ok(service.searchByMotif(motif));
+    }
+}

src/main/java/com/pmu/betengine/controller/PariController.java

@@ -1,113 +1,196 @@
 package com.pmu.betengine.controller;
 
 import com.pmu.betengine.model.Pari;
-import com.pmu.betengine.model.dto.NewPari;
-import com.pmu.betengine.model.dto.updatePari;
-import com.pmu.betengine.model.statut.StatutParis;
-import com.pmu.betengine.model.type.TypeFormule;
 import com.pmu.betengine.service.CourseService;
 import com.pmu.betengine.service.PariService;
-import io.swagger.v3.oas.annotations.Operation;
-import io.swagger.v3.oas.annotations.responses.ApiResponse;
-import io.swagger.v3.oas.annotations.tags.Tag;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 
 import java.util.List;
-
-import static com.pmu.betengine.util.ChevalUtil.fromIntegerList;
-import static com.pmu.betengine.util.ChevalUtil.numeroToCheval;
+import java.util.UUID;
 
 @RestController
 @RequestMapping("/api/v1/pari")
-@Tag(name = "Gestion des Pari (Bet)", description = "Endpoints relatifs à l'objet pari")
 public class PariController {
 
-    @Autowired
-    private PariService pariService;
-    @Autowired
-    private CourseService courseService;
+    private final PariService pariService;
+    private final CourseService courseService;
+
+    public PariController(PariService pariService, CourseService courseService) {
+        this.pariService = pariService;
+        this.courseService = courseService;
+    }
+
+    // CREATE
     @PostMapping
-    @Operation(summary = "Placer un Pari (Bet)",
-            description = "Permet d'enregistrer tous les types de Pari (Bet) avec toutes les Formules possibles")
-    @ApiResponse(responseCode = "201", description = "Nouveau Pari Enregistré")
-    public ResponseEntity<Pari> placerPari(@RequestBody NewPari pari) {
-        try {
-            return new ResponseEntity<>(pariService.placerPari(fromNewPariDto(pari)), HttpStatus.CREATED);
-        }catch (Exception e){
-            e.printStackTrace();
-            return new ResponseEntity<>(null, HttpStatus.INTERNAL_SERVER_ERROR);
-        }
+    public ResponseEntity<Pari> create(@RequestBody Pari pari) {
+
+        if (pari.getCourse() != null && pari.getCourse().getId() != null) {
+            pari.setCourse(courseService.getCourseById(pari.getCourse().getId()));
         }
 
+        return ResponseEntity.ok(pariService.save(pari));
+    }
+
+    // GET ALL
+    @GetMapping
+    public ResponseEntity<List<Pari>> getAll() {
+        return ResponseEntity.ok(pariService.getAll());
+    }
+
+    // GET BY ID
+    @GetMapping("/{id}")
+    public ResponseEntity<Pari> getById(@PathVariable Long id) {
+        Pari pari = pariService.getById(id);
+        return pari != null ? ResponseEntity.ok(pari) : ResponseEntity.notFound().build();
+    }
+
+    // GET BY COURSE
     @GetMapping("/course/{courseId}")
-    @Operation(summary = "Affiche tous les Pari (Bet) d'une Course")
-    @ApiResponse(responseCode = "200", description = "Paris Trouvés")
-    public ResponseEntity<List<Pari>> obtenirParisParCourse(@PathVariable Long courseId) {
-        return ResponseEntity.ok(pariService.obtenirParisParCourse(courseId));
+    public ResponseEntity<List<Pari>> getByCourse(@PathVariable Long courseId) {
+        return ResponseEntity.ok(pariService.getByCourse(courseId));
     }
 
-
+    // UPDATE STATUS / PAY / REFUND
     @PutMapping("/{ticket}")
-    @Operation(summary = "Mettre à jour un Pari Existant",description = "Cette opération concerne le status (), payé ou remboursé")
-    @ApiResponse(responseCode = "200", description = "Pari Modifié avec succès")
-    @ApiResponse(responseCode = "404", description = "Pari Non Trouvé")
-    public ResponseEntity<String> updateProduct(@PathVariable String ticket, @RequestBody updatePari updatePari) {
-        // Find the product by ID
+    public ResponseEntity<Pari> update(
+            @PathVariable String ticket,
+            @RequestBody Pari update
+    ) {
         Pari pari = pariService.findByTicket(ticket);
 
-        if (pari != null) {
+        if (pari == null) {
+            return ResponseEntity.notFound().build();
+        }
 
-            pari.setStatut(updatePari.getStatus());
-            pari.setEstRembourse(updatePari.isEstRembourse());
-            pari.setEstPaye(updatePari.isEstPaye());
+        pari.setStatut(update.getStatut());
+        pari.setEstRembourse(update.isEstRembourse());
+        pari.setEstPaye(update.isEstPaye());
 
-            Pari pariUpdate = pariService.update(pari);
-            return ResponseEntity.ok(ticket); // Return the updated product
-        } else {
-            return ResponseEntity.status(404).body(ticket);
+        return ResponseEntity.ok(pariService.update(pari));
+    }
+
+    // DELETE
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> delete(@PathVariable Long id) {
+        pariService.delete(id);
+        return ResponseEntity.noContent().build();
     }
 }
 
-  //  @GetMapping("/course/{courseId}/type/{typePari}")
-    public ResponseEntity<List<Pari>> obtenirParisParCourseEtType(
-            @PathVariable Long courseId, @PathVariable TypeFormule typeFormule) {
-        return ResponseEntity.ok(pariService.obtenirParisParCourseEtType(courseId, typeFormule));
-    }
 
-  //  @GetMapping("/cheval/{chevalId}")
-    public ResponseEntity<List<Pari>> obtenirParisParCheval(@PathVariable Long chevalId) {
-        return ResponseEntity.ok(pariService.obtenirParisParCheval(chevalId));
-    }
 
-    private Pari fromNewPariDto(NewPari newPari){
-        return Pari.builder()
-                .datePari(newPari.getDatePari())
-                .course(courseService.obtenirCourseParId(newPari.getCourseId()))
-                .cheval(numeroToCheval(newPari.getCheval()))
-                .cheval1(numeroToCheval(newPari.getCheval1()))
-                .cheval2(numeroToCheval(newPari.getCheval2()))
-                .cheval3(numeroToCheval(newPari.getCheval3()))
-                .chevauxOrdre(newPari.getChevauxOrdre())
-                .chevauxSelectionnes(fromIntegerList(newPari.getChevauxSelectionnes()))
-                .numeroTicket(newPari.getNumeroTicket())
-                .nomParieur(newPari.getNomParieur())
-                .idParieur(newPari.getIdParieur())
-                .statut(StatutParis.EN_ATTENTE)
-                .mise(newPari.getMise())
-                .premier(numeroToCheval(newPari.getPremier()))
-                .deuxieme(numeroToCheval(newPari.getDeuxieme()))
-                .troisieme(numeroToCheval(newPari.getTroisieme()))
-                .typeFormule(newPari.getTypeFormule())
-                .typePari(newPari.getTypePari())
-                .estRembourse(false)
-                .estPaye(false)
-                .typeMulti(newPari.getTypeMulti())
-                .ordrePredit(newPari.getOrdrePredit())
-                .validationOrdreExact(newPari.getValidationOrdreExact())
-                .build();
-    }
-}
+
+// package com.pmu.betengine.controller;
+
+// import com.pmu.betengine.model.Pari;
+// import com.pmu.betengine.model.dto.NewPari;
+// import com.pmu.betengine.model.dto.updatePari;
+// import com.pmu.betengine.model.statut.StatutParis;
+// import com.pmu.betengine.model.type.TypeFormule;
+// import com.pmu.betengine.service.CourseService;
+// import com.pmu.betengine.service.PariService;
+// import io.swagger.v3.oas.annotations.Operation;
+// import io.swagger.v3.oas.annotations.responses.ApiResponse;
+// import io.swagger.v3.oas.annotations.tags.Tag;
+// import org.springframework.beans.factory.annotation.Autowired;
+// import org.springframework.http.HttpStatus;
+// import org.springframework.http.ResponseEntity;
+// import org.springframework.web.bind.annotation.*;
+
+// import java.util.List;
+
+// import static com.pmu.betengine.util.ChevalUtil.fromIntegerList;
+// import static com.pmu.betengine.util.ChevalUtil.numeroToCheval;
+
+// @RestController
+// @RequestMapping("/api/v1/pari")
+// @Tag(name = "Gestion des Pari (Bet)", description = "Endpoints relatifs à l'objet pari")
+// public class PariController {
+
+//     @Autowired
+//     private PariService pariService;
+//     @Autowired
+//     private CourseService courseService;
+//     @PostMapping
+//     @Operation(summary = "Placer un Pari (Bet)",
+//             description = "Permet d'enregistrer tous les types de Pari (Bet) avec toutes les Formules possibles")
+//     @ApiResponse(responseCode = "201", description = "Nouveau Pari Enregistré")
+//     public ResponseEntity<Pari> placerPari(@RequestBody NewPari pari) {
+//         try {
+//             return new ResponseEntity<>(pariService.placerPari(fromNewPariDto(pari)), HttpStatus.CREATED);
+//         }catch (Exception e){
+//             e.printStackTrace();
+//             return new ResponseEntity<>(null, HttpStatus.INTERNAL_SERVER_ERROR);
+//         }
+//         }
+
+//     @GetMapping("/course/{courseId}")
+//     @Operation(summary = "Affiche tous les Pari (Bet) d'une Course")
+//     @ApiResponse(responseCode = "200", description = "Paris Trouvés")
+//     public ResponseEntity<List<Pari>> obtenirParisParCourse(@PathVariable Long courseId) {
+//         return ResponseEntity.ok(pariService.obtenirParisParCourse(courseId));
+//     }
+
+
+//     @PutMapping("/{ticket}")
+//     @Operation(summary = "Mettre à jour un Pari Existant",description = "Cette opération concerne le status (), payé ou remboursé")
+//     @ApiResponse(responseCode = "200", description = "Pari Modifié avec succès")
+//     @ApiResponse(responseCode = "404", description = "Pari Non Trouvé")
+//     public ResponseEntity<String> updateProduct(@PathVariable String ticket, @RequestBody updatePari updatePari) {
+//         // Find the product by ID
+//         Pari pari = pariService.findByTicket(ticket);
+
+//         if (pari != null) {
+
+//             pari.setStatut(updatePari.getStatus());
+//             pari.setEstRembourse(updatePari.isEstRembourse());
+//             pari.setEstPaye(updatePari.isEstPaye());
+
+//             Pari pariUpdate = pariService.update(pari);
+//             return ResponseEntity.ok(ticket); // Return the updated product
+//         } else {
+//             return ResponseEntity.status(404).body(ticket);
+//         }
+//     }
+
+//   //  @GetMapping("/course/{courseId}/type/{typePari}")
+//     public ResponseEntity<List<Pari>> obtenirParisParCourseEtType(
+//             @PathVariable Long courseId, @PathVariable TypeFormule typeFormule) {
+//         return ResponseEntity.ok(pariService.obtenirParisParCourseEtType(courseId, typeFormule));
+//     }
+
+//   //  @GetMapping("/cheval/{chevalId}")
+//     public ResponseEntity<List<Pari>> obtenirParisParCheval(@PathVariable Long chevalId) {
+//         return ResponseEntity.ok(pariService.obtenirParisParCheval(chevalId));
+//     }
+
+//     private Pari fromNewPariDto(NewPari newPari){
+//         return Pari.builder()
+//                 .datePari(newPari.getDatePari())
+//                 .course(courseService.obtenirCourseParId(newPari.getCourseId()))
+//                 .cheval(numeroToCheval(newPari.getCheval()))
+//                 .cheval1(numeroToCheval(newPari.getCheval1()))
+//                 .cheval2(numeroToCheval(newPari.getCheval2()))
+//                 .cheval3(numeroToCheval(newPari.getCheval3()))
+//                 .chevauxOrdre(newPari.getChevauxOrdre())
+//                 .chevauxSelectionnes(fromIntegerList(newPari.getChevauxSelectionnes()))
+//                 .numeroTicket(newPari.getNumeroTicket())
+//                 .nomParieur(newPari.getNomParieur())
+//                 .idParieur(newPari.getIdParieur())
+//                 .statut(StatutParis.EN_ATTENTE)
+//                 .mise(newPari.getMise())
+//                 .premier(numeroToCheval(newPari.getPremier()))
+//                 .deuxieme(numeroToCheval(newPari.getDeuxieme()))
+//                 .troisieme(numeroToCheval(newPari.getTroisieme()))
+//                 .typeFormule(newPari.getTypeFormule())
+//                 .typePari(newPari.getTypePari())
+//                 .estRembourse(false)
+//                 .estPaye(false)
+//                 .typeMulti(newPari.getTypeMulti())
+//                 .ordrePredit(newPari.getOrdrePredit())
+//                 .validationOrdreExact(newPari.getValidationOrdreExact())
+//                 .build();
+//     }
+// }
 

src/main/java/com/pmu/betengine/controller/PermissionController.java

@@ -0,0 +1,46 @@
+package com.pmu.betengine.controller;
+
+import com.pmu.betengine.model.Permission;
+import com.pmu.betengine.service.PermissionService;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/v1/permissions")
+@CrossOrigin
+public class PermissionController {
+
+    private final PermissionService permissionService;
+
+    public PermissionController(PermissionService permissionService) {
+        this.permissionService = permissionService;
+    }
+
+    @PostMapping
+    public ResponseEntity<Permission> create(@RequestBody Permission permission) {
+        return ResponseEntity.ok(permissionService.create(permission));
+    }
+
+    @PutMapping("/{id}")
+    public ResponseEntity<Permission> update(@PathVariable Long id, @RequestBody Permission permission) {
+        return ResponseEntity.ok(permissionService.update(id, permission));
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<Permission> getById(@PathVariable Long id) {
+        return ResponseEntity.ok(permissionService.getById(id));
+    }
+
+    @GetMapping
+    public ResponseEntity<List<Permission>> getAll() {
+        return ResponseEntity.ok(permissionService.getAll());
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> delete(@PathVariable Long id) {
+        permissionService.delete(id);
+        return ResponseEntity.noContent().build();
+    }
+}

src/main/java/com/pmu/betengine/controller/ResultatController.java

@@ -1,54 +1,195 @@
 package com.pmu.betengine.controller;
 
+import com.pmu.betengine.model.Cheval;
+import com.pmu.betengine.model.Course;
 import com.pmu.betengine.model.Resultat;
-import com.pmu.betengine.model.dto.NewResultat;
-import com.pmu.betengine.model.dto.ResultatDto;
+import com.pmu.betengine.model.SearchParam;
 import com.pmu.betengine.service.CourseService;
 import com.pmu.betengine.service.ResultatService;
-import io.swagger.v3.oas.annotations.Operation;
-import io.swagger.v3.oas.annotations.tags.Tag;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.PostMapping;
-import org.springframework.web.bind.annotation.RequestBody;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
 
-import static com.pmu.betengine.util.ChevalUtil.fromIntegerList;
+import io.swagger.v3.oas.annotations.Operation;
+
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
 @RestController
 @RequestMapping("/api/v1/resultat")
-@Tag(name = "Gestion des Resultats des Courses", description = "Endpoints relatifs à l'objet resultat")
 public class ResultatController {
-    @Autowired
-    private ResultatService resultatCourseService;
 
-    @Autowired
-    private CourseService courseService;
+    private final ResultatService resultatService;
+    private final CourseService courseService;
 
+    public ResultatController(ResultatService resultatService, CourseService courseService) {
+        this.resultatService = resultatService;
+        this.courseService = courseService;
+    }
+
+    // CREATE
     @PostMapping
-    @Operation(summary = "Enregistrer le Resultat d'une course",
-    description = "Méthode permettant d'enregistrer le résultat d'une course")
-    public ResponseEntity<?> enregistrerResultat(@RequestBody NewResultat resultatDto) {
-        try {
-            resultatCourseService.save(fromNewResultat(resultatDto));
-            return ResponseEntity.ok().build();
-        } catch (Exception e) {
-            return ResponseEntity.badRequest().body(e.getMessage());
-        }
-    }
+    public ResponseEntity<Resultat> create(@RequestBody Resultat dto) {
 
-    private Resultat fromNewResultat(NewResultat resultat){
+        Course course = courseService.getCourseById(dto.getCourse().getId());
 
-        return Resultat.builder()
-                .course(courseService.obtenirCourseParId(resultat.getIdCourse().longValue()))
-                .aDeadHeat(resultat.isADeadHeat())
-                .premiers(fromIntegerList(resultat.getChevauxPremiers()))
-                .seconds(fromIntegerList(resultat.getChevauxDeuxiemes()))
-                .troisiemes(fromIntegerList(resultat.getChevauxTroisiemes()))
-                .quatriemes(fromIntegerList(resultat.getChevauxQuatriemes()))
-                .cinquiemes(fromIntegerList(resultat.getChevauxCinquiemes()))
-                .ordreArrivee(fromIntegerList(resultat.getOrdreArrivee()))
+        Resultat resultat = Resultat.builder()
+                .course(course)
+                .ordreArrivee(dto.getOrdreArrivee() != null ? dto.getOrdreArrivee() : List.of())
+                .chevauxDeadHeat(dto.getChevauxDeadHeat())
+                .aDeadHeat(dto.isADeadHeat())
+                .totalMises(dto.getTotalMises())
+                .masseAPartager(dto.getMasseAPartager())
+                .prelevementsLegaux(dto.getPrelevementsLegaux())
+                .montantRembourse(dto.getMontantRembourse())
+                .montantCagnotte(dto.getMontantCagnotte())
                 .build();
+
+        return ResponseEntity.ok(resultatService.save(resultat));
+    }
+
+    // GET ALL
+    @GetMapping
+    public ResponseEntity<List<Resultat>> getAll() {
+        return ResponseEntity.ok(resultatService.getAll());
+    }
+
+    // GET BY ID
+    @GetMapping("/{id}")
+    public ResponseEntity<Resultat> getById(@PathVariable Long id) {
+        Resultat r = resultatService.getById(id);
+        return r != null ? ResponseEntity.ok(r) : ResponseEntity.notFound().build();
+    }
+
+    // GET BY COURSE
+      @GetMapping("/course/{courseId}")
+    public ResponseEntity<?> getByCourse(@PathVariable Long courseId) {
+        Resultat r = resultatService.getByCourseId(courseId);
+        if (r != null) {
+            return ResponseEntity.ok(r);
+        } else {
+            Map<String, String> response = new HashMap<>();
+            response.put("message", "Aucun résultat disponible pour cette course");
+            return ResponseEntity.ok(response);
         }
     }
+
+    // UPDATE
+    @PutMapping("/{id}")
+    public ResponseEntity<Resultat> update(@PathVariable Long id, @RequestBody Resultat update) {
+        Resultat existing = resultatService.getById(id);
+
+        if (existing == null) {
+            return ResponseEntity.notFound().build();
+        }
+
+        update.setId(id);
+        return ResponseEntity.ok(resultatService.save(update));
+    }
+
+    // DELETE BY ID
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> delete(@PathVariable Long id) {
+        resultatService.delete(id);
+        return ResponseEntity.noContent().build();
+    }
+
+    // DELETE BY COURSE
+    @DeleteMapping("/course/{courseId}")
+    public ResponseEntity<Void> deleteByCourse(@PathVariable Long courseId) {
+        resultatService.deleteByCourseId(courseId);
+        return ResponseEntity.noContent().build();
+    }
+
+    @PostMapping("/publish")
+public ResponseEntity<Resultat> publishResultat(@RequestBody Resultat dto) {
+
+    // Fetch the course
+    Course course = courseService.getCourseById(dto.getCourse().getId());
+
+    // Build the resultat object
+    Resultat resultat = Resultat.builder()
+            .course(course)
+            .ordreArrivee(dto.getOrdreArrivee() != null ? dto.getOrdreArrivee() : List.of())
+            .chevauxDeadHeat(dto.getChevauxDeadHeat())
+            .aDeadHeat(dto.isADeadHeat())
+            .totalMises(dto.getTotalMises())
+            .masseAPartager(dto.getMasseAPartager())
+            .prelevementsLegaux(dto.getPrelevementsLegaux())
+            .montantRembourse(dto.getMontantRembourse())
+            .montantCagnotte(dto.getMontantCagnotte())
+            .build();
+
+    // Save resultat and update course statut
+    Resultat saved = resultatService.saveAndUpdateCourse(resultat);
+
+    return ResponseEntity.ok(saved);
+}
+
+@PostMapping("/searchByParams")
+@Operation(summary = "Rechercher des résultats avec critères")
+public ResponseEntity<List<Resultat>> searchResultats(@RequestBody SearchParam searchParam) {
+    return ResponseEntity.ok(resultatService.search(searchParam));
+}
+
+
+}
+
+
+
+
+// package com.pmu.betengine.controller;
+
+// import com.pmu.betengine.model.Resultat;
+// import com.pmu.betengine.model.dto.NewResultat;
+// import com.pmu.betengine.model.dto.ResultatDto;
+// import com.pmu.betengine.service.CourseService;
+// import com.pmu.betengine.service.ResultatService;
+// import io.swagger.v3.oas.annotations.Operation;
+// import io.swagger.v3.oas.annotations.tags.Tag;
+// import org.springframework.beans.factory.annotation.Autowired;
+// import org.springframework.http.ResponseEntity;
+// import org.springframework.web.bind.annotation.PostMapping;
+// import org.springframework.web.bind.annotation.RequestBody;
+// import org.springframework.web.bind.annotation.RequestMapping;
+// import org.springframework.web.bind.annotation.RestController;
+
+// import static com.pmu.betengine.util.ChevalUtil.fromIntegerList;
+
+// @RestController
+// @RequestMapping("/api/v1/resultat")
+// @Tag(name = "Gestion des Resultats des Courses", description = "Endpoints relatifs à l'objet resultat")
+// public class ResultatController {
+//     @Autowired
+//     private ResultatService resultatCourseService;
+
+//     @Autowired
+//     private CourseService courseService;
+
+//     @PostMapping
+//     @Operation(summary = "Enregistrer le Resultat d'une course",
+//     description = "Méthode permettant d'enregistrer le résultat d'une course")
+//     public ResponseEntity<?> enregistrerResultat(@RequestBody NewResultat resultatDto) {
+//         try {
+//             resultatCourseService.save(fromNewResultat(resultatDto));
+//             return ResponseEntity.ok().build();
+//         } catch (Exception e) {
+//             return ResponseEntity.badRequest().body(e.getMessage());
+//         }
+//     }
+
+//     private Resultat fromNewResultat(NewResultat resultat){
+
+//         return Resultat.builder()
+//                 .course(courseService.obtenirCourseParId(resultat.getIdCourse().longValue()))
+//                 .aDeadHeat(resultat.isADeadHeat())
+//                 .premiers(fromIntegerList(resultat.getChevauxPremiers()))
+//                 .seconds(fromIntegerList(resultat.getChevauxDeuxiemes()))
+//                 .troisiemes(fromIntegerList(resultat.getChevauxTroisiemes()))
+//                 .quatriemes(fromIntegerList(resultat.getChevauxQuatriemes()))
+//                 .cinquiemes(fromIntegerList(resultat.getChevauxCinquiemes()))
+//                 .ordreArrivee(fromIntegerList(resultat.getOrdreArrivee()))
+//                 .build();
+//     }
+// }

src/main/java/com/pmu/betengine/controller/ReunionController.java

@@ -1,11 +1,9 @@
 package com.pmu.betengine.controller;
 
-import com.pmu.betengine.model.dto.ReunionDTO;
-import com.pmu.betengine.model.dto.ReunionRequestDTO;
+import com.pmu.betengine.model.Reunion;
 import com.pmu.betengine.service.ReunionService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
-import jakarta.validation.Valid;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
@@ -14,8 +12,8 @@ import java.util.List;
 
 @RestController
 @RequestMapping("/api/v1/reunions")
-@Tag(name = "Gestion des Réunions des Courses", description = "Endpoints relatifs à l'objet Reunion")
 @CrossOrigin(origins = "*")
+@Tag(name = "Gestion des Réunions", description = "Endpoints relatifs aux Réunions")
 public class ReunionController {
 
     private final ReunionService reunionService;
@@ -25,30 +23,51 @@ public class ReunionController {
     }
 
     @GetMapping
-    public ResponseEntity<List<ReunionDTO>> getAllReunions() {
+    @Operation(summary = "Lister toutes les Réunions")
+    public ResponseEntity<List<Reunion>> getAllReunions() {
         return ResponseEntity.ok(reunionService.getAllReunions());
     }
 
     @GetMapping("/{id}")
-    public ResponseEntity<ReunionDTO> getReunionById(@PathVariable Long id) {
+    @Operation(summary = "Obtenir une Réunion par ID")
+    public ResponseEntity<Reunion> getReunionById(@PathVariable Long id) {
         return ResponseEntity.ok(reunionService.getReunionById(id));
     }
 
     @PostMapping
-    @Operation(summary = "Enregistrer Une réunion",
-            description = "Méthode permettant d'enregistrer la réunion")
-    public ResponseEntity<ReunionDTO> createReunion(@Valid @RequestBody ReunionRequestDTO requestDTO) {
-        return new ResponseEntity<>(reunionService.createReunion(requestDTO), HttpStatus.CREATED);
+    @Operation(summary = "Créer une Réunion")
+    public ResponseEntity<Reunion> createReunion(@RequestBody Reunion reunion) {
+        return new ResponseEntity<>(reunionService.createReunion(reunion), HttpStatus.CREATED);
     }
 
     @PutMapping("/{id}")
-    public ResponseEntity<ReunionDTO> updateReunion(@PathVariable Long id, @Valid @RequestBody ReunionRequestDTO requestDTO) {
-        return ResponseEntity.ok(reunionService.updateReunion(id, requestDTO));
+    @Operation(summary = "Modifier une Réunion")
+    public ResponseEntity<Reunion> updateReunion(@PathVariable Long id, @RequestBody Reunion reunion) {
+        return ResponseEntity.ok(reunionService.updateReunion(id, reunion));
     }
 
+    // @DeleteMapping("/{id}")
+    // @Operation(summary = "Supprimer une Réunion")
+    // public ResponseEntity<String> deleteReunion(@PathVariable Long id) {
+    //     return ResponseEntity.ok(reunionService.deleteReunion(id));
+    // }
+
     @DeleteMapping("/{id}")
-    public ResponseEntity<Void> deleteReunion(@PathVariable Long id) {
-        reunionService.deleteReunion(id);
-        return ResponseEntity.noContent().build();
+    @Operation(summary = "Désactiver une Réunion")
+    public ResponseEntity<String> deleteReunion(@PathVariable Long id) {
+        return ResponseEntity.ok(reunionService.deleteReunion(id));
+    }
+
+    @PutMapping("/restore/{id}")
+    @Operation(summary = "Restaurer une Réunion désactivée")
+    public ResponseEntity<Reunion> restoreReunion(@PathVariable Long id) {
+        return ResponseEntity.ok(reunionService.restoreReunion(id));
+    }
+
+
+    @GetMapping("/code/{code}")
+    @Operation(summary = "Obtenir une Réunion par code")
+    public ResponseEntity<Reunion> getReunionByCode(@PathVariable String code) {
+        return ResponseEntity.ok(reunionService.getReunionByCode(code));
     }
 }

src/main/java/com/pmu/betengine/controller/RoleController.java

@@ -0,0 +1,46 @@
+package com.pmu.betengine.controller;
+
+import com.pmu.betengine.model.Role;
+import com.pmu.betengine.service.RoleService;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/v1/roles")
+@CrossOrigin
+public class RoleController {
+
+    private final RoleService roleService;
+
+    public RoleController(RoleService roleService) {
+        this.roleService = roleService;
+    }
+
+    @PostMapping
+    public ResponseEntity<Role> create(@RequestBody Role role) {
+        return ResponseEntity.ok(roleService.create(role));
+    }
+
+    @PutMapping("/{id}")
+    public ResponseEntity<Role> update(@PathVariable Long id, @RequestBody Role role) {
+        return ResponseEntity.ok(roleService.update(id, role));
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<Role> getById(@PathVariable Long id) {
+        return ResponseEntity.ok(roleService.getById(id));
+    }
+
+    @GetMapping
+    public ResponseEntity<List<Role>> getAll() {
+        return ResponseEntity.ok(roleService.getAll());
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> delete(@PathVariable Long id) {
+        roleService.delete(id);
+        return ResponseEntity.noContent().build();
+    }
+}

src/main/java/com/pmu/betengine/controller/TPEController.java

@@ -1,5 +1,6 @@
 package com.pmu.betengine.controller;
 
+import com.pmu.betengine.model.TPE;
 import com.pmu.betengine.model.dto.TPEDTO;
 import com.pmu.betengine.model.dto.TPERequestDTO;
 import com.pmu.betengine.model.statut.StatutTPE;
@@ -18,6 +19,7 @@ import java.util.Map;
 @RequestMapping("/api/v1/tpes")
 @CrossOrigin(origins = "*")
 @Tag(name = "Gestion des TPE", description = "Endpoints relatifs à l'objet TPE")
+
 public class TPEController {
 
     private final TPEService tpeService;
@@ -27,94 +29,84 @@ public class TPEController {
     }
 
     @GetMapping
-    public ResponseEntity<List<TPEDTO>> getAllTPEs() {
+    public ResponseEntity<List<TPE>> getAllTPEs() {
         return ResponseEntity.ok(tpeService.getAllTPEs());
     }
 
     @GetMapping("/{id}")
-    public ResponseEntity<TPEDTO> getTPEById(@PathVariable Long id) {
+    public ResponseEntity<TPE> getTPEById(@PathVariable Long id) {
         return ResponseEntity.ok(tpeService.getTPEById(id));
     }
 
     @PostMapping
-    @Operation(summary = "Enregistrer Un TPE",
-            description = "Méthode permettant d'enregistrer un TPE")
-    public ResponseEntity<TPEDTO> createTPE(@Valid @RequestBody TPERequestDTO requestDTO) {
-        return new ResponseEntity<>(tpeService.createTPE(requestDTO), HttpStatus.CREATED);
+    public ResponseEntity<TPE> createTPE(@RequestBody TPE tpe) {
+        return new ResponseEntity<>(tpeService.createTPE(tpe), HttpStatus.CREATED);
     }
 
     @PutMapping("/{id}")
-    @Operation(summary = "Modifier Un TPE",
-            description = "Méthode permettant de modifier un TPE")
-    public ResponseEntity<TPEDTO> updateTPE(@PathVariable Long id, @Valid @RequestBody TPERequestDTO requestDTO) {
-        return ResponseEntity.ok(tpeService.updateTPE(id, requestDTO));
+    public ResponseEntity<TPE> updateTPE(@PathVariable Long id, @RequestBody TPE tpe) {
+        return ResponseEntity.ok(tpeService.updateTPE(id, tpe));
     }
 
     @DeleteMapping("/{id}")
-    @Operation(summary = "Supprimer Un TPE",
-            description = "Méthode permettant de supprimer un TPE")
     public ResponseEntity<Void> deleteTPE(@PathVariable Long id) {
         tpeService.deleteTPE(id);
         return ResponseEntity.noContent().build();
     }
 
     @PatchMapping("/{id}/statut")
-    @Operation(summary = "Modifier le Statut d'un TPE",
-            description = "Méthode permettant de modifier le statut  d'un TPE")
-    public ResponseEntity<TPEDTO> updateStatut(@PathVariable Long id, @RequestBody Map<String, String> request) {
+    public ResponseEntity<TPE> updateStatut(@PathVariable Long id, @RequestBody Map<String, String> request) {
         String statutStr = request.get("statut");
-        try {
         StatutTPE statut = StatutTPE.valueOf(statutStr.toUpperCase());
         return ResponseEntity.ok(tpeService.updateStatut(id, statut));
-        } catch (IllegalArgumentException e) {
-            throw new RuntimeException("Statut invalide: " + statutStr);
-        }
     }
 
-    @PatchMapping("/{id}/assigner")
-    @Operation(summary = "Assigner Un TPE",
-            description = "Méthode permettant d'd'assigner un TPE")
-    public ResponseEntity<TPEDTO> assignerTPE(@PathVariable Long id) {
-        return ResponseEntity.ok(tpeService.assignerTPE(id));
+    // @PatchMapping("/{id}/assigner")
+    // public ResponseEntity<TPE> assignerTPE(@PathVariable Long id, @RequestParam Long agentId) {
+    //     return ResponseEntity.ok(tpeService.assignerTPE(id, agentId));
+    // }
+    @PatchMapping("/assigner")
+    @Operation(summary = "Assigner Un TPE", description = "Assigner un TPE à un Agent")
+    public ResponseEntity<TPE> assignerTPE(@RequestBody Map<String, Long> request) {
+        Long tpeId = request.get("tpeId");
+        Long agentId = request.get("agentId");
+        return ResponseEntity.ok(tpeService.assignerTPE(tpeId, agentId));
     }
 
-    @PatchMapping("/{id}/liberer")
-    @Operation(summary = "Libérer Un TPE",
-            description = "Méthode permettant de libérer un TPE")
-    public ResponseEntity<TPEDTO> libererTPE(@PathVariable Long id) {
+
+    @PatchMapping("/liberer/{id}")
+    public ResponseEntity<TPE> libererTPE(@PathVariable Long id) {
         return ResponseEntity.ok(tpeService.libererTPE(id));
     }
 
     @GetMapping("/statut/{statut}")
-    @Operation(summary = "Lister les TPE par statut",
-            description = "Méthode permettant d'obtenir les TPE du statut en parametre")
-    public ResponseEntity<List<TPEDTO>> getTPEsByStatut(@PathVariable StatutTPE statut) {
+    public ResponseEntity<List<TPE>> getTPEsByStatut(@PathVariable StatutTPE statut) {
         return ResponseEntity.ok(tpeService.getTPEsByStatut(statut));
     }
 
     @GetMapping("/disponibles")
-    @Operation(summary = "Lister les TPE Disponibles",
-            description = "Méthode permettant de lister les TPE disponibles")
-    public ResponseEntity<List<TPEDTO>> getTPEsDisponibles() {
+    public ResponseEntity<List<TPE>> getTPEsDisponibles() {
         return ResponseEntity.ok(tpeService.getTPEsDisponibles());
     }
 
     @GetMapping("/search")
-    public ResponseEntity<List<TPEDTO>> searchTPEs(@RequestParam String q) {
+    public ResponseEntity<List<TPE>> searchTPEs(@RequestParam String q) {
         return ResponseEntity.ok(tpeService.searchTPEs(q));
     }
 
     @GetMapping("/stats/count-by-statut")
     public ResponseEntity<Map<StatutTPE, Long>> getCountByStatut() {
-        Map<StatutTPE, Long> stats = Map.of(
+        return ResponseEntity.ok(Map.of(
+                StatutTPE.VALIDE, tpeService.countTPEsByStatut(StatutTPE.VALIDE),
+                StatutTPE.INVALIDE, tpeService.countTPEsByStatut(StatutTPE.INVALIDE),
+                StatutTPE.EN_PANNE, tpeService.countTPEsByStatut(StatutTPE.EN_PANNE),
+                StatutTPE.BLOQUE, tpeService.countTPEsByStatut(StatutTPE.BLOQUE),
                 StatutTPE.DISPONIBLE, tpeService.countTPEsByStatut(StatutTPE.DISPONIBLE),
                 StatutTPE.AFFECTE, tpeService.countTPEsByStatut(StatutTPE.AFFECTE),
-                StatutTPE.EN_PANNE, tpeService.countTPEsByStatut(StatutTPE.EN_PANNE),
                 StatutTPE.EN_MAINTENANCE, tpeService.countTPEsByStatut(StatutTPE.EN_MAINTENANCE),
                 StatutTPE.HORS_SERVICE, tpeService.countTPEsByStatut(StatutTPE.HORS_SERVICE),
                 StatutTPE.VOLE, tpeService.countTPEsByStatut(StatutTPE.VOLE)
-        );
-        return ResponseEntity.ok(stats);
+        ));
     }
 
     @GetMapping("/stats/assignes")
@@ -122,3 +114,4 @@ public class TPEController {
         return ResponseEntity.ok(tpeService.countTPEsAssignes());
     }
 }
+

src/main/java/com/pmu/betengine/controller/UserController.java

@@ -0,0 +1,46 @@
+package com.pmu.betengine.controller;
+
+import com.pmu.betengine.model.User;
+import com.pmu.betengine.service.UserService;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/v1/users")
+@CrossOrigin
+public class UserController {
+
+    private final UserService userService;
+
+    public UserController(UserService userService) {
+        this.userService = userService;
+    }
+
+    @PostMapping
+    public ResponseEntity<User> create(@RequestBody User user) {
+        return ResponseEntity.ok(userService.create(user));
+    }
+
+    @PutMapping("/{id}")
+    public ResponseEntity<User> update(@PathVariable Long id, @RequestBody User user) {
+        return ResponseEntity.ok(userService.update(id, user));
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<User> getById(@PathVariable Long id) {
+        return ResponseEntity.ok(userService.getById(id));
+    }
+
+    @GetMapping
+    public ResponseEntity<List<User>> getAll() {
+        return ResponseEntity.ok(userService.getAll());
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> delete(@PathVariable Long id) {
+        userService.delete(id);
+        return ResponseEntity.noContent().build();
+    }
+}

src/main/java/com/pmu/betengine/model/Agent.java

@@ -1,5 +1,6 @@
 package com.pmu.betengine.model;
 
+import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.annotation.JsonFormat;
 import com.pmu.betengine.model.statut.StatutAgent;
 import jakarta.persistence.*;
@@ -16,70 +17,82 @@ import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.util.List;
 
-@Entity
 @Data
 @Builder
 @NoArgsConstructor
 @AllArgsConstructor
-@Table(name = "agent")
+@Entity
+@Table(name = "agents")
 public class Agent {
+
     @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @GeneratedValue
     private Long id;
 
     private String code;
     private String profile;
     private String principalCode;
     private String caisseProfile;
-    private StatutAgent statut;
+    
+    @Enumerated(EnumType.STRING)
+    private StatutAgent statut = StatutAgent.ACTIF;
+
     private String zone;
     private String kiosk;
     private String fonction;
-    @Pattern(regexp = "^\\d{2}/\\d{2}/\\d{4}$", message = "La date  doit être au format dd/MM/yyyy")
-    @JsonFormat(pattern = "dd/MM/yyyy", shape = JsonFormat.Shape.STRING)
-    private LocalDate dateEmbauche;
-    @NotBlank(message = "Le nom est obligatoire")
+
+    @Column(name = "date_embauche")
+    private LocalDateTime dateEmbauche;
+
+    @Column(name = "derniere_connexion")
+    private LocalDateTime derniereConnexion;
+
+
     private String nom;
     private String prenom;
     private String autresNoms;
-    @Pattern(regexp = "^\\d{2}/\\d{2}/\\d{4}$", message = "La date de naissance doit être au format dd/MM/yyyy")
-    @Column(name = "date_naissance", nullable = false)
-    @JsonFormat(pattern = "dd/MM/yyyy", shape = JsonFormat.Shape.STRING)
+
+    @Column(name = "date_naissance")
     private LocalDate dateNaissance;
+
     private String lieuNaissance;
     private String ville;
     private String adresse;
     private Boolean autoriserAides;
     private String phone;
     private String pin;
+
     private Double limiteInferieure;
     private Double limiteSuperieure;
     private Double limiteParTransaction;
     private Double limiteMinAirtime;
     private Double limiteMaxAirtime;
+
     private Integer maxPeripheriques;
-    private String limitId;
-    // Légales
+    @OneToMany(mappedBy = "agent")
+    @JsonIgnore 
+    private List<TPE> tpes;
+    @Column(name = "limit_id")
+    private Long limitId;
     private String nationalite;
     private String cni;
-    private String cniDelivreeLe;
+
+    @Column(name = "cni_delivree_le")
+    private LocalDate cniDelivreeLe;
+
     private String cniDelivreeA;
     private String residence;
     private String autreAdresse1;
     private String statutMarital;
     private String epoux;
     private String autreTelephone;
-    // Situation familiale
-    @OneToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
-    @JoinTable(name = "agent_famille",
-            joinColumns = @JoinColumn(name = "agent_id"),
-            inverseJoinColumns = @JoinColumn(name = "famille_id"))
-    private List<AgentFamilyMember> famille;
-    // TPE assignés
-    private String [] assignedTpeIds;
-    @CreationTimestamp
+
+    @Column(name = "created_at")
     private LocalDateTime createdAt;
-    @UpdateTimestamp
+
+    @Column(name = "updated_at")
     private LocalDateTime updatedAt;
+
+    @Column(name = "created_by")
     private String createdBy;
 }

src/main/java/com/pmu/betengine/model/AgentFamilyMember.java

@@ -12,25 +12,45 @@ import lombok.NoArgsConstructor;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 
-@Entity
+
 @Data
 @Builder
 @NoArgsConstructor
 @AllArgsConstructor
-@Table(name = "agent_family_member")
+@Entity
+@Table(name = "agent_family_members")
 public class AgentFamilyMember {
+
     @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @GeneratedValue
     private Long id;
-    @NotBlank(message = "Le nom est obligatoire")
-    public String nom;
-    public String statut;
-    @Pattern(regexp = "^\\d{2}/\\d{2}/\\d{4}$", message = "La date de naissance doit être au format dd/MM/yyyy")
-    @Column(name = "date_naissance", nullable = false)
-    @JsonFormat(pattern = "dd/MM/yyyy", shape = JsonFormat.Shape.STRING)
-    public LocalDate dateNaissance;
-    @NotBlank(message = "Le sexe est obligatoire")
-    @Pattern(regexp = "^(M|F)$", message = "Le sexe doit être M (Masculin) ou F (Féminin)")
-    @Column(nullable = false, length = 1)
-    public String sexe;
+
+    @Column(name = "agent_id")
+    private Long agentId;
+
+    private String nom;
+    private String statut;
+
+    @Column(name = "date_naissance")
+    private LocalDate dateNaissance;
+
+    private String sexe;
 }
+
+// @Table(name = "agent_family_member")
+// public class AgentFamilyMember {
+//     @Id
+//     @GeneratedValue(strategy = GenerationType.IDENTITY)
+//     private Long id;
+//     @NotBlank(message = "Le nom est obligatoire")
+//     public String nom;
+//     public String statut;
+//     @Pattern(regexp = "^\\d{2}/\\d{2}/\\d{4}$", message = "La date de naissance doit être au format dd/MM/yyyy")
+//     @Column(name = "date_naissance", nullable = false)
+//     @JsonFormat(pattern = "dd/MM/yyyy", shape = JsonFormat.Shape.STRING)
+//     public LocalDate dateNaissance;
+//     @NotBlank(message = "Le sexe est obligatoire")
+//     @Pattern(regexp = "^(M|F)$", message = "Le sexe doit être M (Masculin) ou F (Féminin)")
+//     @Column(nullable = false, length = 1)
+//     public String sexe;
+// }

src/main/java/com/pmu/betengine/model/AgentLimit.java

@@ -25,7 +25,7 @@ public class AgentLimit {
         public String nom;
         public boolean isDefault;
         public boolean actif;
-        // Bet limits (Double for nullable number fields)
+        // Bet limits
         public Double betMin;
         public Double betMax;
         public Double maxBet;

src/main/java/com/pmu/betengine/model/AuthRequest.java

@@ -0,0 +1,23 @@
+package com.pmu.betengine.model;
+
+public class AuthRequest {
+
+    private String identifiant;
+    private String password;
+
+    public String getIdentifiant() {
+        return identifiant;
+    }
+
+    public void setIdentifiant(String identifiant) {
+        this.identifiant = identifiant;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+}

src/main/java/com/pmu/betengine/model/AuthRequestAgent.java

@@ -0,0 +1,9 @@
+package com.pmu.betengine.model;
+
+public class AuthRequestAgent {
+    private String pin;
+
+    // Getter and Setter
+    public String getPin() { return pin; }
+    public void setPin(String pin) { this.pin = pin; }
+}

src/main/java/com/pmu/betengine/model/AuthResponse.java

@@ -0,0 +1,32 @@
+package com.pmu.betengine.model;
+
+public class AuthResponse {
+
+    private String message;
+    private Long userId;
+    private String nom;
+    private String prenom;
+
+    public AuthResponse(String message, Long userId, String nom, String prenom) {
+        this.message = message;
+        this.userId = userId;
+        this.nom = nom;
+        this.prenom = prenom;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public Long getUserId() {
+        return userId;
+    }
+
+    public String getNom() {
+        return nom;
+    }
+
+    public String getPrenom() {
+        return prenom;
+    }
+}

src/main/java/com/pmu/betengine/model/Course.java

@@ -10,8 +10,10 @@ import lombok.Builder;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 
+import java.sql.Date;
 import java.time.LocalDateTime;
 import java.util.List;
+import java.util.UUID;
 
 @Entity
 @Data
@@ -21,36 +23,41 @@ import java.util.List;
 @Table(name = "course")
 public class Course {
      @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @GeneratedValue
     private Long id;
-    private String numero;
-    @OneToOne
-    private Reunion reunion;
-    @Pattern(regexp = "^\\d{2}/\\d{2}/\\d{4}$", message = "La date  doit être au format dd/MM/yyyy HH:mm:ss")
-    @JsonFormat(pattern = "dd/MM/yyyy HH:mm:ss", shape = JsonFormat.Shape.STRING)
-    @Column(name = "heure_course")
-    private LocalDateTime heureCourse;
-    private String lieu;
-    private int nombreChevauxInscrits;
+    private String type;
+    private Integer numero;
+    private String nom;
+    @Column(name = "date_depart_course")
+    private LocalDateTime dateDepartCourse;
+    @Column(name = "date_debut_paris")
+    private LocalDateTime dateDebutParis;
+    @Column(name = "date_fin_paris")
+    private LocalDateTime dateFinParis;
+    @Column(name = "reunion_id")
+    private Long reunionId;
+    @Column(name = "reunion_course")
+    private Integer reunionCourse;
+    private String particularite;
+    private Integer partants;
+    private Integer distance;
+    private String condition;
     private boolean estTerminee;
     private boolean estAnnulee;
     private boolean aDeadHeat;
+    private String statut;
+    private int nombreChevauxInscrits;
+    @Column(name = "resultat_statut")
+    private String resultatStatut;
+    @Column(name = "created_by")
+    private String createdBy;
+    @Column(name = "validated_by")
+    private String validatedBy;
+    @Column(name = "created_at")
+    private LocalDateTime createdAt;
+    @Column(name = "updated_at")
+    private LocalDateTime updatedAt;
+    @Column(name = "nom_partants")
+    private List<String> nonPartants;
 
-    @Enumerated(EnumType.STRING)
-    private StatutCourse statut;
-
-    @OneToOne(mappedBy = "course")
-    private Resultat resultat;
-
-    @OneToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
-    @JoinTable(name = "course_chevaux",
-            joinColumns = @JoinColumn(name = "course_id"),
-            inverseJoinColumns = @JoinColumn(name = "cheval_id"))
-    private List<Cheval> chevaux;
-
-    @OneToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL,mappedBy = "course")
-    private List<Pari> paris;
-    public boolean estEligiblePourTrioOrdre() {
-        return chevaux != null && chevaux.size() >= 3 && chevaux.size() <= 7;
-    }
 }

src/main/java/com/pmu/betengine/model/CourseReportDetailRow.java

@@ -0,0 +1,42 @@
+package com.pmu.betengine.model;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Entity
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "course_report_detail_rows")
+public class CourseReportDetailRow {
+
+    @Id
+    @GeneratedValue
+    private Long id;
+
+    @Column(name = "detail_id")
+    private Long detailId;
+
+    @Column(name = "type_gain")
+    private String typeGain;
+
+    @Column(name = "type_jeu")
+    private String typeJeu;
+
+    private Double montant;
+
+    private Integer nombre;
+
+    private String statut;
+
+    private Boolean distributed;
+
+    private Boolean externe;
+}
+

src/main/java/com/pmu/betengine/model/Hippodrome.java

@@ -11,28 +11,55 @@ import org.hibernate.annotations.UpdateTimestamp;
 import java.time.LocalDateTime;
 import java.util.List;
 
-@Entity
+
 @Data
 @Builder
 @NoArgsConstructor
 @AllArgsConstructor
-@Table(name = "hippodrome")
+@Entity
+@Table(name = "hippodromes")
 public class Hippodrome {
+
     @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @GeneratedValue
     private Long id;
 
-    public String nom;
-    public String ville;
-    public String pays;
-    public boolean actif;
-    public Integer capacite;
-    public String description;
+    private String nom;
+    private String ville;
+    private String pays;
+
+    private Boolean actif;
+    private Integer capacite;
+
+    private String description;
+
     @CreationTimestamp
+    @Column(name = "created_at", updatable = false)
     private LocalDateTime createdAt;
+    
     @UpdateTimestamp
+    @Column(name = "updated_at")
     private LocalDateTime updatedAt;
     
-    @OneToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL, mappedBy = "hippodrome")
-    private List<Reunion> reunions;
 }
+
+// @Table(name = "hippodrome")
+// public class Hippodrome {
+//     @Id
+//     @GeneratedValue(strategy = GenerationType.IDENTITY)
+//     private Long id;
+
+//     public String nom;
+//     public String ville;
+//     public String pays;
+//     public boolean actif;
+//     public Integer capacite;
+//     public String description;
+//     @CreationTimestamp
+//     private LocalDateTime  createdAt;
+//     @UpdateTimestamp
+//     private LocalDateTime updatedAt;
+
+//     @OneToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL, mappedBy = "hippodrome")
+//     private List<Reunion> reunions;
+// }

src/main/java/com/pmu/betengine/model/Mise.java

@@ -0,0 +1,25 @@
+package com.pmu.betengine.model;
+
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@Entity
+@Table(name = "mises")
+public class Mise {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+    String typePari;
+    Double montantMise;
+}

src/main/java/com/pmu/betengine/model/NonPartant.java

@@ -0,0 +1,35 @@
+package com.pmu.betengine.model;
+
+import java.time.LocalDateTime;
+import java.util.UUID;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+import lombok.Data;
+
+@Entity
+@Data
+@Table(name = "non_partants")
+public class NonPartant {
+
+    @Id
+    @GeneratedValue
+    private Long id;
+    @ManyToOne
+    @JoinColumn(name = "course_id")
+    private Course course;
+    private Integer numero;
+    @Column(name = "nom_cheval")
+    private String nomCheval;
+    private String motif;
+    @Column(name = "declare_par")
+    private String declarePar;
+    @Column(name = "date_declaration")
+    private LocalDateTime dateDeclaration;
+}
+

src/main/java/com/pmu/betengine/model/Pari.java

@@ -6,7 +6,6 @@ import com.pmu.betengine.model.type.TypeFormule;
 import com.pmu.betengine.model.type.TypeMulti;
 import com.pmu.betengine.model.type.TypePari;
 import jakarta.persistence.*;
-import jakarta.validation.constraints.Pattern;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
@@ -15,7 +14,6 @@ import lombok.NoArgsConstructor;
 import java.time.LocalDateTime;
 import java.util.List;
 
-
 @Entity
 @Data
 @Builder
@@ -23,86 +21,148 @@ import java.util.List;
 @AllArgsConstructor
 @Table(name = "pari")
 public class Pari {
+
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
 
-    @Column(nullable = false)
     private String numeroTicket;
 
+    @Enumerated(EnumType.STRING)
     @Column(name = "type_pari")
     private TypePari typePari;
 
+    @Enumerated(EnumType.STRING)
     @Column(name = "type_formule")
-    private TypeFormule typeFormule; // GAGNANT ou PLACE
+    private TypeFormule typeFormule;
+
     private double mise = 500.0;
-    @Pattern(regexp = "^\\d{2}/\\d{2}/\\d{4}$", message = "La date doit être au format dd/MM/yyyy HH:mm:ss")
-    @JsonFormat(pattern = "dd/MM/yyyy HH:mm:ss", shape = JsonFormat.Shape.STRING)
+
+    @JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss")
     private LocalDateTime datePari;    
 
     private boolean estPaye;
     private boolean estRembourse;
-
-    @ManyToOne(cascade = CascadeType.ALL)
+    private StatutParis statut;
+    @ManyToOne
     @JoinColumn(name = "course_id")
     private Course course;
-    @Column(name = "parieur_id")
-    private String idParieur;
-    private String nomParieur;
-    private StatutParis statut;
-    private Double gain;
-
-    ///////////////////Cheval////
-    @ManyToOne(cascade = CascadeType.ALL)
-    @JoinColumn(name = "cheval_id")
-    private Cheval cheval;
-
-    @ManyToOne(cascade = CascadeType.ALL)
-    @JoinColumn(name = "cheval1_id")
-    private Cheval cheval1;
-
-    @ManyToOne(cascade = CascadeType.ALL)
-    @JoinColumn(name = "cheval2_id")
-    private Cheval cheval2;
-
-    @ManyToOne(cascade = CascadeType.ALL)
-    @JoinColumn(name = "cheval3_id")
-    private Cheval cheval3;
-
-    @ManyToOne(cascade = CascadeType.ALL)
-    private Cheval premier;
-
-    @ManyToOne(cascade = CascadeType.ALL)
-    private Cheval deuxieme;
-
-    @ManyToOne(cascade = CascadeType.ALL)
-    private Cheval troisieme;
-
-    // TRIPLET
+    // LIST OF SELECTED CHEVAL NUMBERS
     @ElementCollection
-    @CollectionTable(name = "pari_chevaux_ordre", joinColumns = @JoinColumn(name = "pari_id"))
-    @Column(name = "cheval_id")
-    @OrderColumn(name = "position")
-    private List<Integer> chevauxOrdre;
-
-    // QUATRO, QUARTE PLUS, MULTI,
-    @ManyToMany(fetch = FetchType.LAZY,cascade = CascadeType.ALL)
-    @JoinTable(name = "pari_chevaux",
-            joinColumns = @JoinColumn(name = "pari_id"),
-            inverseJoinColumns = @JoinColumn(name = "cheval_id"))
-    private List<Cheval> chevauxSelectionnes;
-
+    private List<String> chevauxSelectionnes;
     @ElementCollection
-    private List<Integer> ordrePredit;
+    private List<String> ordrePredit;
     private Boolean validationOrdreExact;
-
-    // MULTI
     @Enumerated(EnumType.STRING)
     private TypeMulti typeMulti;
-
-
-    public boolean estFormuleChamp() {
-        return typeFormule.name().contains("CHAMP");
 }
 
-}
+
+// package com.pmu.betengine.model;
+
+// import com.fasterxml.jackson.annotation.JsonFormat;
+// import com.pmu.betengine.model.statut.StatutParis;
+// import com.pmu.betengine.model.type.TypeFormule;
+// import com.pmu.betengine.model.type.TypeMulti;
+// import com.pmu.betengine.model.type.TypePari;
+// import jakarta.persistence.*;
+// import jakarta.validation.constraints.Pattern;
+// import lombok.AllArgsConstructor;
+// import lombok.Builder;
+// import lombok.Data;
+// import lombok.NoArgsConstructor;
+
+// import java.time.LocalDateTime;
+// import java.util.List;
+
+
+// @Entity
+// @Data
+// @Builder
+// @NoArgsConstructor
+// @AllArgsConstructor
+// @Table(name = "pari")
+// public class Pari{
+//     @Id
+//     @GeneratedValue(strategy = GenerationType.IDENTITY)
+//     private Long id;
+
+//     @Column(nullable = false)
+//     private String numeroTicket;
+
+//     @Column(name = "type_pari")
+//     private TypePari typePari;
+
+//     @Column(name = "type_formule")
+//     private TypeFormule typeFormule; // GAGNANT ou PLACE
+//     private double mise = 500.0;
+//     @Pattern(regexp = "^\\d{2}/\\d{2}/\\d{4}$", message = "La date doit être au format dd/MM/yyyy HH:mm:ss")
+//     @JsonFormat(pattern = "dd/MM/yyyy HH:mm:ss", shape = JsonFormat.Shape.STRING)
+//     private LocalDateTime datePari;
+
+//     private boolean estPaye;
+//     private boolean estRembourse;
+
+//     @ManyToOne(cascade = CascadeType.ALL)
+//     @JoinColumn(name = "course_id")
+//     private Course course;
+//     @Column(name = "parieur_id")
+//     private String idParieur;
+//     private String nomParieur;
+//     private StatutParis statut;
+//     private Double gain;
+
+//     ///////////////////Cheval////
+//     @ManyToOne(cascade = CascadeType.ALL)
+//     @JoinColumn(name = "cheval_id")
+//     private Cheval cheval;
+
+//     @ManyToOne(cascade = CascadeType.ALL)
+//     @JoinColumn(name = "cheval1_id")
+//     private Cheval cheval1;
+
+//     @ManyToOne(cascade = CascadeType.ALL)
+//     @JoinColumn(name = "cheval2_id")
+//     private Cheval cheval2;
+
+//     @ManyToOne(cascade = CascadeType.ALL)
+//     @JoinColumn(name = "cheval3_id")
+//     private Cheval cheval3;
+
+//     @ManyToOne(cascade = CascadeType.ALL)
+//     private Cheval premier;
+
+//     @ManyToOne(cascade = CascadeType.ALL)
+//     private Cheval deuxieme;
+
+//     @ManyToOne(cascade = CascadeType.ALL)
+//     private Cheval troisieme;
+
+//     // TRIPLET
+//     @ElementCollection
+//     @CollectionTable(name = "pari_chevaux_ordre", joinColumns = @JoinColumn(name = "pari_id"))
+//     @Column(name = "cheval_id")
+//     @OrderColumn(name = "position")
+//     private List<Integer> chevauxOrdre;
+
+//     // QUATRO, QUARTE PLUS, MULTI,
+//     @ManyToMany(fetch = FetchType.LAZY,cascade = CascadeType.ALL)
+//     @JoinTable(name = "pari_chevaux",
+//             joinColumns = @JoinColumn(name = "pari_id"),
+//             inverseJoinColumns = @JoinColumn(name = "cheval_id"))
+//     private List<Cheval> chevauxSelectionnes;
+
+//     @ElementCollection
+//     private List<Integer> ordrePredit;
+//     private Boolean validationOrdreExact;
+
+//     // MULTI
+//     @Enumerated(EnumType.STRING)
+//     private TypeMulti typeMulti;
+
+
+//     public boolean estFormuleChamp() {
+//         return typeFormule.name().contains("CHAMP");
+//     }
+
+// }

src/main/java/com/pmu/betengine/model/Permission.java

@@ -0,0 +1,23 @@
+package com.pmu.betengine.model;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Entity
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "permissions")
+public class Permission {
+
+    @Id
+    @GeneratedValue
+    private Long id;
+
+    private String name;
+    private String description;
+}

src/main/java/com/pmu/betengine/model/Resultat.java

@@ -15,6 +15,7 @@ import java.util.List;
 @AllArgsConstructor
 @Table(name = "resultat")
 public class Resultat {
+
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
@@ -23,55 +24,37 @@ public class Resultat {
     @JoinColumn(name = "course_id")
     private Course course;
 
-    @ManyToMany
-    @CollectionTable(name = "resultat_ordre_arrivee")
+    @ElementCollection
+    @CollectionTable(
+        name = "resultat_ordre_arrivee",
+        joinColumns = @JoinColumn(name = "resultat_id")
+    )
     @OrderColumn(name = "ordre_position")
-    private List<Cheval> ordreArrivee;
-
-    @ManyToMany(fetch = FetchType.LAZY)
-    @JoinTable(name = "resultat_premiers",
-            joinColumns = @JoinColumn(name = "resultat_id"),
-            inverseJoinColumns = @JoinColumn(name = "cheval_id"))
-    private List<Cheval> premiers;
-
-    @ManyToMany(fetch = FetchType.LAZY)
-    @JoinTable(name = "resultat_seconds",
-            joinColumns = @JoinColumn(name = "resultat_id"),
-            inverseJoinColumns = @JoinColumn(name = "cheval_id"))
-    private List<Cheval> seconds;
-
-    @ManyToMany(fetch = FetchType.LAZY)
-    @JoinTable(name = "resultat_troisiemes",
-            joinColumns = @JoinColumn(name = "resultat_id"),
-            inverseJoinColumns = @JoinColumn(name = "cheval_id"))
-    private List<Cheval> troisiemes;
-
-    @ManyToMany(fetch = FetchType.LAZY)
-    @JoinTable(name = "resultat_quatriemes",
-            joinColumns = @JoinColumn(name = "resultat_id"),
-            inverseJoinColumns = @JoinColumn(name = "cheval_id"))
-    private List<Cheval> quatriemes;
-
-    @ManyToMany(fetch = FetchType.LAZY)
-    @JoinTable(name = "resultat_cinquiemes",
-            joinColumns = @JoinColumn(name = "resultat_id"),
-            inverseJoinColumns = @JoinColumn(name = "cheval_id"))
-    private List<Cheval> cinquiemes;
+    @Column(name = "cheval_nom")
+    private List<String> ordreArrivee;
 
     @ElementCollection
-    private List<Long> chevauxDeadHeat;
+    @CollectionTable(
+        name = "resultat_chevaux_deadheat",
+        joinColumns = @JoinColumn(name = "resultat_id")
+    )
+    @Column(name = "cheval_nom")
+    private List<String> chevauxDeadHeat;
 
     private boolean aDeadHeat;
 
-
     @Column(name = "total_mises")
     private double totalMises;
+
     @Column(name = "masse_apartager")
     private double masseAPartager;
+
     @Column(name = "prelevements_legaux")
     private double prelevementsLegaux;
+
     @Column(name = "montant_rembourse")
     private double montantRembourse;
+
     @Column(name = "montant_cagnotte")
     private double montantCagnotte;
 }

src/main/java/com/pmu/betengine/model/Reunion.java

@@ -10,7 +10,9 @@ import lombok.NoArgsConstructor;
 import org.hibernate.annotations.CreationTimestamp;
 import org.hibernate.annotations.UpdateTimestamp;
 
+import java.time.LocalDate;
 import java.time.LocalDateTime;
+import java.util.List;
 
 @Entity
 @Data
@@ -19,26 +21,31 @@ import java.time.LocalDateTime;
 @AllArgsConstructor
 @Table(name = "reunion")
 public class Reunion {
+
     @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @GeneratedValue
     private Long id;
 
-    public String code;
-    public String nom;
-    @JsonFormat(pattern = "dd/MM/yyyy", shape = JsonFormat.Shape.STRING)
-    private LocalDateTime date;
-    public int numero;
-    public StatutReunion statut;
+    private String code;
+    private String nom;
 
-    @ManyToOne(cascade = CascadeType.ALL)
-    @JoinColumn(name = "hippodrome_id")
-    public Hippodrome hippodrome;
+    private LocalDate date;
 
-    public Integer totalCourses;
-    @JsonFormat(pattern = "dd/MM/yyyy", shape = JsonFormat.Shape.STRING)
-    @CreationTimestamp
+    private Integer numero;
+
+    @Column(name = "statut", nullable = false)
+    @Builder.Default
+    private String statut = "ACTIF";
+
+    @Column(name = "hippodrome_id")
+    private Long hippodromeId;
+
+    @Column(name = "total_courses")
+    private Integer totalCourses;
+
+    @Column(name = "created_at")
     private LocalDateTime createdAt;
-    @JsonFormat(pattern = "dd/MM/yyyy", shape = JsonFormat.Shape.STRING)
-    @UpdateTimestamp
+
+    @Column(name = "updated_at")
     private LocalDateTime updatedAt;
 }

src/main/java/com/pmu/betengine/model/Role.java

@@ -0,0 +1,33 @@
+package com.pmu.betengine.model;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+@Entity
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "roles")
+public class Role {
+
+    @Id
+    @GeneratedValue
+    private Long id;
+
+    private String name;
+    private String description;
+
+    @ManyToMany
+    @JoinTable(
+            name = "role_permissions",
+            joinColumns = @JoinColumn(name = "role_id"),
+            inverseJoinColumns = @JoinColumn(name = "permission_id")
+    )
+    private List<Permission> permissions;
+}

src/main/java/com/pmu/betengine/model/SearchParam.java

@@ -0,0 +1,31 @@
+package com.pmu.betengine.model;
+
+import lombok.Data;
+
+import java.io.Serializable;
+import java.time.LocalDate;
+
+@Data
+public class SearchParam implements Serializable {
+
+    private Long id;
+
+    private LocalDate date;
+    private LocalDate startDate;
+    private LocalDate endDate;
+
+    private Long userId;
+    private Long categoryId;
+
+    private String criteria;
+    private String query;
+    private String annee;
+    private String mois;
+    private String status;
+
+    private int page = 0;
+    private int pageSize = 10;
+
+    public SearchParam() {
+    }
+}

src/main/java/com/pmu/betengine/model/TPE.java

@@ -54,6 +54,11 @@ public class TPE {
     @Column(nullable = false)
     private StatutTPE statut = StatutTPE.DISPONIBLE;
 
+    @ManyToOne
+    @JoinColumn(name = "agent_id")
+    private Agent agent;
+
+
     @Column(nullable = false)
     private boolean assigne = false;
 

src/main/java/com/pmu/betengine/model/User.java

@@ -0,0 +1,53 @@
+package com.pmu.betengine.model;
+
+import java.time.LocalDateTime;
+import java.util.UUID;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Entity
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "users")
+public class User {
+
+    @Id
+    @GeneratedValue
+    private Long id;
+
+    private String nom;
+    private String prenom;
+    private String identifiant;
+    private String password;
+    private String matriculeAgent;
+
+    @Column(name = "role_id")
+    private Long roleId;
+
+    private Boolean restrictionConnexion;
+    private Boolean restrictionAutomatique;
+
+    private Integer nombreIpAutorise;
+    private Integer nombreIpAutoAutorise;
+
+    private String statut;
+
+    @Column(name = "derniere_connexion")
+    private LocalDateTime derniereConnexion;
+
+    @Column(name = "created_at")
+    private LocalDateTime createdAt;
+
+    @Column(name = "updated_at")
+    private LocalDateTime updatedAt;
+}

src/main/java/com/pmu/betengine/model/dto/ReunionRequestDTO.java

@@ -1,13 +1,19 @@
 package com.pmu.betengine.model.dto;
 
+import com.fasterxml.jackson.annotation.JsonFormat;
 import com.pmu.betengine.model.statut.StatutReunion;
 import lombok.Data;
+import java.time.LocalDateTime; 
 
 @Data
 public class ReunionRequestDTO {
     private String code;
     private String nom;
-    private String date;
+    
+    // FIX: Changé String à LocalDateTime et ajouté le formatage
+    @JsonFormat(pattern = "dd/MM/yyyy HH:mm", shape = JsonFormat.Shape.STRING)
+    private LocalDateTime date; 
+    
     private int numero;
     private StatutReunion statut;
     private Integer totalCourses;

src/main/java/com/pmu/betengine/model/statut/StatutUser.java

@@ -0,0 +1,7 @@
+package com.pmu.betengine.model.statut;
+
+public enum StatutUser  {
+ACTIF,
+INACTIF,
+SUSPENDU
+}

src/main/java/com/pmu/betengine/model/type/TypeFormule.java

@@ -28,6 +28,4 @@ public enum TypeFormule {
     CHAMP_TOTAL_1,
     CHAMP_PARTIEL_1,
 
-
-
 }

src/main/java/com/pmu/betengine/model/type/TypePaiement.java

@@ -10,9 +10,7 @@ public enum TypePaiement {
     QUARTE_PLUS_ORDRE_INEXACT,
     BONUS_3,
     BONUS_3_BIS,
-
     MULTI_4,
-
     MULTI_5,
     MULTI_6,
     MULTI_7,

src/main/java/com/pmu/betengine/model/type/TypePari.java

@@ -1,5 +1,4 @@
 package com.pmu.betengine.model.type;
-
 public enum TypePari {
     SIMPLE,
     JUMELE_GAGNANT,
@@ -11,5 +10,11 @@ public enum TypePari {
     QUATRO,
     QUARTE_PLUS,
     MULTI,
-    QUINTE_PLUS
+    QUINTE_PLUS,
+
+    TIERCE, 
+    QUARTE, 
+    QUINTE, 
+    COUPLE_GAGNANT, 
+    COUPLE_PLACE
 }

src/main/java/com/pmu/betengine/repository/AgentFamilyMemberRepository.java

@@ -7,7 +7,6 @@ import org.springframework.stereotype.Repository;
 
 import java.time.LocalDate;
 import java.util.List;
-import java.util.Optional;
 
 @Repository
 public interface AgentFamilyMemberRepository extends JpaRepository<AgentFamilyMember, Long> {

src/main/java/com/pmu/betengine/repository/AgentLimitRepository.java

@@ -0,0 +1,21 @@
+package com.pmu.betengine.repository;
+
+import com.pmu.betengine.model.AgentLimit;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+
+@Repository
+public interface AgentLimitRepository extends JpaRepository<AgentLimit, Long> {
+
+    Optional<AgentLimit> findByCode(String code);
+
+    List<AgentLimit> findByActif(boolean actif);
+
+    boolean existsByCode(String code);
+
+    List<AgentLimit> findByNomContainingIgnoreCase(String nom);
+
+}

src/main/java/com/pmu/betengine/repository/AgentRepository.java

@@ -0,0 +1,26 @@
+package com.pmu.betengine.repository;
+
+import com.pmu.betengine.model.Agent;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+
+@Repository
+public interface AgentRepository extends JpaRepository<Agent, Long> {
+
+    Optional<Agent> findByCode(String code);
+
+    Optional<Agent> findByPin(String pin);
+
+    boolean existsByCode(String code);
+
+    List<Agent> findByStatut(String statut);
+
+    List<Agent> findByVille(String ville);
+
+    List<Agent> findByProfile(String profile);
+
+    List<Agent> findByNomContainingIgnoreCaseOrPrenomContainingIgnoreCase(String nom, String prenom);
+}

src/main/java/com/pmu/betengine/repository/ChevalRepository.java

@@ -9,7 +9,11 @@ import java.util.Optional;
 
 @Repository
 public interface ChevalRepository extends JpaRepository<Cheval, Long> {
-    //List<Cheval> findByCourseId(Long courseId);
+
     List<Cheval> findByNomEcurie(String nomEcurie);
+
     Optional<Cheval> getChevalByNumero(int numero);
+
+    // Placeholder for future relation with Course
+    // List<Cheval> findByCourseId(Long courseId);
 }

src/main/java/com/pmu/betengine/repository/CourseReportDetailRowRepository.java

@@ -0,0 +1,23 @@
+package com.pmu.betengine.repository;
+
+import com.pmu.betengine.model.CourseReportDetailRow;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface CourseReportDetailRowRepository extends JpaRepository<CourseReportDetailRow, Long> {
+
+    List<CourseReportDetailRow> findByDetailId(Long detailId);
+
+    List<CourseReportDetailRow> findByTypeGain(String typeGain);
+
+    List<CourseReportDetailRow> findByTypeJeu(String typeJeu);
+
+    List<CourseReportDetailRow> findByStatut(String statut);
+
+    List<CourseReportDetailRow> findByDistributed(Boolean distributed);
+
+    List<CourseReportDetailRow> findByExterne(Boolean externe);
+}

src/main/java/com/pmu/betengine/repository/CourseRepository.java

@@ -2,11 +2,39 @@ package com.pmu.betengine.repository;
 
 import com.pmu.betengine.model.Course;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
 import org.springframework.stereotype.Repository;
 
+import java.time.LocalDateTime;
 import java.util.List;
+import java.util.UUID;
 
 @Repository
 public interface CourseRepository extends JpaRepository<Course, Long> {
+
+    // Find courses by "estTerminee" boolean (if you still track this)
     List<Course> findByEstTerminee(boolean estTerminee);
+
+    // Search courses by name
+    List<Course> findByNomContainingIgnoreCase(String nom);
+
+    List<Course> findByReunionId(Long reunionId);
+
+    List<Course> findByReunionIdAndStatut(Long reunionId, String statut);
+
+    @Query("SELECT c FROM Course c " +
+    "WHERE c.dateDebutParis >= :startOfDay " +
+    "AND c.dateDebutParis < :endOfDay " +
+    "AND c.dateFinParis >= :now " +
+    "AND c.statut = 'VALIDATED'")
+List<Course> findByDateDebutParisAndNotFinished(
+     @Param("startOfDay") LocalDateTime startOfDay,
+     @Param("endOfDay") LocalDateTime endOfDay,
+     @Param("now") LocalDateTime now
+);
+
+
+    
+
 }

src/main/java/com/pmu/betengine/repository/HippodromeRepository.java

@@ -2,27 +2,22 @@ package com.pmu.betengine.repository;
 
 import com.pmu.betengine.model.Hippodrome;
 import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.data.jpa.repository.Query;
 import org.springframework.stereotype.Repository;
 
 import java.util.List;
-import java.util.Optional;
 
 @Repository
 public interface HippodromeRepository extends JpaRepository<Hippodrome, Long> {
     
-    Optional<Hippodrome> findByNom(String nom);
-
-    List<Hippodrome> findByVille(String ville);
-
-    List<Hippodrome> findByPays(String pays);
-
-    List<Hippodrome> findByActif(boolean actif);
-
     boolean existsByNom(String nom);
+    List<Hippodrome> findByVille(String ville);
+    List<Hippodrome> findByPays(String pays);
+    List<Hippodrome> findByActif(boolean actif);
+    List<Hippodrome> findByNomContainingIgnoreCase(String nom);
 
-    @Query("SELECT h FROM Hippodrome h WHERE h.nom LIKE %:nom%")
-    List<Hippodrome> findByNomContaining(String nom);
 
-    Optional<Hippodrome> findByReunionId(Long reunionId);
+    List<Hippodrome> findByActifTrue();
+    List<Hippodrome> findByVilleAndActifTrue(String ville);
+    List<Hippodrome> findByPaysAndActifTrue(String pays);
+    List<Hippodrome> findByNomContainingIgnoreCaseAndActifTrue(String nom);
 }

src/main/java/com/pmu/betengine/repository/MiseRepository.java

@@ -0,0 +1,7 @@
+package com.pmu.betengine.repository;
+
+import com.pmu.betengine.model.Mise;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface MiseRepository extends JpaRepository<Mise, Long> {
+}

src/main/java/com/pmu/betengine/repository/NonPartantRepository.java

@@ -0,0 +1,17 @@
+package com.pmu.betengine.repository;
+
+import com.pmu.betengine.model.NonPartant;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface NonPartantRepository extends JpaRepository<NonPartant, Long> {
+
+    List<NonPartant> findByCourseId(Long courseId);
+
+    List<NonPartant> findByNomChevalContainingIgnoreCase(String nomCheval);
+
+    List<NonPartant> findByMotifContainingIgnoreCase(String motif);
+}

src/main/java/com/pmu/betengine/repository/PariRepository.java

@@ -3,17 +3,37 @@ package com.pmu.betengine.repository;
 import com.pmu.betengine.model.Pari;
 import com.pmu.betengine.model.type.TypeFormule;
 import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
 
 import java.util.List;
 import java.util.Optional;
+import java.util.UUID;
 
-@Repository
 public interface PariRepository extends JpaRepository<Pari, Long> {
-    List<Pari> findByCourseId(Long courseId);
-    List<Pari> findByCourseIdAndTypeFormule(Long courseId, TypeFormule typeFormule);
-    List<Pari> findByChevalId(Long chevalId);
+
     Optional<Pari> findByNumeroTicket(String ticket);
 
-   // List<Pari> findByChevalIdAndTypePari(Long chevalId, String typePari);
+    List<Pari> findByCourseId(Long courseId);
+
+    List<Pari> findByCourseIdAndTypeFormule(Long courseId, TypeFormule typeFormule);
 }
+
+
+// package com.pmu.betengine.repository;
+
+// import com.pmu.betengine.model.Pari;
+// import com.pmu.betengine.model.type.TypeFormule;
+// import org.springframework.data.jpa.repository.JpaRepository;
+// import org.springframework.stereotype.Repository;
+
+// import java.util.List;
+// import java.util.Optional;
+
+// @Repository
+// public interface PariRepository extends JpaRepository<Pari, Long> {
+//     List<Pari> findByCourseId(Long courseId);
+//     List<Pari> findByCourseIdAndTypeFormule(Long courseId, TypeFormule typeFormule);
+//     List<Pari> findByChevalId(Long chevalId);
+//     Optional<Pari> findByNumeroTicket(String ticket);
+
+//    // List<Pari> findByChevalIdAndTypePari(Long chevalId, String typePari);
+// }

src/main/java/com/pmu/betengine/repository/PermissionRepository.java

@@ -0,0 +1,7 @@
+package com.pmu.betengine.repository;
+
+import com.pmu.betengine.model.Permission;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface PermissionRepository extends JpaRepository<Permission, Long> {
+}

src/main/java/com/pmu/betengine/repository/ResultatRepository.java

@@ -2,24 +2,54 @@ package com.pmu.betengine.repository;
 
 import com.pmu.betengine.model.Resultat;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Modifying;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
 import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
 
+import java.time.LocalDateTime;
+import java.util.List;
 import java.util.Optional;
 
 @Repository
 public interface ResultatRepository extends JpaRepository<Resultat, Long> {
     Optional<Resultat> findByCourseId(Long courseId);
-
     @Query("SELECT r FROM Resultat r WHERE r.course.id = :courseId")
     Optional<Resultat> findByCourse(@Param("courseId") Long courseId);
-
-    @Query("SELECT CASE WHEN COUNT(r) > 0 THEN true ELSE false END FROM Resultat r WHERE r.course.id = :courseId")
-    boolean existsByCourseId(@Param("courseId") Long courseId);
-
+    boolean existsByCourseId(Long courseId);
+    @Modifying
+    @Transactional
     @Query("DELETE FROM Resultat r WHERE r.course.id = :courseId")
     void deleteByCourseId(@Param("courseId") Long courseId);
-
+    @Query("SELECT r FROM Resultat r WHERE r.course.dateDebutParis >= :start AND r.course.dateDebutParis < :end")
+    List<Resultat> findByCourseDate(@Param("start") LocalDateTime start, @Param("end") LocalDateTime end);
 
 }
+
+
+// package com.pmu.betengine.repository;
+
+// import com.pmu.betengine.model.Resultat;
+// import org.springframework.data.jpa.repository.JpaRepository;
+// import org.springframework.data.jpa.repository.Query;
+// import org.springframework.data.repository.query.Param;
+// import org.springframework.stereotype.Repository;
+
+// import java.util.Optional;
+
+// @Repository
+// public interface ResultatRepository extends JpaRepository<Resultat, Long> {
+//     Optional<Resultat> findByCourseId(Long courseId);
+
+//     @Query("SELECT r FROM Resultat r WHERE r.course.id = :courseId")
+//     Optional<Resultat> findByCourse(@Param("courseId") Long courseId);
+
+//     @Query("SELECT CASE WHEN COUNT(r) > 0 THEN true ELSE false END FROM Resultat r WHERE r.course.id = :courseId")
+//     boolean existsByCourseId(@Param("courseId") Long courseId);
+
+//     @Query("DELETE FROM Resultat r WHERE r.course.id = :courseId")
+//     void deleteByCourseId(@Param("courseId") Long courseId);
+
+
+// }

src/main/java/com/pmu/betengine/repository/ReunionRepository.java

@@ -8,6 +8,8 @@ import java.util.Optional;
 
 @Repository
 public interface ReunionRepository extends JpaRepository<Reunion, Long> {
+
     Optional<Reunion> findByCode(String code);
+
     boolean existsByCode(String code);
 }

src/main/java/com/pmu/betengine/repository/RoleRepository.java

@@ -0,0 +1,7 @@
+package com.pmu.betengine.repository;
+
+import com.pmu.betengine.model.Role;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface RoleRepository extends JpaRepository<Role, Long> {
+}

src/main/java/com/pmu/betengine/repository/UserRepository.java

@@ -0,0 +1,20 @@
+package com.pmu.betengine.repository;
+
+import com.pmu.betengine.model.User;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.Optional;
+
+@Repository
+public interface UserRepository extends JpaRepository<User, Long> {
+
+    // Récupérer un utilisateur par identifiant (connexion)
+    Optional<User> findByIdentifiant(String identifiant);
+
+    // Vérifier si un identifiant existe déjà (création)
+    boolean existsByIdentifiant(String identifiant);
+
+    // Vérifier si un matricule existe déjà (création)
+    boolean existsByMatriculeAgent(String matriculeAgent);
+}

src/main/java/com/pmu/betengine/service/AgentFamilyMemberService.java

@@ -1,121 +1,84 @@
 package com.pmu.betengine.service;
 
 import com.pmu.betengine.model.AgentFamilyMember;
-import com.pmu.betengine.model.dto.AgentFamilyMemberDTO;
-import com.pmu.betengine.model.dto.AgentFamilyMemberRequestDTO;
 import com.pmu.betengine.repository.AgentFamilyMemberRepository;
-import org.modelmapper.ModelMapper;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.util.List;
-import java.util.stream.Collectors;
 
 @Service
 @Transactional
 public class AgentFamilyMemberService {
 
-    private final AgentFamilyMemberRepository agentFamilyMemberRepository;
-    private final ModelMapper modelMapper;
+    private final AgentFamilyMemberRepository repository;
 
-    public AgentFamilyMemberService(AgentFamilyMemberRepository agentFamilyMemberRepository,
-                                    ModelMapper modelMapper) {
-        this.agentFamilyMemberRepository = agentFamilyMemberRepository;
-        this.modelMapper = modelMapper;
+    public AgentFamilyMemberService(AgentFamilyMemberRepository repository) {
+        this.repository = repository;
     }
 
-    public List<AgentFamilyMemberDTO> getAllFamilyMembers() {
-        return agentFamilyMemberRepository.findAllOrderByNom()
-                .stream()
-                .map(this::convertToDTO)
-                .collect(Collectors.toList());
+    // Create
+    public AgentFamilyMember createFamilyMember(AgentFamilyMember member) {
+        if (repository.existsByNomAndDateNaissance(member.getNom(), member.getDateNaissance())) {
+            throw new RuntimeException("Un membre avec ce nom et cette date de naissance existe déjà");
+        }
+        return repository.save(member);
     }
 
-    public AgentFamilyMemberDTO getFamilyMemberById(Long id) {
-        AgentFamilyMember member = agentFamilyMemberRepository.findById(id)
+    // Get all
+    public List<AgentFamilyMember> getAllFamilyMembers() {
+        return repository.findAllOrderByNom();
+    }
+
+    // Get by ID
+    public AgentFamilyMember getFamilyMemberById(Long id) {
+        return repository.findById(id)
                 .orElseThrow(() -> new RuntimeException("Membre de famille non trouvé avec l'id: " + id));
-        return convertToDTO(member);
     }
 
-    public AgentFamilyMemberDTO createFamilyMember(AgentFamilyMemberRequestDTO requestDTO) {
-        // Vérifier si le membre existe déjà
-        if (agentFamilyMemberRepository.existsByNomAndDateNaissance(requestDTO.getNom(), requestDTO.getDateNaissance())) {
+    // Update
+    public AgentFamilyMember updateFamilyMember(Long id, AgentFamilyMember updated) {
+        AgentFamilyMember existing = getFamilyMemberById(id);
+
+        // Vérification des doublons sauf pour l'enregistrement courant
+        if ((!existing.getNom().equals(updated.getNom()) ||
+             !existing.getDateNaissance().equals(updated.getDateNaissance())) &&
+            repository.existsByNomAndDateNaissance(updated.getNom(), updated.getDateNaissance())) {
             throw new RuntimeException("Un membre avec ce nom et cette date de naissance existe déjà");
         }
 
-        AgentFamilyMember member = convertToEntity(requestDTO);
-        AgentFamilyMember saved = agentFamilyMemberRepository.save(member);
-        return convertToDTO(saved);
+        existing.setAgentId(updated.getAgentId());
+        existing.setNom(updated.getNom());
+        existing.setStatut(updated.getStatut());
+        existing.setDateNaissance(updated.getDateNaissance());
+        existing.setSexe(updated.getSexe());
+
+        return repository.save(existing);
     }
 
-    public AgentFamilyMemberDTO updateFamilyMember(Long id, AgentFamilyMemberRequestDTO requestDTO) {
-        AgentFamilyMember existing = agentFamilyMemberRepository.findById(id)
-                .orElseThrow(() -> new RuntimeException("Membre de famille non trouvé avec l'id: " + id));
-
-        // Vérifier les doublons (sauf pour l'enregistrement actuel)
-        if (!existing.getNom().equals(requestDTO.getNom()) ||
-                !existing.getDateNaissance().equals(requestDTO.getDateNaissance())) {
-
-            if (agentFamilyMemberRepository.existsByNomAndDateNaissance(requestDTO.getNom(), requestDTO.getDateNaissance())) {
-                throw new RuntimeException("Un membre avec ce nom et cette date de naissance existe déjà");
-            }
-        }
-
-        // Mise à jour des champs
-        modelMapper.map(requestDTO, existing);
-
-        return convertToDTO(agentFamilyMemberRepository.save(existing));
-    }
-
-    public void deleteFamilyMember(Long id) {
-        if (!agentFamilyMemberRepository.existsById(id)) {
+    // Delete
+    public String deleteFamilyMember(Long id) {
+        if (!repository.existsById(id)) {
             throw new RuntimeException("Membre de famille non trouvé avec l'id: " + id);
         }
-        agentFamilyMemberRepository.deleteById(id);
+        repository.deleteById(id);
+        return "Membre de famille avec l'ID " + id + " supprimé avec succès.";
     }
 
-    public List<AgentFamilyMemberDTO> getFamilyMembersByStatut(String statut) {
-        return agentFamilyMemberRepository.findByStatut(statut)
-                .stream()
-                .map(this::convertToDTO)
-                .collect(Collectors.toList());
+    // Search / Filters
+    public List<AgentFamilyMember> getFamilyMembersByStatut(String statut) {
+        return repository.findByStatut(statut);
     }
 
-    public List<AgentFamilyMemberDTO> getFamilyMembersBySexe(String sexe) {
-        return agentFamilyMemberRepository.findBySexe(sexe)
-                .stream()
-                .map(this::convertToDTO)
-                .collect(Collectors.toList());
+    public List<AgentFamilyMember> getFamilyMembersBySexe(String sexe) {
+        return repository.findBySexe(sexe);
     }
 
-    public List<AgentFamilyMemberDTO> searchFamilyMembers(String keyword) {
-        return agentFamilyMemberRepository.searchByKeyword(keyword)
-                .stream()
-                .map(this::convertToDTO)
-                .collect(Collectors.toList());
+    public List<AgentFamilyMember> searchFamilyMembers(String keyword) {
+        return repository.searchByKeyword(keyword);
     }
 
-    public List<AgentFamilyMemberDTO> getFamilyMembersByNom(String nom) {
-        return agentFamilyMemberRepository.findByNomContainingIgnoreCase(nom)
-                .stream()
-                .map(this::convertToDTO)
-                .collect(Collectors.toList());
-    }
-
-    private AgentFamilyMemberDTO convertToDTO(AgentFamilyMember member) {
-        AgentFamilyMemberDTO dto = modelMapper.map(member, AgentFamilyMemberDTO.class);
-
-        // Ajouter le libellé du sexe
-        if ("M".equals(member.getSexe())) {
-            dto.setSexeLibelle("Masculin");
-        } else if ("F".equals(member.getSexe())) {
-            dto.setSexeLibelle("Féminin");
-        }
-
-        return dto;
-    }
-
-    private AgentFamilyMember convertToEntity(AgentFamilyMemberRequestDTO dto) {
-        return modelMapper.map(dto, AgentFamilyMember.class);
+    public List<AgentFamilyMember> getFamilyMembersByNom(String nom) {
+        return repository.findByNomContainingIgnoreCase(nom);
     }
 }

src/main/java/com/pmu/betengine/service/AgentLimitService.java

@@ -0,0 +1,82 @@
+package com.pmu.betengine.service;
+
+import com.pmu.betengine.model.AgentLimit;
+import com.pmu.betengine.repository.AgentLimitRepository;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+@Service
+@Transactional
+public class AgentLimitService {
+
+    private final AgentLimitRepository repository;
+
+    public AgentLimitService(AgentLimitRepository repository) {
+        this.repository = repository;
+    }
+
+    // Create
+    public AgentLimit createAgentLimit(AgentLimit agentLimit) {
+        if (repository.existsByCode(agentLimit.getCode())) {
+            throw new RuntimeException("Un AgentLimit avec ce code existe déjà: " + agentLimit.getCode());
+        }
+        agentLimit.actif=true;
+        return repository.save(agentLimit);
+    }
+
+    // Get all
+    public List<AgentLimit> getAllAgentLimits() {
+        return repository.findAll();
+    }
+
+    // Get by ID
+    public AgentLimit getAgentLimitById(Long id) {
+        return repository.findById(id)
+                .orElseThrow(() -> new RuntimeException("AgentLimit non trouvé avec l'id: " + id));
+    }
+
+    // Update
+    public AgentLimit updateAgentLimit(Long id, AgentLimit updated) {
+        AgentLimit existing = getAgentLimitById(id);
+
+        if (!existing.getCode().equals(updated.getCode()) && repository.existsByCode(updated.getCode())) {
+            throw new RuntimeException("Un AgentLimit avec ce code existe déjà: " + updated.getCode());
+        }
+
+        existing.setCode(updated.getCode());
+        existing.setConfigCode(updated.getConfigCode());
+        existing.setNom(updated.getNom());
+        existing.setDefault(updated.isDefault());
+        existing.setActif(updated.isActif());
+        existing.setBetMin(updated.getBetMin());
+        existing.setBetMax(updated.getBetMax());
+        existing.setMaxBet(updated.getMaxBet());
+        existing.setMaxDisburseBet(updated.getMaxDisburseBet());
+        existing.setAirtimeMin(updated.getAirtimeMin());
+        existing.setAirtimeMax(updated.getAirtimeMax());
+        existing.setCreatedBy(updated.getCreatedBy());
+
+        return repository.save(existing);
+    }
+
+    // Delete
+    public String deleteAgentLimit(Long id) {
+        if (!repository.existsById(id)) {
+            throw new RuntimeException("AgentLimit non trouvé avec l'id: " + id);
+        }
+        repository.deleteById(id);
+        return "AgentLimit avec l'ID " + id + " supprimé avec succès.";
+    }
+
+    // Search / Filters
+    public List<AgentLimit> getAgentLimitsByActif(boolean actif) {
+        return repository.findByActif(actif);
+    }
+
+    public List<AgentLimit> searchAgentLimitsByNom(String nom) {
+        return repository.findByNomContainingIgnoreCase(nom);
+    }
+
+}

src/main/java/com/pmu/betengine/service/AgentService.java

@@ -0,0 +1,149 @@
+package com.pmu.betengine.service;
+
+import com.pmu.betengine.model.Agent;
+import com.pmu.betengine.model.statut.StatutAgent;
+import com.pmu.betengine.repository.AgentRepository;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+@Service
+public class AgentService {
+
+    private final AgentRepository agentRepository;
+
+    public AgentService(AgentRepository agentRepository) {
+        this.agentRepository = agentRepository;
+    }
+
+    // Create
+    public Agent createAgent(Agent agent) {
+        if (agentRepository.existsByCode(agent.getCode())) {
+            throw new RuntimeException("Un agent avec ce code existe déjà: " + agent.getCode());
+        }
+        agent.setCreatedAt(LocalDateTime.now());
+        return agentRepository.save(agent);
+    }
+
+    // Get all
+    public List<Agent> getAllAgents() {
+        // return agentRepository.findAll();
+        return agentRepository.findByStatut(StatutAgent.ACTIF.name());
+    }
+
+    // Get by ID
+    public Agent getAgentById(Long id) {
+        return agentRepository.findById(id)
+                .orElseThrow(() -> new RuntimeException("Agent non trouvé avec l'id: " + id));
+    }
+
+    // Update
+    public Agent updateAgent(Long id, Agent updatedAgent) {
+        Agent existing = getAgentById(id);
+
+        existing.setCode(updatedAgent.getCode());
+        existing.setProfile(updatedAgent.getProfile());
+        existing.setPrincipalCode(updatedAgent.getPrincipalCode());
+        existing.setCaisseProfile(updatedAgent.getCaisseProfile());
+        existing.setStatut(updatedAgent.getStatut());
+        existing.setZone(updatedAgent.getZone());
+        existing.setKiosk(updatedAgent.getKiosk());
+        existing.setFonction(updatedAgent.getFonction());
+        existing.setDateEmbauche(updatedAgent.getDateEmbauche());
+        existing.setNom(updatedAgent.getNom());
+        existing.setPrenom(updatedAgent.getPrenom());
+        existing.setAutresNoms(updatedAgent.getAutresNoms());
+        existing.setDateNaissance(updatedAgent.getDateNaissance());
+        existing.setLieuNaissance(updatedAgent.getLieuNaissance());
+        existing.setVille(updatedAgent.getVille());
+        existing.setAdresse(updatedAgent.getAdresse());
+        existing.setAutoriserAides(updatedAgent.getAutoriserAides());
+        existing.setPhone(updatedAgent.getPhone());
+        existing.setPin(updatedAgent.getPin());
+        existing.setLimiteInferieure(updatedAgent.getLimiteInferieure());
+        existing.setLimiteSuperieure(updatedAgent.getLimiteSuperieure());
+        existing.setLimiteParTransaction(updatedAgent.getLimiteParTransaction());
+        existing.setLimiteMinAirtime(updatedAgent.getLimiteMinAirtime());
+        existing.setLimiteMaxAirtime(updatedAgent.getLimiteMaxAirtime());
+        existing.setMaxPeripheriques(updatedAgent.getMaxPeripheriques());
+        existing.setLimitId(updatedAgent.getLimitId());
+        existing.setNationalite(updatedAgent.getNationalite());
+        existing.setCni(updatedAgent.getCni());
+        existing.setCniDelivreeLe(updatedAgent.getCniDelivreeLe());
+        existing.setCniDelivreeA(updatedAgent.getCniDelivreeA());
+        existing.setResidence(updatedAgent.getResidence());
+        existing.setAutreAdresse1(updatedAgent.getAutreAdresse1());
+        existing.setStatutMarital(updatedAgent.getStatutMarital());
+        existing.setEpoux(updatedAgent.getEpoux());
+        existing.setAutreTelephone(updatedAgent.getAutreTelephone());
+        existing.setUpdatedAt(LocalDateTime.now());
+
+        return agentRepository.save(existing);
+    }
+
+    // Delete
+ public String deleteAgent(Long id) {
+    Agent agent = getAgentById(id);
+
+    if (agent.getStatut() == StatutAgent.INACTIF) {
+        throw new RuntimeException("Cet agent est déjà désactivé.");
+    }
+
+    agent.setStatut(StatutAgent.INACTIF);
+    agent.setUpdatedAt(LocalDateTime.now());
+
+    agentRepository.save(agent);
+
+    return "Agent désactivé avec succès (soft delete).";
+}
+
+public Agent restoreAgent(Long id) {
+    Agent agent = getAgentById(id);
+
+    if (agent.getStatut() == StatutAgent.ACTIF) {
+        throw new RuntimeException("Cet agent est déjà actif.");
+    }
+
+    agent.setStatut(StatutAgent.ACTIF);
+    agent.setUpdatedAt(LocalDateTime.now());
+
+    return agentRepository.save(agent);
+}
+
+
+    // Find by code
+    public Agent getAgentByCode(String code) {
+        return agentRepository.findByCode(code)
+                .orElseThrow(() -> new RuntimeException("Agent non trouvé avec le code: " + code));
+    }
+
+    // Find by statut
+    public List<Agent> getAgentsByStatut(String statut) {
+        return agentRepository.findByStatut(statut);
+    }
+
+    public Agent toggleAgentStatus(Long id) {
+        Agent agent = getAgentById(id);
+    
+        if (agent.getStatut() == StatutAgent.ACTIF) {
+            agent.setStatut(StatutAgent.INACTIF);
+        } else {
+            agent.setStatut(StatutAgent.ACTIF);
+        }
+    
+        agent.setUpdatedAt(LocalDateTime.now());
+        return agentRepository.save(agent);
+    }
+
+    
+    // Find by ville
+    public List<Agent> getAgentsByVille(String ville) {
+        return agentRepository.findByVille(ville);
+    }
+
+    // Search by name
+    public List<Agent> searchAgentsByName(String query) {
+        return agentRepository.findByNomContainingIgnoreCaseOrPrenomContainingIgnoreCase(query, query);
+    }
+}

src/main/java/com/pmu/betengine/service/AuthService.java

@@ -0,0 +1,54 @@
+package com.pmu.betengine.service;
+
+import com.pmu.betengine.model.AuthRequest;
+import com.pmu.betengine.model.AuthRequestAgent;
+import com.pmu.betengine.model.User;
+import com.pmu.betengine.model.Agent;
+import com.pmu.betengine.repository.UserRepository;
+import com.pmu.betengine.repository.AgentRepository;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDateTime;
+
+@Service
+public class AuthService {
+
+    private final UserRepository userRepository;
+    private final AgentRepository agentRepository;
+
+    @Autowired
+    private PasswordEncoder passwordEncoder;
+
+    public AuthService(UserRepository userRepository, AgentRepository agentRepository) {
+        this.userRepository = userRepository;
+        this.agentRepository = agentRepository;
+    }
+
+    // USER LOGIN
+    public User login(AuthRequest request) {
+        User user = userRepository.findByIdentifiant(request.getIdentifiant())
+                .orElseThrow(() -> new RuntimeException("User not found"));
+
+        if (!passwordEncoder.matches(request.getPassword(), user.getPassword())) {
+            throw new RuntimeException("Invalid credentials");
+        }
+
+        user.setDerniereConnexion(LocalDateTime.now());
+        return userRepository.save(user);
+    }
+
+    // AGENT ALR LOGIN  
+    public Agent loginAgentWithPin(AuthRequestAgent request) {
+        Agent agent = agentRepository.findByPin(request.getPin())
+                .orElseThrow(() -> new RuntimeException("Invalid PIN"));
+    
+        agent.setDerniereConnexion(LocalDateTime.now());
+        agentRepository.save(agent);
+    
+        return agent;
+    }
+    
+}

src/main/java/com/pmu/betengine/service/ChevalService.java

@@ -2,26 +2,47 @@ package com.pmu.betengine.service;
 
 import com.pmu.betengine.model.Cheval;
 import com.pmu.betengine.repository.ChevalRepository;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 
 import java.util.List;
 
 @Service
+@Transactional
 public class ChevalService {
 
-    @Autowired
-    private ChevalRepository chevalRepository;
+    private final ChevalRepository chevalRepository;
+
+    public ChevalService(ChevalRepository chevalRepository) {
+        this.chevalRepository = chevalRepository;
+    }
 
     public Cheval ajouterCheval(Cheval cheval) {
         return chevalRepository.save(cheval);
     }
 
     public List<Cheval> obtenirChevauxParCourse(Long courseId) {
+        // Replace with actual repository method when Course relation exists
         return null; // chevalRepository.findByCourseId(courseId);
     }
 
     public List<Cheval> obtenirChevauxParEcurie(String nomEcurie) {
         return chevalRepository.findByNomEcurie(nomEcurie);
     }
+
+    public Cheval obtenirChevalParNumero(int numero) {
+        return chevalRepository.getChevalByNumero(numero)
+                .orElseThrow(() -> new RuntimeException("Cheval non trouvé avec le numéro: " + numero));
+    }
+
+    public List<Cheval> obtenirTousLesChevaux() {
+        return chevalRepository.findAll();
+    }
+
+    public void supprimerCheval(Long id) {
+        if (!chevalRepository.existsById(id)) {
+            throw new RuntimeException("Cheval non trouvé avec l'id: " + id);
+        }
+        chevalRepository.deleteById(id);
+    }
 }

src/main/java/com/pmu/betengine/service/CourseReportDetailRowService.java

@@ -0,0 +1,78 @@
+package com.pmu.betengine.service;
+
+import com.pmu.betengine.model.CourseReportDetailRow;
+import com.pmu.betengine.repository.CourseReportDetailRowRepository;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+@Service
+@Transactional
+public class CourseReportDetailRowService {
+
+    private final CourseReportDetailRowRepository repository;
+
+    public CourseReportDetailRowService(CourseReportDetailRowRepository repository) {
+        this.repository = repository;
+    }
+
+    public CourseReportDetailRow create(CourseReportDetailRow row) {
+        return repository.save(row);
+    }
+
+    public CourseReportDetailRow getById(Long id) {
+        return repository.findById(id)
+                .orElseThrow(() -> new RuntimeException("CourseReportDetailRow non trouvé avec l'id: " + id));
+    }
+
+    public List<CourseReportDetailRow> getAll() {
+        return repository.findAll();
+    }
+
+    public CourseReportDetailRow update(Long id, CourseReportDetailRow row) {
+        CourseReportDetailRow existing = getById(id);
+
+        existing.setDetailId(row.getDetailId());
+        existing.setTypeGain(row.getTypeGain());
+        existing.setTypeJeu(row.getTypeJeu());
+        existing.setMontant(row.getMontant());
+        existing.setNombre(row.getNombre());
+        existing.setStatut(row.getStatut());
+        existing.setDistributed(row.getDistributed());
+        existing.setExterne(row.getExterne());
+
+        return repository.save(existing);
+    }
+
+    public void delete(Long id) {
+        if (!repository.existsById(id)) {
+            throw new RuntimeException("CourseReportDetailRow non trouvé avec l'id: " + id);
+        }
+        repository.deleteById(id);
+    }
+
+    public List<CourseReportDetailRow> getByDetailId(Long detailId) {
+        return repository.findByDetailId(detailId);
+    }
+
+    public List<CourseReportDetailRow> getByTypeGain(String typeGain) {
+        return repository.findByTypeGain(typeGain);
+    }
+
+    public List<CourseReportDetailRow> getByTypeJeu(String typeJeu) {
+        return repository.findByTypeJeu(typeJeu);
+    }
+
+    public List<CourseReportDetailRow> getByStatut(String statut) {
+        return repository.findByStatut(statut);
+    }
+
+    public List<CourseReportDetailRow> getByDistributed(Boolean distributed) {
+        return repository.findByDistributed(distributed);
+    }
+
+    public List<CourseReportDetailRow> getByExterne(Boolean externe) {
+        return repository.findByExterne(externe);
+    }
+}

src/main/java/com/pmu/betengine/service/CourseService.java

@@ -1,37 +1,158 @@
 package com.pmu.betengine.service;
 
-
 import com.pmu.betengine.model.Course;
+import com.pmu.betengine.model.NonPartant;
+import com.pmu.betengine.model.SearchParam;
 import com.pmu.betengine.repository.CourseRepository;
+import com.pmu.betengine.repository.ReunionRepository;
+
+import jakarta.transaction.Transactional;
+
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.PageRequest;
 import org.springframework.stereotype.Service;
 
+import java.time.LocalDate;
+import java.time.LocalDateTime;
 import java.util.List;
-
+import java.util.UUID;
 
 @Service
 public class CourseService {
 
     @Autowired
     private CourseRepository courseRepository;
+      @Autowired
+    private ReunionRepository reunionRepository;
+
+  // Create
+  public Course createCourse(Course course) {
+    // Vérifie si la réunion existe
+    if (course.getReunionId() == null || 
+        !reunionRepository.existsById(course.getReunionId())) {
+        throw new IllegalArgumentException("Impossible de créer la course : réunion invalide");
+    }
+
+    LocalDateTime now = LocalDateTime.now();
+    course.setCreatedAt(now);
+    course.setUpdatedAt(now);
 
-    public Course creerCourse(Course course) {
     return courseRepository.save(course);
 }
 
-    public List<Course> obtenirToutesCourses() {
+    // Get all
+    public List<Course> getAllCourses() {
         return courseRepository.findAll();
     }
 
-    public Course obtenirCourseParId(Long id) {
-        return courseRepository.findById(id).orElse(null);
+    // Get by ID
+    public Course getCourseById(Long id) {
+        return courseRepository.findById(id)
+                .orElseThrow(() -> new RuntimeException("Course not found"));
     }
 
-    public List<Course> obtenirCoursesTerminees() {
-        return courseRepository.findByEstTerminee(true);
+    // Update
+    public Course updateCourse(Long id, Course updatedCourse) {
+        Course course = getCourseById(id);
+        course.setNom(updatedCourse.getNom());
+        course.setType(updatedCourse.getType());
+        course.setNumero(updatedCourse.getNumero());
+        course.setDateDepartCourse(updatedCourse.getDateDepartCourse());
+        course.setDateDebutParis(updatedCourse.getDateDebutParis());
+        course.setDateFinParis(updatedCourse.getDateFinParis());
+        course.setReunionId(updatedCourse.getReunionId());
+        course.setReunionCourse(updatedCourse.getReunionCourse());
+        course.setParticularite(updatedCourse.getParticularite());
+        course.setPartants(updatedCourse.getPartants());
+        course.setDistance(updatedCourse.getDistance());
+        course.setCondition(updatedCourse.getCondition());
+        course.setStatut(updatedCourse.getStatut());
+        course.setResultatStatut(updatedCourse.getResultatStatut());
+        course.setCreatedBy(updatedCourse.getCreatedBy());
+        course.setValidatedBy(updatedCourse.getValidatedBy());
+        course.setUpdatedAt(updatedCourse.getUpdatedAt());
+        return courseRepository.save(course);
     }
 
-    public List<Course> obtenirCoursesAVenir() {
-        return courseRepository.findByEstTerminee(false);
+    // Delete
+    public void deleteCourse(Long id) {
+        courseRepository.deleteById(id);
+    }
+
+    // Search by name
+    public List<Course> searchCourses(String query) {
+        return courseRepository.findByNomContainingIgnoreCase(query);
+    }
+
+    // Update statut
+    public Course updateStatut(Long id, String statut) {
+        Course course = getCourseById(id);
+        course.setStatut(statut);
+        return courseRepository.save(course);
+    }
+
+    public List<Course> getCoursesByReunionId(Long reunionId) {
+        return courseRepository.findByReunionId(reunionId);
+    }
+
+    public List<Course> getCoursesByReunionIdAndStatut(Long reunionId, String statut) {
+        return courseRepository.findByReunionIdAndStatut(reunionId, statut);
+    }
+    
+    
+    @Transactional
+    public List<String> replaceCourseNonPartants(Long courseId, List<String> newNonPartants) {
+        if (courseId == null) {
+            throw new IllegalArgumentException("L'identifiant de la course est obligatoire.");
+        }
+        Course course = courseRepository.findById(courseId)
+                .orElseThrow(() -> new RuntimeException("Aucune course trouvée avec l'ID : " + courseId));
+    
+        if (newNonPartants == null) {
+            throw new IllegalArgumentException("La liste des non-partants ne peut pas être nulle.");
+        }
+        course.setNonPartants(newNonPartants);
+        course.setUpdatedAt(LocalDateTime.now());
+        courseRepository.save(course);
+        return course.getNonPartants();
+    }
+    
+
+
+    public List<Course> search(SearchParam searchParam) {
+        System.out.println("******************** THE SEARCH PARAM " + searchParam);
+    
+        if (searchParam.getCriteria() == null) {
+            throw new IllegalArgumentException("Le paramètre 'criteria' est obligatoire et ne peut pas être null");
+        }
+    
+        try {
+            String criteria = searchParam.getCriteria();
+    
+            if (criteria.equals("1")) {
+                return courseRepository.findAll();
+            } else if(criteria.equals("2") && searchParam.getDate() != null) {
+                    LocalDate date = searchParam.getDate();
+                    LocalDateTime startOfDay = date.atStartOfDay();
+                    LocalDateTime endOfDay = startOfDay.plusDays(1);
+                    return courseRepository.findByDateDebutParisAndNotFinished(
+                            startOfDay,
+                            endOfDay,
+                            LocalDateTime.now()
+                    );
+            }
+
+    
+            // Cas par défaut
+            return courseRepository.findAll();
+    
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw new RuntimeException("Erreur lors de la recherche des courses");
         }
     }
+    
+
+
+    
+}

src/main/java/com/pmu/betengine/service/HippodromeService.java

@@ -1,77 +1,57 @@
 package com.pmu.betengine.service;
 
 import com.pmu.betengine.model.Hippodrome;
-import com.pmu.betengine.model.Reunion;
-import com.pmu.betengine.model.dto.HippodromeDTO;
-import com.pmu.betengine.model.dto.HippodromeRequestDTO;
 import com.pmu.betengine.repository.HippodromeRepository;
-import com.pmu.betengine.repository.ReunionRepository;
-import org.modelmapper.ModelMapper;
 import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
 
-import java.time.format.DateTimeFormatter;
+import java.time.LocalDateTime;
 import java.util.List;
-import java.util.stream.Collectors;
 
 @Service
-@Transactional
 public class HippodromeService {
 
     private final HippodromeRepository hippodromeRepository;
-    private final ReunionRepository reunionRepository;
-    private final ModelMapper modelMapper;
 
-    public HippodromeService(HippodromeRepository hippodromeRepository,
-                             ReunionRepository reunionRepository,
-                             ModelMapper modelMapper) {
+    public HippodromeService(HippodromeRepository hippodromeRepository) {
         this.hippodromeRepository = hippodromeRepository;
-        this.reunionRepository = reunionRepository;
-        this.modelMapper = modelMapper;
     }
 
-    public List<HippodromeDTO> getAllHippodromes() {
-        return hippodromeRepository.findAll()
-                .stream()
-                .map(this::convertToDTO)
-                .collect(Collectors.toList());
+  public Hippodrome createHippodrome(Hippodrome hippodrome) {
+    if (hippodromeRepository.existsByNom(hippodrome.getNom())) {
+        throw new RuntimeException("Un hippodrome avec ce nom existe déjà: " + hippodrome.getNom());
     }
 
-    public HippodromeDTO getHippodromeById(Long id) {
-        Hippodrome hippodrome = hippodromeRepository.findById(id)
+    hippodrome.setCreatedAt(LocalDateTime.now());
+    hippodrome.setUpdatedAt(LocalDateTime.now());
+
+    return hippodromeRepository.save(hippodrome);
+}
+
+
+    // Get all
+    public List<Hippodrome> getAllHippodromes() {
+        return hippodromeRepository.findAll();
+    }
+
+    // Get by ID
+    public Hippodrome getHippodromeById(Long id) {
+        return hippodromeRepository.findById(id)
                 .orElseThrow(() -> new RuntimeException("Hippodrome non trouvé avec l'id: " + id));
-        return convertToDTO(hippodrome);
     }
 
-    public HippodromeDTO createHippodrome(HippodromeRequestDTO requestDTO) {
-        if (hippodromeRepository.existsByNom(requestDTO.getNom())) {
-            throw new RuntimeException("Un hippodrome avec ce nom existe déjà: " + requestDTO.getNom());
-        }
-
-        Hippodrome hippodrome = convertToEntity(requestDTO);
-
-        Hippodrome saved = hippodromeRepository.save(hippodrome);
-        return convertToDTO(saved);
-    }
-
-    public HippodromeDTO updateHippodrome(Long id, HippodromeRequestDTO requestDTO) {
-        Hippodrome existing = hippodromeRepository.findById(id)
-                .orElseThrow(() -> new RuntimeException("Hippodrome non trouvé avec l'id: " + id));
-
-        // Vérification du nom si modifié
-        if (!existing.getNom().equals(requestDTO.getNom()) &&
-                hippodromeRepository.existsByNom(requestDTO.getNom())) {
-            throw new RuntimeException("Un hippodrome avec ce nom existe déjà: " + requestDTO.getNom());
-        }
-
-        // Mise à jour des champs
-        modelMapper.map(requestDTO, existing);
-
-
-
-        return convertToDTO(hippodromeRepository.save(existing));
+    // Update
+    public Hippodrome updateHippodrome(Long id, Hippodrome updatedHippodrome) {
+        Hippodrome existing = getHippodromeById(id);
+        existing.setNom(updatedHippodrome.getNom());
+        existing.setVille(updatedHippodrome.getVille());
+        existing.setPays(updatedHippodrome.getPays());
+        existing.setActif(updatedHippodrome.getActif());
+        existing.setCapacite(updatedHippodrome.getCapacite());
+        existing.setDescription(updatedHippodrome.getDescription());
+        return hippodromeRepository.save(existing);
     }
 
+    // Delete
     public void deleteHippodrome(Long id) {
         if (!hippodromeRepository.existsById(id)) {
             throw new RuntimeException("Hippodrome non trouvé avec l'id: " + id);
@@ -79,43 +59,40 @@ public class HippodromeService {
         hippodromeRepository.deleteById(id);
     }
 
-    public List<HippodromeDTO> getHippodromesByVille(String ville) {
-        return hippodromeRepository.findByVille(ville)
-                .stream()
-                .map(this::convertToDTO)
-                .collect(Collectors.toList());
+    public void deleteHippodrome2(Long id) {
+        Hippodrome hippodrome = hippodromeRepository.findById(id)
+                .orElseThrow(() -> new RuntimeException("Hippodrome non trouvé"));
+    
+        hippodrome.setActif(false);
+        hippodromeRepository.save(hippodrome);
     }
     
-    public List<HippodromeDTO> getHippodromesActifs() {
-        return hippodromeRepository.findByActif(true)
-                .stream()
-                .map(this::convertToDTO)
-                .collect(Collectors.toList());
+    public Hippodrome restoreHippodrome(Long id) {
+        Hippodrome hippodrome = hippodromeRepository.findById(id)
+                .orElseThrow(() -> new RuntimeException("Hippodrome non trouvé"));
+    
+        if (hippodrome.getActif()) {
+            throw new RuntimeException("Hippodrome est déjà actif");
         }
     
-    public HippodromeDTO getHippodromeByReunion(Long reunionId) {
-        Hippodrome hippodrome = hippodromeRepository.findByReunionId(reunionId)
-                .orElseThrow(() -> new RuntimeException("Aucun hippodrome trouvé pour la réunion avec l'id: " + reunionId));
-        return convertToDTO(hippodrome);
-    }
-
-    private HippodromeDTO convertToDTO(Hippodrome hippodrome) {
-        HippodromeDTO dto = modelMapper.map(hippodrome, HippodromeDTO.class);
-
-        // Formatage des dates
-        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm");
-        if (hippodrome.getCreatedAt() != null) {
-            dto.setCreatedAt(hippodrome.getCreatedAt().format(formatter));
-        }
-        if (hippodrome.getUpdatedAt() != null) {
-            dto.setUpdatedAt(hippodrome.getUpdatedAt().format(formatter));
+        hippodrome.setActif(true);
+        return hippodromeRepository.save(hippodrome);
     }
     
     
-        return dto;
+
+    // Search by ville
+    public List<Hippodrome> getHippodromesByVille(String ville) {
+        return hippodromeRepository.findByVille(ville);
     }
 
-    private Hippodrome convertToEntity(HippodromeRequestDTO dto) {
-        return modelMapper.map(dto, Hippodrome.class);
+    // Get only active hippodromes
+    public List<Hippodrome> getHippodromesActifs() {
+        return hippodromeRepository.findByActif(true);
+    }
+
+    // Search by name
+    public List<Hippodrome> searchHippodromesByNom(String nom) {
+        return hippodromeRepository.findByNomContainingIgnoreCase(nom);
     }
 }

src/main/java/com/pmu/betengine/service/MiseService.java

@@ -0,0 +1,41 @@
+package com.pmu.betengine.service;
+
+import com.pmu.betengine.model.Mise;
+import com.pmu.betengine.repository.MiseRepository;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+public class MiseService {
+
+    private final MiseRepository repository;
+
+    public MiseService(MiseRepository repository) {
+        this.repository = repository;
+    }
+
+    public Mise create(Mise mise) {
+        return repository.save(mise);
+    }
+
+    public Mise getById(Long id) {
+        return repository.findById(id)
+                .orElseThrow(() -> new RuntimeException("Mise not found"));
+    }
+
+    public List<Mise> getAll() {
+        return repository.findAll();
+    }
+
+    public Mise update(Long id, Mise mise) {
+        Mise existing = getById(id);
+        existing.setTypePari(mise.getTypePari());
+        existing.setMontantMise(mise.getMontantMise());
+        return repository.save(existing);
+    }
+
+    public void delete(Long id) {
+        repository.deleteById(id);
+    }
+}

src/main/java/com/pmu/betengine/service/NonPartantService.java

@@ -0,0 +1,64 @@
+package com.pmu.betengine.service;
+
+import com.pmu.betengine.model.NonPartant;
+import com.pmu.betengine.repository.NonPartantRepository;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+@Service
+@Transactional
+public class NonPartantService {
+
+    private final NonPartantRepository repository;
+
+    public NonPartantService(NonPartantRepository repository) {
+        this.repository = repository;
+    }
+
+    public NonPartant createNonPartant(NonPartant np) {
+        return repository.save(np);
+    }
+
+    public List<NonPartant> getAllNonPartants() {
+        return repository.findAll();
+    }
+
+    public NonPartant getNonPartantById(Long id) {
+        return repository.findById(id)
+                .orElseThrow(() -> new RuntimeException("NonPartant non trouvé avec l'id: " + id));
+    }
+
+    public NonPartant updateNonPartant(Long id, NonPartant updated) {
+        NonPartant existing = getNonPartantById(id);
+
+        existing.setCourse(updated.getCourse());
+        existing.setNumero(updated.getNumero());
+        existing.setNomCheval(updated.getNomCheval());
+        existing.setMotif(updated.getMotif());
+        existing.setDeclarePar(updated.getDeclarePar());
+        existing.setDateDeclaration(updated.getDateDeclaration());
+
+        return repository.save(existing);
+    }
+
+    public void deleteNonPartant(Long id) {
+        if (!repository.existsById(id)) {
+            throw new RuntimeException("NonPartant non trouvé avec l'id: " + id);
+        }
+        repository.deleteById(id);
+    }
+
+    public List<NonPartant> getByCourseId(Long courseId) {
+        return repository.findByCourseId(courseId);
+    }
+
+    public List<NonPartant> searchByNomCheval(String nomCheval) {
+        return repository.findByNomChevalContainingIgnoreCase(nomCheval);
+    }
+
+    public List<NonPartant> searchByMotif(String motif) {
+        return repository.findByMotifContainingIgnoreCase(motif);
+    }
+}

src/main/java/com/pmu/betengine/service/PariService.java

@@ -4,11 +4,8 @@ import com.pmu.betengine.model.Course;
 import com.pmu.betengine.model.Pari;
 import com.pmu.betengine.model.statut.StatutParis;
 import com.pmu.betengine.model.type.TypeFormule;
-import com.pmu.betengine.model.type.TypePari;
-import com.pmu.betengine.repository.ChevalRepository;
 import com.pmu.betengine.repository.CourseRepository;
 import com.pmu.betengine.repository.PariRepository;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 import java.util.List;
@@ -16,52 +13,142 @@ import java.util.List;
 @Service
 public class PariService {
 
-    @Autowired
-    private PariRepository pariRepository;
+    private final PariRepository pariRepository;
+    private final CourseRepository courseRepository;
 
-    @Autowired
-    private CourseRepository courseRepository;
+    public PariService(PariRepository pariRepository, CourseRepository courseRepository) {
+        this.pariRepository = pariRepository;
+        this.courseRepository = courseRepository;
+    }
 
-    @Autowired
-    private ChevalRepository chevalRepository;
+    // CREATE
+    public Pari save(Pari pari) {
 
-    private static final double MISE_DE_BASE = 500.0;
-
-
-
-    public Pari placerPari(Pari pari) {
-     TypePari tp= pari.getTypePari();
-        // Vérifier que le type de pari est valide pour la course
         pari.setStatut(StatutParis.EN_ATTENTE);
-        Course course = (Course) pari.getCourse();
-        if ("GAGNANT".equals(pari.getTypeFormule().name()) && course.getNombreChevauxInscrits() < 2) {
-            throw new IllegalArgumentException("Pari GAGNANT impossible: moins de 2 chevaux");
-        }
 
-        if ("PLACE".equals(pari.getTypeFormule().name()) && course.getNombreChevauxInscrits() < 3) {
-            throw new IllegalArgumentException("Pari PLACE impossible: moins de 3 chevaux");
+        Course course = pari.getCourse();
+
+        // // Business rules
+        // if (pari.getTypeFormule() == TypeFormule.GAGNANT && course.getNombreChevauxInscrits() < 2) {
+        //     throw new IllegalArgumentException("Pari GAGNANT impossible: moins de 2 chevaux.");
+        // }
+        // if (pari.getTypeFormule() == TypeFormule.PLACE && course.getNombreChevauxInscrits() < 3) {
+        //     throw new IllegalArgumentException("Pari PLACE impossible: moins de 3 chevaux.");
+        // }
+         // Business rules
+         if (pari.getTypeFormule() == TypeFormule.GAGNANT && course.getPartants() < 2) {
+            throw new IllegalArgumentException("Pari GAGNANT impossible: moins de 2 chevaux.");
+        }
+        if (pari.getTypeFormule() == TypeFormule.PLACE && course.getPartants() < 3) {
+            throw new IllegalArgumentException("Pari PLACE impossible: moins de 3 chevaux.");
         }
 
         return pariRepository.save(pari);
     }
 
-public Pari update(Pari pari){
-        return pariRepository.save(pari);
+    // GET ALL
+    public List<Pari> getAll() {
+        return pariRepository.findAll();
     }
 
-public Pari findByTicket(String ticket){
-
-        return pariRepository.findByNumeroTicket(ticket).orElse(null);
+    // GET BY ID
+    public Pari getById(Long id) {
+        return pariRepository.findById(id).orElse(null);
     }
-    public List<Pari> obtenirParisParCourse(Long courseId) {
+
+    // DELETE
+    public void delete(Long id) {
+        pariRepository.deleteById(id);
+    }
+
+    // GET BY COURSE
+    public List<Pari> getByCourse(Long courseId) {
         return pariRepository.findByCourseId(courseId);
     }
 
-    public List<Pari> obtenirParisParCourseEtType(Long courseId, TypeFormule typeFormule) {
+    // GET BY TICKET
+    public Pari findByTicket(String ticket) {
+        return pariRepository.findByNumeroTicket(ticket).orElse(null);
+    }
+
+    // GET BY COURSE + TYPE
+    public List<Pari> getByCourseAndType(Long courseId, TypeFormule typeFormule) {
         return pariRepository.findByCourseIdAndTypeFormule(courseId, typeFormule);
     }
 
-    public List<Pari> obtenirParisParCheval(Long chevalId) {
-        return pariRepository.findByChevalId(chevalId);
+    // UPDATE
+    public Pari update(Pari pari) {
+        return pariRepository.save(pari);
     }
 }
+
+
+
+
+// package com.pmu.betengine.service;
+
+// import com.pmu.betengine.model.Course;
+// import com.pmu.betengine.model.Pari;
+// import com.pmu.betengine.model.statut.StatutParis;
+// import com.pmu.betengine.model.type.TypeFormule;
+// import com.pmu.betengine.model.type.TypePari;
+// import com.pmu.betengine.repository.ChevalRepository;
+// import com.pmu.betengine.repository.CourseRepository;
+// import com.pmu.betengine.repository.PariRepository;
+// import org.springframework.beans.factory.annotation.Autowired;
+// import org.springframework.stereotype.Service;
+
+// import java.util.List;
+
+// @Service
+// public class PariService {
+
+//     @Autowired
+//     private PariRepository pariRepository;
+
+//     @Autowired
+//     private CourseRepository courseRepository;
+
+//     @Autowired
+//     private ChevalRepository chevalRepository;
+
+//     private static final double MISE_DE_BASE = 500.0;
+
+
+
+//     public Pari placerPari(Pari pari) {
+//      TypePari tp= pari.getTypePari();
+//         // Vérifier que le type de pari est valide pour la course
+//         pari.setStatut(StatutParis.EN_ATTENTE);
+//         Course course = (Course) pari.getCourse();
+//         if ("GAGNANT".equals(pari.getTypeFormule().name()) && course.getNombreChevauxInscrits() < 2) {
+//             throw new IllegalArgumentException("Pari GAGNANT impossible: moins de 2 chevaux");
+//         }
+
+//         if ("PLACE".equals(pari.getTypeFormule().name()) && course.getNombreChevauxInscrits() < 3) {
+//             throw new IllegalArgumentException("Pari PLACE impossible: moins de 3 chevaux");
+//         }
+
+//         return pariRepository.save(pari);
+//     }
+
+// public Pari update(Pari pari){
+//         return pariRepository.save(pari);
+// }
+
+// public Pari findByTicket(String ticket){
+
+//         return pariRepository.findByNumeroTicket(ticket).orElse(null);
+// }
+//     public List<Pari> obtenirParisParCourse(Long courseId) {
+//         return pariRepository.findByCourseId(courseId);
+//     }
+
+//     public List<Pari> obtenirParisParCourseEtType(Long courseId, TypeFormule typeFormule) {
+//         return pariRepository.findByCourseIdAndTypeFormule(courseId, typeFormule);
+//     }
+
+//     public List<Pari> obtenirParisParCheval(Long chevalId) {
+//         return pariRepository.findByChevalId(chevalId);
+//     }
+// }

src/main/java/com/pmu/betengine/service/PermissionService.java

@@ -0,0 +1,42 @@
+package com.pmu.betengine.service;
+
+import com.pmu.betengine.model.Permission;
+import com.pmu.betengine.repository.PermissionRepository;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+public class PermissionService {
+
+    private final PermissionRepository permissionRepository;
+
+    public PermissionService(PermissionRepository permissionRepository) {
+        this.permissionRepository = permissionRepository;
+    }
+
+    public Permission create(Permission permission) {
+        return permissionRepository.save(permission);
+    }
+
+    public Permission update(Long id, Permission updatedPermission) {
+        return permissionRepository.findById(id).map(permission -> {
+            permission.setName(updatedPermission.getName());
+            permission.setDescription(updatedPermission.getDescription());
+            return permissionRepository.save(permission);
+        }).orElseThrow(() -> new RuntimeException("Permission not found"));
+    }
+
+    public Permission getById(Long id) {
+        return permissionRepository.findById(id)
+                .orElseThrow(() -> new RuntimeException("Permission not found"));
+    }
+
+    public List<Permission> getAll() {
+        return permissionRepository.findAll();
+    }
+
+    public void delete(Long id) {
+        permissionRepository.deleteById(id);
+    }
+}

src/main/java/com/pmu/betengine/service/ResultatService.java

@@ -1,27 +1,139 @@
 package com.pmu.betengine.service;
 
+import com.pmu.betengine.model.Course;
 import com.pmu.betengine.model.Resultat;
+import com.pmu.betengine.model.SearchParam;
 import com.pmu.betengine.repository.ResultatRepository;
 import lombok.RequiredArgsConstructor;
+
+import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Service;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
 
 import java.util.Optional;
+import java.util.Map;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.util.HashMap;
+import java.util.List;
 
 @Service
 @RequiredArgsConstructor
 public class ResultatService {
 
-    private final ResultatRepository resultatCourseRepository;
+    private final ResultatRepository resultatRepository;
+    private final CourseService courseService;
 
-    public Optional<Resultat> findByCourseId(Long courseId) {
-        return resultatCourseRepository.findByCourseId(courseId);
+    // CREATE / UPDATE
+    public Resultat save(Resultat resultat) {
+        return resultatRepository.save(resultat);
     }
 
-    public Resultat save(Resultat resultatCourse) {
-        return resultatCourseRepository.save(resultatCourse);
+    // GET ALL
+    public List<Resultat> getAll() {
+        return resultatRepository.findAll();
     }
 
+    // GET BY ID
+    public Resultat getById(Long id) {
+        return resultatRepository.findById(id).orElse(null);
+    }
+
+    // GET BY COURSE
+    public Resultat getByCourseId(Long courseId) {
+        return resultatRepository.findByCourseId(courseId).orElse(null);
+    }
+
+
+    // DELETE BY ID
+    public void delete(Long id) {
+        resultatRepository.deleteById(id);
+    }
+
+    // DELETE BY COURSE
     public void deleteByCourseId(Long courseId) {
-        resultatCourseRepository.deleteByCourseId(courseId);
+        resultatRepository.deleteByCourseId(courseId);
+    }
+
+      public Resultat saveAndUpdateCourse(Resultat resultat) {
+        // Save the resultat
+        Resultat savedResultat = resultatRepository.save(resultat);
+
+        // Update the course statut
+        Course course = savedResultat.getCourse();
+        if (course != null) {
+            course.setStatut("RESULT_PUBLISHED"); // or whatever statut you want
+            courseService.updateCourse(course.getId(), course);
+        }
+
+        return savedResultat;
+    }
+
+    public List<Resultat> search(SearchParam searchParam) {
+    System.out.println("******************** SEARCH PARAM: " + searchParam);
+
+    if (searchParam.getCriteria() == null) {
+        throw new IllegalArgumentException("Le paramètre 'criteria' est obligatoire et ne peut pas être null");
+    }
+
+    try {
+        String criteria = searchParam.getCriteria();
+
+        if ("1".equals(criteria)) {
+            // Retourne tous les résultats
+            return resultatRepository.findAll();
+        } else if ("2".equals(criteria) && searchParam.getDate() != null) {
+            LocalDate date = searchParam.getDate();
+            LocalDateTime startOfDay = date.atStartOfDay();
+            LocalDateTime endOfDay = startOfDay.plusDays(1);
+
+            return resultatRepository.findByCourseDate(startOfDay, endOfDay);
+        } else if ("3".equals(criteria) && searchParam.getId() != null) {
+            return resultatRepository.findByCourseId(searchParam.getId())
+                    .map(List::of)
+                    .orElse(List.of());
+        }
+
+        // Cas par défaut
+        return resultatRepository.findAll();
+
+    } catch (Exception e) {
+        e.printStackTrace();
+        throw new RuntimeException("Erreur lors de la recherche des résultats");
     }
 }
+
+
+}
+
+
+
+
+// package com.pmu.betengine.service;
+
+// import com.pmu.betengine.model.Resultat;
+// import com.pmu.betengine.repository.ResultatRepository;
+// import lombok.RequiredArgsConstructor;
+// import org.springframework.stereotype.Service;
+
+// import java.util.Optional;
+
+// @Service
+// @RequiredArgsConstructor
+// public class ResultatService {
+
+//     private final ResultatRepository resultatCourseRepository;
+
+//     public Optional<Resultat> findByCourseId(Long courseId) {
+//         return resultatCourseRepository.findByCourseId(courseId);
+//     }
+
+//     public Resultat save(Resultat resultatCourse) {
+//         return resultatCourseRepository.save(resultatCourse);
+//     }
+
+//     public void deleteByCourseId(Long courseId) {
+//         resultatCourseRepository.deleteByCourseId(courseId);
+//     }
+// }

src/main/java/com/pmu/betengine/service/ReunionService.java

@@ -1,71 +1,114 @@
 package com.pmu.betengine.service;
 
 import com.pmu.betengine.model.Reunion;
-import com.pmu.betengine.model.dto.ReunionDTO;
-import com.pmu.betengine.model.dto.ReunionRequestDTO;
 import com.pmu.betengine.repository.ReunionRepository;
-import org.modelmapper.ModelMapper;
 import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
 
 import java.time.LocalDateTime;
 import java.util.List;
-import java.util.stream.Collectors;
 
 @Service
-@Transactional
 public class ReunionService {
 
     private final ReunionRepository reunionRepository;
-    private final ModelMapper modelMapper;
 
-    public ReunionService(ReunionRepository reunionRepository, ModelMapper modelMapper) {
+    public ReunionService(ReunionRepository reunionRepository) {
         this.reunionRepository = reunionRepository;
-        this.modelMapper = modelMapper;
     }
 
-    public List<ReunionDTO> getAllReunions() {
+    // Create
+    public Reunion createReunion(Reunion reunion) {
+
+        // Check if hippodrome ID is missing
+        if (reunion.getHippodromeId() == null) {
+            throw new RuntimeException("Aucun hippodrome assigné à cette réunion.");
+        }
+    
+        // Check if reunion code already exists
+        if (reunionRepository.existsByCode(reunion.getCode())) {
+            throw new RuntimeException("Code déjà existant: " + reunion.getCode());
+        }
+    
+        reunion.setCreatedAt(LocalDateTime.now());
+        reunion.setUpdatedAt(LocalDateTime.now());
+    
+        return reunionRepository.save(reunion);
+    }
+    
+
+    // Get all
+    // public List<Reunion> getAllReunions() {
+    //     return reunionRepository.findAll();
+    // }
+    // Soft delete
+public String deleteReunion(Long id) {
+    Reunion reunion = getReunionById(id);
+
+    if ("INACTIF".equals(reunion.getStatut())) {
+        throw new RuntimeException("Cette réunion est déjà désactivée.");
+    }
+
+    reunion.setStatut("INACTIF");
+    reunion.setUpdatedAt(LocalDateTime.now());
+    reunionRepository.save(reunion);
+
+    return "Réunion désactivée avec succès.";
+}
+
+// Optional: restore
+public Reunion restoreReunion(Long id) {
+    Reunion reunion = getReunionById(id);
+
+    if ("ACTIF".equals(reunion.getStatut())) {
+        throw new RuntimeException("Cette réunion est déjà active.");
+    }
+
+    reunion.setStatut("ACTIF");
+    reunion.setUpdatedAt(LocalDateTime.now());
+    return reunionRepository.save(reunion);
+}
+
+// Override getAll to return only active reunions
+public List<Reunion> getAllReunions() {
     return reunionRepository.findAll()
             .stream()
-                .map(this::convertToDTO)
-                .collect(Collectors.toList());
+            .filter(r -> "ACTIF".equals(r.getStatut()))
+            .toList();
 }
 
-    public ReunionDTO getReunionById(Long id) {
-        Reunion reunion = reunionRepository.findById(id)
-                .orElseThrow(() -> new RuntimeException("Reunion non trouvée"));
-        return convertToDTO(reunion);
+
+    // Get by ID
+    public Reunion getReunionById(Long id) {
+        return reunionRepository.findById(id)
+                .orElseThrow(() -> new RuntimeException("Réunion non trouvée avec l'id: " + id));
     }
 
-    public ReunionDTO createReunion(ReunionRequestDTO requestDTO) {
-        if (reunionRepository.existsByCode(requestDTO.getCode())) {
-            throw new RuntimeException("Code déjà existant");
-        }
-
-        Reunion reunion = convertToEntity(requestDTO);
-        reunion.setCreatedAt(LocalDateTime.now());
-        Reunion saved = reunionRepository.save(reunion);
-        return convertToDTO(saved);
-    }
-
-    public ReunionDTO updateReunion(Long id, ReunionRequestDTO requestDTO) {
-        Reunion existing = reunionRepository.findById(id)
-                .orElseThrow(() -> new RuntimeException("Reunion non trouvée"));
-
-        modelMapper.map(requestDTO, existing);
+    // Update
+    public Reunion updateReunion(Long id, Reunion updatedReunion) {
+        Reunion existing = getReunionById(id);
+        existing.setCode(updatedReunion.getCode());
+        existing.setNom(updatedReunion.getNom());
+        existing.setDate(updatedReunion.getDate());
+        existing.setNumero(updatedReunion.getNumero());
+        existing.setStatut(updatedReunion.getStatut());
+        existing.setHippodromeId(updatedReunion.getHippodromeId());
+        existing.setTotalCourses(updatedReunion.getTotalCourses());
         existing.setUpdatedAt(LocalDateTime.now());
-        return convertToDTO(reunionRepository.save(existing));
+        return reunionRepository.save(existing);
     }
 
-    public void deleteReunion(Long id) {
-        reunionRepository.deleteById(id);
-    }
+    // Delete
+    // public String deleteReunion(Long id) {
+    //     if (!reunionRepository.existsById(id)) {
+    //         throw new RuntimeException("Réunion non trouvée avec l'id: " + id);
+    //     }
+    //     reunionRepository.deleteById(id);
+    //     return "Réunion avec l'ID " + id + " supprimée avec succès.";
+    // }
 
-    private ReunionDTO convertToDTO(Reunion reunion) {
-        return modelMapper.map(reunion, ReunionDTO.class);
-    }
-
-    private Reunion convertToEntity(ReunionRequestDTO dto) {
-        return modelMapper.map(dto, Reunion.class);
+    // Find by code
+    public Reunion getReunionByCode(String code) {
+        return reunionRepository.findByCode(code)
+                .orElseThrow(() -> new RuntimeException("Réunion non trouvée avec le code: " + code));
     }
 }

src/main/java/com/pmu/betengine/service/RoleService.java

@@ -0,0 +1,43 @@
+package com.pmu.betengine.service;
+
+import com.pmu.betengine.model.Role;
+import com.pmu.betengine.repository.RoleRepository;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+public class RoleService {
+
+    private final RoleRepository roleRepository;
+
+    public RoleService(RoleRepository roleRepository) {
+        this.roleRepository = roleRepository;
+    }
+
+    public Role create(Role role) {
+        return roleRepository.save(role);
+    }
+
+    public Role update(Long id, Role updatedRole) {
+        return roleRepository.findById(id).map(role -> {
+            role.setName(updatedRole.getName());
+            role.setDescription(updatedRole.getDescription());
+            role.setPermissions(updatedRole.getPermissions());
+            return roleRepository.save(role);
+        }).orElseThrow(() -> new RuntimeException("Role not found"));
+    }
+
+    public Role getById(Long id) {
+        return roleRepository.findById(id)
+                .orElseThrow(() -> new RuntimeException("Role not found"));
+    }
+
+    public List<Role> getAll() {
+        return roleRepository.findAll();
+    }
+
+    public void delete(Long id) {
+        roleRepository.deleteById(id);
+    }
+}

src/main/java/com/pmu/betengine/service/TPEService.java

@@ -1,79 +1,69 @@
 package com.pmu.betengine.service;
 
+import com.pmu.betengine.model.Agent;
 import com.pmu.betengine.model.TPE;
-import com.pmu.betengine.model.dto.TPEDTO;
-import com.pmu.betengine.model.dto.TPERequestDTO;
 import com.pmu.betengine.model.statut.StatutTPE;
+import com.pmu.betengine.repository.AgentRepository;
 import com.pmu.betengine.repository.TPERepository;
-import org.modelmapper.ModelMapper;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
-import java.time.format.DateTimeFormatter;
 import java.util.List;
-import java.util.stream.Collectors;
 
 @Service
 @Transactional
 public class TPEService {
 
     private final TPERepository tpeRepository;
-    private final ModelMapper modelMapper;
+    private final AgentRepository agentRepository;
 
-    public TPEService(TPERepository tpeRepository, ModelMapper modelMapper) {
+    public TPEService(TPERepository tpeRepository, AgentRepository agentRepository) {
         this.tpeRepository = tpeRepository;
-        this.modelMapper = modelMapper;
+        this.agentRepository = agentRepository;
     }
 
-    public List<TPEDTO> getAllTPEs() {
-        return tpeRepository.findAll()
-                .stream()
-                .map(this::convertToDTO)
-                .collect(Collectors.toList());
+    public List<TPE> getAllTPEs() {
+        return tpeRepository.findAll();
     }
 
-    public TPEDTO getTPEById(Long id) {
-        TPE tpe = tpeRepository.findById(id)
+    public TPE getTPEById(Long id) {
+        return tpeRepository.findById(id)
                 .orElseThrow(() -> new RuntimeException("TPE non trouvé avec l'id: " + id));
-        return convertToDTO(tpe);
     }
 
-    public TPEDTO createTPE(TPERequestDTO requestDTO) {
-        // Vérifier l'unicité de l'IMEI
-        if (tpeRepository.existsByImei(requestDTO.getImei())) {
-            throw new RuntimeException("Un TPE avec cet IMEI existe déjà: " + requestDTO.getImei());
+    public TPE createTPE(TPE tpe) {
+        if (tpeRepository.existsByImei(tpe.getImei())) {
+            throw new RuntimeException("Un TPE avec cet IMEI existe déjà: " + tpe.getImei());
+        }
+        if (tpeRepository.existsBySerial(tpe.getSerial())) {
+            throw new RuntimeException("Un TPE avec ce numéro de série existe déjà: " + tpe.getSerial());
+        }
+        return tpeRepository.save(tpe);
     }
 
-        // Vérifier l'unicité du numéro de série
-        if (tpeRepository.existsBySerial(requestDTO.getSerial())) {
-            throw new RuntimeException("Un TPE avec ce numéro de série existe déjà: " + requestDTO.getSerial());
-        }
-
-        TPE tpe = convertToEntity(requestDTO);
-        TPE saved = tpeRepository.save(tpe);
-        return convertToDTO(saved);
-    }
-
-    public TPEDTO updateTPE(Long id, TPERequestDTO requestDTO) {
+    public TPE updateTPE(Long id, TPE tpeDetails) {
         TPE existing = tpeRepository.findById(id)
                 .orElseThrow(() -> new RuntimeException("TPE non trouvé avec l'id: " + id));
 
-        // Vérifier l'unicité de l'IMEI si modifié
-        if (!existing.getImei().equals(requestDTO.getImei()) &&
-                tpeRepository.existsByImei(requestDTO.getImei())) {
-            throw new RuntimeException("Un TPE avec cet IMEI existe déjà: " + requestDTO.getImei());
+        if (!existing.getImei().equals(tpeDetails.getImei()) &&
+                tpeRepository.existsByImei(tpeDetails.getImei())) {
+            throw new RuntimeException("Un TPE avec cet IMEI existe déjà: " + tpeDetails.getImei());
         }
 
-        // Vérifier l'unicité du numéro de série si modifié
-        if (!existing.getSerial().equals(requestDTO.getSerial()) &&
-                tpeRepository.existsBySerial(requestDTO.getSerial())) {
-            throw new RuntimeException("Un TPE avec ce numéro de série existe déjà: " + requestDTO.getSerial());
+        if (!existing.getSerial().equals(tpeDetails.getSerial()) &&
+                tpeRepository.existsBySerial(tpeDetails.getSerial())) {
+            throw new RuntimeException("Un TPE avec ce numéro de série existe déjà: " + tpeDetails.getSerial());
         }
 
-        // Mise à jour des champs
-        modelMapper.map(requestDTO, existing);
+        // Update fields
+        existing.setImei(tpeDetails.getImei());
+        existing.setSerial(tpeDetails.getSerial());
+        existing.setType(tpeDetails.getType());
+        existing.setMarque(tpeDetails.getMarque());
+        existing.setModele(tpeDetails.getModele());
+        existing.setStatut(tpeDetails.getStatut());
 
-        return convertToDTO(tpeRepository.save(existing));
+        return tpeRepository.save(existing);
     }
 
     public void deleteTPE(Long id) {
@@ -83,69 +73,44 @@ public class TPEService {
         tpeRepository.deleteById(id);
     }
 
-    public TPEDTO updateStatut(Long id, StatutTPE statut) {
-        TPE tpe = tpeRepository.findById(id)
-                .orElseThrow(() -> new RuntimeException("TPE non trouvé avec l'id: " + id));
-
+    public TPE updateStatut(Long id, StatutTPE statut) {
+        TPE tpe = getTPEById(id);
         tpe.setStatut(statut);
+        tpe.setAssigne(statut == StatutTPE.AFFECTE);
+        if (statut == StatutTPE.DISPONIBLE) tpe.setAssigne(false);
+        return tpeRepository.save(tpe);
+    }
 
-        // Si le statut est AFFECTE, mettre à jour le champ assigne
-        if (statut == StatutTPE.AFFECTE) {
+    public TPE assignerTPE(Long tpeId, Long agentId) {
+        TPE tpe = getTPEById(tpeId);
+        Agent agent = agentRepository.findById(agentId)
+                .orElseThrow(() -> new RuntimeException("Agent not found"));
+        tpe.setAgent(agent);
         tpe.setAssigne(true);
-        } else if (statut == StatutTPE.DISPONIBLE) {
-            tpe.setAssigne(false);
+        return tpeRepository.save(tpe);
     }
 
-        return convertToDTO(tpeRepository.save(tpe));
-    }
-
-    public TPEDTO assignerTPE(Long id) {
-        TPE tpe = tpeRepository.findById(id)
-                .orElseThrow(() -> new RuntimeException("TPE non trouvé avec l'id: " + id));
-
-        if (tpe.isAssigne()) {
-            throw new RuntimeException("Le TPE est déjà assigné");
-        }
-
-        tpe.setAssigne(true);
-        tpe.setStatut(StatutTPE.AFFECTE);
-
-        return convertToDTO(tpeRepository.save(tpe));
-    }
-
-    public TPEDTO libererTPE(Long id) {
-        TPE tpe = tpeRepository.findById(id)
-                .orElseThrow(() -> new RuntimeException("TPE non trouvé avec l'id: " + id));
-
+    public TPE libererTPE(Long id) {
+        TPE tpe = getTPEById(id);
         if (!tpe.isAssigne()) {
             throw new RuntimeException("Le TPE n'est pas assigné");
         }
-
         tpe.setAssigne(false);
         tpe.setStatut(StatutTPE.DISPONIBLE);
-
-        return convertToDTO(tpeRepository.save(tpe));
+        tpe.setAgent(null);
+        return tpeRepository.save(tpe);
     }
 
-    public List<TPEDTO> getTPEsByStatut(StatutTPE statut) {
-        return tpeRepository.findByStatut(statut)
-                .stream()
-                .map(this::convertToDTO)
-                .collect(Collectors.toList());
+    public List<TPE> getTPEsByStatut(StatutTPE statut) {
+        return tpeRepository.findByStatut(statut);
     }
 
-    public List<TPEDTO> getTPEsDisponibles() {
-        return tpeRepository.findAvailableTPE()
-                .stream()
-                .map(this::convertToDTO)
-                .collect(Collectors.toList());
+    public List<TPE> getTPEsDisponibles() {
+        return tpeRepository.findAvailableTPE();
     }
 
-    public List<TPEDTO> searchTPEs(String searchTerm) {
-        return tpeRepository.searchByTerm(searchTerm)
-                .stream()
-                .map(this::convertToDTO)
-                .collect(Collectors.toList());
+    public List<TPE> searchTPEs(String searchTerm) {
+        return tpeRepository.searchByTerm(searchTerm);
     }
 
     public long countTPEsByStatut(StatutTPE statut) {
@@ -156,22 +121,4 @@ public class TPEService {
         return tpeRepository.countByAssigne(true);
     }
 
-    private TPEDTO convertToDTO(TPE tpe) {
-        TPEDTO dto = modelMapper.map(tpe, TPEDTO.class);
-
-        // Formatage des dates
-        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm");
-        if (tpe.getCreatedAt() != null) {
-            dto.setCreatedAt(tpe.getCreatedAt().format(formatter));
-        }
-        if (tpe.getUpdatedAt() != null) {
-            dto.setUpdatedAt(tpe.getUpdatedAt().format(formatter));
-        }
-
-        return dto;
-    }
-
-    private TPE convertToEntity(TPERequestDTO dto) {
-        return modelMapper.map(dto, TPE.class);
-    }
 }

src/main/java/com/pmu/betengine/service/UserService.java

@@ -0,0 +1,102 @@
+package com.pmu.betengine.service;
+
+import com.pmu.betengine.model.User;
+import com.pmu.betengine.model.statut.StatutUser;
+import com.pmu.betengine.repository.UserRepository;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+@Service
+public class UserService {
+
+    private final UserRepository userRepository;
+
+    @Autowired
+    private PasswordEncoder passwordEncoder;
+
+    public UserService(UserRepository userRepository) {
+        this.userRepository = userRepository;
+    }
+
+    // CREATE
+    public User create(User user) {
+        // 1. Vérification des champs obligatoires
+        if (!StringUtils.hasText(user.getNom())) {throw new RuntimeException("Le nom est obligatoire");}
+        if (!StringUtils.hasText(user.getPrenom())) {throw new RuntimeException("Le prénom est obligatoire");}
+        if (!StringUtils.hasText(user.getIdentifiant())) {throw new RuntimeException("L'identifiant est obligatoire");}
+        if (!StringUtils.hasText(user.getPassword())) {throw new RuntimeException("Le mot de passe est obligatoire");}
+        if (user.getRoleId() == null) {throw new RuntimeException("L'ID du rôle est obligatoire");}
+        // 2. Vérification de l'unicité
+        if (userRepository.existsByIdentifiant(user.getIdentifiant())) {throw new RuntimeException("Cet identifiant existe déjà");}
+        if (user.getMatriculeAgent() != null &&
+            userRepository.existsByMatriculeAgent(user.getMatriculeAgent())) {throw new RuntimeException("Ce matricule agent existe déjà");}
+        // 3. Validation du mot de passe
+        if (!user.getPassword().matches("^(?=.*[0-9])(?=.*[a-zA-Z]).{8,}$")) {throw new RuntimeException("Le mot de passe doit contenir au moins 8 caractères, incluant lettres et chiffres");}
+        // 4. Définition des valeurs par défaut et encodage du mot de passe
+        user.setId(null);
+        user.setPassword(passwordEncoder.encode(user.getPassword()));
+        user.setStatut(StatutUser.ACTIF.name());
+        user.setCreatedAt(LocalDateTime.now());
+        user.setUpdatedAt(LocalDateTime.now());
+        user.setDerniereConnexion(null); 
+        // 5. Vérification des champs numériques
+        if (user.getNombreIpAutorise() == null || user.getNombreIpAutorise() < 0) {
+            user.setNombreIpAutorise(0);
+        }
+        if (user.getNombreIpAutoAutorise() == null || user.getNombreIpAutoAutorise() < 0) {
+            user.setNombreIpAutoAutorise(0);
+        }
+        // 6. Nettoyage des chaînes
+        user.setIdentifiant(user.getIdentifiant().trim().toLowerCase());
+        if (user.getMatriculeAgent() != null) {
+            user.setMatriculeAgent(user.getMatriculeAgent().trim().toUpperCase());
+        }
+        // 7. Enregistrement
+        return userRepository.save(user);
+    }
+
+    // UPDATE
+    public User update(Long id, User updatedUser) {
+        return userRepository.findById(id).map(user -> {
+
+            user.setNom(updatedUser.getNom());
+            user.setPrenom(updatedUser.getPrenom());
+            user.setIdentifiant(updatedUser.getIdentifiant());
+            user.setMatriculeAgent(updatedUser.getMatriculeAgent());
+            user.setRoleId(updatedUser.getRoleId());
+            user.setRestrictionConnexion(updatedUser.getRestrictionConnexion());
+            user.setRestrictionAutomatique(updatedUser.getRestrictionAutomatique());
+            user.setNombreIpAutorise(updatedUser.getNombreIpAutorise());
+            user.setNombreIpAutoAutorise(updatedUser.getNombreIpAutoAutorise());
+            user.setStatut(updatedUser.getStatut());
+            user.setDerniereConnexion(updatedUser.getDerniereConnexion());
+
+            user.setUpdatedAt(LocalDateTime.now());
+
+            return userRepository.save(user);
+
+        }).orElseThrow(() -> new RuntimeException("Utilisateur introuvable"));
+    }
+
+    // READ by ID
+    public User getById(Long id) {
+        return userRepository.findById(id)
+                .orElseThrow(() -> new RuntimeException("Utilisateur introuvable"));
+    }
+
+    // READ all
+    public List<User> getAll() {
+        return userRepository.findAll();
+    }
+
+    // DELETE
+    public void delete(Long id) {
+        userRepository.deleteById(id);
+    }
+}