Athlete endpoints, not finished

back_end/src/main/java/hackathon/FrisbYEE/rest/AthleteResource.java

@@ -1,5 +1,10 @@
 package hackathon.FrisbYEE.rest;
 
+import java.time.LocalDate;
+import java.time.chrono.ChronoLocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
 import org.apache.el.stream.Optional;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
@@ -8,13 +13,19 @@ import io.swagger.v3.oas.annotations.media.Content;
 import io.swagger.v3.oas.annotations.media.Schema;
 import io.swagger.v3.oas.annotations.responses.ApiResponse;
 import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import hackathon.FrisbYEE.jpa.dto.ActiviteDTO;
 import hackathon.FrisbYEE.jpa.dto.AthleteDTO;
+import hackathon.FrisbYEE.jpa.dto.SessionDTO;
+import hackathon.FrisbYEE.jpa.metier.Activite;
 import hackathon.FrisbYEE.jpa.metier.Athlete;
+import hackathon.FrisbYEE.jpa.metier.Session;
 import hackathon.FrisbYEE.jpa.service.AthleteDAO;
+import hackathon.FrisbYEE.jpa.service.SessionDAO;
 
 public class AthleteResource {
 
     private AthleteDAO athleteDAO;
+    private SessionDAO sessionDAO;
 
     @Operation(summary = "Récupère tous les utilisateurs")
     @ApiResponses(value = {
@@ -22,14 +33,113 @@ public class AthleteResource {
             content = @Content(mediaType = "application/json",
             schema = @Schema(implementation = AthleteDTO.class)))
     })
-    @GetMapping("/joueur/{id}")
+    @GetMapping("/athlete/{id}")
-    public AthleteDTO getJoueurById(@PathVariable Integer joueurId)  {
+    public AthleteDTO getAthleteById(@PathVariable Integer athleteId)  {
         // return pet
-        System.out.println("ID A CHERCHER" + joueurId);
+        System.out.println("ID A CHERCHER" + athleteId);
-        java.util.Optional<Athlete> j = athleteDAO.findById(joueurId);
+        java.util.Optional<Athlete> j = athleteDAO.findById(athleteId);
         AthleteDTO jDTO = new AthleteDTO();
         System.out.println(j);
         return jDTO;
     }
-    
+    @GetMapping("/athlete/{id}/session")
+    public List<SessionDTO> getSessionsAthlete(@PathVariable Integer athleteId)  {
+        // return pet
+        System.out.println("ID A CHERCHER" + athleteId);
+        java.util.Optional<Athlete> j = athleteDAO.findById(athleteId);
+        List<Session> sessions = sessionDAO.findAll();
+        List<SessionDTO> athleteSessions = new ArrayList<>();
+        for(Session s : sessions){
+            if(s.getAthletes().contains(j.get())){
+                SessionDTO dto = new SessionDTO();
+                dto.setId(s.getId());
+                dto.setName(s.getName());
+                // Map other fields as necessary
+                athleteSessions.add(dto);
+            }
+        }
+        System.out.println(j);
+        return athleteSessions;
+    }
+    
+    @GetMapping("/athletes/session")
+    public List<SessionDTO> getAllSessions()  {
+        List<Session> sessions = sessionDAO.findAll();
+        System.out.println(sessions);
+        List<SessionDTO> sessionDTOs = new ArrayList<>();
+        for (Session session : sessions) {
+            SessionDTO dto = new SessionDTO();
+            dto.setId(session.getId());
+            dto.setName(session.getName());
+            // Map other fields as necessary
+            sessionDTOs.add(dto);
+        }
+        return sessionDTOs;
+    }
+
+    @GetMapping("/athletes/session/{id}/activities")
+    public List<ActiviteDTO> getActivitiesForSession(@PathVariable Integer id) {
+        // Récupérer la session par ID
+        java.util.Optional<Session> sessionOpt = sessionDAO.findById(id);
+        if (sessionOpt.isPresent()) {
+            Session session = sessionOpt.get();
+            // Retourner les activités de la session
+            List<ActiviteDTO> activiteDTOs = new ArrayList<>();
+            for (Activite activite : session.getActivites()) {
+                ActiviteDTO dto = new ActiviteDTO();
+                dto.setId(activite.getId());
+                dto.setName(activite.getName());
+                // Map other fields as necessary
+                activiteDTOs.add(dto);
+            }
+            return activiteDTOs;
+        }
+        return new ArrayList<>();
+    }
+
+    @GetMapping("/athletes/{id}/session/after/{date}")
+    public List<SessionDTO> getSessionsAfterDate(@PathVariable Integer id, @PathVariable String date) {
+        // Récupérer l'athlète par ID
+        java.util.Optional<Athlete> athleteOpt = athleteDAO.findById(id);
+        if (athleteOpt.isPresent()) {
+            Athlete athlete = athleteOpt.get();
+            // Récupérer les sessions de l'athlète après la date donnée
+            List<Session> sessions = sessionDAO.findAll();
+            List<SessionDTO> filteredSessions = new ArrayList<>();
+            for (Session session : sessions) {
+                if (session.getAthletes().contains(athlete) && session.getCreneau().isAfter(ChronoLocalDateTime.from(LocalDate.parse(date)))) { //WTF toujours sympa les dates
+                    SessionDTO dto = new SessionDTO();
+                    dto.setId(session.getId());
+                    dto.setName(session.getName());
+                    // Map other fields as necessary
+                    filteredSessions.add(dto);
+                }
+            }
+            return filteredSessions;
+        }
+        return new ArrayList<>();
+    }
+
+    @GetMapping("/athletes/{id}/session/between/{startDate}/{endDate}")
+    public List<SessionDTO> getSessionsBetweenDates(@PathVariable Integer id, @PathVariable String startDate, @PathVariable String endDate) {
+        // Récupérer l'athlète par ID
+        java.util.Optional<Athlete> athleteOpt = athleteDAO.findById(id);
+        if (athleteOpt.isPresent()) {
+            Athlete athlete = athleteOpt.get();
+            // Récupérer les sessions de l'athlète entre les deux dates données
+            List<Session> sessions = sessionDAO.findAll();
+            List<SessionDTO> filteredSessions = new ArrayList<>();
+            for (Session session : sessions) {
+                if (session.getAthletes().contains(athlete) && session.getCreneau().isAfter(ChronoLocalDateTime.from(LocalDate.parse(startDate))) && session.getCreneau().isBefore(ChronoLocalDateTime.from(LocalDate.parse(endDate)))) {
+                    SessionDTO dto = new SessionDTO();
+                    dto.setId(session.getId());
+                    dto.setName(session.getName());
+                    // Map other fields as necessary
+                    filteredSessions.add(dto);
+                }
+            }
+            return filteredSessions;
+        }
+        return new ArrayList<>();
+    }
 }