Les contrôleurs (personnage, inventaire, objet)

PersonnageController

Ce code définit un contrôleur RESTful pour gérer les demandes liées aux personnages dans une application Spring. Le contrôleur est annoté avec @RestController et @RequestMapping pour indiquer qu’il s’agit d’un contrôleur RESTful et pour mapper les demandes à l’URI /api/personnages.

Le contrôleur utilise l’annotation @Autowired pour injecter une instance de PersonnageRepository dans la classe. Le PersonnageRepository est utilisé pour effectuer des opérations CRUD (Create, Read, Update, Delete) sur les données des personnages.

// Définition du package où se trouve le contrôleur
package com.example.rest.Controller.Personnage;

// Importation des classes nécessaires pour définir les DTOs (Data Transfer Objects)
import com.example.rest.DTO.InventaireDTO;
import com.example.rest.DTO.ObjetDTO;
import com.example.rest.DTO.PersonnageDTO;
import com.example.rest.DTO.ProfilDTO;

// Importation des modèles nécessaires pour définir les types d'entités et leurs relations
import com.example.rest.Model.Profil;
import com.example.rest.Model.Personnage.Inventaire;
import com.example.rest.Model.Personnage.Objet;
import com.example.rest.Model.Personnage.Personnage;

// Importation de l'interface du repository pour accéder aux données des personnages
import com.example.rest.Repository.Personnage.IPersonnageRepository;

// Importation de l'annotation pour définir une méthode comme transactionnelle
import jakarta.transaction.Transactional;

// Importations nécessaires pour l'injection de dépendances et la gestion des exceptions
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

// Importations pour la gestion des collections et des flux de données
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

// Définition de la route de base pour ce contrôleur
@RestController
@RequestMapping("/personnages")
public class PersonnageController {
    // Injection de l'interface du repository pour accéder aux données des personnages
    @Autowired
    private IPersonnageRepository personnageRepository;

    // Get all Personnages
    // @GetMapping
    // public ResponseEntity<List<Personnage>> getAllPersonnages() {
    // List<Personnage> personnages = (List<Personnage>)
    // personnageRepository.findAll();
    // return new ResponseEntity<>(personnages, HttpStatus.OK);
    // }

    // curl -X GET http://localhost:8080/personnages
    // Méthode pour obtenir tous les personnages sous forme de DTOs
    @GetMapping
    public ResponseEntity<List<PersonnageDTO>> getAllPersonnages() {
        List<Personnage> personnages = (List<Personnage>) personnageRepository.findAll();
        List<PersonnageDTO> personnageDTOs = personnages.stream()
                .map(personnage -> convertToDTO(personnage))
                .collect(Collectors.toList());
        return new ResponseEntity<>(personnageDTOs, HttpStatus.OK);
    }

    // Méthode pour convertir un objet Personnage en PersonnageDTO
    private PersonnageDTO convertToDTO(Personnage personnage) {
        PersonnageDTO dto = new PersonnageDTO();
        dto.setId(personnage.getId());
        dto.setNom(personnage.getNom());
        dto.setClasse(personnage.getClasse());
        dto.setPointsExperience(personnage.getPointsExperience());
        dto.setPointsMana(personnage.getPointsMana());
        dto.setPointsVie(personnage.getPointsVie());
        dto.setpointForce(personnage.getPointsForce());
        dto.setpointScore(personnage.getPointsScore());
        dto.setNiveau(personnage.getNiveau());

        // Convertir Set<Inventaire> à Set<InventaireDTO>
        Set<InventaireDTO> inventaireDTOs = personnage.getInventaire().stream()
                .map(this::convertToInventaireDTO)
                .collect(Collectors.toSet());
        dto.setInventaire(inventaireDTOs);

        // Convertir Profil à ProfilDTO
        ProfilDTO profilDTO = convertToProfilDTO(personnage.getProfil());
        dto.setProfil(profilDTO);

        return dto;
    }
    // Méthode pour convertir un objet Inventaire en InventaireDTO
    private InventaireDTO convertToInventaireDTO(Inventaire inventaire) {
        // Implémentez la logique de conversion ici
        if(inventaire == null) {
            return null; // ou vous pouvez choisir de retourner une instance par défaut de InventaireDTO
        }
        
        InventaireDTO inventaireDTO = new InventaireDTO();
        
        inventaireDTO.setId(inventaire.getId());
        
        // Si vous avez une méthode pour convertir Personnage à PersonnageDTO
        inventaireDTO.setPersonnage(convertToPersonnageDTO(inventaire.getPersonnage()));
        
        // Si vous avez une méthode pour convertir Objet à ObjetDTO
        inventaireDTO.setObjet(convertToObjetDTO(inventaire.getObjet()));
        
        inventaireDTO.setQuantite(inventaire.getQuantite());
        
        return inventaireDTO;
    }

