NS’App v1.0

Poisson Rouges « Notes Cours  » — ## les routes et les contrôleurs structurent les requêtes HTTP et organisent la logique de l’ application ## VOIR LA DOC Routes    Voir La DOC Controleurs

Commandes pour générer les contrôleurs API dans le répertoire app/Http/Controllers/Api/

Chaque conytroleur correspond à une table de la BdD créer par les migrations

php artisan make:controller Api/ExerciseController --api
php artisan make:controller Api/PageController --api
php artisan make:controller Api/PlanController --api
php artisan make:controller Api/PlanWorkoutController --api
php artisan make:controller Api/RoleController --api
php artisan make:controller Api/SwimSetController --api
php artisan make:controller Api/UploadController --api
php artisan make:controller Api/UserController --api
php artisan make:controller Api/WorkoutController --api
php artisan make:controller Api/WorkoutExerciseController --api
php artisan make:controller Api/WorkoutSwimSetController --api
php artisan make:controller Api/MylisteController --api
php artisan make:controller Api/MylisteItemController --api

Contrôleur

namespace App\Http\Controllers;

use App\Models\Role;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;

class RoleController extends Controller
{
    /**
     * Display a listing of the resource.
     */
    public function index()
    {
        $roles = Role::all();
        return response()->json($roles, 200); // Réponse JSON brute
    }

    /**
     * Store a newly created resource in storage.
     */
    public function store(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'name' => 'required|unique:roles|max:255',
        ]);

        if ($validator->fails()) {
            return response()->json(['errors' => $validator->errors()], 400);
        }

        $role = Role::create($request->validated());
        return response()->json($role, 201); // 201 Created
    }

    /**
     * Display the specified resource.
     */
    public function show(Role $role)
    {
        return response()->json($role, 200);
    }

    /**
     * Update the specified resource in storage.
     */
    public function update(Request $request, Role $role)
    {
        $validator = Validator::make($request->all(), [
            'name' => 'required|unique:roles,name,' . $role->id . '|max:255',
        ]);

        if ($validator->fails()) {
            return response()->json(['errors' => $validator->errors()], 400);
        }

        $role->update($request->validated());
        return response()->json($role, 200);
    }

    /**
     * Remove the specified resource from storage.
     */
    public function destroy(Role $role)
    {
        $role->delete();
        return response()->json(null, 204); // 204 No Content
    }
}

Contrôleur

namespace App\Http\Controllers;

use App\Models\User;
use App\Models\Role; // Importez le modèle Role
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;
use Illuminate\Support\Facades\Hash; // Pour hasher le mot de passe

class UserController extends Controller
{
    /**
     * Display a listing of the resource.
     */
    public function index()
    {
        $users = User::all();
        return response()->json($users, 200);
    }

    /**
     * Store a newly created resource in storage.
     */
    public function store(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'username' => 'required|unique:users|max:255',
            'email' => 'required|email|unique:users|max:255',
            'password' => 'required|min:8',
            'first_name' => 'nullable|max:255',
            'last_name' => 'nullable|max:255',
            'role_id' => 'nullable|exists:roles,id', // Valider l'existence du rôle
        ]);

        if ($validator->fails()) {
            return response()->json(['errors' => $validator->errors()], 400);
        }

        $user = User::create([
            'username' => $request->input('username'),
            'email' => $request->input('email'),
            'password' => Hash::make($request->input('password')), // Hasher le mot de passe
            'first_name' => $request->input('first_name'),
            'last_name' => $request->input('last_name'),
            'role_id' => $request->input('role_id'),
        ]);

        return response()->json($user, 201);
    }

    /**
     * Display the specified resource.
     */
    public function show(User $user)
    {
        return response()->json($user, 200);
    }

    /**
     * Update the specified resource in storage.
     */
    public function update(Request $request, User $user)
    {
        $validator = Validator::make($request->all(), [
            'username' => 'required|max:255|unique:users,username,' . $user->id,
            'email' => 'required|email|max:255|unique:users,email,' . $user->id,
            'first_name' => 'nullable|max:255',
            'last_name' => 'nullable|max:255',
            'role_id' => 'nullable|exists:roles,id',
        ]);

        if ($validator->fails()) {
            return response()->json(['errors' => $validator->errors()], 400);
        }

        $user->update([
            'username' => $request->input('username'),
            'email' => $request->input('email'),
            'first_name' => $request->input('first_name'),
            'last_name' => $request->input('last_name'),
            'role_id' => $request->input('role_id'),
        ]);

        // Gérer la modification du mot de passe si fourni
        if ($request->filled('password')) {
            $user->password = Hash::make($request->input('password'));
            $user->save();
        }

        return response()->json($user, 200);
    }

    /**
     * Remove the specified resource from storage.
     */
    public function destroy(User $user)
    {
        $user->delete();
        return response()->json(null, 204);
    }

    /**
     * Get users by role.
     */
    public function getUsersByRole(Role $role)
    {
        $users = $role->users; // Utiliser la relation définie dans le modèle Role
        return response()->json($users, 200);
    }
}

