Merge remote-tracking branch 'refs/remotes/origin/main'

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

@@ -1,41 +0,0 @@
-package hackathon.FrisbYEE.rest;
-
-
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.ResponseEntity;
-import org.springframework.security.oauth2.jwt.Jwt;
-import org.springframework.security.core.context.SecurityContextHolder;
-
-import hackathon.FrisbYEE.jpa.metier.Athlete;
-import hackathon.FrisbYEE.jpa.service.AthleteDAO;
-import jakarta.transaction.Transactional;
-import org.springframework.web.bind.annotation.CrossOrigin;
-import org.springframework.web.bind.annotation.PostMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
-
-@RestController
-@RequestMapping("/users")
-@CrossOrigin(origins = "http://localhost:3000")
-public class UserSyncResource {
-    @Autowired
-    private AthleteDAO athleteDAO;
-
-    @PostMapping("/sync")
-    @Transactional
-    public ResponseEntity<Void> sync() {
-        Jwt jwt = (Jwt) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
-        String keycloakId = jwt.getSubject();
-        String firstName = jwt.getClaimAsString("given_name");
-        String lastName = jwt.getClaimAsString("family_name");
-        if (!athleteDAO.existsByKeycloakId(keycloakId)) {
-            Athlete athlete = new Athlete();
-            athlete.setKeycloakId(keycloakId);
-            athlete.setName(lastName);
-            athlete.setPrenom(firstName);
-            athlete.setRole(hackathon.FrisbYEE.jpa.metier.Role.athlete);
-            athleteDAO.save(athlete);
-        }
-        return ResponseEntity.ok().build();
-    }
-}

front_end/src/api.ts