    private PersonnageDTO convertToPersonnageDTO(Personnage personnage) {
        if(personnage == null) {
            return null; // ou vous pouvez choisir de retourner une instance par défaut de PersonnageDTO
        }
        
        PersonnageDTO personnageDTO = new PersonnageDTO();
        
        personnageDTO.setId(personnage.getId());
        personnageDTO.setNom(personnage.getNom());
        personnageDTO.setClasse(personnage.getClasse());
        personnageDTO.setNiveau(personnage.getNiveau());
        personnageDTO.setPointsExperience(personnage.getPointsExperience());
        personnageDTO.setPointsVie(personnage.getPointsVie());
        personnageDTO.setPointsMana(personnage.getPointsMana());
        personnageDTO.setpointForce(personnage.getPointsForce());
        personnageDTO.setpointScore(personnage.getPointsScore());
        
        // Convertir les objets associés
        personnageDTO.setProfil(convertToProfilDTO(personnage.getProfil()));
        
        // Si Inventaire est une collection, vous devrez la convertir en une collection de DTOs
        Set<InventaireDTO> inventaireDTOs = personnage.getInventaire().stream()
            .map(this::convertToInventaireDTO)
            .collect(Collectors.toSet());
        personnageDTO.setInventaire(inventaireDTOs);
        
        return personnageDTO;
    }
    
    // Méthode pour convertir un objet Profil en ProfilDTO
    private ProfilDTO convertToProfilDTO(Profil profil) {
        ProfilDTO dto = new ProfilDTO();
        dto.setId(profil.getId());
        dto.setName(profil.getName());

        // Settez les champs de profil dans ProfilDTO
        return dto;
    }

    private ObjetDTO convertToObjetDTO(Objet objet) {
        if(objet == null) {
            return null; // ou vous pouvez choisir de retourner une instance par défaut de ObjetDTO
        }
        
        ObjetDTO objetDTO = new ObjetDTO();
        
        // Initialisez les champs de ObjetDTO avec les valeurs de l'objet Objet
       // objetDTO.setId(objet.getId());
        // ... (autres champs à initialiser)
    
        return objetDTO;
    }
    

    // Get a single Personnage by ID
    @GetMapping("/{id}")
    public ResponseEntity<PersonnageDTO> getPersonnageById(@PathVariable Long id) {
        Optional<Personnage> optionalPersonnage = personnageRepository.findById(id);

        if (optionalPersonnage.isPresent()) {
            PersonnageDTO personnageDTO = convertToDTO(optionalPersonnage.get());
            return new ResponseEntity<>(personnageDTO, HttpStatus.OK);
        } else {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }
    }
    // curl -X GET http://localhost:8080/personnages/{id}

    // Create a new Personnage
    @PostMapping
    public ResponseEntity<Personnage> createPersonnage(@RequestBody Personnage personnage) {
        Personnage savedPersonnage = personnageRepository.save(personnage);
        return new ResponseEntity<>(savedPersonnage, HttpStatus.CREATED);
    }
    // curl -X POST -H "Content-Type: application/json" -d
    // '{"nom":"Roger","classe":"Lapin","niveau":1,"pointsExperience":0,"pointsVie":100,"pointsMana":100,"pointsForce":10,"pointsScore":0}'
    // http://localhost:8080/personnages

    // Update a Personnage by ID
    @PutMapping("/{id}")
    public ResponseEntity<Personnage> updatePersonnage(@PathVariable Long id,
            @RequestBody Personnage personnageDetails) {
        Optional<Personnage> personnageOptional = personnageRepository.findById(id);
        if (personnageOptional.isEmpty())
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);

