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

2026-01-09 12:54:46 +01:00
parent 29bb452d19 9ac25f9ab6
commit b707167627
8 changed files with 156 additions and 149 deletions
--- a/back_end/src/main/java/hackathon/FrisbYEE/rest/UserSyncResource.java
+++ b/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();
-    }
-}
--- a/front_end/src/api.ts
+++ b/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 = {
--- a/front_end/src/components/edt.tsx
+++ b/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)

--- a/front_end/src/components/login.tsx
+++ b/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 {
-        keycloak.login();
-        //TODO setUser
+    useEffect(() => {
+        loginUser()
+    },[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>
--- a/front_end/src/components/object/activite.tsx
+++ b/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
--- a/front_end/src/components/ressourceList.tsx
+++ b/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}>
-                    <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>
+                    <ObjectActivite activite={activite}/>
            ))}
-        </ul>
+            
+        </div>
    );
 }

--- a/front_end/src/components/test_api.tsx
+++ b/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 {
--- a/front_end/src/requetes.tsx
+++ b/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>{
    }   
 }

-/*
-retourne toutes les Session dont l'user est inscrit
-*/
-export async function updateSessionsOfUserAPI(user:Coach|Athlete, min: Date|null, max: Date|null){
+export async function updateActivitiesOfSessionAPI(session:Session,activities:Activite[]){
    try {
-        const response = await api.get<Session[]>(`/users/${user.id}/sessions`, {
-            params: {
-                minDate: min ? min.toISOString() : undefined,
-                maxDate: max ? max.toISOString() : undefined
-            }
-        });
-        return response.data;
-    } catch (error) {
-        console.error("Error fetching sessions for user:", error);
-        return [];
-    }
-}
-
-export async function updateActivitiesOfSessionAPI(session:Session){
-    try {
-        const response = await api.get<Activite[]>(`/sessions/${session.id}/activities`);
+        const session_id = session.id
+        for (const activity of activities) {
+            const response = await activiteService.update(activity.id!, {
+                name: activity.nom,
+                duree: activity.duree,
+                date: activity.data,
+                theme: activity.theme,
+                sessionId: session_id,
+            },
+        );
+        }
+        // To refresh the activities in the session object
+        const response = await sessionService.getActivities(session_id!);
        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;
+    }
+}
+