Contrôleur

namespace App\Http\Controllers;

use App\Models\Upload;
use App\Models\User; // Importez le modèle User
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;
use Illuminate\Support\Facades\Storage; // Pour la gestion des fichiers

class UploadController extends Controller
{
    /**
     * Display a listing of the resource.
     */
    public function index()
    {
        $uploads = Upload::all();
        return response()->json($uploads, 200);
    }

    /**
     * Store a newly created resource in storage.
     */
    public function store(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'filename' => 'required|max:255', // Peut-être pas nécessaire si géré automatiquement
            'file' => 'required|file|mimes:jpeg,png,jpg,gif,pdf|max:2048', // Exemple de types de fichiers
            'type' => 'nullable|max:255',
            'user_id' => 'nullable|exists:users,id',
        ]);

        if ($validator->fails()) {
            return response()->json(['errors' => $validator->errors()], 400);
        }

        if ($request->hasFile('file')) {
            $file = $request->file('file');
            $path = $file->store('uploads'); // Enregistrement dans storage/app/uploads

            $upload = Upload::create([
                'filename' => $file->getClientOriginalName(), // Ou un nom généré
                'path' => $path,
                'type' => $request->input('type'),
                'user_id' => $request->input('user_id'),
            ]);

            return response()->json($upload, 201);
        }

        return response()->json(['error' => 'No file uploaded'], 400); // Si aucun fichier n'est présent
    }

    /**
     * Display the specified resource.
     */
    public function show(Upload $upload)
    {
        return response()->json($upload, 200);
    }

    /**
     * Update the specified resource in storage.
     */
    public function update(Request $request, Upload $upload)
    {
        $validator = Validator::make($request->all(), [
            'filename' => 'required|max:255',
            'type' => 'nullable|max:255',
            'user_id' => 'nullable|exists:users,id',
        ]);

        if ($validator->fails()) {
            return response()->json(['errors' => $validator->errors()], 400);
        }

        $upload->update([
            'filename' => $request->input('filename'),
            'type' => $request->input('type'),
            'user_id' => $request->input('user_id'),
        ]);

        return response()->json($upload, 200);
    }

    /**
     * Remove the specified resource from storage.
     */
    public function destroy(Upload $upload)
    {
        // Supprimer le fichier physique
        Storage::delete($upload->path);
        $upload->delete();
        return response()->json(null, 204);
    }

    /**
     * Get uploads by user.
     */
    public function getUserUploads(User $user)
    {
        $uploads = $user->uploads; // Utiliser la relation définie dans le modèle User
        return response()->json($uploads, 200);
    }
}

## La méthode store utilise $request->file(‘file’)->store(‘uploads’) pour enregistrer le fichier dans le dossier storage/app/uploads.

## Configuration de stockage dans config/filesystem.php

## Le nom du fichier est récupéré avec $file->getClientOriginalName()

Contrôleur

namespace App\Http\Controllers;

use App\Models\Page;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;

class PageController extends Controller
{
    /**
     * Display a listing of the resource.
     */
    public function index()
    {
        $pages = Page::all();
        return response()->json($pages, 200);
    }