        Personnage personnage = personnageOptional.get();
        // Update the fields of the existing Personnage
        // For example, if Personnage has a field 'name', you can do:
        // personnage.setName(personnageDetails.getName());
        personnage.setNom(personnageDetails.getNom());
        personnage.setClasse(personnageDetails.getClasse());
        personnage.setNiveau(personnageDetails.getNiveau());
        personnage.setPointsExperience(personnageDetails.getPointsExperience());
        personnage.setPointsVie(personnageDetails.getPointsVie());
        personnage.setPointsMana(personnageDetails.getPointsMana());
        personnage.setPointsForce(personnageDetails.getPointsForce());
        personnage.setPointsScore(personnageDetails.getPointsScore());

        Personnage updatedPersonnage = personnageRepository.save(personnage);
        return new ResponseEntity<>(updatedPersonnage, HttpStatus.OK);
    }
    // curl -X PUT -H "Content-Type: application/json" -d
    // '{"nom":"UpdatedName","classe":"UpdatedClass","niveau":2,"pointsExperience":10,"pointsVie":110,"pointsMana":110,"pointsForce":11,"dexterite":11,"constitution":11,"intelligence":16,"sagesse":16,"charisme":21,"location":"UpdatedLocation","pointsScore":1}'
    // http://localhost:8080/personnages/{id}

    // Méthode pour supprimer un personnage spécifique par son ID
    @DeleteMapping("/{id}")
    @Transactional
    public ResponseEntity<Void> deletePersonnage(@PathVariable Long id) {
        System.out.println("Delete method called with ID: " + id); // Log de débogage
        try {
            personnageRepository.deleteById(id);
            return new ResponseEntity<>(HttpStatus.NO_CONTENT);
        } catch (EmptyResultDataAccessException e) {
            e.printStackTrace(); // Log the exception to get more details
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        } catch (Exception e) {
            e.printStackTrace(); // Log the exception to get more details
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }
    // curl -X DELETE http://localhost:8080/personnages/{id}

    // Get all Objets from the Inventaire of a Personnage by ID
    @GetMapping("/{id}/inventaire/objets")
    public ResponseEntity<List<ObjetDTO>> getObjetsFromPersonnageInventaire(
            @PathVariable(value = "id") Long personnageId) {
        Optional<Personnage> personnageOptional = personnageRepository.findByIdWithInventairesAndObjet(personnageId);

        if (!personnageOptional.isPresent()) {
            return ResponseEntity.notFound().build(); // Personnage non trouvé
        }

        Personnage personnage = personnageOptional.get();
        Set<Inventaire> inventaires = personnage.getInventaire();

        if (inventaires == null || inventaires.isEmpty()) {
            return ResponseEntity.notFound().build(); // Inventaire non trouvé pour le personnage donné
        }

        List<ObjetDTO> objetsDto = inventaires.stream()
                .map(Inventaire::getObjet) // Assurez-vous que cette méthode existe
                .filter(Objects::nonNull)
                .map(ObjetDTO::new) // Convertissez l'objet en DTO
                .collect(Collectors.toList());

        return objetsDto.isEmpty() ? ResponseEntity.ok(Collections.emptyList()) : ResponseEntity.ok(objetsDto);
    }

}

getPersonnageById, pas à pas :

La méthode getPersonnageById est une méthode HTTP GET définie pour traiter les requêtes à l'URL /personnages/{id}, où {id} est un paramètre représentant l'ID du Personnage à récupérer. Elle est déclarée comme suit : @GetMapping("/{id}") public ResponseEntity<PersonnageDTO> getPersonnageById(@PathVariable Long id).

Dans cette méthode, le personnageRepository est utilisé pour rechercher un Personnage par son ID : Optional<Personnage> optionalPersonnage = personnageRepository.findById(id);. Le résultat de cette recherche est stocké dans un objet Optional, qui sera vide si aucun Personnage avec l'ID spécifié n'est trouvé.

Ensuite, la méthode vérifie si l'objet Optional contient un Personnage avec la ligne if (optionalPersonnage.isPresent()) {. Si un Personnage est trouvé, il est converti en PersonnageDTO grâce à la méthode convertToDTO: PersonnageDTO personnageDTO = convertToDTO(optionalPersonnage.get());.