@@ -70,9 +70,6 @@ export const sessionService = {
     delete: (id: number | string) => api.delete(`/session/delete/${id}`),
     update: (id: number | string, data: any) => api.put(`/session/update/${id}`, data),
 
-    // plural variants used around the frontend (keep for compatibility)
-    createPlural: (data: any) => api.post(`/sessions`, data),
-    getAllPlural: () => api.get(`/sessions`),
     getActivities: (sessionId: number | string) => api.get(`/sessions/${sessionId}/activities`),
     addActivity: (sessionId: number | string, activity: any) => api.post(`/sessions/${sessionId}/activities`, activity),
     subscribe: (sessionId: number | string, userId: number | string) => api.post(`/sessions/${sessionId}/subscribe`, { userId }),
@@ -87,9 +84,6 @@ export const coachService = {
     update: (id: number | string, data: any) => api.put(`/coach/update/${id}`, data),
     delete: (id: number | string) => api.delete(`/coach/delete/${id}`),
     getSessionsForCoach: (coachId: number | string) => api.get(`/coach/${coachId}/session`),
-    // plural convenience
-    createPlural: (data: any) => api.post(`/coaches`, data),
-    getAllPlural: () => api.get(`/coaches`),
 };
 
 export const userService = {

front_end/src/components/edt.tsx

@@ -2,7 +2,7 @@ import { useEffect, useState } from "react"
 import { Athlete, Coach, Session} from "../classes"
 import { useLocalData } from "../context/useLocalData"
 import './style/edt.css';
-import {updateSessionsOfUserAPI } from "../requetes";
+import {getSessionsOfUserAPI } from "../requetes";
 import EdtSession from "./edt_session";
 import {delay} from "../requetes";
 import Loading from "./loading";
@@ -34,9 +34,6 @@ export const EDT =() =>{
     const week_days:String[] = ["Lundi","Mardi","Mercredi","Jeudi","Vendredi","Samedi","Dimanche"];
     const week_days_nums:number[] = [1,2,3,4,5,6,0];
 
-
-
-
     function loadSessions(date:Date){
         var maxDate = getNextDay(date,6)
 

front_end/src/components/login.tsx

@@ -2,7 +2,7 @@ import { useKeycloak } from '@react-keycloak/web'
 import { useEffect } from 'react';
 import { Athlete, User } from '../classes';
 import { useLocalData } from '../context/useLocalData';
-import { postAthlete } from '../requetes';
+import { loginOrRegister, postAthlete } from '../requetes';
 import { clearAuthToken, setAuthToken } from '../api';
 import { AthleteDTO } from '../classesDTO';
 
@@ -10,7 +10,7 @@ export const Login =() =>{
     const {user,setUser} = useLocalData()
     const { keycloak } = useKeycloak();
 
-    useEffect(() => {
+    /*useEffect(() => {
         const syncAndLoadUser = async () => {
             if (keycloak.authenticated && keycloak.token && keycloak.tokenParsed) {
                 try {
@@ -24,47 +24,39 @@ export const Login =() =>{
                     
                     const athlete: Athlete = await postAthlete(newAthlete);
                     setUser(athlete);
-                    } catch (error) {
-                        console.error("Error :", error);
-                    }
-                }
-            };
-            /*postAthlete
-            if (keycloak.authenticated && keycloak.token) {
-                const tokenParsed = keycloak.tokenParsed;
-                setUser(
-                    
-                    {
-                    id: 0,
-                    keycloakId: tokenParsed!.sub!,
-                    email: tokenParsed?.email || "",
-                    nom: tokenParsed?.family_name || "",
-                    prenom: tokenParsed?.given_name || "",
-                    sessions: []
-                }
-            );
-                try {
-                    const response = await fetch("http://localhost:8081/api/users/sync", {
-                        method: "POST",
-                        headers: {
-                            "Authorization": `Bearer ${keycloak.token}`,
-                            "Content-Type": "application/json"
-                        },
-                    });
-                    console.log("Sync status:", response.status);
                 } catch (error) {
-                    console.error("Sync fetch failed:", error);
+                    console.error("Error :", error);
                 }
-            }*/
+            }
-        
+        };
 
         syncAndLoadUser();
     }, [keycloak.authenticated, keycloak.token, setUser]);
+    */
 
+    async function loginUser(){
+        if(keycloak.authenticated){
+            setAuthToken(keycloak.token);
+            //alert("Connexion en cours : " + keycloak.tokenParsed?.sub + " " + keycloak.tokenParsed?.realm_access?.roles);
+            
+            const logedUser = await loginOrRegister(keycloak);
+            console.log(logedUser);
+            if(logedUser!==null){
+                setUser(logedUser);
+               // alert("Connexion avec succès ! " + keycloak.tokenParsed?.sub);
+            }
+            else{
+                alert("Erreur de connexion " + keycloak.tokenParsed?.sub + " " + keycloak.tokenParsed?.realm_access?.roles);
+            }
+        }
+    }
 
-    function handleLogin(): void {
+    useEffect(() => {
-        keycloak.login();
+        loginUser()
-        //TODO setUser
+    },[keycloak.authenticated])
+
+    async function handleLogin() {
+        await keycloak.login();
     }
 
     function handleLogout(): void {
@@ -81,9 +73,12 @@ export const Login =() =>{
             <div>
                 <div>
                     Keycloak ID : { keycloak.tokenParsed?.sub}
+                </div>
+                 <div>
+                    Prenom : { user.prenom}
                 </div>
                 <div>
-                    User nom : { user.nom}
+                    Nom : { user.nom}
                 </div>
             
             </div>

front_end/src/components/object/activite.tsx

@@ -0,0 +1,34 @@
+import { useState } from 'react';
+import { Activite } from '../../classes';
+import '../style/objectList.css';
+
+type Props = {
+    activite: Activite
+}
+
+function ObjectActivite({activite}: Props) {
+    const [open, setOpen] = useState<boolean>(false);
+    
+    function handleOpen(): void {
+        setOpen(!open);
+    }
+    
+    return (
+        <div>
+            <div className="object" onClick={() => handleOpen()}>
+                <div>{activite.nom}</div>
+                <div>{activite.theme ? activite.theme : "Pas de thème défini pour l'activité"}</div>
+                <div>{activite.duree} min</div>
+            </div>
+            {open && activite.data && activite.data.size > 0 && (
+                <div className="object_details">
+                    {Array.from(activite.data.entries()).map(([key, value]) => (
+                        <div key={key}><strong>{key}:</strong> {value}</div>
+                    ))}
+                </div>
+            )}
+        </div>
+    )
+}
+
+export default ObjectActivite

front_end/src/components/ressourceList.tsx

@@ -3,6 +3,7 @@ import { Athlete, Activite, Coach, Session, Ligne } from "../classes";
 import ObjectSession from "./object/session";
 import {calculStatsAthlete, niveauAlerte} from "../utils/athleteUtils";
 import {calculTempsDeJeuParLigne} from "../utils/ligneUtils";
+import ObjectActivite from "./object/activite";
 
 
 type AthleteListProps = { athletes: Athlete[], sessions: Session[]};
@@ -87,21 +88,12 @@ function AthleteList({ athletes, sessions }: AthleteListProps) {
 
 function ActiviteList({ activites }: ActiviteListProps) {
     return (
-        <ul className="ActiviteList">
+        <div className="list_object">
             {activites.map((activite) => (
-                <li key={activite.id}>
+                    <ObjectActivite activite={activite}/>
-                    <div>
-                        <strong>Nom:</strong> {activite.nom}
-                    </div>
-                    <div>
-                        <strong>Thème:</strong> {activite.theme}
-                    </div>
-                    <div>
-                        <strong>Durée:</strong> {activite.duree} minutes
-                    </div>
-                </li>
             ))}
-        </ul>
+            
+        </div>
     );
 }
 

front_end/src/components/test_api.tsx

@@ -1,5 +1,5 @@
 import { useKeycloak } from "@react-keycloak/web"
-import { getCoachsAPI, getUsersAPI, postAdmin } from "../requetes"
+import { getAllCoach, getUsersAPI, postAdmin } from "../requetes"
 import { Admin } from "../classes";
 
 
@@ -7,7 +7,7 @@ function TestAPI(){
     const { keycloak } = useKeycloak()
 
     function handleGetUsers(): void {
-        getCoachsAPI();
+        getAllCoach();
     }
 
     function handleSendAdmin(): void {

front_end/src/requetes.tsx

@@ -2,6 +2,7 @@ import api, { activiteService, athleteService, coachService, sessionService } fr
 import { Activite, Admin, Athlete, Coach, Session, User } from "./classes";
 import Keycloak from 'keycloak-js'
 import { AdminDTO, AthleteDTO, CoachDTO } from "./classesDTO";
+import { useLocalData } from "./context/useLocalData";
 
 //debug:
 export function delay(ms: number): Promise<void> {
@@ -15,28 +16,46 @@ export function delay(ms: number): Promise<void> {
 /*
 retourne l'utilisateur lié à l'identifiant keyloack
 */
-export async function getUser(keycloak:Keycloak): Promise<User|null>{
+export async function loginOrRegister(keycloak:Keycloak): Promise<User|null>{
     try {
+        if(keycloak.tokenParsed!=null){
         const roles = keycloak.tokenParsed?.realm_access?.roles
         if(roles!=null){
             if(roles.includes("admin")){
-                const response = await athleteService.create(keycloak.tokenParsed);
+                    const id = keycloak.tokenParsed?.sub;
+                    if(id!=null){
+                        const response = await athleteService.getByKeycloakId(id);
                 const admin = new Admin(response.data);
                 return admin;
             }
+                }
             else if(roles.includes("coach")){
-                const response = await coachService.create(keycloak.tokenParsed);
+                    const id = keycloak.tokenParsed?.sub;
+                    if(id!=null){
+                        const response = await coachService.getByKeycloakId(id);
                 const coach = new Coach(response.data);
                 return coach;
             }
-            else if(roles.includes("athletes")){
+                }
-                const response = await athleteService.create(keycloak.tokenParsed);
+                else if(roles.includes("athlete")){
+                    console.error("role = Athlete");
+                    const newAthlete: Athlete = new Athlete();
+                    newAthlete.keycloakId = keycloak.tokenParsed.sub || "";
+                    newAthlete.email = keycloak.tokenParsed.email || "";
+                    newAthlete.nom = keycloak.tokenParsed.family_name || "";
+                    newAthlete.prenom = keycloak.tokenParsed.given_name || "";
+                    const response = await athleteService.create(newAthlete.toDTO());
+                    console.log(response);
                 const athlete = new Athlete(response.data);
+                    console.log(athlete);
                 return athlete;
             }
-            console.error("Error roles inconnu");
+                else console.error("Error : role inconnu");
+            }
+            else console.error("Error : role null");
         }
-
+        else console.error("Error : token Keylcoak null");
+        console.error("Error : pendant la récupération de l'User");
         return null;
     }
     catch (error) {
@@ -45,27 +64,21 @@ export async function getUser(keycloak:Keycloak): Promise<User|null>{
     }   
 }
 
-/*
+export async function updateActivitiesOfSessionAPI(session:Session,activities:Activite[]){
-retourne toutes les Session dont l'user est inscrit
-*/
-export async function updateSessionsOfUserAPI(user:Coach|Athlete, min: Date|null, max: Date|null){
     try {
-        const response = await api.get<Session[]>(`/users/${user.id}/sessions`, {
+        const session_id = session.id
-            params: {
+        for (const activity of activities) {
-                minDate: min ? min.toISOString() : undefined,
+            const response = await activiteService.update(activity.id!, {
-                maxDate: max ? max.toISOString() : undefined
+                name: activity.nom,
-            }
+                duree: activity.duree,
-        });
+                date: activity.data,
-        return response.data;
+                theme: activity.theme,
-    } catch (error) {
+                sessionId: session_id,
-        console.error("Error fetching sessions for user:", error);
+            },
-        return [];
+        );
-    }
+        }
-}
+        // To refresh the activities in the session object
-
+        const response = await sessionService.getActivities(session_id!);
-export async function updateActivitiesOfSessionAPI(session:Session){
-    try {
-        const response = await api.get<Activite[]>(`/sessions/${session.id}/activities`);
         session.activites = response.data;
     } catch (error) {
         console.error("Error fetching activities for session:", error);
@@ -75,7 +88,9 @@ export async function updateActivitiesOfSessionAPI(session:Session){
 
 export async function subscribeSessionAPI(user:User, session:Session):Promise<boolean>{
     try {
-        await api.post(`/sessions/${session.id}/subscribe`);
+        const session_id =session.id
+        const user_id = user.id
+        const response = await sessionService.subscribe(session_id!, user_id!);
         return true;
     } catch (error) {
         console.error("Error subscribing to session:", error);
@@ -85,7 +100,9 @@ export async function subscribeSessionAPI(user:User, session:Session):Promise<bo
 
 export async function unsubscribeSessionAPI(user:User, session:Session):Promise<boolean>{
     try {
-        await api.post(`/session/${session.id}/unsubscribe`);
+        const session_id =session.id
+        const user_id = user.id
+        const response = await sessionService.unsubscribe(session_id!, user_id!);
         return true;
     } catch (error) {
         console.error("Error unsubscribing from session:", error);
@@ -95,10 +112,6 @@ export async function unsubscribeSessionAPI(user:User, session:Session):Promise<
 
 // ADMIN :
 
-export async function updateAllSessionAPI(min: Date, max: Date){
-    //TODO
-}
-
 export async function updateAllUserAPI(){
 
 }
@@ -192,26 +205,37 @@ export async function setSessionCreneauAPI(session: Session, date:Date){
 
 }
 
-export async function getSessionsAPI(): Promise<Session[]> {
+//GET /////////////////////////////////////////////////////////
+
+//SESSION
+
+export async function getSessionsOfUserAPI(user:Coach|Athlete){
     try {
-        const response = await api.get<Session[]>("/session");
+        if (user instanceof Coach) {
+            const response = await coachService.getSessionsForCoach(user.id); //TODO
+            return response.data;
+        }else if (user instanceof Athlete) {
+            const response = await athleteService.getSessionsForAthlete(user.id); //TODO
+            return response.data;
+        }
+    }catch (error) {
+        console.error("Error fetching sessions for user:", error);
+        return [];
+    }
+}
+
+export async function getAllSessionsAPI():Promise<Session[]>{
+    try {
+        const response = await sessionService.getAll();
         return response.data;
     } catch (error) {
         console.error("Error fetching sessions:", error);
         throw error;
     }
 }
-export async function getUsersAPI(): Promise<User[]> {
-    try {
-        const response = await api.get<User[]>("/coach/all");
-        return response.data;
-    } catch (error) {
-        console.error("Error fetching users:", error);
-        throw error;
-    }
-}
 
-export async function getCoachsAPI(): Promise<Coach[]> {
+//COACH
+export async function getAllCoach(): Promise<Coach[]> {
     try {
         const response = await api.get<Coach[]>("/coach/all");
         console.log(response);
@@ -220,4 +244,16 @@ export async function getCoachsAPI(): Promise<Coach[]> {
         console.error("Error fetching coachs:", error);
         throw error;
     }
-}
+}
+
+//ATHLETE
+export async function getAllAthlete(): Promise<Athlete[]> {
+    try {
+        const response = await athleteService.getAll();
+        return response.data;
+    } catch (error) {
+        console.error("Error fetching users:", error);
+        throw error;
+    }
+}
+