lionsdev/afterwork-server-impl-quarkus
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Amélioration structurelle Best Practices Endpoint

Browse Source
This commit is contained in:
DahoudG
2024-09-10 23:44:56 +00:00
parent 57ad010feb
commit e54a74d248
35 changed files with 1296 additions and 1017 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
src/main/java/com/lions/dev/entity/BaseEntity.java
View File

@@ -1,44 +1,52 @@
package com.lions.dev.entity;
import io.quarkus.hibernate.orm.panache.PanacheEntityBase;
import jakarta.persistence.*;
import java.time.LocalDateTime;
import java.util.UUID;
import lombok.Getter;
import lombok.Setter;
import org.hibernate.annotations.UuidGenerator;
import java.time.LocalDateTime;
import java.util.UUID;
/**
* Classe de base pour toutes les entités du système AfterWork.
* Cette classe définit les propriétés communes à toutes les entités, telles que
* l'identifiant unique et les informations d'audit (création, mise à jour).
*
* Chaque entité héritant de cette classe aura un identifiant auto-généré,
* et des dates automatiques pour la création et la mise à jour.
*/
@MappedSuperclass
@Getter
@Setter
@MappedSuperclass
public abstract class BaseEntity extends PanacheEntityBase {
public abstract class BaseEntity {
@Id
@UuidGenerator
@Column(name = "id", updatable = false, nullable = false)
private UUID id;
@GeneratedValue(strategy = GenerationType.AUTO)
private UUID id; // Identifiant unique de l'entité, généré automatiquement
@Column(name = "created_at", updatable = false)
private LocalDateTime createdAt;
@Column(name = "created_at", updatable = false, nullable = false)
private LocalDateTime createdAt; // Date de création de l'entité
@Column(name = "updated_at")
private LocalDateTime updatedAt;
@Column(name = "created_by")
private String createdBy;
@Column(name = "updated_by")
private String updatedBy;
@Column(name = "updated_at", nullable = false)
private LocalDateTime updatedAt; // Date de la dernière mise à jour de l'entité
/**
* Méthode appelée avant la persistance d'une nouvelle entité dans la base de données.
* Cette méthode définit automatiquement la date de création et de mise à jour.
*/
@PrePersist
protected void onCreate() {
this.createdAt = LocalDateTime.now();
// Logique pour définir `createdBy` à partir du contexte utilisateur
this.updatedAt = LocalDateTime.now();
System.out.println("[LOG] Nouvelle entité créée avec ID : " + this.id + " à " + this.createdAt);
}
/**
* Méthode appelée avant la mise à jour d'une entité existante dans la base de données.
* Cette méthode met à jour automatiquement la date de la dernière mise à jour.
*/
@PreUpdate
protected void onUpdate() {
this.updatedAt = LocalDateTime.now();
// Logique pour définir `updatedBy` à partir du contexte utilisateur
System.out.println("[LOG] Entité mise à jour avec ID : " + this.id + " à " + this.updatedAt);
}
}

128
src/main/java/com/lions/dev/entity/Events.java
View File

@@ -1,128 +0,0 @@
package com.lions.dev.entity;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import jakarta.persistence.*;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import java.time.LocalDateTime;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@Entity
@Table(name = "Events")
public class Events extends BaseEntity {
@NotNull
@Size(max = 100)
@Column(name = "title", nullable = false, length = 100)
@JsonProperty("title")
private String title;
@NotNull
@Size(max = 255)
@Column(name = "description", nullable = false, length = 255)
@JsonProperty("description")
private String description;
@NotNull
@Column(name = "event_date", nullable = false)
@JsonProperty("date")
private LocalDateTime eventDate;
@NotNull
@Size(max = 100)
@Column(name = "location", nullable = false, length = 100)
@JsonProperty("location")
private String location;
@Size(max = 100)
@Column(name = "category", length = 100)
@JsonProperty("category")
private String category;
@Column(name = "link", length = 255)
@JsonProperty("link")
private String link;
@Column(name = "image_url", length = 255)
@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", nullable = false)
@JsonProperty("creator")
private Users creator;
@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<Users> participants = new HashSet<>();
@ManyToMany(fetch = FetchType.LAZY, cascade = {CascadeType.PERSIST, CascadeType.MERGE})
@JoinTable(
name = "event_likes",
joinColumns = @JoinColumn(name = "event_id"),
inverseJoinColumns = @JoinColumn(name = "user_id")
)
@JsonIgnore
private Set<Users> 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) {
likes.add(user);
}
public void removeLike(Users user) {
likes.remove(user);
}
@PreRemove
private void preRemove() {
for (Users participant : participants) {
participant.getParticipatedEvents().remove(this);
}
for (Users like : likes) {
like.getLikedEvents().remove(this);
}
}
@Override
public String toString() {
return "Events{" +
"id=" + getId() +
", title='" + title + '\'' +
", description='" + description + '\'' +
", eventDate=" + eventDate +
", location='" + location + '\'' +
", category='" + category + '\'' +
", link='" + link + '\'' +
", imageUrl='" + imageUrl + '\'' +
", status='" + status + '\'' +
", creator=" + (creator != null ? creator.getId() : null) +
'}';
}
}