Après la conversion, la méthode renvoie une réponse HTTP avec le statut 200 OK et le PersonnageDTO converti : return new ResponseEntity<>(personnageDTO, HttpStatus.OK);. Cela signifie que la requête a été traitée avec succès et que le PersonnageDTO est inclus dans le corps de la réponse HTTP.

Si, en revanche, aucun Personnage n'est trouvé, la méthode renvoie une réponse avec le statut 404 Not Found : return new ResponseEntity<>(HttpStatus.NOT_FOUND);. Cela indique au client que la ressource demandée, dans ce cas un Personnage avec l'ID spécifié, n'a pas été trouvée.

En résumé, la méthode getPersonnageById tente de trouver et de renvoyer un Personnage en fonction de l'ID fourni, converti en PersonnageDTO, et gère les cas où le Personnage spécifié n'est pas trouvé en renvoyant le statut approprié.

updatePersonnage, pas à pas :

La méthode updatePersonnage est conçue pour gérer les requêtes HTTP PUT destinées à mettre à jour un objet Personnage existant dans la base de données. Elle est annotée avec @PutMapping("/{id}"), ce qui signifie qu'elle répond aux requêtes PUT sur le chemin /personnages/{id}, où {id} est une variable représentant l'ID du Personnage à mettre à jour.

La signature de la méthode est public ResponseEntity<Personnage> updatePersonnage(@PathVariable Long id, @RequestBody Personnage personnageDetails), où @PathVariable Long id indique que la méthode prend un paramètre id du chemin de l'URL, et @RequestBody Personnage personnageDetails indique qu'elle prend également un objet Personnage du corps de la requête HTTP, qui contient les détails à mettre à jour.

À l'intérieur de la méthode, on utilise personnageRepository.findById(id) pour tenter de trouver le Personnage existant correspondant à l'ID donné. Cette opération renvoie un objet Optional<Personnage>, qui sera non vide si un Personnage avec l'ID spécifié est trouvé, et vide dans le cas contraire.

Si l'Optional est vide, signifiant que le Personnage à mettre à jour n'a pas été trouvé, la méthode renvoie une réponse avec un statut 404 Not Found: return new ResponseEntity<>(HttpStatus.NOT_FOUND);.

Si un Personnage est trouvé, il est extrait de l'Optional avec Personnage personnage = personnageOptional.get();, et ses champs sont ensuite mis à jour avec les valeurs de personnageDetails, l'objet Personnage reçu dans le corps de la requête. Par exemple, personnage.setNom(personnageDetails.getNom()); met à jour le nom du Personnage trouvé avec le nom de personnageDetails.

Après la mise à jour de tous les champs nécessaires, le Personnage mis à jour est sauvegardé dans la base de données avec Personnage updatedPersonnage = personnageRepository.save(personnage);, et renvoyé dans le corps de la réponse HTTP avec un statut 200 OK: return new ResponseEntity<>(updatedPersonnage, HttpStatus.OK);.

En résumé, la méthode updatePersonnage sert à mettre à jour un Personnage existant avec de nouveaux détails reçus dans le corps de la requête, et gère les cas où le Personnage à mettre à jour n'est pas trouvé dans la base de données.

InventaireController.java

package com.example.rest.Controller.Personnage;

import com.example.rest.Model.Personnage.Inventaire;
import com.example.rest.Model.Personnage.Objet;
import com.example.rest.Repository.Personnage.IInventaireRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Optional;

import java.util.stream.Collectors;
import java.util.stream.StreamSupport;

@RestController
@RequestMapping("/inventaires")
public class InventaireController {

    private final IInventaireRepository inventaireRepository;

    @Autowired
    public InventaireController(IInventaireRepository inventaireRepository) {
        this.inventaireRepository = inventaireRepository;
    }

    // Get all Inventaires
    @GetMapping
    public List<Inventaire> getAllInventaires() {
        return StreamSupport.stream(inventaireRepository.findAll().spliterator(), false).collect(Collectors.toList());
    }

    // Get a single Inventaire by ID
    @GetMapping("/{id}")
    public ResponseEntity<Inventaire> getInventaireById(@PathVariable(value = "id") Long inventaireId) {
        Optional<Inventaire> inventaire = inventaireRepository.findById(inventaireId);
        return inventaire.map(ResponseEntity::ok).orElseGet(() -> ResponseEntity.notFound().build());
    }

