From d20e1e9372349150593ea7db801a2a7eb8fcd97f Mon Sep 17 00:00:00 2001 From: DahoudG Date: Mon, 2 Sep 2024 03:05:37 +0000 Subject: [PATCH] =?UTF-8?q?Refactoring=20etam=C3=A9lioration?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/lions/dev/entity/Events.java | 64 ++++++++++-------- src/main/java/com/lions/dev/entity/Users.java | 67 ++++++++++++++++--- .../lions/dev/resource/EventsResource.java | 26 +++++++ 3 files changed, 120 insertions(+), 37 deletions(-) diff --git a/src/main/java/com/lions/dev/entity/Events.java b/src/main/java/com/lions/dev/entity/Events.java index 3f02fbc..a3d3b69 100644 --- a/src/main/java/com/lions/dev/entity/Events.java +++ b/src/main/java/com/lions/dev/entity/Events.java @@ -7,7 +7,6 @@ import jakarta.validation.constraints.NotNull; import jakarta.validation.constraints.Size; import java.time.LocalDateTime; import java.util.HashSet; -import java.util.List; import java.util.Set; import java.util.UUID; import lombok.Getter; @@ -36,6 +35,7 @@ public class Events extends BaseEntity { @JsonProperty("date") private LocalDateTime eventDate; + @NotNull @Size(max = 100) @Column(name = "location", nullable = false, length = 100) @JsonProperty("location") @@ -54,36 +54,26 @@ public class Events extends BaseEntity { @JsonProperty("imageUrl") private String imageUrl; + @NotNull + @Column(name = "status", nullable = false) + @JsonProperty("status") + private String status = "OPEN"; // Par défaut, un événement est "OUVERT". + @ManyToOne(fetch = FetchType.LAZY) - @JoinColumn(name = "creator_id") + @JoinColumn(name = "creator_id", nullable = false) @JsonProperty("creator") private Users creator; - @ManyToMany(mappedBy = "participatedEvents", fetch = FetchType.LAZY) + @ManyToMany(fetch = FetchType.LAZY, cascade = {CascadeType.PERSIST, CascadeType.MERGE}) + @JoinTable( + name = "event_participants", + joinColumns = @JoinColumn(name = "event_id"), + inverseJoinColumns = @JoinColumn(name = "user_id") + ) @JsonIgnore private Set participants = new HashSet<>(); - // Méthode pour ajouter un participant - public void addParticipant(Users user) { - if (participants == null) { - participants = new HashSet<>(); - } - if (!participants.contains(user)) { - participants.add(user); - user.getParticipatedEvents().add(this); - } - } - - // Méthode pour retirer un participant - public void removeParticipant(Users user) { - if (participants != null && participants.contains(user)) { - participants.remove(user); - user.getParticipatedEvents().remove(this); - } - } - - // Si vous avez une fonctionnalité de "like", vous pouvez ajouter une collection et des méthodes similaires - @ManyToMany(fetch = FetchType.LAZY) + @ManyToMany(fetch = FetchType.LAZY, cascade = {CascadeType.PERSIST, CascadeType.MERGE}) @JoinTable( name = "event_likes", joinColumns = @JoinColumn(name = "event_id"), @@ -92,16 +82,31 @@ public class Events extends BaseEntity { @JsonIgnore private Set likes = new HashSet<>(); + public void addParticipant(Users user) { + participants.add(user); + user.getParticipatedEvents().add(this); + } + + public void removeParticipant(Users user) { + participants.remove(user); + user.getParticipatedEvents().remove(this); + } + public void addLike(Users user) { - if (likes == null) { - likes = new HashSet<>(); - } likes.add(user); } public void removeLike(Users user) { - if (likes != null) { - likes.remove(user); + likes.remove(user); + } + + @PreRemove + private void preRemove() { + for (Users participant : participants) { + participant.getParticipatedEvents().remove(this); + } + for (Users like : likes) { + like.getLikedEvents().remove(this); } } @@ -116,6 +121,7 @@ public class Events extends BaseEntity { ", category='" + category + '\'' + ", link='" + link + '\'' + ", imageUrl='" + imageUrl + '\'' + + ", status='" + status + '\'' + ", creator=" + (creator != null ? creator.getId() : null) + '}'; } diff --git a/src/main/java/com/lions/dev/entity/Users.java b/src/main/java/com/lions/dev/entity/Users.java index b538d8e..332c56b 100644 --- a/src/main/java/com/lions/dev/entity/Users.java +++ b/src/main/java/com/lions/dev/entity/Users.java @@ -9,10 +9,12 @@ import jakarta.validation.constraints.Size; import java.nio.charset.StandardCharsets; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; -import java.util.List; -import java.util.UUID; +import java.util.HashSet; +import java.util.Set; import lombok.Getter; import lombok.Setter; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; @Getter @Setter @@ -20,6 +22,8 @@ import lombok.Setter; @Table(name = "Users") public class Users extends BaseEntity { + private static final Logger logger = LoggerFactory.getLogger(Users.class); + @NotNull @Size(max = 100) @Column(name = "nom", nullable = false, length = 100) @@ -42,7 +46,7 @@ public class Users extends BaseEntity { @NotNull @Size(min = 8, max = 255) @Column(name = "mot_de_passe", nullable = false, length = 255) - @JsonProperty(access = JsonProperty.Access.READ_WRITE) + @JsonProperty(access = JsonProperty.Access.WRITE_ONLY) private String motDePasse; @Size(max = 50) @@ -50,35 +54,65 @@ public class Users extends BaseEntity { @JsonProperty("role") private String role; + // Relation avec les événements créés par l'utilisateur @OneToMany(mappedBy = "creator", cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.LAZY) @JsonIgnore - private List createdEvents; + private Set createdEvents = new HashSet<>(); - @ManyToMany(fetch = FetchType.LAZY) + // Relation avec les événements auxquels l'utilisateur participe + @ManyToMany(fetch = FetchType.LAZY, cascade = {CascadeType.PERSIST, CascadeType.MERGE}) @JoinTable( name = "User_Event_Participation", joinColumns = @JoinColumn(name = "user_id"), inverseJoinColumns = @JoinColumn(name = "event_id") ) @JsonIgnore - private List participatedEvents; + private Set participatedEvents = new HashSet<>(); - // Méthode pour définir un mot de passe haché avec SHA-256 + // Relation avec les événements "likés" par l'utilisateur + @ManyToMany(fetch = FetchType.LAZY, cascade = {CascadeType.PERSIST, CascadeType.MERGE}) + @JoinTable( + name = "User_Event_Likes", + joinColumns = @JoinColumn(name = "user_id"), + inverseJoinColumns = @JoinColumn(name = "event_id") + ) + @JsonIgnore + private Set likedEvents = new HashSet<>(); + + /** + * Définit le mot de passe de l'utilisateur en le hachant avec l'algorithme SHA-256. + * + * @param motDePasse Le mot de passe en clair que l'utilisateur souhaite utiliser. + */ public void setMotDePasse(String motDePasse) { + logger.debug("Définition du mot de passe pour l'utilisateur {}", email); this.motDePasse = hashPasswordSHA256(motDePasse); } - // Hachage du mot de passe avec SHA-256 + /** + * Hache le mot de passe en utilisant l'algorithme SHA-256. + * + * @param motDePasse Le mot de passe en clair. + * @return Le mot de passe haché en format hexadécimal. + */ private String hashPasswordSHA256(String motDePasse) { + logger.debug("Hachage du mot de passe pour l'utilisateur {}", email); try { MessageDigest digest = MessageDigest.getInstance("SHA-256"); byte[] encodedhash = digest.digest(motDePasse.getBytes(StandardCharsets.UTF_8)); return bytesToHex(encodedhash); } catch (NoSuchAlgorithmException e) { + logger.error("Erreur lors du hachage du mot de passe pour l'utilisateur {}: {}", email, e.getMessage()); throw new RuntimeException(e); } } + /** + * Convertit un tableau de bytes en une chaîne hexadécimale. + * + * @param hash Le tableau de bytes à convertir. + * @return La chaîne hexadécimale correspondante. + */ private String bytesToHex(byte[] hash) { StringBuilder hexString = new StringBuilder(2 * hash.length); for (byte b : hash) { @@ -91,6 +125,23 @@ public class Users extends BaseEntity { return hexString.toString(); } + /** + * Méthode appelée avant la suppression d'un utilisateur. Elle retire cet utilisateur des événements + * auxquels il participe ou qu'il a "liké" pour éviter des violations de contraintes de clé étrangère. + */ + @PreRemove + private void preRemove() { + logger.info("Préparation à la suppression de l'utilisateur {}", email); + for (Events event : participatedEvents) { + event.getParticipants().remove(this); + logger.debug("L'utilisateur {} a été retiré de l'événement {}", email, event.getId()); + } + for (Events event : likedEvents) { + event.getLikes().remove(this); + logger.debug("L'utilisateur {} a été retiré des 'likes' de l'événement {}", email, event.getId()); + } + } + @Override public String toString() { return "Users{" + diff --git a/src/main/java/com/lions/dev/resource/EventsResource.java b/src/main/java/com/lions/dev/resource/EventsResource.java index dafe85e..e37d9fe 100644 --- a/src/main/java/com/lions/dev/resource/EventsResource.java +++ b/src/main/java/com/lions/dev/resource/EventsResource.java @@ -195,4 +195,30 @@ public class EventsResource { event.removeLike(user); return Response.ok(event).build(); } + + @POST + @Path("{eventId}/close") + @Transactional + @Operation(summary = "Fermer un événement", description = "Ferme un événement existant") + public Response closeEvent(@PathParam("eventId") UUID eventId) { + Events event = eventsRepository.findById(eventId); + + if (event == null) { + return Response.status(Response.Status.NOT_FOUND) + .entity("Événement non trouvé.") + .build(); + } + + if ("CLOSED".equals(event.getStatus())) { + return Response.status(Response.Status.BAD_REQUEST) + .entity("L'événement est déjà fermé.") + .build(); + } + + event.setStatus("CLOSED"); + eventsRepository.persist(event); + + return Response.ok("Événement fermé avec succès.").build(); + } + }