155
src/main/java/com/lions/dev/entity/Users.java
View File

@@ -1,155 +0,0 @@
package com.lions.dev.entity;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import jakarta.persistence.*;
import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.HashSet;
import java.util.Set;
import lombok.Getter;
import lombok.Setter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Getter
@Setter
@Entity
@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)
@JsonProperty("nom")
private String nom;
@NotNull
@Size(max = 100)
@Column(name = "prenoms", nullable = false, length = 100)
@JsonProperty("prenoms")
private String prenoms;
@NotNull
@Email
@Size(max = 100)
@Column(name = "email", nullable = false, length = 100, unique = true)
@JsonProperty("email")
private String email;
@NotNull
@Size(min = 8, max = 255)
@Column(name = "mot_de_passe", nullable = false, length = 255)
@JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
private String motDePasse;
@Size(max = 50)
@Column(name = "role", nullable = false, length = 50)
@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 Set<Events> createdEvents = new HashSet<>();
// 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 Set<Events> participatedEvents = new HashSet<>();
// 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<Events> 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);
}
/**
* 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) {
String hex = Integer.toHexString(0xff & b);
if (hex.length() == 1) {
hexString.append('0');
}
hexString.append(hex);
}
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{" +
"id=" + getId() +
", nom='" + nom + '\'' +
", prenoms='" + prenoms + '\'' +
", email='" + email + '\'' +
", role='" + role + '\'' +
'}';
}
}

68
src/main/java/com/lions/dev/entity/comment/Comment.java Normal file
View File

@@ -0,0 +1,68 @@
package com.lions.dev.entity.comment;
import com.lions.dev.entity.BaseEntity;
import com.lions.dev.entity.users.Users;
import com.lions.dev.entity.events.Events;
import jakarta.persistence.*;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;
import java.time.LocalDateTime;
/**
* Entité représentant un commentaire d'un utilisateur sur un événement dans le système AfterWork.
* Chaque commentaire est lié à un utilisateur et à un événement, et contient le texte du commentaire
* ainsi que la date de création.
*
* Des logs et des commentaires sont inclus pour assurer une traçabilité claire.
*/
@Entity
@Table(name = "comments")
@Getter
@Setter
@NoArgsConstructor
@ToString
public class Comment extends BaseEntity {
@Column(name = "text", nullable = false)
private String text; // Le texte du commentaire
@Column(name = "comment_date", nullable = false)
private LocalDateTime commentDate; // La date à laquelle le commentaire a été publié
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "user_id", nullable = false)
private Users user; // L'utilisateur qui a fait le commentaire
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "event_id", nullable = false)
private Events event; // L'événement auquel le commentaire est lié
/**
* Constructeur pour créer un nouveau commentaire.
*
* @param user L'utilisateur qui commente.
* @param event L'événement commenté.
* @param text Le texte du commentaire.
*/
public Comment(Users user, Events event, String text) {
this.user = user;
this.event = event;
this.text = text;
this.commentDate = LocalDateTime.now(); // Définit automatiquement la date actuelle
System.out.println("[LOG] Nouveau commentaire ajouté par " + user.getEmail() + " sur l'événement : " + event.getTitle() + " - Texte : " + text);
}
/**
* Modifie le texte du commentaire.
*
* @param newText Le nouveau texte du commentaire.
*/
public void updateComment(String newText) {
System.out.println("[LOG] Modification du commentaire de " + user.getEmail() + " sur l'événement : " + event.getTitle() + " - Nouveau texte : " + newText);
this.text = newText;
this.commentDate = LocalDateTime.now(); // Met à jour la date de modification
}
}