    // Create a new Inventaire
    @PostMapping
    public Inventaire createInventaire(@RequestBody Inventaire inventaire) {
        return inventaireRepository.save(inventaire);
    }

    // Update an Inventaire by ID
    @PutMapping("/{id}")
    public ResponseEntity<Inventaire> updateInventaire(@PathVariable(value = "id") Long inventaireId,
            @RequestBody Inventaire newInventaire) {
        Optional<Inventaire> optionalInventaire = inventaireRepository.findById(inventaireId);
        if (optionalInventaire.isPresent()) {
            Inventaire inventaire = optionalInventaire.get();
            // Update the fields you want to change using newInventaire
            inventaireRepository.save(inventaire);
            return ResponseEntity.ok(inventaire);
        } else {
            return ResponseEntity.notFound().build();
        }
    }

    // Delete an Inventaire by ID
    @DeleteMapping("/{id}")
    public ResponseEntity<?> deleteInventaire(@PathVariable(value = "id") Long inventaireId) {
        return inventaireRepository.findById(inventaireId).map(inventaire -> {
            inventaireRepository.delete(inventaire);
            return ResponseEntity.ok().build();
        }).orElseGet(() -> ResponseEntity.notFound().build());
    }

    // Get all Objets from an Inventaire by personnage ID
    
    // Increase the quantity of an Inventaire by ID
    @PutMapping("/increaseQuantity/{id}")
    public ResponseEntity<Inventaire> increaseQuantity(@PathVariable(value = "id") Long inventaireId) {
        Optional<Inventaire> optionalInventaire = inventaireRepository.findById(inventaireId);
        if (optionalInventaire.isPresent()) {
            Inventaire inventaire = optionalInventaire.get();
            inventaire.setQuantite(inventaire.getQuantite() + 1); // Increase the quantity by 1
            inventaireRepository.save(inventaire); // Save the updated inventaire
            return ResponseEntity.ok(inventaire); // Return the updated inventaire
        } else {
            return ResponseEntity.notFound().build(); // Return 404 if the inventaire is not found
        }
    }
    // curl -X PUT http://localhost:8080/inventaires/increaseQuantity/{id}


     // Liste tous les objets dans l'inventaire d'un personnage par ID de personnage
    @GetMapping("/personnage/{personnageId}/objets")
    public ResponseEntity<List<Objet>> getObjetsInInventaireByPersonnageId(@PathVariable(value = "personnageId") Long personnageId) {
        List<Inventaire> inventaires = inventaireRepository.findAllByPersonnageId(personnageId);
        
        if(inventaires.isEmpty()) {
            return ResponseEntity.notFound().build();
        }
        
        List<Objet> objets = inventaires.stream()
                                        .map(Inventaire::getObjet)
                                        .collect(Collectors.toList());
        return ResponseEntity.ok(objets);
    }
}

Ce code est un contrôleur dans une application Spring Boot, spécifiquement pour gérer les opérations CRUD sur les Inventaire. Le contrôleur est annoté avec @RestController, indiquant qu'il s'agit d'un contrôleur REST, et @RequestMapping("/inventaires"), spécifiant que ce contrôleur gère les requêtes à l'URI de base /inventaires.

Le contrôleur utilise l'injection de dépendances, via l'annotation @Autowired, pour injecter une instance de IInventaireRepository, qui est utilisée pour interagir avec la base de données pour les opérations sur les Inventaire.

Voici un résumé des méthodes de ce contrôleur et de leur fonctionnalité:

1. getAllInventaires():

   • Annotée avec @GetMapping, elle gère les requêtes GET à /inventaires.
   • Elle renvoie une liste de tous les Inventaire dans la base de données.

2. getInventaireById(@PathVariable(value = "id") Long inventaireId):

   • Annotée avec @GetMapping("/{id}"), elle gère les requêtes GET à /inventaires/{id}.
   • Elle renvoie un Inventaire spécifique basé sur l'ID fourni, ou une réponse 404 Not Found si l'Inventaire n'est pas trouvé.