    /**
     * Store a newly created resource in storage.
     */
    public function store(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'title' => 'required|max:255',
            'content' => 'required', // Ou nullable si le contenu peut être vide
            'page_category' => 'nullable|max:255',
            'upload_id' => 'nullable|exists:uploads,id',
            'user_id' => 'required|exists:users,id',
        ]);

        if ($validator->fails()) {
            return response()->json(['errors' => $validator->errors()], 400);
        }

        $page = Page::create($request->validated());
        return response()->json($page, 201);
    }

    /**
     * Display the specified resource.
     */
    public function show(Page $page)
    {
        return response()->json($page, 200);
    }

    /**
     * Update the specified resource in storage.
     */
    public function update(Request $request, Page $page)
    {
        $validator = Validator::make($request->all(), [
            'title' => 'required|max:255',
            'content' => 'required', // Ou nullable si le contenu peut être vide
            'page_category' => 'nullable|max:255',
            'upload_id' => 'nullable|exists:uploads,id',
            'user_id' => 'required|exists:users,id',
        ]);

        if ($validator->fails()) {
            return response()->json(['errors' => $validator->errors()], 400);
        }

        $page->update($request->validated());
        return response()->json($page, 200);
    }

    /**
     * Remove the specified resource from storage.
     */
    public function destroy(Page $page)
    {
        $page->delete();
        return response()->json(null, 204);
    }
}

## Validation pour tous les champs —== les clés étrangères (upload_id et user_id). exists:uploads,id et exists:users,id vérifient que les IDs fournis existent dans les tables correspondantes
## content est marqué comme required pour ne pas avoir de page vide

Contrôleur

namespace App\Http\Controllers;

use App\Models\Exercise;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;

class ExerciseController extends Controller
{
    /**
     * Display a listing of the resource.
     */
    public function index()
    {
        $exercises = Exercise::all();
        return response()->json($exercises, 200);
    }

    /**
     * Store a newly created resource in storage.
     */
    public function store(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'title' => 'required|max:255',
            'description' => 'nullable',
            'exercise_level' => 'nullable|max:255',
            'exercise_category' => 'nullable|max:255',
            'upload_id' => 'nullable|exists:uploads,id',
            'user_id' => 'required|exists:users,id',
        ]);

        if ($validator->fails()) {
            return response()->json(['errors' => $validator->errors()], 400);
        }

        $exercise = Exercise::create($request->validated());
        return response()->json($exercise, 201);
    }

    /**
     * Display the specified resource.
     */
    public function show(Exercise $exercise)
    {
        return response()->json($exercise, 200);
    }

    /**
     * Update the specified resource in storage.
     */
    public function update(Request $request, Exercise $exercise)
    {
        $validator = Validator::make($request->all(), [
            'title' => 'required|max:255',
            'description' => 'nullable',
            'exercise_level' => 'nullable|max:255',
            'exercise_category' => 'nullable|max:255',
            'upload_id' => 'nullable|exists:uploads,id',
            'user_id' => 'required|exists:users,id',
        ]);

        if ($validator->fails()) {
            return response()->json(['errors' => $validator->errors()], 400);
        }

        $exercise->update($request->validated());
        return response()->json($exercise, 200);
    }

    /**
     * Remove the specified resource from storage.
     */
    public function destroy(Exercise $exercise)
    {
        $exercise->delete();
        return response()->json(null, 204);
    }
}

## Validation pour tous les champs +++=== compris les clés étrangères (upload_id et user_id). exists:uploads,id et exists:users,id +++ vérifier que les IDs fournis existent dans les tables
## Tous les champs sont validés
## règles (nullable ou required) a voir selon …..
Clés étrangères upload_id et user_id en BdD dans le modèle Exercise

Contrôleur

namespace App\Http\Controllers;

use App\Models\Plan;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;

class PlanController extends Controller
{
    /**
     * Display a listing of the resource.
     */
    public function index()
    {
        $plans = Plan::all();
        return response()->json($plans, 200);
    }

    /**
     * Store a newly created resource in storage.
     */
    public function store(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'title' => 'required|max:255',
            'description' => 'nullable',
            'plan_category' => 'nullable|max:255',
            'user_id' => 'required|exists:users,id',
        ]);

        if ($validator->fails()) {
            return response()->json(['errors' => $validator->errors()], 400);
        }

        $plan = Plan::create($request->validated());
        return response()->json($plan, 201);
    }

    /**
     * Display the specified resource.
     */
    public function show(Plan $plan)
    {
        return response()->json($plan, 200);
    }

    /**
     * Update the specified resource in storage.
     */
    public function update(Request $request, Plan $plan)
    {
        $validator = Validator::make($request->all(), [
            'title' => 'required|max:255',
            'description' => 'nullable',
            'plan_category' => 'nullable|max:255',
            'user_id' => 'required|exists:users,id',
        ]);

        if ($validator->fails()) {
            return response()->json(['errors' => $validator->errors()], 400);
        }

        $plan->update($request->validated());
        return response()->json($plan, 200);
    }

    /**
     * Remove the specified resource from storage.
     */
    public function destroy(Plan $plan)
    {
        $plan->delete();
        return response()->json(null, 204);
    }
}