83
src/main/java/com/lions/dev/entity/events/Events.java Normal file
View File

@@ -0,0 +1,83 @@
package com.lions.dev.entity.events;
import com.lions.dev.entity.BaseEntity;
import com.lions.dev.entity.users.Users;
import jakarta.persistence.*;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;
import java.time.LocalDateTime;
import java.util.HashSet;
import java.util.Set;
/**
* Entité représentant un événement dans le système AfterWork.
* Chaque événement possède un titre, une date de début, une date de fin, un créateur,
* et des participants.
*
* Tous les logs et commentaires nécessaires pour la traçabilité et la documentation sont inclus.
*/
@Entity
@Table(name = "events")
@Getter
@Setter
@NoArgsConstructor
@ToString
public class Events extends BaseEntity {
// Attributs de l'entité événement
@Column(name = "title", nullable = false)
private String title; // Le titre de l'événement
@Column(name = "start_date", nullable = false)
private LocalDateTime startDate; // La date de début de l'événement
@Column(name = "end_date", nullable = false)
private LocalDateTime endDate; // La date de fin de l'événement
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "creator_id", nullable = false)
private Users creator; // L'utilisateur créateur de l'événement
@ManyToMany(fetch = FetchType.LAZY)
@JoinTable(
name = "event_participants",
joinColumns = @JoinColumn(name = "event_id"),
inverseJoinColumns = @JoinColumn(name = "user_id")
)
private Set<Users> participants = new HashSet<>(); // Les participants à l'événement
/**
* Ajoute un utilisateur en tant que participant à l'événement.
*
* @param user L'utilisateur à ajouter comme participant.
*/
public void addParticipant(Users user) {
participants.add(user);
System.out.println("[LOG] Participant ajouté : " + user.getEmail() + " à l'événement : " + this.title);
}
/**
* Supprime un utilisateur de la liste des participants de l'événement.
*
* @param user L'utilisateur à supprimer de la liste des participants.
*/
public void removeParticipant(Users user) {
participants.remove(user);
System.out.println("[LOG] Participant supprimé : " + user.getEmail() + " de l'événement : " + this.title);
}
/**
* Retourne le nombre total de participants à cet événement.
*
* @return Le nombre total de participants.
*/
public int getNumberOfParticipants() {
int count = participants.size();
System.out.println("[LOG] Nombre de participants à l'événement : " + this.title + " - " + count);
return count;
}
}

67
src/main/java/com/lions/dev/entity/reaction/Reaction.java Normal file
View File