3. createInventaire(@RequestBody Inventaire inventaire):

   • Annotée avec @PostMapping, elle gère les requêtes POST à /inventaires.
   • Elle crée un nouvel Inventaire avec les détails fournis dans le corps de la requête et le sauvegarde dans la base de données.

4. updateInventaire(@PathVariable(value = "id") Long inventaireId, @RequestBody Inventaire newInventaire):

   • Annotée avec @PutMapping("/{id}"), elle gère les requêtes PUT à /inventaires/{id}.
   • Elle met à jour un Inventaire existant avec l'ID fourni avec les nouveaux détails fournis dans le corps de la requête, ou renvoie une réponse 404 Not Found si l'Inventaire n'est pas trouvé.

5. deleteInventaire(@PathVariable(value = "id") Long inventaireId):

   • Annotée avec @DeleteMapping("/{id}"), elle gère les requêtes DELETE à /inventaires/{id}.
   • Elle supprime un Inventaire existant avec l'ID fourni, ou renvoie une réponse 404 Not Found si l'Inventaire n'est pas trouvé.

6. increaseQuantity(@PathVariable(value = "id") Long inventaireId):

   • Annotée avec @PutMapping("/increaseQuantity/{id}"), elle gère les requêtes PUT à /inventaires/increaseQuantity/{id}.
   • Elle augmente la quantité d'un Inventaire spécifique basé sur l'ID fourni, ou renvoie une réponse 404 Not Found si l'Inventaire n'est pas trouvé.

7. getObjetsInInventaireByPersonnageId(@PathVariable(value = "personnageId") Long personnageId):

   • Annotée avec @GetMapping("/personnage/{personnageId}/objets"), elle gère les requêtes GET à /inventaires/personnage/{personnageId}/objets.
   • Elle renvoie une liste d'Objet dans l'Inventaire d'un Personnage spécifique basé sur l'ID de Personnage fourni, ou une réponse 404 Not Found si aucun Inventaire n'est trouvé pour ce Personnage.

En résumé, ce contrôleur gère de manière exhaustive les opérations CRUD sur les Inventaire, permettant la récupération, la création, la mise à jour, la suppression, et d'autres opérations spécifiques sur les Inventaire et leurs relations avec d'autres entités comme Personnage et Objet.

package com.example.rest.Controller.Personnage;

import com.example.rest.Model.Personnage.Objet;
import com.example.rest.Repository.Personnage.IObjetRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Optional;

@RestController
@RequestMapping("/objets")
public class ObjetController {

    @Autowired
    private IObjetRepository objetRepository;

    // Create Objet
    @PostMapping
    public Objet createObjet(@RequestBody Objet objet) {
        return objetRepository.save(objet);
    }
    // curl -X POST -H "Content-Type: application/json" -d '{"nom":"Epée","description":"Une épée tranchante"}' http://localhost:8080/api/objets

    // Get All Objets
    @GetMapping
    public List<Objet> getAllObjets() {
        return (List<Objet>) objetRepository.findAll();
    }
    // ### GET ALL OBJETS
    // GET http://localhost:8080/api/objets

    // Get Objet by ID
    @GetMapping("/{id}")
    public ResponseEntity<Objet> getObjetById(@PathVariable Long id) {
        Optional<Objet> objet = objetRepository.findById(id);
        return objet.map(ResponseEntity::ok).orElseGet(() -> ResponseEntity.notFound().build());
    }
    // ### GET OBJET BY ID
    // GET http://localhost:8080/api/objets/{id}

    // Update Objet
    @PutMapping("/{id}")
    public ResponseEntity<Objet> updateObjet(@PathVariable Long id, @RequestBody Objet newObjet) {
        Optional<Objet> oldObjet = objetRepository.findById(id);
        if (oldObjet.isPresent()) {
            Objet objet = oldObjet.get();
            objet.setNom(newObjet.getNom());
            objet.setDescription(newObjet.getDescription());
            objetRepository.save(objet);
            return ResponseEntity.ok(objet);
        } else {
            return ResponseEntity.notFound().build();
        }
    }
    // ### UPDATE OBJET
    // PUT http://localhost:8080/api/objets/{id}
    // Content-Type: application/json
    // {"nom":"NouveauNom","description":"NouvelleDescription"}