## validation pour tous les champs +++=== clé étrangère user_id. exists:users,id
## Clé étrangère vérifiée dans le modèle Plan.

Contrôleur

namespace App\Http\Controllers;

use App\Models\Workout;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;

class WorkoutController extends Controller
{
    /**
     * Display a listing of the resource.
     */
    public function index()
    {
        $workouts = Workout::all();
        return response()->json($workouts, 200);
    }

    /**
     * Store a newly created resource in storage.
     */
    public function store(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'title' => 'required|max:255',
            'description' => 'nullable',
            'workout_category' => 'nullable|max:255',
            'user_id' => 'required|exists:users,id',
        ]);

        if ($validator->fails()) {
            return response()->json(['errors' => $validator->errors()], 400);
        }

        $workout = Workout::create($request->validated());
        return response()->json($workout, 201);
    }

    /**
     * Display the specified resource.
     */
    public function show(Workout $workout)
    {
        return response()->json($workout, 200);
    }

    /**
     * Update the specified resource in storage.
     */
    public function update(Request $request, Workout $workout)
    {
        $validator = Validator::make($request->all(), [
            'title' => 'required|max:255',
            'description' => 'nullable',
            'workout_category' => 'nullable|max:255',
            'user_id' => 'required|exists:users,id',
        ]);

        if ($validator->fails()) {
            return response()->json(['errors' => $validator->errors()], 400);
        }

        $workout->update($request->validated());
        return response()->json($workout, 200);
    }

    /**
     * Remove the specified resource from storage.
     */
    public function destroy(Workout $workout)
    {
        $workout->delete();
        return response()->json(null, 204);
    }
}

## validation a été ajoutée pour tous les champs +++ clé étrangère user_id. exists:users,id

Contrôleur

namespace App\Http\Controllers;

use App\Models\Myliste;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;

class MylisteController extends Controller
{
    /**
     * Display a listing of the resource.
     */
    public function index()
    {
        $mylistes = Myliste::all();
        return response()->json($mylistes, 200);
    }

    /**
     * Store a newly created resource in storage.
     */
    public function store(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'user_id' => 'required|exists:users,id',
            'title' => 'required|max:255',
            'description' => 'nullable',
        ]);

        if ($validator->fails()) {
            return response()->json(['errors' => $validator->errors()], 400);
        }

        $myliste = Myliste::create($request->validated());
        return response()->json($myliste, 201);
    }

    /**
     * Display the specified resource.
     */
    public function show(Myliste $myliste)
    {
        return response()->json($myliste, 200);
    }

    /**
     * Update the specified resource in storage.
     */
    public function update(Request $request, Myliste $myliste)
    {
        $validator = Validator::make($request->all(), [
            'user_id' => 'required|exists:users,id',
            'title' => 'required|max:255',
            'description' => 'nullable',
        ]);

        if ($validator->fails()) {
            return response()->json(['errors' => $validator->errors()], 400);
        }

        $myliste->update($request->validated());
        return response()->json($myliste, 200);
    }

    /**
     * Remove the specified resource from storage.
     */
    public function destroy(Myliste $myliste)
    {
        $myliste->delete();
        return response()->json(null, 204);
    }
}

Contrôleur

namespace App\Http\Controllers;

use App\Models\SwimSet;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;

class SwimSetController extends Controller
{
    /**
     * Display a listing of the resource.
     */
    public function index()
    {
        $swimSets = SwimSet::all();
        return response()->json($swimSets, 200);
    }