@@ -0,0 +1,67 @@
package com.lions.dev.entity.reaction;
import com.lions.dev.entity.BaseEntity;
import com.lions.dev.entity.users.Users;
import com.lions.dev.entity.events.Events;
import jakarta.persistence.*;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;
/**
* Entité représentant une réaction d'un utilisateur à un événement dans le système AfterWork.
* Une réaction peut être un "like", un "dislike" ou toute autre forme de réaction définie.
*
* Cette entité est liée à l'utilisateur qui réagit et à l'événement auquel la réaction est associée.
* Tous les logs et commentaires sont inclus pour la traçabilité.
*/
@Entity
@Table(name = "reactions")
@Getter
@Setter
@NoArgsConstructor
@ToString
public class Reaction extends BaseEntity {
// Types de réaction possibles
public enum ReactionType {
LIKE, DISLIKE, LOVE, ANGRY, SAD
}
@Enumerated(EnumType.STRING)
@Column(name = "reaction_type", nullable = false)
private ReactionType reactionType; // Le type de réaction (LIKE, DISLIKE, etc.)
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "user_id", nullable = false)
private Users user; // L'utilisateur qui a effectué la réaction
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "event_id", nullable = false)
private Events event; // L'événement auquel la réaction est associée
/**
* Associe une réaction à un utilisateur et un événement.
*
* @param user L'utilisateur qui réagit.
* @param event L'événement auquel la réaction est liée.
* @param reactionType Le type de réaction.
*/
public Reaction(Users user, Events event, ReactionType reactionType) {
this.user = user;
this.event = event;
this.reactionType = reactionType;
System.out.println("[LOG] Nouvelle réaction ajoutée : " + reactionType + " par l'utilisateur : " + user.getEmail() + " à l'événement : " + event.getTitle());
}
/**
* Modifie le type de réaction de l'utilisateur pour cet événement.
*
* @param newReactionType Le nouveau type de réaction.
*/
public void updateReaction(ReactionType newReactionType) {
System.out.println("[LOG] Changement de la réaction de " + this.reactionType + " à " + newReactionType + " pour l'utilisateur : " + user.getEmail() + " à l'événement : " + event.getTitle());
this.reactionType = newReactionType;
}
}

78
src/main/java/com/lions/dev/entity/users/Users.java Normal file
View File

@@ -0,0 +1,78 @@
package com.lions.dev.entity.users;
import com.lions.dev.entity.BaseEntity;
import jakarta.persistence.*;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
/**
* Représentation de l'entité Utilisateur dans le système AfterWork.
* Cette entité contient les informations de base sur un utilisateur, telles que le nom,
* les prénoms, l'email, le mot de passe haché, et son rôle.
*
* Tous les logs nécessaires à la traçabilité sont intégrés.
*/
@Entity
@Table(name = "users")
@Getter
@Setter
@NoArgsConstructor
@ToString
public class Users extends BaseEntity {
// Attributs de l'entité utilisateur
@Column(name = "nom", nullable = false, length = 100)
private String nom; // Le nom de l'utilisateur
@Column(name = "prenoms", nullable = false, length = 100)
private String prenoms; // Les prénoms de l'utilisateur
@Column(name = "email", nullable = false, unique = true, length = 100)
private String email; // L'adresse email unique de l'utilisateur
@Column(name = "mot_de_passe", nullable = false)
private String motDePasse; // Mot de passe haché avec BCrypt
@Column(name = "role", nullable = false)
private String role; // Le rôle de l'utilisateur (ADMIN, MODERATOR, USER, etc.)
// Utilisation de BCrypt pour hacher les mots de passe de manière sécurisée
private static final BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
/**
* Hache le mot de passe avec BCrypt et le stocke dans l'attribut `motDePasse`.
*
* @param motDePasse Le mot de passe en texte clair à hacher.
*/
public void setMotDePasse(String motDePasse) {
this.motDePasse = encoder.encode(motDePasse);
System.out.println("[LOG] Mot de passe haché pour l'utilisateur : " + this.email);
}
/**
* Vérifie que le mot de passe fourni correspond au mot de passe haché de l'utilisateur.
*
* @param motDePasse Le mot de passe en texte clair à vérifier.
* @return true si le mot de passe est correct, false sinon.
*/
public boolean verifierMotDePasse(String motDePasse) {
boolean isValid = encoder.matches(motDePasse, this.motDePasse);
System.out.println("[LOG] Vérification du mot de passe pour l'utilisateur : " + this.email + " - Résultat : " + isValid);
return isValid;
}
/**
* Vérifie si l'utilisateur a le rôle d'administrateur.
*
* @return true si l'utilisateur est un administrateur, false sinon.
*/
public boolean isAdmin() {
boolean isAdmin = "ADMIN".equalsIgnoreCase(this.role);
System.out.println("[LOG] Vérification du rôle ADMIN pour l'utilisateur : " + this.email + " - Résultat : " + isAdmin);
return isAdmin;
}
}