    // Delete Objet
    @DeleteMapping("/{id}")
    public ResponseEntity<String> deleteObjet(@PathVariable Long id) {
        try {
            objetRepository.deleteById(id);
            return ResponseEntity.ok("Objet deleted successfully");
        } catch (Exception e) {
            return ResponseEntity.status(500).body("Error deleting objet");
        }
    }
    // ### DELETE OBJET
    // DELETE http://localhost:8080/api/objets/{id}
}

// Package contenant le contrôleur
package com.example.rest.Controller;

// Importation des classes nécessaires
import java.util.Optional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import com.example.rest.DTO.LoginDTO;
import com.example.rest.Model.Account;
import com.example.rest.Repository.IAcountRepository;

// Annotation indiquant que cette classe est un contrôleur Spring
@Controller
// Chemin de base pour toutes les méthodes de ce contrôleur
@RequestMapping(path = "/account")
public class AcountController {

    // Injection de dépendances des repositories et du cryptage
    @Autowired
    private IAcountRepository userRepository;
    @Autowired
    private BCryptPasswordEncoder bCryptPasswordEncoder;

    // Méthode de connexion, supposément pour renvoyer un token à l'avenir
    @PostMapping(path = "/login")
    public ResponseEntity<Account> login(@RequestBody LoginDTO loginDTO) {
        Account u = userRepository.findByEmail(loginDTO.getUsername());
        if(u == null) return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(null);
        if(!bCryptPasswordEncoder.matches(loginDTO.getPassword(), u.getPassword())) return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(null);
        return ResponseEntity.ok(u);
    }

    // Méthode pour ajouter un nouvel utilisateur
    @PostMapping()
    public @ResponseBody Account addNewUser(@RequestBody Account account) {
        Account u = new Account(account);
        u.setPassword(bCryptPasswordEncoder.encode(account.getPassword()));
   

        userRepository.save(u);
        return u;
    }

    // Méthode pour obtenir un utilisateur par son ID
    @GetMapping(path = "/{id}")
    public @ResponseBody Optional<Account> getUserById(@PathVariable Integer id) {
        return userRepository.findById(id);
    }

    // Méthode pour obtenir tous les utilisateurs
    @GetMapping()
    public @ResponseBody Iterable<Account> getAllUsers() {
        return userRepository.findAll();
    }

    // Méthode pour mettre à jour un utilisateur
    @PutMapping(path = "/{id}")
    public @ResponseBody Account updateUser(@PathVariable Integer id, @RequestBody Account user) throws Exception {
        Optional<Account> current = userRepository.findById(id);
        if (!current.isPresent())
            throw new Exception("Account not found!");
        user.setId((long) id);
        userRepository.save(user);
        return user;
    }

    // Méthode pour supprimer un utilisateur
    @DeleteMapping(path = "/{id}")
    public @ResponseBody Account deleteUser(@PathVariable Integer id) throws Exception {
        Account u = userRepository.findById(id).orElse(null);
        if (u == null)
            throw new Exception("Account not found!");
        userRepository.deleteById(id);
        return u;
    }


    // Méthode commentée pour obtenir les utilisateurs par leur nom
    // @GetMapping(path = "/findbyname/{name}")
    // public @ResponseBody List<User> getName(@PathVariable String name) {
    // return userRepository.findByName(name);
    // }
}

package com.example.rest.Controller;

import com.example.rest.Model.Profil;
import com.example.rest.Repository.IProfilRepository;
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;

@RestController
@RequestMapping("/profils")
public class ProfilController {

    private final IProfilRepository profilRepository;

    @Autowired
    public ProfilController(IProfilRepository profilRepository) {
        this.profilRepository = profilRepository;
    }

    @GetMapping
    public ResponseEntity<List<Profil>> getAllProfils() {
        List<Profil> profils = (List<Profil>) profilRepository.findAll();
        return new ResponseEntity<>(profils, HttpStatus.OK);
    }

    @GetMapping("/{id}")
    public ResponseEntity<Profil> getProfilById(@PathVariable Integer id) {
        Profil profil = profilRepository.findById(id).orElse(null);
        if (profil != null) {
            return new ResponseEntity<>(profil, HttpStatus.OK);
        } else {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }
    }