    /**
     * Store a newly created resource in storage.
     */
    public function store(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'workout_id' => 'nullable|exists:workouts,id',
            'exercise_id' => 'nullable|exists:exercises,id',
            'set_distance' => 'nullable|integer',
            'set_repetition' => 'nullable|integer',
            'rest_time' => 'nullable|integer',
        ]);

        if ($validator->fails()) {
            return response()->json(['errors' => $validator->errors()], 400);
        }

        $swimSet = SwimSet::create($request->validated());
        return response()->json($swimSet, 201);
    }

    /**
     * Display the specified resource.
     */
    public function show(SwimSet $swimSet)
    {
        return response()->json($swimSet, 200);
    }

    /**
     * Update the specified resource in storage.
     */
    public function update(Request $request, SwimSet $swimSet)
    {
        $validator = Validator::make($request->all(), [
            'workout_id' => 'nullable|exists:workouts,id',
            'exercise_id' => 'nullable|exists:exercises,id',
            'set_distance' => 'nullable|integer',
            'set_repetition' => 'nullable|integer',
            'rest_time' => 'nullable|integer',
        ]);

        if ($validator->fails()) {
            return response()->json(['errors' => $validator->errors()], 400);
        }

        $swimSet->update($request->validated());
        return response()->json($swimSet, 200);
    }

    /**
     * Remove the specified resource from storage.
     */
    public function destroy(SwimSet $swimSet)
    {
        $swimSet->delete();
        return response()->json(null, 204);
    }
}

Contrôleur

Ce contrôleur gère l’association entre les séances d’entraînement (workouts) et les exercices (exercises) via une relation Many-to-Many
Les modèles Workout et Exercise sont ajoués / injectés  dans les méthodes

• index: Récupère tous les exercices associés à un workout
• store: Attache un exercice à un workout.  méthode vérifie d’abord si l’association existe déjà avant de l’attacher pour eviter  les doublons dans la table de jointure.
• destroy: Détache un exercice d’un workout elle vérifie si l’association existe avant de la détacher
•  store valide l’id de l’exercice pour s’assurer qu’il existe

namespace App\Http\Controllers;

use App\Models\Workout;
use App\Models\Exercise;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;

class WorkoutExerciseController extends Controller
{
    /**
     * Display a listing of the exercises for a given workout.
     */
    public function index(Workout $workout)
    {
        return response()->json($workout->exercises, 200);
    }

    /**
     * Attach an exercise to a workout.
     */
    public function store(Request $request, Workout $workout)
    {
        $validator = Validator::make($request->all(), [
            'exercise_id' => 'required|exists:exercises,id',
        ]);

        if ($validator->fails()) {
            return response()->json(['errors' => $validator->errors()], 400);
        }

        // Vérifier si l'association existe déjà
        if ($workout->exercises()->where('exercise_id', $request->input('exercise_id'))->exists()) {
            return response()->json(['error' => 'Exercise already attached to this workout.'], 400);
        }

        $workout->exercises()->attach($request->input('exercise_id'));

        return response()->json(['message' => 'Exercise attached successfully.'], 201);
    }



    /**
     * Detach an exercise from a workout.
     */
    public function destroy(Workout $workout, Exercise $exercise)
    {
       // Vérifier si l'association existe avant de détacher
        if (!$workout->exercises()->where('exercise_id', $exercise->id)->exists()) {
            return response()->json(['error' => 'Exercise is not attached to this workout.'], 400);
        }
        $workout->exercises()->detach($exercise->id);
        return response()->json(null, 204);
    }
}

## relation Many-to-Many entre les séances d’entraînement (workouts) et les séries de natation (swim sets)

## Injection de dépendances des modèles Workout et SwimSet dans les méthodes.

• index récupère les swim sets associés à un workout 
• store attache un swim set à un workout avec injection de SwimSet $swimSet 
• destroy détache un swim set d’un workout

namespace App\Http\Controllers;

use App\Models\Workout;
use App\Models\SwimSet;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;

class WorkoutSwimSetController extends Controller
{
    /**
     * Display a listing of the swim sets for a given workout.
     */
    public function index(Workout $workout)
    {
        return response()->json($workout->swimSets, 200);
    }

    /**
     * Attach a swim set to a workout.
     */
    public function store(Request $request, Workout $workout, SwimSet $swimSet) // Ajout de SwimSet dans l'injection
    {
        // Pas de validation ici, car l'ID de swimSet est déjà validé par l'injection de dépendances

        // Vérifier si l'association existe déjà
        if ($workout->swimSets()->where('swim_set_id', $swimSet->id)->exists()) {
            return response()->json(['error' => 'Swim set already attached to this workout.'], 400);
        }

        $workout->swimSets()->attach($swimSet->id); // Utiliser l'ID directement
        return response()->json(['message' => 'Swim set attached successfully.'], 201);
    }

    /**
     * Detach a swim set from a workout.
     */
    public function destroy(Workout $workout, SwimSet $swimSet)  // Ajout de SwimSet dans l'injection
    {
         // Vérifier si l'association existe avant de détacher
        if (!$workout->swimSets()->where('swim_set_id', $swimSet->id)->exists()) {
            return response()->json(['error' => 'Swim set is not attached to this workout.'], 400);
        }

        $workout->swimSets()->detach($swimSet->id); // Utiliser l'ID directement
        return response()->json(null, 204);
    }
}