    @PostMapping
    public ResponseEntity<Profil> createProfil(@RequestBody Profil profil) {
        Profil createdProfil = profilRepository.save(profil);
        return new ResponseEntity<>(createdProfil, HttpStatus.CREATED);
    }

    @PutMapping("/{id}")
    public ResponseEntity<Profil> updateProfil(@PathVariable Integer id, @RequestBody Profil profil) {
        Profil existingProfil = profilRepository.findById(id).orElse(null);
        if (existingProfil != null) {
            profil.setId(id);
            Profil updatedProfil = profilRepository.save(profil);
            return new ResponseEntity<>(updatedProfil, HttpStatus.OK);
        } else {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteProfil(@PathVariable Integer id) {
        Profil existingProfil = profilRepository.findById(id).orElse(null);
        if (existingProfil != null) {
            profilRepository.delete(existingProfil);
            return new ResponseEntity<>(HttpStatus.NO_CONTENT);
        } else {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }
    }
}

package com.example.rest.Controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.example.rest.Model.Profil;
import com.example.rest.Repository.IGameRepository;
import com.example.rest.Repository.IProfilRepository;

import jakarta.transaction.Transactional;

import java.util.Set;

import com.example.rest.Model.Game;

@RestController
@RequestMapping(path = "/game")
public class GameController {

    @Autowired
    private IProfilRepository profilRepository;

    @Autowired
    private IGameRepository gameRepository;

    // ... Autres méthodes ...

    @PostMapping(path = "/add")
    public ResponseEntity<Game> addNewGame(@RequestBody Game game) {
        // Créez une nouvelle instance de Game avec le nom donné
        Game newGame = new Game();
        newGame.setName(game.getName());

        // Enregistrez le jeu dans la base de données AVANT de l'ajouter à un profil
        newGame = gameRepository.save(newGame);

        // Obtenez ou créez un profil par défaut
        Profil defaultProfile = profilRepository.findByName("Default Profile");
        if (defaultProfile == null) {
            defaultProfile = new Profil();
            defaultProfile.setName("Default Profile");
            profilRepository.save(defaultProfile);
        }

        // Ajoutez le jeu au profil par défaut
        defaultProfile.getGames().add(newGame);
        profilRepository.save(defaultProfile);

        // Retournez le jeu enregistré
        return ResponseEntity.ok(newGame);
    }

    @GetMapping(path = "/profil/{profilId}")
    public ResponseEntity<Set<Game>> getGamesByProfileId(@PathVariable("profilId") Integer profilId) {
        Profil profil = profilRepository.findById(profilId).orElse(null);

        if (profil != null) {
            return ResponseEntity.ok(profil.getGames()); // Retourne 200 OK avec les jeux
        }

        // Retourne 404 NOT FOUND si aucun profil n'est trouvé avec cet ID
        return ResponseEntity.notFound().build();
    }

    @GetMapping(path = "/all")
    public ResponseEntity<Iterable<Game>> getAllGames() {
        Iterable<Game> games = gameRepository.findAll(); // Supposant que vous avez une méthode findAll dans votre
                                                         // repository
        return ResponseEntity.ok(games);
    }

    @PutMapping(path = "/update/{id}")
    public ResponseEntity<Game> updateGame(@PathVariable("id") Integer gameId, @RequestBody Game updatedGame) {
        try {
            Game game = gameRepository.findById(gameId).orElseThrow(); // Supposant que vous avez une méthode findById
                                                                       // dans votre repository
            game.setName(updatedGame.getName()); // Mettez à jour les champs nécessaires
            gameRepository.save(game); // Enregistrez les modifications
            return ResponseEntity.ok(game);
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
        }
    }

    @DeleteMapping(path = "/delete/{id}")
    @Transactional
    public ResponseEntity<Void> deleteGame(@PathVariable("id") Integer gameId) {
        try {
            Game game = gameRepository.findById(gameId).orElseThrow();
            profilRepository.deleteByGameId(gameId); // Supprimez les enregistrements enfants dans la table
                                                     // `profil_game`
            gameRepository.deleteById(gameId);
            return ResponseEntity.ok().build();
        } catch (Exception e) {
            return ResponseEntity.notFound().build();
        }
    }

}