## Relations Many-to-Many entre les plans et les séances d’entraînement (workouts

##Injection de dépendances des modèles Plan et Workout dans les méthodes

• index récupère tous les workouts associés à un plan 
• store lie  un workout à un plan …  validation parr l’injection de Workout $workout s’occupe déjà de vérifier que l’ID existe
• destroy détache un workout d’un plan

namespace App\Http\Controllers;

use App\Models\Plan;
use App\Models\Workout;
use Illuminate\Http\Request;

class PlanWorkoutController extends Controller
{
    /**
     * Display a listing of the workouts for a given plan.
     */
    public function index(Plan $plan)
    {
        return response()->json($plan->workouts, 200);
    }

    /**
     * Attach a workout to a plan.
     */
    public function store(Request $request, Plan $plan, Workout $workout)
    {
        // Pas de validation ici, car l'ID de workout est déjà validé par l'injection de dépendances

        // Vérifier si l'association existe déjà
        if ($plan->workouts()->where('workout_id', $workout->id)->exists()) {
            return response()->json(['error' => 'Workout already attached to this plan.'], 400);
        }

        $plan->workouts()->attach($workout->id);
        return response()->json(['message' => 'Workout attached successfully.'], 201);
    }

    /**
     * Detach a workout from a plan.
     */
    public function destroy(Plan $plan, Workout $workout)
    {
        // Vérifier si l'association existe avant de détacher
        if (!$plan->workouts()->where('workout_id', $workout->id)->exists()) {
            return response()->json(['error' => 'Workout is not attached to this plan.'], 400);
        }

        $plan->workouts()->detach($workout->id);
        return response()->json(null, 204);
    }
}

### Ce contrôleur gère l’ajout et la suppression d’éléments polymorphiques (exercices, séances, plans) dans les listes personnelles (mylistes)

Le modèle Myliste est injecté pour simplifier son utilisation ### MylisteItem est injecté aussi  dans destroy pour faciliter la suppression et la validation

• index récupère tous les éléments (polymorphiques) associés à une une myliste 
• store ajoute un nouvel élément à une myliste
• destroy supprime un élément d’une myliste

namespace App\Http\Controllers;

use App\Models\Myliste;
use App\Models\MylisteItem;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;

class MylisteItemController extends Controller
{
    /**
     * Display a listing of the items for a given myliste.
     */
    public function index(Myliste $myliste)
    {
        return response()->json($myliste->mylisteItems, 200);
    }

    /**
     * Store a new item in a given myliste.
     */
    public function store(Request $request, Myliste $myliste)
    {
        $validator = Validator::make($request->all(), [
            'item_id' => 'required|integer',  // Validation de l'ID
            'item_type' => 'required|string|max:255', // Validation du type
        ]);

        if ($validator->fails()) {
            return response()->json(['errors' => $validator->errors()], 400);
        }

        $itemType = $request->input('item_type');
        $itemId = $request->input('item_id');

        // Vérifier si l'item existe bien en fonction de son type
        switch ($itemType) {
            case 'exercise':
                $item = \App\Models\Exercise::find($itemId);
                break;
            case 'workout':
                $item = \App\Models\Workout::find($itemId);
                break;
            case 'plan':
                $item = \App\Models\Plan::find($itemId);
                break;
            default:
                return response()->json(['error' => 'Invalid item type.'], 400);
        }

         if (!$item) {
            return response()->json(['error' => 'Item not found.'], 404);
        }


        $mylisteItem = new MylisteItem();
        $mylisteItem->myliste_id = $myliste->id;
        $mylisteItem->item_id = $itemId;
        $mylisteItem->item_type = $itemType;
        $mylisteItem->save();


        return response()->json($mylisteItem, 201);
    }

    /**
     * Remove an item from a given myliste.
     */
    public function destroy(Myliste $myliste, MylisteItem $mylisteItem)
    {

        // Vérifier que l'item appartient bien à la liste
        if ($mylisteItem->myliste_id !== $myliste->id) {
            return response()->json(['error' => 'Item does not belong to this list.'], 400);
        }
        $mylisteItem->delete();
        return response()->json(null, 204);
    }
}