Merge pull request #2 from gbanedahoud/develop

Develop

.dockerignore

@@ -1,44 +1,5 @@
-# Build artifacts
+*
-# Note: target/ et *.jar sont nécessaires pour le Docker build
+!target/*-runner
-# car on copie le JAR runner depuis target/
+!target/*-runner.jar
-*.war
+!target/lib/*
-*.ear
+!target/quarkus-app/*
-
-# IDE
-.idea/
-*.iml
-.vscode/
-.settings/
-.project
-.classpath
-*.swp
-*.swo
-
-# OS
-.DS_Store
-Thumbs.db
-
-# Git
-.git/
-.gitignore
-.github/
-
-# Documentation
-*.md
-docs/
-README.md
-
-# Tests
-**/test/
-**/*Test.java
-**/*TestCase.java
-
-# Logs
-*.log
-logs/
-
-# Temporaires
-*.tmp
-*.temp
-tmp/
-temp/

.gitignore

@@ -41,11 +41,3 @@ nb-configuration.xml
 
 # Plugin directory
 /.quarkus/cli/plugins/
-# TLS Certificates
-.certs/
-
-# Logs
-*.log
-hs_err_pid*.log
-replay_pid*.log
-backend_log.txt

.mvn/jvm.config

@@ -1,3 +0,0 @@
--Xmx2048m
--Xms1024m
--XX:MaxMetaspaceSize=512m

.mvn/wrapper/MavenWrapperDownloader.java

@@ -21,72 +21,77 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.net.Authenticator;
 import java.net.PasswordAuthentication;
-import java.net.URI;
 import java.net.URL;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.nio.file.StandardCopyOption;
-import java.util.concurrent.ThreadLocalRandom;
 
-public final class MavenWrapperDownloader {
+public final class MavenWrapperDownloader
-    private static final String WRAPPER_VERSION = "3.3.2";
+{
+    private static final String WRAPPER_VERSION = "3.2.0";
 
-    private static final boolean VERBOSE = Boolean.parseBoolean(System.getenv("MVNW_VERBOSE"));
+    private static final boolean VERBOSE = Boolean.parseBoolean( System.getenv( "MVNW_VERBOSE" ) );
 
-    public static void main(String[] args) {
+    public static void main( String[] args )
-        log("Apache Maven Wrapper Downloader " + WRAPPER_VERSION);
+    {
+        log( "Apache Maven Wrapper Downloader " + WRAPPER_VERSION );
 
-        if (args.length != 2) {
+        if ( args.length != 2 )
-            System.err.println(" - ERROR wrapperUrl or wrapperJarPath parameter missing");
+        {
-            System.exit(1);
+            System.err.println( " - ERROR wrapperUrl or wrapperJarPath parameter missing" );
+            System.exit( 1 );
         }
 
-        try {
+        try
-            log(" - Downloader started");
+        {
-            final URL wrapperUrl = URI.create(args[0]).toURL();
+            log( " - Downloader started" );
-            final String jarPath = args[1].replace("..", ""); // Sanitize path
+            final URL wrapperUrl = new URL( args[0] );
-            final Path wrapperJarPath = Paths.get(jarPath).toAbsolutePath().normalize();
+            final String jarPath = args[1].replace( "..", "" ); // Sanitize path
-            downloadFileFromURL(wrapperUrl, wrapperJarPath);
+            final Path wrapperJarPath = Paths.get( jarPath ).toAbsolutePath().normalize();
-            log("Done");
+            downloadFileFromURL( wrapperUrl, wrapperJarPath );
-        } catch (IOException e) {
+            log( "Done" );
-            System.err.println("- Error downloading: " + e.getMessage());
+        }
-            if (VERBOSE) {
+        catch ( IOException e )
+        {
+            System.err.println( "- Error downloading: " + e.getMessage() );
+            if ( VERBOSE )
+            {
                 e.printStackTrace();
             }
-            System.exit(1);
+            System.exit( 1 );
         }
     }
 
-    private static void downloadFileFromURL(URL wrapperUrl, Path wrapperJarPath)
+    private static void downloadFileFromURL( URL wrapperUrl, Path wrapperJarPath )
-            throws IOException {
+        throws IOException
-        log(" - Downloading to: " + wrapperJarPath);
+    {
-        if (System.getenv("MVNW_USERNAME") != null && System.getenv("MVNW_PASSWORD") != null) {
+        log( " - Downloading to: " + wrapperJarPath );
-            final String username = System.getenv("MVNW_USERNAME");
+        if ( System.getenv( "MVNW_USERNAME" ) != null && System.getenv( "MVNW_PASSWORD" ) != null )
-            final char[] password = System.getenv("MVNW_PASSWORD").toCharArray();
+        {
-            Authenticator.setDefault(new Authenticator() {
+            final String username = System.getenv( "MVNW_USERNAME" );
+            final char[] password = System.getenv( "MVNW_PASSWORD" ).toCharArray();
+            Authenticator.setDefault( new Authenticator()
+            {
                 @Override
-                protected PasswordAuthentication getPasswordAuthentication() {
+                protected PasswordAuthentication getPasswordAuthentication()
-                    return new PasswordAuthentication(username, password);
+                {
+                    return new PasswordAuthentication( username, password );
                 }
-            });
+            } );
         }
-        Path temp = wrapperJarPath
+        try ( InputStream inStream = wrapperUrl.openStream() )
-                .getParent()
+        {
-                .resolve(wrapperJarPath.getFileName() + "."
+            Files.copy( inStream, wrapperJarPath, StandardCopyOption.REPLACE_EXISTING );
-                        + Long.toUnsignedString(ThreadLocalRandom.current().nextLong()) + ".tmp");
-        try (InputStream inStream = wrapperUrl.openStream()) {
-            Files.copy(inStream, temp, StandardCopyOption.REPLACE_EXISTING);
-            Files.move(temp, wrapperJarPath, StandardCopyOption.REPLACE_EXISTING);
-        } finally {
-            Files.deleteIfExists(temp);
         }
-        log(" - Downloader complete");
+        log( " - Downloader complete" );
     }
 
-    private static void log(String msg) {
+    private static void log( String msg )
-        if (VERBOSE) {
+    {
-            System.out.println(msg);
+        if ( VERBOSE )
+        {
+            System.out.println( msg );
         }
     }
 

.mvn/wrapper/maven-wrapper.properties

@@ -14,7 +14,5 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-wrapperVersion=3.3.2
+distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.7/apache-maven-3.9.7-bin.zip
-distributionType=source
+wrapperUrl=https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar
-distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.9/apache-maven-3.9.9-bin.zip
-wrapperUrl=https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.3.2/maven-wrapper-3.3.2.jar

BACKEND_ENDPOINTS_A_CREER.md

@@ -1,115 +0,0 @@
-# Endpoints Backend à Créer - AfterWork
-
-## 📋 Vue d'ensemble
-
-Ce document liste tous les endpoints backend manquants nécessaires pour une application complète et professionnelle.
-
----
-
-## 🔔 1. Notifications (`/notifications`)
-
-### Entité à créer
-- `com.lions.dev.entity.notification.Notification.java`
-
-### Endpoints à créer
-- `GET /notifications/user/{userId}` - Récupérer les notifications d'un utilisateur
-- `PUT /notifications/{id}/read` - Marquer une notification comme lue
-- `PUT /notifications/user/{userId}/mark-all-read` - Marquer toutes comme lues
-- `DELETE /notifications/{id}` - Supprimer une notification
-- `POST /notifications` - Créer une notification
-
-### Resource à créer
-- `com.lions.dev.resource.NotificationResource.java`
-
-### Service à créer
-- `com.lions.dev.service.NotificationService.java`
-
-### Repository à créer
-- `com.lions.dev.repository.NotificationRepository.java`
-
----
-
-## 📱 2. Posts Sociaux (`/posts`)
-
-### Entité à créer
-- `com.lions.dev.entity.social.SocialPost.java`
-
-### Endpoints à créer
-- `GET /posts` - Récupérer tous les posts (avec pagination)
-- `POST /posts` - Créer un post
-- `GET /posts/{id}` - Récupérer un post par ID
-- `PUT /posts/{id}` - Mettre à jour un post
-- `DELETE /posts/{id}` - Supprimer un post
-- `GET /posts/search?q={query}` - Rechercher des posts
-- `POST /posts/{id}/like` - Liker un post
-- `POST /posts/{id}/comment` - Commenter un post
-- `POST /posts/{id}/share` - Partager un post
-
-### Resource à créer
-- `com.lions.dev.resource.SocialPostResource.java`
-
-### Service à créer
-- `com.lions.dev.service.SocialPostService.java`
-
-### Repository à créer
-- `com.lions.dev.repository.SocialPostRepository.java`
-
----
-
-## 📝 Structure des Entités
-
-### Notification
-```java
-@Entity
-@Table(name = "notifications")
-public class Notification extends BaseEntity {
-    private String title;
-    private String message;
-    private String type; // event, friend, reminder, other
-    private boolean isRead;
-    private UUID userId;
-    private UUID eventId; // optionnel
-    private Map<String, Object> metadata; // optionnel
-}
-```
-
-### SocialPost
-```java
-@Entity
-@Table(name = "social_posts")
-public class SocialPost extends BaseEntity {
-    private String content;
-    private UUID userId;
-    private String imageUrl; // optionnel
-    private int likesCount;
-    private int commentsCount;
-    private int sharesCount;
-    
-    @ManyToOne
-    private Users user;
-}
-```
-
----
-
-## 🚀 Ordre d'Implémentation Recommandé
-
-1. **Notifications** (plus simple, moins de dépendances)
-2. **Posts Sociaux** (plus complexe, nécessite interactions)
-
----
-
-## ✅ Checklist
-
-- [ ] Créer entité Notification
-- [ ] Créer NotificationRepository
-- [ ] Créer NotificationService
-- [ ] Créer NotificationResource
-- [ ] Créer entité SocialPost
-- [ ] Créer SocialPostRepository
-- [ ] Créer SocialPostService
-- [ ] Créer SocialPostResource
-- [ ] Créer les DTOs correspondants
-- [ ] Tester tous les endpoints
-- [ ] Documenter l'API (OpenAPI)
-

DATABASE_CONFIG.md

@@ -1,305 +0,0 @@
-# 🗄️ Configuration Base de Données AfterWork
-
-**Date** : 2026-01-10
-**Statut** : ✅ Aligné avec unionflow et btpxpress
-
----
-
-## 📋 Configuration Production PostgreSQL
-
-### Paramètres de Connexion
-
-```yaml
-DB_HOST: postgresql       # Service Kubernetes (pas "postgres")
-DB_PORT: 5432            # Port standard PostgreSQL
-DB_NAME: afterwork_db    # Nom de la base de données
-DB_USERNAME: afterwork   # Utilisateur de la base
-DB_PASSWORD: AfterWork2025!  # Mot de passe (pattern cohérent)
-```
-
-### URL JDBC Complète
-```
-jdbc:postgresql://postgresql:5432/afterwork_db
-```
-
----
-
-## 🔍 Analyse des Autres Projets
-
-### BTPXpress (Production)
-```yaml
-DB_URL: jdbc:postgresql://postgresql:5432/btpxpress
-DB_USERNAME: btpxpress
-DB_PASSWORD: btpxpress_secure_2024
-```
-
-### UnionFlow (Production)
-```yaml
-DB_HOST: postgresql  # (implicite dans le projet)
-DB_USERNAME: unionflow  # (pattern standard)
-DB_PASSWORD: UnionFlow2025!
-```
-
----
-
-## ✅ Corrections Appliquées
-
-### 1. ConfigMap (kubernetes/afterwork-configmap.yaml)
-**Avant:**
-```yaml
-DB_HOST: "postgres"  # ❌ Incorrect
-```
-
-**Après:**
-```yaml
-DB_HOST: "postgresql"  # ✅ Cohérent avec btpxpress/unionflow
-```
-
-### 2. Secrets (kubernetes/afterwork-secrets.yaml)
-**Avant:**
-```yaml
-DB_PASSWORD: "CHANGE_ME_IN_PRODUCTION"  # ❌ Placeholder
-```
-
-**Après:**
-```yaml
-DB_PASSWORD: "AfterWork2025!"  # ✅ Pattern cohérent
-```
-
-### 3. application-prod.properties
-**Avant:**
-```properties
-jdbc:postgresql://${DB_HOST:postgres}:${DB_PORT:5432}  # ❌ Défaut incorrect
-```
-
-**Après:**
-```properties
-jdbc:postgresql://${DB_HOST:postgresql}:${DB_PORT:5432}  # ✅ Défaut correct
-```
-
-### 4. Dockerfile.prod
-**Avant:**
-```dockerfile
-DB_HOST=postgres  # ❌ Incorrect
-```
-
-**Après:**
-```dockerfile
-DB_HOST=postgresql  # ✅ Cohérent
-```
-
----
-
-## 🏗️ Structure de la Base de Données
-
-### Tables Principales
-
-```sql
--- Utilisateurs et Authentification
-users
-friendship
-friendship_request
-
--- Chat et Messagerie
-conversation
-message
-
--- Social
-social_post
-social_comment
-social_like
-
--- Stories
-story
-story_view
-
--- Notifications
-notification
-
--- Événements
-events
-event_participants
-```
-
----
-
-## 🔧 Commandes Utiles
-
-### Vérifier la Connexion depuis un Pod
-
-```bash
-# Tester depuis un pod temporaire
-kubectl run -it --rm psql-test --image=postgres:15 --restart=Never -- \
-  psql -h postgresql -U afterwork -d afterwork_db
-
-# Password: AfterWork2025!
-```
-
-### Créer la Base de Données (si nécessaire)
-
-```bash
-# Se connecter au PostgreSQL
-kubectl exec -it <postgres-pod-name> -n <postgres-namespace> -- psql -U postgres
-
-# Créer la base et l'utilisateur
-CREATE DATABASE afterwork_db;
-CREATE USER afterwork WITH PASSWORD 'AfterWork2025!';
-GRANT ALL PRIVILEGES ON DATABASE afterwork_db TO afterwork;
-ALTER DATABASE afterwork_db OWNER TO afterwork;
-```
-
-### Vérifier les Tables
-
-```bash
-# Lister les tables
-kubectl exec -it <postgres-pod-name> -n <postgres-namespace> -- \
-  psql -U afterwork -d afterwork_db -c "\dt"
-
-# Compter les enregistrements
-kubectl exec -it <postgres-pod-name> -n <postgres-namespace> -- \
-  psql -U afterwork -d afterwork_db -c "SELECT COUNT(*) FROM users;"
-```
-
----
-
-## 🔐 Sécurité
-
-### Bonnes Pratiques Appliquées
-
-1. **Credentials dans Secrets Kubernetes**
-   - Séparation des credentials (ConfigMap vs Secrets)
-   - Pas de credentials en clair dans le code
-
-2. **Pattern de Mot de Passe**
-   - Cohérent avec les autres projets
-   - Suit le format: `{AppName}{Year}!`
-
-3. **Connexion Pool**
-   ```properties
-   max-size=20   # Maximum de connexions
-   min-size=5    # Minimum de connexions maintenues
-   ```
-
-4. **SSL/TLS**
-   - Géré par Kubernetes et le service PostgreSQL
-   - Pas de configuration SSL dans l'application
-
----
-
-## 📊 Variables d'Environnement
-
-### Injectées par Kubernetes
-
-**Via ConfigMap (afterwork-config):**
-- `DB_HOST`
-- `DB_PORT`
-- `DB_NAME`
-- `DB_USERNAME`
-- `QUARKUS_PROFILE`
-- `TZ`
-
-**Via Secret (afterwork-secrets):**
-- `DB_PASSWORD`
-
-### Utilisées par Quarkus
-
-```properties
-# application-prod.properties
-quarkus.datasource.jdbc.url=jdbc:postgresql://${DB_HOST}:${DB_PORT}/${DB_NAME}
-quarkus.datasource.username=${DB_USERNAME}
-quarkus.datasource.password=${DB_PASSWORD}
-```
-
----
-
-## 🐛 Troubleshooting
-
-### Problème : "Could not connect to database"
-
-**Vérifications:**
-
-1. **Service PostgreSQL actif?**
-   ```bash
-   kubectl get svc -n <postgres-namespace> | grep postgresql
-   ```
-
-2. **Credentials corrects?**
-   ```bash
-   kubectl get secret afterwork-secrets -n applications -o yaml
-   # Décoder le password:
-   echo "YourBase64Value" | base64 -d
-   ```
-
-3. **Firewall/Network Policy?**
-   ```bash
-   kubectl get networkpolicy -n applications
-   ```
-
-4. **Logs de l'application:**
-   ```bash
-   kubectl logs -n applications -l app=afterwork-api | grep -i "database\|connection"
-   ```
-
-### Problème : "Database does not exist"
-
-**Solution:**
-```sql
--- Se connecter en tant que postgres
-CREATE DATABASE afterwork_db;
-GRANT ALL PRIVILEGES ON DATABASE afterwork_db TO afterwork;
-```
-
-### Problème : "Authentication failed"
-
-**Vérifier:**
-```bash
-# Le mot de passe dans le secret
-kubectl get secret afterwork-secrets -n applications -o jsonpath='{.data.DB_PASSWORD}' | base64 -d
-
-# Devrait afficher: AfterWork2025!
-```
-
----
-
-## ✅ Checklist de Vérification
-
-Avant le déploiement:
-
-- [x] DB_HOST = `postgresql` (pas `postgres`)
-- [x] DB_PORT = `5432`
-- [x] DB_NAME = `afterwork_db`
-- [x] DB_USERNAME = `afterwork`
-- [x] DB_PASSWORD = `AfterWork2025!`
-- [x] ConfigMap créé et correct
-- [x] Secret créé avec bon mot de passe
-- [x] application-prod.properties correct
-- [x] Dockerfile.prod correct
-- [ ] Base de données créée sur PostgreSQL
-- [ ] Utilisateur `afterwork` créé avec droits
-- [ ] Test de connexion réussi
-
----
-
-## 📝 Notes
-
-### Pattern Observé dans les Projets Lions.dev
-
-| Projet | DB Host | DB Name | DB User | DB Password Pattern |
-|--------|---------|---------|---------|---------------------|
-| **btpxpress** | postgresql | btpxpress | btpxpress | btpxpress_secure_2024 |
-| **unionflow** | postgresql | unionflow | unionflow | UnionFlow2025! |
-| **afterwork** | postgresql | afterwork_db | afterwork | AfterWork2025! |
-
-### Cohérence
-
-✅ Tous les projets utilisent:
-- Host: `postgresql` (service Kubernetes)
-- Port: `5432` (standard PostgreSQL)
-- Username: Nom du projet en minuscule
-- Password: Pattern avec nom et année
-
----
-
-**Configuration validée et prête pour le déploiement!** ✅
-
-**Dernière mise à jour:** 2026-01-10

DEPLOYMENT.md

@@ -1,565 +0,0 @@
-# 🚀 Guide de Déploiement AfterWork Server
-
-## 📋 Vue d'Ensemble
-
-Ce guide décrit le processus de déploiement de l'API AfterWork sur le VPS via `lionesctl pipeline`.
-
-**URL de l'API** : `https://api.lions.dev/afterwork`
-
----
-
-## 🔧 Prérequis
-
-### Environnement Local
-- Java 17 (JDK)
-- Maven 3.9+
-- Docker 20.10+
-- `lionesctl` CLI installé et configuré
-
-### Environnement Serveur
-- PostgreSQL 15+
-- Kubernetes cluster configuré
-- Ingress Controller (nginx)
-- Cert-Manager pour les certificats SSL (Let's Encrypt)
-
----
-
-## 📁 Fichiers de Configuration
-
-### 1. Variables d'Environnement Requises
-
-Les variables suivantes doivent être définies dans Kubernetes Secrets :
-
-```yaml
-DB_HOST: postgres          # Hostname du serveur PostgreSQL
-DB_PORT: 5432              # Port PostgreSQL
-DB_NAME: afterwork_db      # Nom de la base de données
-DB_USERNAME: afterwork     # Utilisateur de la base de données
-DB_PASSWORD: <secret>      # Mot de passe (à définir dans le secret)
-```
-
-### 2. Dockerfile.prod
-
-Le fichier `Dockerfile.prod` utilise une approche multi-stage :
-- **Stage 1** : Build avec Maven dans une image UBI8 OpenJDK 17
-- **Stage 2** : Runtime optimisé avec l'uber-jar compilé
-
-### 3. application-prod.properties
-
-Configuration production avec :
-- Context path : `/afterwork`
-- CORS : `https://afterwork.lions.dev`
-- Health checks : `/q/health/ready` et `/q/health/live`
-- Métriques : `/q/metrics`
-
----
-
-## 🏗️ Build de l'Image Docker
-
-### Build Local (Test)
-
-```bash
-# Build de l'image
-docker build -f Dockerfile.prod -t afterwork-api:latest .
-
-# Test local
-docker run -p 8080:8080 \
-  -e DB_HOST=localhost \
-  -e DB_PORT=5432 \
-  -e DB_NAME=afterwork_db \
-  -e DB_USERNAME=afterwork \
-  -e DB_PASSWORD=changeme \
-  afterwork-api:latest
-```
-
-### Build pour Registry
-
-```bash
-# Tag pour le registry
-docker tag afterwork-api:latest registry.lions.dev/afterwork-api:1.0.0
-docker tag afterwork-api:latest registry.lions.dev/afterwork-api:latest
-
-# Push vers le registry
-docker push registry.lions.dev/afterwork-api:1.0.0
-docker push registry.lions.dev/afterwork-api:latest
-```
-
----
-
-## 🚢 Déploiement avec lionesctl
-
-### Commande de Déploiement
-
-```bash
-# Déploiement via lionesctl pipeline
-lionesctl pipeline deploy \
-  --app afterwork-api \
-  --image registry.lions.dev/afterwork-api:1.0.0 \
-  --namespace applications \
-  --port 8080 \
-  --replicas 2
-
-# Ou avec le fichier de configuration
-lionesctl pipeline deploy -f kubernetes/afterwork-deployment.yaml
-```
-
-### Vérification du Déploiement
-
-```bash
-# Status du déploiement
-lionesctl pipeline status --app afterwork-api
-
-# Logs en temps réel
-lionesctl pipeline logs --app afterwork-api --follow
-
-# Health check
-curl https://api.lions.dev/afterwork/q/health/ready
-```
-
----
-
-## 📦 Structure Kubernetes
-
-### 1. Secret (kubernetes/afterwork-secrets.yaml)
-
-```yaml
-apiVersion: v1
-kind: Secret
-metadata:
-  name: afterwork-secrets
-  namespace: applications
-type: Opaque
-stringData:
-  DB_PASSWORD: "CHANGE_ME_IN_PRODUCTION"
-```
-
-### 2. ConfigMap (kubernetes/afterwork-configmap.yaml)
-
-```yaml
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: afterwork-config
-  namespace: applications
-data:
-  DB_HOST: "postgres"
-  DB_PORT: "5432"
-  DB_NAME: "afterwork_db"
-  DB_USERNAME: "afterwork"
-  QUARKUS_PROFILE: "prod"
-  TZ: "Africa/Douala"
-```
-
-### 3. Deployment (kubernetes/afterwork-deployment.yaml)
-
-```yaml
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: afterwork-api
-  namespace: applications
-  labels:
-    app: afterwork-api
-    version: 1.0.0
-spec:
-  replicas: 2
-  selector:
-    matchLabels:
-      app: afterwork-api
-  template:
-    metadata:
-      labels:
-        app: afterwork-api
-    spec:
-      containers:
-      - name: afterwork-api
-        image: registry.lions.dev/afterwork-api:1.0.0
-        imagePullPolicy: Always
-        ports:
-        - containerPort: 8080
-          name: http
-          protocol: TCP
-        envFrom:
-        - configMapRef:
-            name: afterwork-config
-        - secretRef:
-            name: afterwork-secrets
-        resources:
-          requests:
-            memory: "512Mi"
-            cpu: "250m"
-          limits:
-            memory: "1Gi"
-            cpu: "1000m"
-        livenessProbe:
-          httpGet:
-            path: /afterwork/q/health/live
-            port: 8080
-          initialDelaySeconds: 60
-          periodSeconds: 30
-          timeoutSeconds: 10
-          failureThreshold: 3
-        readinessProbe:
-          httpGet:
-            path: /afterwork/q/health/ready
-            port: 8080
-          initialDelaySeconds: 30
-          periodSeconds: 10
-          timeoutSeconds: 5
-          failureThreshold: 3
-      imagePullSecrets:
-      - name: registry-credentials
-```
-
-### 4. Service (kubernetes/afterwork-service.yaml)
-
-```yaml
-apiVersion: v1
-kind: Service
-metadata:
-  name: afterwork-api
-  namespace: applications
-  labels:
-    app: afterwork-api
-spec:
-  type: ClusterIP
-  ports:
-  - port: 8080
-    targetPort: 8080
-    protocol: TCP
-    name: http
-  selector:
-    app: afterwork-api
-```
-
-### 5. Ingress (kubernetes/afterwork-ingress.yaml)
-
-```yaml
-apiVersion: networking.k8s.io/v1
-kind: Ingress
-metadata:
-  name: afterwork-api
-  namespace: applications
-  annotations:
-    cert-manager.io/cluster-issuer: "letsencrypt-prod"
-    nginx.ingress.kubernetes.io/ssl-redirect: "true"
-    nginx.ingress.kubernetes.io/force-ssl-redirect: "true"
-    nginx.ingress.kubernetes.io/proxy-body-size: "10m"
-    nginx.ingress.kubernetes.io/rewrite-target: /$2
-spec:
-  ingressClassName: nginx
-  tls:
-  - hosts:
-    - api.lions.dev
-    secretName: afterwork-api-tls
-  rules:
-  - host: api.lions.dev
-    http:
-      paths:
-      - path: /afterwork(/|$)(.*)
-        pathType: Prefix
-        backend:
-          service:
-            name: afterwork-api
-            port:
-              number: 8080
-```
-
----
-
-## 🔄 Processus de Déploiement Complet
-
-### Étape 1 : Préparation
-
-```bash
-cd C:\Users\dadyo\PersonalProjects\mic-after-work-server-impl-quarkus-main
-
-# Build Maven
-mvn clean package -DskipTests
-
-# Vérifier que le JAR est créé
-ls target/*-runner.jar
-```
-
-### Étape 2 : Build Docker
-
-```bash
-# Build l'image de production
-docker build -f Dockerfile.prod -t registry.lions.dev/afterwork-api:1.0.0 .
-
-# Test local (optionnel)
-docker run --rm -p 8080:8080 \
-  -e DB_HOST=postgres \
-  -e DB_NAME=afterwork_db \
-  -e DB_USERNAME=afterwork \
-  -e DB_PASSWORD=test123 \
-  registry.lions.dev/afterwork-api:1.0.0
-```
-
-### Étape 3 : Push vers Registry
-
-```bash
-# Login au registry
-docker login registry.lions.dev
-
-# Push
-docker push registry.lions.dev/afterwork-api:1.0.0
-docker tag registry.lions.dev/afterwork-api:1.0.0 registry.lions.dev/afterwork-api:latest
-docker push registry.lions.dev/afterwork-api:latest
-```
-
-### Étape 4 : Déploiement Kubernetes
-
-```bash
-# Créer le namespace si nécessaire
-kubectl create namespace applications --dry-run=client -o yaml | kubectl apply -f -
-
-# Créer les secrets (MODIFIER LES VALEURS!)
-kubectl apply -f kubernetes/afterwork-secrets.yaml
-
-# Créer la ConfigMap
-kubectl apply -f kubernetes/afterwork-configmap.yaml
-
-# Déployer l'application
-kubectl apply -f kubernetes/afterwork-deployment.yaml
-kubectl apply -f kubernetes/afterwork-service.yaml
-kubectl apply -f kubernetes/afterwork-ingress.yaml
-
-# Ou via lionesctl pipeline
-lionesctl pipeline deploy -f kubernetes/
-```
-
-### Étape 5 : Vérification
-
-```bash
-# Pods
-kubectl get pods -n applications -l app=afterwork-api
-
-# Logs
-kubectl logs -n applications -l app=afterwork-api --tail=100 -f
-
-# Service
-kubectl get svc -n applications afterwork-api
-
-# Ingress
-kubectl get ingress -n applications afterwork-api
-
-# Test health
-curl https://api.lions.dev/afterwork/q/health/ready
-curl https://api.lions.dev/afterwork/q/health/live
-
-# Test API
-curl https://api.lions.dev/afterwork/api/users/test
-```
-
----
-
-## 🔧 Maintenance
-
-### Mise à Jour de l'Application
-
-```bash
-# 1. Build nouvelle version
-mvn clean package -DskipTests
-docker build -f Dockerfile.prod -t registry.lions.dev/afterwork-api:1.0.1 .
-docker push registry.lions.dev/afterwork-api:1.0.1
-
-# 2. Mise à jour du déploiement
-kubectl set image deployment/afterwork-api \
-  afterwork-api=registry.lions.dev/afterwork-api:1.0.1 \
-  -n applications
-
-# 3. Rollout status
-kubectl rollout status deployment/afterwork-api -n applications
-```
-
-### Rollback
-
-```bash
-# Voir l'historique
-kubectl rollout history deployment/afterwork-api -n applications
-
-# Rollback à la version précédente
-kubectl rollout undo deployment/afterwork-api -n applications
-
-# Rollback à une révision spécifique
-kubectl rollout undo deployment/afterwork-api --to-revision=2 -n applications
-```
-
-### Scaling
-
-```bash
-# Scale up
-kubectl scale deployment afterwork-api --replicas=3 -n applications
-
-# Scale down
-kubectl scale deployment afterwork-api --replicas=1 -n applications
-
-# Autoscaling (HPA)
-kubectl autoscale deployment afterwork-api \
-  --min=2 --max=10 \
-  --cpu-percent=80 \
-  -n applications
-```
-
----
-
-## 🐛 Troubleshooting
-
-### Problème : Pods ne démarrent pas
-
-```bash
-# Vérifier les événements
-kubectl describe pod <pod-name> -n applications
-
-# Vérifier les logs
-kubectl logs <pod-name> -n applications
-
-# Vérifier les secrets
-kubectl get secret afterwork-secrets -n applications -o yaml
-```
-
-### Problème : Base de données inaccessible
-
-```bash
-# Tester la connexion depuis un pod
-kubectl run -it --rm debug --image=postgres:15 --restart=Never -- \
-  psql -h postgres -U afterwork -d afterwork_db
-
-# Vérifier le service PostgreSQL
-kubectl get svc -n postgresql
-```
-
-### Problème : Ingress ne fonctionne pas
-
-```bash
-# Vérifier l'Ingress
-kubectl describe ingress afterwork-api -n applications
-
-# Vérifier les certificats TLS
-kubectl get certificate -n applications
-
-# Logs du contrôleur Ingress
-kubectl logs -n ingress-nginx -l app.kubernetes.io/name=ingress-nginx
-```
-
----
-
-## 📊 Monitoring
-
-### Métriques Prometheus
-
-```bash
-# Accéder aux métriques
-curl https://api.lions.dev/afterwork/q/metrics
-
-# Ou via port-forward
-kubectl port-forward -n applications svc/afterwork-api 8080:8080
-curl http://localhost:8080/q/metrics
-```
-
-### Logs Centralisés
-
-```bash
-# Tous les logs de l'application
-kubectl logs -n applications -l app=afterwork-api --tail=1000
-
-# Logs en temps réel
-kubectl logs -n applications -l app=afterwork-api -f
-
-# Logs d'un pod spécifique
-kubectl logs -n applications <pod-name> --previous
-```
-
----
-
-## 🔐 Sécurité
-
-### Secrets
-
-- ⚠️ **NE JAMAIS** commiter les secrets dans Git
-- Utiliser Sealed Secrets ou Vault pour la gestion des secrets
-- Rotation régulière des mots de passe de base de données
-
-### Network Policies
-
-```yaml
-apiVersion: networking.k8s.io/v1
-kind: NetworkPolicy
-metadata:
-  name: afterwork-api-netpol
-  namespace: applications
-spec:
-  podSelector:
-    matchLabels:
-      app: afterwork-api
-  policyTypes:
-  - Ingress
-  - Egress
-  ingress:
-  - from:
-    - namespaceSelector:
-        matchLabels:
-          name: ingress-nginx
-    ports:
-    - protocol: TCP
-      port: 8080
-  egress:
-  - to:
-    - namespaceSelector:
-        matchLabels:
-          name: postgresql
-    ports:
-    - protocol: TCP
-      port: 5432
-  - to:
-    - namespaceSelector: {}
-    ports:
-    - protocol: TCP
-      port: 443  # Pour les APIs externes
-```
-
----
-
-## 📝 Checklist de Déploiement
-
-### Avant le Déploiement
-
-- [ ] Tests unitaires passent
-- [ ] Build Maven réussit
-- [ ] Image Docker créée
-- [ ] Variables d'environnement configurées
-- [ ] Secrets créés dans Kubernetes
-- [ ] Base de données PostgreSQL prête
-
-### Pendant le Déploiement
-
-- [ ] Image pushée vers le registry
-- [ ] Manifests Kubernetes appliqués
-- [ ] Pods démarrent correctement
-- [ ] Health checks réussissent
-- [ ] Ingress configuré avec TLS
-
-### Après le Déploiement
-
-- [ ] API accessible via HTTPS
-- [ ] WebSocket fonctionne
-- [ ] Tests d'intégration passent
-- [ ] Métriques remontées dans Prometheus
-- [ ] Logs centralisés fonctionnent
-- [ ] Documentation mise à jour
-
----
-
-## 📞 Support
-
-En cas de problème :
-1. Consulter les logs : `kubectl logs -n applications -l app=afterwork-api`
-2. Vérifier les events : `kubectl get events -n applications`
-3. Tester les health checks : `curl https://api.lions.dev/afterwork/q/health`
-4. Contacter l'équipe DevOps
-
----
-
-**Dernière mise à jour** : 2026-01-09
-**Version** : 1.0.0

DEPLOYMENT_STATUS.md

@@ -1,281 +0,0 @@
-# ✅ Statut du Déploiement AfterWork API
-
-**Date** : 2026-01-10
-**Statut** : ✅ Prêt pour le déploiement
-
----
-
-## 📋 Résumé de la Préparation
-
-### ✅ Backend (Quarkus)
-
-| Élément | Statut | Description |
-|---------|--------|-------------|
-| **Build Maven** | ✅ Validé | Build réussi avec uber-jar (73M) |
-| **Tests** | ✅ Configuré | Non-bloquants (`testFailureIgnore=true`) |
-| **Dockerfile.prod** | ✅ Créé | Multi-stage build avec UBI8 OpenJDK 17 |
-| **.dockerignore** | ✅ Créé | Optimisation du contexte Docker |
-| **application-prod.properties** | ✅ Créé | Configuration production avec context path `/afterwork` |
-| **Kubernetes Manifests** | ✅ Créés | Deployment, Service, Ingress, ConfigMap, Secrets |
-| **Scripts de déploiement** | ✅ Créés | `deploy.ps1` et documentation complète |
-
-### ✅ Frontend (Flutter)
-
-| Élément | Statut | Description |
-|---------|--------|-------------|
-| **env_config.dart** | ✅ Configuré | Support `--dart-define` pour API_BASE_URL |
-| **build-prod.ps1** | ✅ Créé | Build APK/AAB avec `https://api.lions.dev/afterwork` |
-| **Configuration API** | ✅ Prête | Pointe vers `https://api.lions.dev/afterwork` |
-
----
-
-## 🔧 Fichiers Créés/Modifiés
-
-### Backend
-```
-mic-after-work-server-impl-quarkus-main/
-├── Dockerfile.prod                          ✅ NOUVEAU
-├── .dockerignore                            ✅ NOUVEAU
-├── pom.xml                                  ✅ MODIFIÉ (tests non-bloquants)
-├── deploy.ps1                               ✅ NOUVEAU
-├── DEPLOYMENT.md                            ✅ NOUVEAU
-├── QUICK_DEPLOY.md                          ✅ NOUVEAU
-├── DEPLOYMENT_STATUS.md                     ✅ NOUVEAU (ce fichier)
-├── src/main/resources/
-│   └── application-prod.properties          ✅ NOUVEAU
-└── kubernetes/
-    ├── afterwork-configmap.yaml             ✅ NOUVEAU
-    ├── afterwork-secrets.yaml               ✅ NOUVEAU (⚠️ MODIFIER MOT DE PASSE)
-    ├── afterwork-deployment.yaml            ✅ NOUVEAU
-    ├── afterwork-service.yaml               ✅ NOUVEAU
-    └── afterwork-ingress.yaml               ✅ NOUVEAU
-```
-
-### Frontend
-```
-afterwork/
-├── lib/core/constants/env_config.dart       ✅ EXISTE (configuré)
-└── build-prod.ps1                           ✅ NOUVEAU
-```
-
----
-
-## 🚀 Prochaines Étapes pour le Déploiement
-
-### 1️⃣ Modifier le Secret de Base de Données
-
-```bash
-# Éditer le fichier
-notepad C:\Users\dadyo\PersonalProjects\mic-after-work-server-impl-quarkus-main\kubernetes\afterwork-secrets.yaml
-
-# Changer cette ligne:
-DB_PASSWORD: "CHANGE_ME_IN_PRODUCTION"
-
-# Par le vrai mot de passe (encodé en base64 ou en clair avec stringData)
-```
-
-### 2️⃣ Déployer via PowerShell Script (Recommandé)
-
-```powershell
-cd C:\Users\dadyo\PersonalProjects\mic-after-work-server-impl-quarkus-main
-
-# Déploiement complet
-.\deploy.ps1 -Action all -Version 1.0.0
-
-# Ou étape par étape
-.\deploy.ps1 -Action build     # Build Maven + Docker
-.\deploy.ps1 -Action push      # Push vers registry
-.\deploy.ps1 -Action deploy    # Déploiement K8s
-```
-
-### 3️⃣ Déployer via lionesctl (Alternative)
-
-```bash
-cd C:\Users\dadyo\PersonalProjects\mic-after-work-server-impl-quarkus-main
-
-# Build local
-mvn clean package -DskipTests -Dquarkus.package.type=uber-jar
-docker build -f Dockerfile.prod -t registry.lions.dev/afterwork-api:1.0.0 .
-docker push registry.lions.dev/afterwork-api:1.0.0
-
-# Déploiement
-lionesctl pipeline deploy -f kubernetes/
-```
-
-### 4️⃣ Vérifier le Déploiement
-
-```bash
-# Pods
-kubectl get pods -n applications -l app=afterwork-api
-
-# Logs
-kubectl logs -n applications -l app=afterwork-api -f
-
-# Health check
-curl https://api.lions.dev/afterwork/q/health/ready
-curl https://api.lions.dev/afterwork/q/health/live
-
-# Statut complet
-.\deploy.ps1 -Action status
-```
-
-### 5️⃣ Builder l'Application Flutter
-
-```powershell
-cd C:\Users\dadyo\PersonalProjects\lions-workspace\afterwork
-
-# Build APK production
-.\build-prod.ps1 -Target apk
-
-# Ou AAB pour Play Store
-.\build-prod.ps1 -Target appbundle
-
-# Les artefacts seront dans:
-# build/app/outputs/flutter-apk/app-arm64-v8a-release.apk
-```
-
----
-
-## 📊 Tests de Build Effectués
-
-### Build Maven (Validé ✅)
-
-```
-[INFO] BUILD SUCCESS
-[INFO] Total time:  59.644 s
-[INFO] Finished at: 2026-01-10T00:10:21Z
-
-Artefact créé:
-✅ target/mic-after-work-server-impl-quarkus-main-1.0.0-SNAPSHOT-runner.jar (73M)
-```
-
-**Notes:**
-- Les tests sont skippés comme demandé
-- Quelques warnings sur des configurations non reconnues (micrometer, health checks)
-  - Ces extensions sont probablement manquantes dans le pom.xml
-  - Cela n'empêche pas le déploiement
-  - Les health checks Quarkus fonctionneront avec les chemins par défaut
-
----
-
-## ⚠️ Avertissements et Prérequis
-
-### Prérequis pour le Déploiement
-
-- [ ] PostgreSQL installé sur le cluster K8s
-- [ ] Base de données `afterwork_db` créée
-- [ ] Utilisateur `afterwork` avec droits appropriés
-- [ ] Mot de passe DB configuré dans `kubernetes/afterwork-secrets.yaml`
-- [ ] Docker installé et fonctionnel
-- [ ] Accès au registry `registry.lions.dev`
-- [ ] kubectl configuré avec accès au cluster
-- [ ] Ingress Controller (nginx) installé
-- [ ] Cert-Manager installé pour les certificats SSL
-
-### Warnings Maven (Non-bloquants)
-
-Les warnings suivants apparaissent lors du build mais n'empêchent pas le fonctionnement :
-
-```
-[WARNING] Unrecognized configuration key "quarkus.micrometer.*"
-[WARNING] Unrecognized configuration key "quarkus.smallrye-health.*"
-[WARNING] Unrecognized configuration key "quarkus.http.body.multipart.*"
-```
-
-**Solutions (Optionnel):**
-
-Pour éliminer ces warnings, ajouter dans `pom.xml`:
-
-```xml
-<dependency>
-    <groupId>io.quarkus</groupId>
-    <artifactId>quarkus-micrometer-registry-prometheus</artifactId>
-</dependency>
-<dependency>
-    <groupId>io.quarkus</groupId>
-    <artifactId>quarkus-smallrye-health</artifactId>
-</dependency>
-```
-
-Mais ce n'est pas nécessaire pour le déploiement initial.
-
----
-
-## 🎯 Configuration des URLs
-
-### Backend (Production)
-- **API Base URL** : `https://api.lions.dev/afterwork`
-- **Health Ready** : `https://api.lions.dev/afterwork/q/health/ready`
-- **Health Live** : `https://api.lions.dev/afterwork/q/health/live`
-- **Métriques** : `https://api.lions.dev/afterwork/q/metrics`
-
-### WebSocket (Production)
-- **Notifications** : `wss://api.lions.dev/afterwork/ws/notifications/{userId}`
-- **Chat** : `wss://api.lions.dev/afterwork/ws/chat/{userId}`
-
-### Frontend
-- Configuré pour pointer vers `https://api.lions.dev/afterwork`
-- Build production via `.\build-prod.ps1`
-- Variables d'environnement injectées via `--dart-define`
-
----
-
-## 📚 Documentation Disponible
-
-1. **DEPLOYMENT.md** - Guide complet de déploiement (~566 lignes)
-   - Prérequis détaillés
-   - Structure Kubernetes complète
-   - Troubleshooting
-   - Monitoring et sécurité
-
-2. **QUICK_DEPLOY.md** - Guide de déploiement rapide
-   - Commandes copier-coller
-   - 3 options de déploiement
-   - Checklist pré-déploiement
-   - Troubleshooting rapide
-
-3. **deploy.ps1** - Script PowerShell automatisé
-   - Actions: build, push, deploy, all, rollback, status
-   - Validation et vérification automatique
-   - Gestion des erreurs
-
-4. **DEPLOYMENT_STATUS.md** - Ce fichier
-   - Résumé de la préparation
-   - Statut actuel
-   - Prochaines étapes
-
----
-
-## 🎉 Résumé
-
-### ✅ Tous les fichiers nécessaires ont été créés
-### ✅ Le build Maven fonctionne correctement
-### ✅ L'uber-jar est généré avec succès (73M)
-### ✅ Les tests sont configurés pour ne pas bloquer
-### ✅ La documentation complète est disponible
-### ✅ Le frontend est configuré pour production
-
-## 🚀 L'API AfterWork est prête à être déployée !
-
----
-
-**Commande recommandée pour déployer:**
-
-```powershell
-cd C:\Users\dadyo\PersonalProjects\mic-after-work-server-impl-quarkus-main
-
-# 1. Modifier le mot de passe DB dans kubernetes/afterwork-secrets.yaml
-# 2. Lancer le déploiement
-.\deploy.ps1 -Action all -Version 1.0.0
-
-# 3. Vérifier
-.\deploy.ps1 -Action status
-curl https://api.lions.dev/afterwork/q/health/ready
-```
-
----
-
-**Pour toute question ou problème, consulter:**
-- DEPLOYMENT.md (guide complet)
-- QUICK_DEPLOY.md (guide rapide)
-- Logs: `kubectl logs -n applications -l app=afterwork-api -f`

Dockerfile

@@ -1,42 +0,0 @@
-##
-## AfterWork Server - Development Dockerfile
-## Image légère avec JRE Alpine
-##
-
-FROM eclipse-temurin:17-jre-alpine
-
-# Variables d'environnement
-ENV LANG='en_US.UTF-8' \
-    QUARKUS_PROFILE=dev \
-    JAVA_OPTS="-Xmx512m -Xms256m -XX:+UseG1GC"
-
-# Installation des dépendances système
-RUN apk add --no-cache curl tzdata && \
-    cp /usr/share/zoneinfo/Africa/Douala /etc/localtime && \
-    echo "Africa/Douala" > /etc/timezone
-
-# Création du user non-root
-RUN addgroup -g 185 -S appuser && \
-    adduser -u 185 -S appuser -G appuser
-
-# Création des répertoires
-RUN mkdir -p /app /tmp/uploads && \
-    chown -R appuser:appuser /app /tmp/uploads
-
-WORKDIR /app
-
-# Copie du JAR
-COPY --chown=appuser:appuser target/*-runner.jar /app/app.jar
-
-# Exposition du port
-EXPOSE 8080
-
-# Healthcheck
-HEALTHCHECK --interval=30s --timeout=5s --start-period=30s --retries=3 \
-    CMD curl -f http://localhost:8080/q/health/ready || exit 1
-
-# User non-root
-USER appuser
-
-# Lancement
-ENTRYPOINT ["java", "-jar", "/app/app.jar"]

Dockerfile.prod

@@ -1,61 +0,0 @@
-##
-## AfterWork Server - Production Dockerfile
-## Build stage avec Maven + Runtime optimisé avec UBI8 OpenJDK 17
-##
-
-# ======================================
-# STAGE 1: Build de l'application
-# ======================================
-FROM registry.access.redhat.com/ubi8/openjdk-17:1.18 AS builder
-
-USER root
-
-# Installation de Maven
-RUN microdnf install -y maven && microdnf clean all
-
-# Copie des fichiers du projet
-WORKDIR /build
-COPY pom.xml .
-COPY src ./src
-
-# Build de l'application (skip tests pour accélérer)
-RUN mvn clean package -DskipTests -Dquarkus.package.type=uber-jar
-
-# ======================================
-# STAGE 2: Image de runtime
-# ======================================
-FROM registry.access.redhat.com/ubi8/openjdk-17-runtime:1.18
-
-# Variables d'environnement par défaut
-ENV LANG='en_US.UTF-8' \
-    LANGUAGE='en_US:en' \
-    TZ='Africa/Douala' \
-    QUARKUS_PROFILE=prod \
-    DB_HOST=postgresql \
-    DB_PORT=5432 \
-    DB_NAME=afterwork_db \
-    DB_USERNAME=afterwork \
-    DB_PASSWORD=changeme \
-    JAVA_OPTS_APPEND="-XX:+UseG1GC \
-                      -XX:+StringDeduplication \
-                      -XX:+OptimizeStringConcat \
-                      -XX:MaxRAMPercentage=75.0 \
-                      -XX:+HeapDumpOnOutOfMemoryError \
-                      -XX:HeapDumpPath=/tmp/heapdump.hprof \
-                      -Djava.net.preferIPv4Stack=true"
-
-# Configuration du port
-EXPOSE 8080
-
-# Copie de l'uber-jar depuis le builder
-COPY --from=builder --chown=185:185 /build/target/*-runner.jar /deployments/app.jar
-
-# User non-root pour la sécurité
-USER 185
-
-# Healthcheck sur l'endpoint Quarkus
-HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
-    CMD curl -f http://localhost:8080/q/health/ready || exit 1
-
-# Lancement de l'application
-ENTRYPOINT ["java", "-jar", "/deployments/app.jar"]

QUICK_DEPLOY.md

@@ -1,172 +0,0 @@
-# 🚀 Déploiement Rapide AfterWork API
-
-## ⚡ Commandes de Déploiement (Copier-Coller)
-
-### Option 1 : Déploiement Automatique via Script PowerShell
-
-```powershell
-cd C:\Users\dadyo\PersonalProjects\mic-after-work-server-impl-quarkus-main
-
-# Déploiement complet (build + push + deploy)
-.\deploy.ps1 -Action all -Version 1.0.0
-
-# Ou étape par étape
-.\deploy.ps1 -Action build    # Build Maven + Docker
-.\deploy.ps1 -Action push     # Push vers registry
-.\deploy.ps1 -Action deploy   # Déploiement K8s
-
-# Vérifier le statut
-.\deploy.ps1 -Action status
-```
-
-### Option 2 : Déploiement Manuel
-
-```powershell
-cd C:\Users\dadyo\PersonalProjects\mic-after-work-server-impl-quarkus-main
-
-# 1. Build Maven (tests non-bloquants)
-mvn clean package -DskipTests
-
-# 2. Build Docker
-docker build -f Dockerfile.prod -t registry.lions.dev/afterwork-api:1.0.0 -t registry.lions.dev/afterwork-api:latest .
-
-# 3. Push vers Registry
-docker login registry.lions.dev
-docker push registry.lions.dev/afterwork-api:1.0.0
-docker push registry.lions.dev/afterwork-api:latest
-
-# 4. Déploiement Kubernetes
-kubectl create namespace applications --dry-run=client -o yaml | kubectl apply -f -
-kubectl apply -f kubernetes/afterwork-configmap.yaml
-kubectl apply -f kubernetes/afterwork-secrets.yaml
-kubectl apply -f kubernetes/afterwork-deployment.yaml
-kubectl apply -f kubernetes/afterwork-service.yaml
-kubectl apply -f kubernetes/afterwork-ingress.yaml
-
-# 5. Vérification
-kubectl get pods -n applications -l app=afterwork-api
-kubectl logs -n applications -l app=afterwork-api -f
-```
-
-### Option 3 : Déploiement via lionesctl
-
-```bash
-cd C:\Users\dadyo\PersonalProjects\mic-after-work-server-impl-quarkus-main
-
-# Build local
-mvn clean package -DskipTests
-docker build -f Dockerfile.prod -t registry.lions.dev/afterwork-api:1.0.0 .
-docker push registry.lions.dev/afterwork-api:1.0.0
-
-# Déploiement
-lionesctl pipeline deploy -f kubernetes/
-```
-
----
-
-## ⚠️ IMPORTANT : Modifier les Secrets AVANT le Déploiement
-
-```bash
-# Éditer le fichier de secrets
-notepad kubernetes/afterwork-secrets.yaml
-
-# Changer la ligne:
-# DB_PASSWORD: "CHANGE_ME_IN_PRODUCTION"
-# Par le vrai mot de passe
-```
-
----
-
-## ✅ Vérifications Post-Déploiement
-
-```bash
-# 1. Pods en cours d'exécution
-kubectl get pods -n applications -l app=afterwork-api
-
-# 2. Health check
-curl https://api.lions.dev/afterwork/q/health/ready
-curl https://api.lions.dev/afterwork/q/health/live
-
-# 3. Logs
-kubectl logs -n applications -l app=afterwork-api --tail=50
-
-# 4. Ingress
-kubectl get ingress -n applications afterwork-api
-```
-
----
-
-## 🔧 Configuration Frontend
-
-Une fois l'API déployée, builder l'application Flutter :
-
-```powershell
-cd C:\Users\dadyo\PersonalProjects\lions-workspace\afterwork
-
-# Build APK production
-.\build-prod.ps1 -Target apk
-
-# Ou Build AAB pour Play Store
-.\build-prod.ps1 -Target appbundle
-
-# Les APKs seront dans:
-# build/app/outputs/flutter-apk/
-```
-
----
-
-## 🐛 Troubleshooting Rapide
-
-### Si les pods ne démarrent pas :
-```bash
-kubectl describe pod <pod-name> -n applications
-kubectl logs <pod-name> -n applications
-```
-
-### Si l'API n'est pas accessible :
-```bash
-# Vérifier l'Ingress
-kubectl describe ingress afterwork-api -n applications
-
-# Vérifier les certificats TLS
-kubectl get certificate -n applications
-
-# Port-forward pour test direct
-kubectl port-forward -n applications svc/afterwork-api 8080:8080
-curl http://localhost:8080/afterwork/q/health
-```
-
-### Si la base de données est inaccessible :
-```bash
-# Tester la connexion DB depuis un pod
-kubectl run -it --rm debug --image=postgres:15 --restart=Never -- \
-  psql -h postgres -U afterwork -d afterwork_db
-```
-
----
-
-## 📋 Checklist Pré-Déploiement
-
-- [ ] PostgreSQL est installé et accessible sur le cluster
-- [ ] La base de données `afterwork_db` existe
-- [ ] L'utilisateur `afterwork` a les droits sur la base
-- [ ] Le mot de passe DB est configuré dans `kubernetes/afterwork-secrets.yaml`
-- [ ] Docker est installé et fonctionnel
-- [ ] Accès au registry `registry.lions.dev` configuré
-- [ ] kubectl configuré et accès au cluster K8s
-- [ ] Ingress Controller (nginx) installé sur le cluster
-- [ ] Cert-Manager installé pour les certificats SSL
-
----
-
-## 🎯 Résumé des URLs
-
-- **API Production** : `https://api.lions.dev/afterwork`
-- **Health Check** : `https://api.lions.dev/afterwork/q/health`
-- **Métriques** : `https://api.lions.dev/afterwork/q/metrics`
-- **WebSocket** : `wss://api.lions.dev/afterwork/ws/notifications/{userId}`
-
----
-
-**Temps estimé de déploiement** : 5-10 minutes
-**Dernière mise à jour** : 2026-01-09

README.md

@@ -1,4 +1,4 @@
-# mic-after-work-server-impl-quarkus-main
+# mic-after-work
 
 This project uses Quarkus, the Supersonic Subatomic Java Framework.
 
@@ -49,17 +49,15 @@ Or, if you don't have GraalVM installed, you can run the native executable build
 ./mvnw package -Dnative -Dquarkus.native.container-build=true
 ```
 
-You can then execute your native executable with: `./target/mic-after-work-server-impl-quarkus-main-1.0.0-SNAPSHOT-runner`
+You can then execute your native executable with: `./target/mic-after-work-1.0.0-SNAPSHOT-runner`
 
 If you want to learn more about building native executables, please consult <https://quarkus.io/guides/maven-tooling>.
 
 ## Related Guides
 
-- Hibernate ORM ([guide](https://quarkus.io/guides/hibernate-orm)): Define your persistent model with Hibernate ORM and Jakarta Persistence
+- Hibernate ORM with Panache ([guide](https://quarkus.io/guides/hibernate-orm-panache)): Simplify your persistence code for Hibernate ORM via the active record or the repository pattern
-- SmallRye OpenAPI ([guide](https://quarkus.io/guides/openapi-swaggerui)): Document your REST APIs with OpenAPI - comes with Swagger UI
 - RESTEasy Classic ([guide](https://quarkus.io/guides/resteasy)): REST endpoint framework implementing Jakarta REST and more
-- Logging JSON ([guide](https://quarkus.io/guides/logging#json-logging)): Add JSON formatter for console logging
+- JDBC Driver - Oracle ([guide](https://quarkus.io/guides/datasource)): Connect to the Oracle database via JDBC
-- JDBC Driver - PostgreSQL ([guide](https://quarkus.io/guides/datasource)): Connect to the PostgreSQL database via JDBC
 
 ## Provided Code
 
@@ -69,6 +67,7 @@ Create your first JPA entity
 
 [Related guide section...](https://quarkus.io/guides/hibernate-orm)
 
+[Related Hibernate with Panache section...](https://quarkus.io/guides/hibernate-orm-panache)
 
 
 ### RESTEasy JAX-RS

REALTIME_ARCHITECTURE_BRAINSTORM.md

@@ -1,450 +0,0 @@
-# 🚀 Architecture Temps Réel - Brainstorming & Plan d'Implémentation
-
-## 📋 Contexte Actuel
-
-### État des Lieux
-- ✅ **Backend**: Jakarta WebSocket (`@ServerEndpoint`) - API legacy
-- ✅ **Frontend**: `web_socket_channel` pour WebSocket
-- ✅ **Services existants**:
-  - `NotificationWebSocket` (`/notifications/ws/{userId}`)
-  - `ChatWebSocket` (`/chat/ws/{userId}`)
-  - Services Flutter: `RealtimeNotificationService`, `ChatWebSocketService`
-
-### Limitations Actuelles
-1. **Pas de persistance des événements** : Si un utilisateur est déconnecté, les messages sont perdus
-2. **Pas de scalabilité horizontale** : Les sessions WebSocket sont en mémoire, ne fonctionnent pas avec plusieurs instances
-3. **Pas de garantie de livraison** : Pas de mécanisme de retry ou de queue
-4. **Pas de découplage** : Services directement couplés aux WebSockets
-
----
-
-## 🎯 Objectifs
-
-1. **Garantir la livraison** : Aucun événement ne doit être perdu
-2. **Scalabilité horizontale** : Support de plusieurs instances Quarkus
-3. **Temps réel garanti** : Latence < 100ms pour les notifications critiques
-4. **Durabilité** : Persistance des événements pour récupération après déconnexion
-5. **Découplage** : Services métier indépendants des WebSockets
-
----
-
-## 🏗️ Architecture Proposée
-
-### Option 1 : WebSockets Next + Kafka (Recommandée) ⭐
-
-```
-┌─────────────┐
-│   Flutter   │
-│   Client    │
-└──────┬──────┘
-       │ WebSocket (wss://)
-       │
-┌──────▼─────────────────────────────────────┐
-│         Quarkus WebSockets Next             │
-│  ┌──────────────────────────────────────┐  │
-│  │  @WebSocket("/notifications/{userId}")│  │
-│  │  @WebSocket("/chat/{userId}")         │  │
-│  └──────┬───────────────────────────────┘  │
-│         │                                    │
-│  ┌──────▼──────────────────────────────┐  │
-│  │  Reactive Messaging Bridge            │  │
-│  │  @Incoming("kafka-notifications")     │  │
-│  │  @Outgoing("websocket-notifications") │  │
-│  └──────┬───────────────────────────────┘  │
-└─────────┼──────────────────────────────────┘
-          │
-          │ Kafka Topics
-          │
-┌─────────▼──────────────────────────────────┐
-│         Apache Kafka Cluster                │
-│  ┌──────────────────────────────────────┐   │
-│  │  Topics:                             │   │
-│  │  - notifications.{userId}           │   │
-│  │  - chat.messages                    │   │
-│  │  - reactions.{postId}               │   │
-│  │  - presence.updates                 │   │
-│  └──────────────────────────────────────┘   │
-└─────────┬──────────────────────────────────┘
-          │
-          │ Producers
-          │
-┌─────────▼──────────────────────────────────┐
-│      Services Métier (Quarkus)             │
-│  - FriendshipService                        │
-│  - MessageService                           │
-│  - SocialPostService                        │
-│  - EventService                             │
-└────────────────────────────────────────────┘
-```
-
-### Avantages
-- ✅ **Scalabilité** : Kafka gère la distribution entre instances
-- ✅ **Durabilité** : Messages persistés dans Kafka (rétention configurable)
-- ✅ **Découplage** : Services publient dans Kafka, WebSocket consomme
-- ✅ **Performance** : WebSockets Next est plus performant que Jakarta WS
-- ✅ **Replay** : Possibilité de rejouer les événements pour récupération
-- ✅ **Monitoring** : Kafka fournit des métriques natives
-
-### Inconvénients
-- ⚠️ **Complexité** : Nécessite un cluster Kafka (mais Quarkus Dev Services le gère automatiquement)
-- ⚠️ **Latence** : Légèrement plus élevée (Kafka + WebSocket vs WebSocket direct)
-- ⚠️ **Ressources** : Kafka consomme plus de mémoire
-
----
-
-## 📦 Technologies & Dépendances
-
-### Backend (Quarkus)
-
-#### 1. WebSockets Next (Remplace Jakarta WebSocket)
-```xml
-<dependency>
-    <groupId>io.quarkus</groupId>
-    <artifactId>quarkus-websockets-next</artifactId>
-</dependency>
-```
-
-**Documentation**: https://quarkus.io/guides/websockets-next
-
-#### 2. Kafka Reactive Messaging
-```xml
-<dependency>
-    <groupId>io.quarkus</groupId>
-    <artifactId>quarkus-messaging-kafka</artifactId>
-</dependency>
-```
-
-**Documentation**: https://quarkus.io/guides/kafka
-
-#### 3. Reactive Messaging HTTP (Bridge Kafka ↔ WebSocket)
-```xml
-<dependency>
-    <groupId>io.quarkiverse.reactivemessaginghttp</groupId>
-    <artifactId>quarkus-reactive-messaging-http</artifactId>
-    <version>1.0.0</version>
-</dependency>
-```
-
-**Documentation**: https://docs.quarkiverse.io/quarkus-reactive-messaging-http/dev/reactive-messaging-websocket.html
-
-### Frontend (Flutter)
-
-#### Package WebSocket (Déjà utilisé)
-```yaml
-dependencies:
-  web_socket_channel: ^2.4.0
-```
-
-**Documentation**: https://pub.dev/packages/web_socket_channel
-
----
-
-## 🔧 Configuration
-
-### application.properties (Quarkus)
-
-```properties
-# ============================================
-# Kafka Configuration
-# ============================================
-kafka.bootstrap.servers=${KAFKA_BOOTSTRAP_SERVERS:localhost:9092}
-
-# Topics
-mp.messaging.outgoing.notifications.connector=smallrye-kafka
-mp.messaging.outgoing.notifications.topic=notifications
-mp.messaging.outgoing.notifications.key.serializer=org.apache.kafka.common.serialization.StringSerializer
-mp.messaging.outgoing.notifications.value.serializer=io.quarkus.kafka.client.serialization.JsonbSerializer
-
-mp.messaging.outgoing.chat-messages.connector=smallrye-kafka
-mp.messaging.outgoing.chat-messages.topic=chat.messages
-mp.messaging.outgoing.chat-messages.key.serializer=org.apache.kafka.common.serialization.StringSerializer
-mp.messaging.outgoing.chat-messages.value.serializer=io.quarkus.kafka.client.serialization.JsonbSerializer
-
-mp.messaging.outgoing.reactions.connector=smallrye-kafka
-mp.messaging.outgoing.reactions.topic=reactions
-mp.messaging.outgoing.reactions.key.serializer=org.apache.kafka.common.serialization.StringSerializer
-mp.messaging.outgoing.reactions.value.serializer=io.quarkus.kafka.client.serialization.JsonbSerializer
-
-# ============================================
-# WebSocket Configuration
-# ============================================
-# WebSockets Next
-quarkus.websockets-next.server.enabled=true
-quarkus.websockets-next.server.port=8080
-
-# ============================================
-# Reactive Messaging HTTP (Bridge)
-# ============================================
-# Incoming Kafka → Outgoing WebSocket
-mp.messaging.incoming.kafka-notifications.connector=smallrye-kafka
-mp.messaging.incoming.kafka-notifications.topic=notifications
-mp.messaging.incoming.kafka-notifications.group.id=websocket-bridge
-mp.messaging.incoming.kafka-notifications.key.deserializer=org.apache.kafka.common.serialization.StringDeserializer
-mp.messaging.incoming.kafka-notifications.value.deserializer=io.quarkus.kafka.client.serialization.JsonbDeserializer
-
-mp.messaging.outgoing.ws-notifications.connector=quarkus-websocket
-mp.messaging.outgoing.ws-notifications.path=/notifications/{userId}
-```
-
----
-
-## 💻 Implémentation
-
-### Backend : Migration vers WebSockets Next
-
-#### 1. Nouveau NotificationWebSocket (WebSockets Next)
-
-```java
-package com.lions.dev.websocket;
-
-import io.quarkus.websockets.next.OnOpen;
-import io.quarkus.websockets.next.OnClose;
-import io.quarkus.websockets.next.OnTextMessage;
-import io.quarkus.websockets.next.WebSocket;
-import io.quarkus.websockets.next.WebSocketConnection;
-import io.smallrye.mutiny.Multi;
-import jakarta.inject.Inject;
-import org.eclipse.microprofile.reactive.messaging.Channel;
-import org.eclipse.microprofile.reactive.messaging.Emitter;
-import org.eclipse.microprofile.reactive.messaging.Incoming;
-import org.eclipse.microprofile.reactive.messaging.Outgoing;
-
-import java.util.UUID;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.Map;
-
-/**
- * WebSocket endpoint pour les notifications en temps réel (WebSockets Next).
- * 
- * Architecture:
- * - Services métier → Kafka Topic → WebSocket Bridge → Client
- */
-@WebSocket(path = "/notifications/{userId}")
-public class NotificationWebSocketNext {
-
-    @Inject
-    @Channel("ws-notifications")
-    Emitter<String> notificationEmitter;
-
-    // Stockage des connexions actives (pour routing)
-    private static final Map<UUID, WebSocketConnection> connections = new ConcurrentHashMap<>();
-
-    @OnOpen
-    public void onOpen(WebSocketConnection connection, String userId) {
-        UUID userUUID = UUID.fromString(userId);
-        connections.put(userUUID, connection);
-        
-        // Envoyer confirmation de connexion
-        connection.sendText("{\"type\":\"connected\",\"timestamp\":" + System.currentTimeMillis() + "}");
-    }
-
-    @OnClose
-    public void onClose(String userId) {
-        UUID userUUID = UUID.fromString(userId);
-        connections.remove(userUUID);
-    }
-
-    @OnTextMessage
-    public void onMessage(String message, String userId) {
-        // Gérer les messages du client (ping, ack, etc.)
-        // ...
-    }
-
-    /**
-     * Bridge: Consomme depuis Kafka et envoie via WebSocket
-     */
-    @Incoming("kafka-notifications")
-    @Outgoing("ws-notifications")
-    public Multi<String> bridgeNotifications(String kafkaMessage) {
-        // Parser le message Kafka
-        // Extraire userId depuis la clé Kafka
-        // Router vers la bonne connexion WebSocket
-        return Multi.createFrom().item(kafkaMessage);
-    }
-}
-```
-
-#### 2. Service Métier Publie dans Kafka
-
-```java
-package com.lions.dev.service;
-
-import org.eclipse.microprofile.reactive.messaging.Channel;
-import org.eclipse.microprofile.reactive.messaging.Emitter;
-import jakarta.inject.Inject;
-
-@ApplicationScoped
-public class FriendshipService {
-    
-    @Inject
-    @Channel("notifications")
-    Emitter<NotificationEvent> notificationEmitter;
-
-    public void sendFriendRequest(UUID fromUserId, UUID toUserId) {
-        // ... logique métier ...
-        
-        // Publier dans Kafka au lieu d'appeler directement WebSocket
-        NotificationEvent event = new NotificationEvent(
-            toUserId.toString(),
-            "friend_request",
-            Map.of("fromUserId", fromUserId.toString(), "fromName", fromUser.getFirstName())
-        );
-        
-        notificationEmitter.send(event);
-    }
-}
-```
-
-### Frontend : Amélioration du Service WebSocket
-
-```dart
-// afterwork/lib/data/services/realtime_notification_service_v2.dart
-
-import 'package:web_socket_channel/web_socket_channel.dart';
-import 'package:web_socket_channel/status.dart' as status;
-
-class RealtimeNotificationServiceV2 {
-  WebSocketChannel? _channel;
-  Timer? _heartbeatTimer;
-  Timer? _reconnectTimer;
-  int _reconnectAttempts = 0;
-  static const int _maxReconnectAttempts = 5;
-  static const Duration _heartbeatInterval = Duration(seconds: 30);
-  static const Duration _reconnectDelay = Duration(seconds: 5);
-
-  Future<void> connect(String userId, String authToken) async {
-    final uri = Uri.parse('wss://api.afterwork.lions.dev/notifications/$userId');
-    
-    _channel = WebSocketChannel.connect(
-      uri,
-      protocols: ['notifications-v2'],
-      headers: {
-        'Authorization': 'Bearer $authToken',
-      },
-    );
-
-    // Heartbeat pour maintenir la connexion
-    _heartbeatTimer = Timer.periodic(_heartbeatInterval, (_) {
-      _channel?.sink.add(jsonEncode({'type': 'ping'}));
-    });
-
-    // Écouter les messages
-    _channel!.stream.listen(
-      _handleMessage,
-      onError: _handleError,
-      onDone: _handleDisconnection,
-      cancelOnError: false,
-    );
-  }
-
-  void _handleDisconnection() {
-    _heartbeatTimer?.cancel();
-    _scheduleReconnect();
-  }
-
-  void _scheduleReconnect() {
-    if (_reconnectAttempts < _maxReconnectAttempts) {
-      _reconnectTimer = Timer(_reconnectDelay * (_reconnectAttempts + 1), () {
-        _reconnectAttempts++;
-        connect(_userId, _authToken);
-      });
-    }
-  }
-}
-```
-
----
-
-## 📊 Comparaison des Options
-
-| Critère | Jakarta WS (Actuel) | WebSockets Next | WebSockets Next + Kafka |
-|---------|---------------------|-----------------|-------------------------|
-| **Performance** | ⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ |
-| **Scalabilité** | ❌ (1 instance) | ⚠️ (limité) | ✅ (illimitée) |
-| **Durabilité** | ❌ | ❌ | ✅ |
-| **Découplage** | ❌ | ⚠️ | ✅ |
-| **Complexité** | ⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐ |
-| **Latence** | < 50ms | < 50ms | < 100ms |
-| **Replay Events** | ❌ | ❌ | ✅ |
-| **Monitoring** | ⚠️ | ⚠️ | ✅ (Kafka metrics) |
-
----
-
-## 🎯 Plan d'Implémentation Recommandé
-
-### Phase 1 : Migration WebSockets Next (Sans Kafka)
-**Durée**: 1-2 semaines
-- Migrer `NotificationWebSocket` vers WebSockets Next
-- Migrer `ChatWebSocket` vers WebSockets Next
-- Tester avec le frontend existant
-- **Avantage**: Amélioration immédiate des performances
-
-### Phase 2 : Intégration Kafka
-**Durée**: 2-3 semaines
-- Ajouter dépendances Kafka
-- Créer les topics Kafka
-- Implémenter les bridges Kafka ↔ WebSocket
-- Migrer les services pour publier dans Kafka
-- **Avantage**: Scalabilité et durabilité
-
-### Phase 3 : Optimisations
-**Durée**: 1 semaine
-- Compression des messages
-- Batching pour les notifications
-- Monitoring et alertes
-- **Avantage**: Performance et observabilité
-
----
-
-## 🔍 Alternatives Considérées
-
-### Option 2 : Server-Sent Events (SSE)
-- ✅ Plus simple que WebSocket
-- ❌ Unidirectionnel (serveur → client uniquement)
-- ❌ Pas adapté pour le chat bidirectionnel
-
-### Option 3 : gRPC Streaming
-- ✅ Performant
-- ❌ Plus complexe à configurer
-- ❌ Nécessite HTTP/2
-
-### Option 4 : Socket.IO
-- ✅ Reconnexion automatique
-- ❌ Nécessite Node.js (pas compatible Quarkus)
-
----
-
-## 📚 Ressources & Documentation
-
-### Quarkus
-- [WebSockets Next Guide](https://quarkus.io/guides/websockets-next)
-- [Kafka Guide](https://quarkus.io/guides/kafka)
-- [Reactive Messaging](https://quarkus.io/guides/messaging)
-
-### Kafka
-- [Kafka Documentation](https://kafka.apache.org/documentation/)
-- [Quarkus Kafka Dev Services](https://quarkus.io/guides/kafka-dev-services)
-
-### Flutter
-- [web_socket_channel Package](https://pub.dev/packages/web_socket_channel)
-- [Flutter WebSocket Best Practices](https://ably.com/topic/websockets-flutter)
-
----
-
-## ✅ Recommandation Finale
-
-**Architecture recommandée**: **WebSockets Next + Kafka**
-
-**Raisons**:
-1. ✅ Scalabilité horizontale garantie
-2. ✅ Durabilité des événements
-3. ✅ Découplage des services
-4. ✅ Compatible avec l'existant (migration progressive)
-5. ✅ Support natif Quarkus (Dev Services pour Kafka)
-6. ✅ Monitoring intégré
-
-**Prochaines étapes**:
-1. Ajouter les dépendances dans `pom.xml`
-2. Créer un POC avec un seul endpoint (notifications)
-3. Tester la scalabilité avec 2 instances Quarkus
-4. Migrer progressivement les autres endpoints

REALTIME_IMPLEMENTATION_EXAMPLES.md

@@ -1,930 +0,0 @@
-# 💻 Exemples d'Implémentation - Temps Réel avec Kafka
-
-## 📦 Étape 1 : Ajouter les Dépendances
-
-### pom.xml
-
-```xml
-<!-- WebSockets Next (remplace quarkus-websockets) -->
-<dependency>
-    <groupId>io.quarkus</groupId>
-    <artifactId>quarkus-websockets-next</artifactId>
-</dependency>
-
-<!-- Kafka Reactive Messaging -->
-<dependency>
-    <groupId>io.quarkus</groupId>
-    <artifactId>quarkus-messaging-kafka</artifactId>
-</dependency>
-
-<!-- Reactive Messaging HTTP (Bridge Kafka ↔ WebSocket) -->
-<dependency>
-    <groupId>io.quarkiverse.reactivemessaginghttp</groupId>
-    <artifactId>quarkus-reactive-messaging-http</artifactId>
-    <version>1.0.0</version>
-</dependency>
-
-<!-- JSON Serialization pour Kafka -->
-<dependency>
-    <groupId>io.quarkus</groupId>
-    <artifactId>quarkus-jsonb</artifactId>
-</dependency>
-```
-
----
-
-## 🔧 Étape 2 : Configuration application.properties
-
-```properties
-# ============================================
-# Kafka Configuration
-# ============================================
-kafka.bootstrap.servers=${KAFKA_BOOTSTRAP_SERVERS:localhost:9092}
-
-# Topic: Notifications
-mp.messaging.outgoing.notifications.connector=smallrye-kafka
-mp.messaging.outgoing.notifications.topic=notifications
-mp.messaging.outgoing.notifications.key.serializer=org.apache.kafka.common.serialization.StringSerializer
-mp.messaging.outgoing.notifications.value.serializer=io.quarkus.kafka.client.serialization.JsonbSerializer
-
-# Topic: Chat Messages
-mp.messaging.outgoing.chat-messages.connector=smallrye-kafka
-mp.messaging.outgoing.chat-messages.topic=chat.messages
-mp.messaging.outgoing.chat-messages.key.serializer=org.apache.kafka.common.serialization.StringSerializer
-mp.messaging.outgoing.chat-messages.value.serializer=io.quarkus.kafka.client.serialization.JsonbSerializer
-
-# Topic: Reactions (likes, comments)
-mp.messaging.outgoing.reactions.connector=smallrye-kafka
-mp.messaging.outgoing.reactions.topic=reactions
-mp.messaging.outgoing.reactions.key.serializer=org.apache.kafka.common.serialization.StringSerializer
-mp.messaging.outgoing.reactions.value.serializer=io.quarkus.kafka.client.serialization.JsonbSerializer
-
-# Topic: Presence Updates
-mp.messaging.outgoing.presence.connector=smallrye-kafka
-mp.messaging.outgoing.presence.topic=presence.updates
-mp.messaging.outgoing.presence.key.serializer=org.apache.kafka.common.serialization.StringSerializer
-mp.messaging.outgoing.presence.value.serializer=io.quarkus.kafka.client.serialization.JsonbSerializer
-
-# ============================================
-# Kafka → WebSocket Bridge (Incoming)
-# ============================================
-# Consommer depuis Kafka et router vers WebSocket
-mp.messaging.incoming.kafka-notifications.connector=smallrye-kafka
-mp.messaging.incoming.kafka-notifications.topic=notifications
-mp.messaging.incoming.kafka-notifications.group.id=websocket-notifications-bridge
-mp.messaging.incoming.kafka-notifications.key.deserializer=org.apache.kafka.common.serialization.StringDeserializer
-mp.messaging.incoming.kafka-notifications.value.deserializer=io.quarkus.kafka.client.serialization.JsonbDeserializer
-mp.messaging.incoming.kafka-notifications.enable.auto.commit=true
-
-mp.messaging.incoming.kafka-chat.connector=smallrye-kafka
-mp.messaging.incoming.kafka-chat.topic=chat.messages
-mp.messaging.incoming.kafka-chat.group.id=websocket-chat-bridge
-mp.messaging.incoming.kafka-chat.key.deserializer=org.apache.kafka.common.serialization.StringDeserializer
-mp.messaging.incoming.kafka-chat.value.deserializer=io.quarkus.kafka.client.serialization.JsonbDeserializer
-mp.messaging.incoming.kafka-chat.enable.auto.commit=true
-
-# ============================================
-# WebSocket Configuration
-# ============================================
-quarkus.websockets-next.server.enabled=true
-```
-
----
-
-## 📝 Étape 3 : DTOs pour les Événements Kafka
-
-### NotificationEvent.java
-
-```java
-package com.lions.dev.dto.events;
-
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.Setter;
-import java.util.Map;
-import java.util.UUID;
-
-/**
- * Événement de notification publié dans Kafka.
- */
-@Getter
-@Setter
-@NoArgsConstructor
-@AllArgsConstructor
-public class NotificationEvent {
-    private String userId; // Clé Kafka (pour routing)
-    private String type; // friend_request, event_reminder, message_alert, etc.
-    private Map<String, Object> data;
-    private Long timestamp;
-    
-    public NotificationEvent(String userId, String type, Map<String, Object> data) {
-        this.userId = userId;
-        this.type = type;
-        this.data = data;
-        this.timestamp = System.currentTimeMillis();
-    }
-}
-```
-
-### ChatMessageEvent.java
-
-```java
-package com.lions.dev.dto.events;
-
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.Setter;
-import java.util.UUID;
-
-/**
- * Événement de message chat publié dans Kafka.
- */
-@Getter
-@Setter
-@NoArgsConstructor
-@AllArgsConstructor
-public class ChatMessageEvent {
-    private String conversationId; // Clé Kafka
-    private String senderId;
-    private String recipientId;
-    private String content;
-    private String messageId;
-    private Long timestamp;
-}
-```
-
-### ReactionEvent.java
-
-```java
-package com.lions.dev.dto.events;
-
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.Setter;
-
-/**
- * Événement de réaction (like, comment) publié dans Kafka.
- */
-@Getter
-@Setter
-@NoArgsConstructor
-@AllArgsConstructor
-public class ReactionEvent {
-    private String postId; // Clé Kafka
-    private String userId;
-    private String reactionType; // like, comment, share
-    private Map<String, Object> data;
-    private Long timestamp;
-}
-```
-
----
-
-## 🔌 Étape 4 : WebSocket avec WebSockets Next
-
-### NotificationWebSocketNext.java
-
-```java
-package com.lions.dev.websocket;
-
-import io.quarkus.logging.Log;
-import io.quarkus.websockets.next.OnClose;
-import io.quarkus.websockets.next.OnOpen;
-import io.quarkus.websockets.next.OnTextMessage;
-import io.quarkus.websockets.next.WebSocket;
-import io.quarkus.websockets.next.WebSocketConnection;
-import jakarta.enterprise.context.ApplicationScoped;
-import jakarta.inject.Inject;
-
-import java.util.Map;
-import java.util.Set;
-import java.util.UUID;
-import java.util.concurrent.ConcurrentHashMap;
-
-/**
- * WebSocket endpoint pour les notifications en temps réel (WebSockets Next).
- * 
- * Architecture:
- * Services → Kafka → Bridge → WebSocket → Client
- */
-@WebSocket(path = "/notifications/{userId}")
-@ApplicationScoped
-public class NotificationWebSocketNext {
-
-    // Stockage des connexions actives par utilisateur (multi-device support)
-    private static final Map<UUID, Set<WebSocketConnection>> userConnections = new ConcurrentHashMap<>();
-
-    @OnOpen
-    public void onOpen(WebSocketConnection connection, String userId) {
-        try {
-            UUID userUUID = UUID.fromString(userId);
-            
-            // Ajouter la connexion à l'ensemble des connexions de l'utilisateur
-            userConnections.computeIfAbsent(userUUID, k -> ConcurrentHashMap.newKeySet())
-                          .add(connection);
-            
-            Log.info("[WS-NEXT] Connexion ouverte pour l'utilisateur: " + userId + 
-                    " (Total: " + userConnections.get(userUUID).size() + ")");
-            
-            // Envoyer confirmation
-            connection.sendText("{\"type\":\"connected\",\"timestamp\":" + 
-                              System.currentTimeMillis() + "}");
-            
-        } catch (IllegalArgumentException e) {
-            Log.error("[WS-NEXT] UUID invalide: " + userId, e);
-            connection.close();
-        }
-    }
-
-    @OnClose
-    public void onClose(String userId) {
-        try {
-            UUID userUUID = UUID.fromString(userId);
-            Set<WebSocketConnection> connections = userConnections.get(userUUID);
-            
-            if (connections != null) {
-                connections.removeIf(conn -> !conn.isOpen());
-                
-                if (connections.isEmpty()) {
-                    userConnections.remove(userUUID);
-                    Log.info("[WS-NEXT] Toutes les connexions fermées pour: " + userId);
-                } else {
-                    Log.info("[WS-NEXT] Connexion fermée pour: " + userId + 
-                            " (Restantes: " + connections.size() + ")");
-                }
-            }
-        } catch (Exception e) {
-            Log.error("[WS-NEXT] Erreur lors de la fermeture", e);
-        }
-    }
-
-    @OnTextMessage
-    public void onMessage(String message, String userId) {
-        try {
-            Log.debug("[WS-NEXT] Message reçu de " + userId + ": " + message);
-            
-            // Parser le message JSON
-            com.fasterxml.jackson.databind.ObjectMapper mapper = 
-                new com.fasterxml.jackson.databind.ObjectMapper();
-            Map<String, Object> messageData = mapper.readValue(message, Map.class);
-            
-            String type = (String) messageData.get("type");
-            
-            switch (type) {
-                case "ping":
-                    handlePing(userId);
-                    break;
-                case "ack":
-                    handleAck(messageData, userId);
-                    break;
-                default:
-                    Log.warn("[WS-NEXT] Type de message inconnu: " + type);
-            }
-        } catch (Exception e) {
-            Log.error("[WS-NEXT] Erreur traitement message", e);
-        }
-    }
-
-    private void handlePing(String userId) {
-        UUID userUUID = UUID.fromString(userId);
-        Set<WebSocketConnection> connections = userConnections.get(userUUID);
-        
-        if (connections != null) {
-            String pong = "{\"type\":\"pong\",\"timestamp\":" + 
-                         System.currentTimeMillis() + "}";
-            connections.forEach(conn -> {
-                if (conn.isOpen()) {
-                    conn.sendText(pong);
-                }
-            });
-        }
-    }
-
-    private void handleAck(Map<String, Object> messageData, String userId) {
-        String notificationId = (String) messageData.get("notificationId");
-        Log.debug("[WS-NEXT] ACK reçu pour notification " + notificationId + 
-                 " de " + userId);
-    }
-
-    /**
-     * Envoie une notification à un utilisateur spécifique.
-     * Appelé par le bridge Kafka → WebSocket.
-     */
-    public static void sendToUser(UUID userId, String message) {
-        Set<WebSocketConnection> connections = userConnections.get(userId);
-        
-        if (connections == null || connections.isEmpty()) {
-            Log.debug("[WS-NEXT] Utilisateur " + userId + " non connecté");
-            return;
-        }
-        
-        int success = 0;
-        int failed = 0;
-        
-        for (WebSocketConnection conn : connections) {
-            if (conn.isOpen()) {
-                try {
-                    conn.sendText(message);
-                    success++;
-                } catch (Exception e) {
-                    failed++;
-                    Log.error("[WS-NEXT] Erreur envoi à " + userId, e);
-                }
-            } else {
-                failed++;
-            }
-        }
-        
-        Log.info("[WS-NEXT] Notification envoyée à " + userId + 
-                " (Succès: " + success + ", Échec: " + failed + ")");
-    }
-}
-```
-
----
-
-## 🌉 Étape 5 : Bridge Kafka → WebSocket
-
-### NotificationKafkaBridge.java
-
-```java
-package com.lions.dev.websocket;
-
-import com.lions.dev.dto.events.NotificationEvent;
-import io.quarkus.logging.Log;
-import jakarta.enterprise.context.ApplicationScoped;
-import org.eclipse.microprofile.reactive.messaging.Incoming;
-import org.eclipse.microprofile.reactive.messaging.Message;
-
-import java.util.UUID;
-
-/**
- * Bridge qui consomme depuis Kafka et envoie via WebSocket.
- * 
- * Architecture:
- * Kafka Topic (notifications) → Bridge → WebSocket (NotificationWebSocketNext)
- */
-@ApplicationScoped
-public class NotificationKafkaBridge {
-
-    /**
-     * Consomme les événements depuis Kafka et les route vers WebSocket.
-     */
-    @Incoming("kafka-notifications")
-    public void processNotification(Message<NotificationEvent> message) {
-        try {
-            NotificationEvent event = message.getPayload();
-            
-            Log.debug("[KAFKA-BRIDGE] Événement reçu: " + event.getType() + 
-                     " pour utilisateur: " + event.getUserId());
-            
-            UUID userId = UUID.fromString(event.getUserId());
-            
-            // Construire le message JSON pour WebSocket
-            String wsMessage = buildWebSocketMessage(event);
-            
-            // Envoyer via WebSocket
-            NotificationWebSocketNext.sendToUser(userId, wsMessage);
-            
-            // Acknowledger le message Kafka
-            message.ack();
-            
-        } catch (Exception e) {
-            Log.error("[KAFKA-BRIDGE] Erreur traitement événement", e);
-            message.nack(e);
-        }
-    }
-
-    private String buildWebSocketMessage(NotificationEvent event) {
-        try {
-            com.fasterxml.jackson.databind.ObjectMapper mapper = 
-                new com.fasterxml.jackson.databind.ObjectMapper();
-            
-            java.util.Map<String, Object> wsMessage = java.util.Map.of(
-                "type", event.getType(),
-                "data", event.getData(),
-                "timestamp", event.getTimestamp()
-            );
-            
-            return mapper.writeValueAsString(wsMessage);
-        } catch (Exception e) {
-            Log.error("[KAFKA-BRIDGE] Erreur construction message", e);
-            return "{\"type\":\"error\",\"message\":\"Erreur de traitement\"}";
-        }
-    }
-}
-```
-
----
-
-## 📤 Étape 6 : Services Publient dans Kafka
-
-### FriendshipService (Modifié)
-
-```java
-package com.lions.dev.service;
-
-import com.lions.dev.dto.events.NotificationEvent;
-import org.eclipse.microprofile.reactive.messaging.Channel;
-import org.eclipse.microprofile.reactive.messaging.Emitter;
-import jakarta.inject.Inject;
-import jakarta.enterprise.context.ApplicationScoped;
-
-@ApplicationScoped
-public class FriendshipService {
-    
-    @Inject
-    @Channel("notifications")
-    Emitter<NotificationEvent> notificationEmitter;
-
-    // ... autres dépendances ...
-
-    /**
-     * Envoie une demande d'amitié (publie dans Kafka).
-     */
-    @Transactional
-    public FriendshipCreateOneResponseDTO sendFriendRequest(
-            FriendshipCreateOneRequestDTO request) {
-        
-        // ... logique métier existante ...
-        
-        // ✅ NOUVEAU: Publier dans Kafka au lieu d'appeler directement WebSocket
-        try {
-            NotificationEvent event = new NotificationEvent(
-                request.getFriendId().toString(), // userId destinataire
-                "friend_request",
-                java.util.Map.of(
-                    "fromUserId", request.getUserId().toString(),
-                    "fromFirstName", user.getFirstName(),
-                    "fromLastName", user.getLastName(),
-                    "requestId", response.getFriendshipId().toString()
-                )
-            );
-            
-            notificationEmitter.send(event);
-            logger.info("[LOG] Événement friend_request publié dans Kafka pour: " + 
-                       request.getFriendId());
-                       
-        } catch (Exception e) {
-            logger.error("[ERROR] Erreur publication Kafka", e);
-            // Ne pas bloquer la demande d'amitié si Kafka échoue
-        }
-        
-        return response;
-    }
-
-    /**
-     * Accepte une demande d'amitié (publie dans Kafka).
-     */
-    @Transactional
-    public FriendshipCreateOneResponseDTO acceptFriendRequest(UUID friendshipId) {
-        // ... logique métier existante ...
-        
-        // ✅ NOUVEAU: Publier dans Kafka
-        try {
-            NotificationEvent event = new NotificationEvent(
-                originalRequest.getUserId().toString(), // userId émetteur
-                "friend_request_accepted",
-                java.util.Map.of(
-                    "friendId", friend.getId().toString(),
-                    "friendFirstName", friend.getFirstName(),
-                    "friendLastName", friend.getLastName(),
-                    "friendshipId", response.getFriendshipId().toString()
-                )
-            );
-            
-            notificationEmitter.send(event);
-            logger.info("[LOG] Événement friend_request_accepted publié dans Kafka");
-            
-        } catch (Exception e) {
-            logger.error("[ERROR] Erreur publication Kafka", e);
-        }
-        
-        return response;
-    }
-}
-```
-
-### MessageService (Modifié)
-
-```java
-package com.lions.dev.service;
-
-import com.lions.dev.dto.events.ChatMessageEvent;
-import org.eclipse.microprofile.reactive.messaging.Channel;
-import org.eclipse.microprofile.reactive.messaging.Emitter;
-import jakarta.inject.Inject;
-
-@ApplicationScoped
-public class MessageService {
-    
-    @Inject
-    @Channel("chat-messages")
-    Emitter<ChatMessageEvent> chatMessageEmitter;
-
-    /**
-     * Envoie un message (publie dans Kafka).
-     */
-    @Transactional
-    public MessageResponseDTO sendMessage(SendMessageRequestDTO request) {
-        // ... logique métier existante ...
-        
-        // ✅ NOUVEAU: Publier dans Kafka
-        try {
-            ChatMessageEvent event = new ChatMessageEvent();
-            event.setConversationId(conversation.getId().toString());
-            event.setSenderId(senderId.toString());
-            event.setRecipientId(recipientId.toString());
-            event.setContent(request.getContent());
-            event.setMessageId(message.getId().toString());
-            event.setTimestamp(System.currentTimeMillis());
-            
-            // Utiliser conversationId comme clé Kafka pour garantir l'ordre
-            chatMessageEmitter.send(org.eclipse.microprofile.reactive.messaging.Message.of(
-                event,
-                () -> CompletableFuture.completedFuture(null), // ack
-                throwable -> {
-                    logger.error("[ERROR] Erreur envoi Kafka", throwable);
-                    return CompletableFuture.completedFuture(null); // nack
-                }
-            ).addMetadata(org.eclipse.microprofile.reactive.messaging.OutgoingMessageMetadata.builder()
-                .withKey(conversation.getId().toString())
-                .build()));
-            
-            logger.info("[LOG] Message publié dans Kafka: " + message.getId());
-            
-        } catch (Exception e) {
-            logger.error("[ERROR] Erreur publication Kafka", e);
-            // Ne pas bloquer l'envoi du message si Kafka échoue
-        }
-        
-        return response;
-    }
-}
-```
-
-### SocialPostService (Modifié pour les Réactions)
-
-```java
-package com.lions.dev.service;
-
-import com.lions.dev.dto.events.ReactionEvent;
-import org.eclipse.microprofile.reactive.messaging.Channel;
-import org.eclipse.microprofile.reactive.messaging.Emitter;
-import jakarta.inject.Inject;
-
-@ApplicationScoped
-public class SocialPostService {
-    
-    @Inject
-    @Channel("reactions")
-    Emitter<ReactionEvent> reactionEmitter;
-
-    /**
-     * Like un post (publie dans Kafka).
-     */
-    @Transactional
-    public SocialPost likePost(UUID postId, UUID userId) {
-        // ... logique métier existante ...
-        
-        // ✅ NOUVEAU: Publier dans Kafka pour notifier en temps réel
-        try {
-            ReactionEvent event = new ReactionEvent();
-            event.setPostId(postId.toString());
-            event.setUserId(userId.toString());
-            event.setReactionType("like");
-            event.setData(java.util.Map.of(
-                "postId", postId.toString(),
-                "userId", userId.toString(),
-                "likesCount", post.getLikesCount()
-            ));
-            event.setTimestamp(System.currentTimeMillis());
-            
-            reactionEmitter.send(event);
-            logger.info("[LOG] Réaction like publiée dans Kafka pour post: " + postId);
-            
-        } catch (Exception e) {
-            logger.error("[ERROR] Erreur publication Kafka", e);
-        }
-        
-        return post;
-    }
-}
-```
-
----
-
-## 🎨 Frontend : Amélioration du Service WebSocket
-
-### realtime_notification_service_v2.dart
-
-```dart
-import 'dart:async';
-import 'dart:convert';
-import 'package:flutter/foundation.dart';
-import 'package:web_socket_channel/web_socket_channel.dart';
-import 'package:web_socket_channel/status.dart' as status;
-
-class RealtimeNotificationServiceV2 extends ChangeNotifier {
-  RealtimeNotificationServiceV2(this.userId, this.authToken);
-
-  final String userId;
-  final String authToken;
-  WebSocketChannel? _channel;
-  StreamSubscription? _subscription;
-  Timer? _heartbeatTimer;
-  Timer? _reconnectTimer;
-  
-  bool _isConnected = false;
-  bool get isConnected => _isConnected;
-  
-  int _reconnectAttempts = 0;
-  static const int _maxReconnectAttempts = 5;
-  static const Duration _heartbeatInterval = Duration(seconds: 30);
-  static const Duration _reconnectDelay = Duration(seconds: 5);
-
-  // Streams pour différents types d'événements
-  final _friendRequestController = StreamController<Map<String, dynamic>>.broadcast();
-  final _systemNotificationController = StreamController<Map<String, dynamic>>.broadcast();
-  final _reactionController = StreamController<Map<String, dynamic>>.broadcast();
-
-  Stream<Map<String, dynamic>> get friendRequestStream => _friendRequestController.stream;
-  Stream<Map<String, dynamic>> get systemNotificationStream => _systemNotificationController.stream;
-  Stream<Map<String, dynamic>> get reactionStream => _reactionController.stream;
-
-  String get _wsUrl {
-    final baseUrl = 'wss://api.afterwork.lions.dev'; // Production
-    return '$baseUrl/notifications/$userId';
-  }
-
-  Future<void> connect() async {
-    if (_isConnected) return;
-
-    try {
-      _channel = WebSocketChannel.connect(
-        Uri.parse(_wsUrl),
-        protocols: ['notifications-v2'],
-        headers: {
-          'Authorization': 'Bearer $authToken',
-        },
-      );
-
-      // Heartbeat pour maintenir la connexion
-      _heartbeatTimer = Timer.periodic(_heartbeatInterval, (_) {
-        _channel?.sink.add(jsonEncode({'type': 'ping'}));
-      });
-
-      // Écouter les messages
-      _subscription = _channel!.stream.listen(
-        _handleMessage,
-        onError: _handleError,
-        onDone: _handleDisconnection,
-        cancelOnError: false,
-      );
-
-      _isConnected = true;
-      notifyListeners();
-      
-    } catch (e) {
-      _isConnected = false;
-      notifyListeners();
-      _scheduleReconnect();
-    }
-  }
-
-  void _handleMessage(dynamic message) {
-    try {
-      final data = jsonDecode(message as String) as Map<String, dynamic>;
-      final type = data['type'] as String;
-      
-      switch (type) {
-        case 'connected':
-          _reconnectAttempts = 0; // Reset sur reconnexion réussie
-          break;
-        case 'pong':
-          // Heartbeat réponse
-          break;
-        case 'friend_request':
-        case 'friend_request_accepted':
-          _friendRequestController.add(data);
-          break;
-        case 'event_reminder':
-        case 'system_notification':
-          _systemNotificationController.add(data);
-          break;
-        case 'reaction':
-          _reactionController.add(data);
-          break;
-        default:
-          // Type inconnu, ignorer ou logger
-          break;
-      }
-    } catch (e) {
-      // Erreur de parsing, ignorer
-    }
-  }
-
-  void _handleError(dynamic error) {
-    _isConnected = false;
-    notifyListeners();
-    _scheduleReconnect();
-  }
-
-  void _handleDisconnection() {
-    _isConnected = false;
-    notifyListeners();
-    _scheduleReconnect();
-  }
-
-  void _scheduleReconnect() {
-    if (_reconnectAttempts >= _maxReconnectAttempts) {
-      // Arrêter les tentatives après max
-      return;
-    }
-
-    _reconnectTimer?.cancel();
-    _reconnectTimer = Timer(_reconnectDelay * (_reconnectAttempts + 1), () {
-      _reconnectAttempts++;
-      connect();
-    });
-  }
-
-  Future<void> disconnect() async {
-    _heartbeatTimer?.cancel();
-    _reconnectTimer?.cancel();
-    await _subscription?.cancel();
-    await _channel?.sink.close(status.normalClosure);
-    _isConnected = false;
-    notifyListeners();
-  }
-
-  @override
-  void dispose() {
-    disconnect();
-    _friendRequestController.close();
-    _systemNotificationController.close();
-    _reactionController.close();
-    super.dispose();
-  }
-}
-```
-
----
-
-## 🧪 Tests
-
-### Test du Bridge Kafka → WebSocket
-
-```java
-package com.lions.dev.websocket;
-
-import io.quarkus.test.junit.QuarkusTest;
-import jakarta.inject.Inject;
-import org.eclipse.microprofile.reactive.messaging.Channel;
-import org.eclipse.microprofile.reactive.messaging.Emitter;
-import org.junit.jupiter.api.Test;
-
-@QuarkusTest
-public class NotificationKafkaBridgeTest {
-    
-    @Inject
-    @Channel("notifications")
-    Emitter<NotificationEvent> notificationEmitter;
-
-    @Test
-    public void testNotificationFlow() {
-        // Publier un événement dans Kafka
-        NotificationEvent event = new NotificationEvent(
-            "user-123",
-            "friend_request",
-            Map.of("fromUserId", "user-456")
-        );
-        
-        notificationEmitter.send(event);
-        
-        // Vérifier que le message arrive bien via WebSocket
-        // (nécessite un client WebSocket de test)
-    }
-}
-```
-
----
-
-## 📊 Monitoring
-
-### Métriques Kafka à Surveiller
-
-1. **Lag Consumer** : Délai entre production et consommation
-2. **Throughput** : Messages/seconde
-3. **Error Rate** : Taux d'erreur
-4. **Connection Count** : Nombre de connexions WebSocket actives
-
-### Endpoint de Santé
-
-```java
-@Path("/health/realtime")
-public class RealtimeHealthResource {
-    
-    @GET
-    public Response health() {
-        return Response.ok(Map.of(
-            "websocket_connections", NotificationWebSocketNext.getConnectionCount(),
-            "kafka_consumers", getKafkaConsumerCount(),
-            "status", "healthy"
-        )).build();
-    }
-}
-```
-
----
-
-## 🚀 Déploiement
-
-### Docker Compose (Kafka Local)
-
-```yaml
-version: '3.8'
-services:
-  zookeeper:
-    image: confluentinc/cp-zookeeper:latest
-    environment:
-      ZOOKEEPER_CLIENT_PORT: 2181
-      ZOOKEEPER_TICK_TIME: 2000
-
-  kafka:
-    image: confluentinc/cp-kafka:latest
-    depends_on:
-      - zookeeper
-    ports:
-      - "9092:9092"
-    environment:
-      KAFKA_BROKER_ID: 1
-      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
-      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://localhost:9092
-      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
-```
-
-### Production (Kubernetes)
-
-```yaml
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: afterwork-backend
-spec:
-  replicas: 3  # ✅ Scalabilité horizontale
-  template:
-    spec:
-      containers:
-      - name: quarkus
-        env:
-        - name: KAFKA_BOOTSTRAP_SERVERS
-          value: "kafka-service:9092"
-```
-
----
-
-## ✅ Checklist d'Implémentation
-
-### Phase 1 : Setup
-- [ ] Ajouter dépendances dans `pom.xml`
-- [ ] Configurer `application.properties`
-- [ ] Tester Kafka avec Quarkus Dev Services
-- [ ] Créer les DTOs d'événements
-
-### Phase 2 : Migration WebSocket
-- [ ] Créer `NotificationWebSocketNext`
-- [ ] Créer `ChatWebSocketNext`
-- [ ] Tester avec le frontend existant
-- [ ] Comparer performances (avant/après)
-
-### Phase 3 : Intégration Kafka
-- [ ] Créer `NotificationKafkaBridge`
-- [ ] Créer `ChatKafkaBridge`
-- [ ] Modifier `FriendshipService` pour publier dans Kafka
-- [ ] Modifier `MessageService` pour publier dans Kafka
-- [ ] Modifier `SocialPostService` pour les réactions
-
-### Phase 4 : Frontend
-- [ ] Améliorer `RealtimeNotificationService` avec heartbeat
-- [ ] Améliorer `ChatWebSocketService` avec reconnect
-- [ ] Tester la reconnexion automatique
-- [ ] Tester multi-device
-
-### Phase 5 : Tests & Monitoring
-- [ ] Tests unitaires des bridges
-- [ ] Tests d'intégration end-to-end
-- [ ] Configurer monitoring Kafka
-- [ ] Configurer alertes
-
----
-
-## 📚 Ressources Complémentaires
-
-- [Quarkus WebSockets Next Tutorial](https://quarkus.io/guides/websockets-next-tutorial)
-- [Quarkus Kafka Guide](https://quarkus.io/guides/kafka)
-- [Reactive Messaging HTTP Extension](https://docs.quarkiverse.io/quarkus-reactive-messaging-http/dev/reactive-messaging-websocket.html)
-- [Kafka Best Practices](https://kafka.apache.org/documentation/#bestPractices)

SESSION_COMPLETE.md

@@ -1,412 +0,0 @@
-# 🎉 Session de Travail Complétée - AfterWork
-
-**Date** : 2026-01-10
-**Projet** : AfterWork (Backend Quarkus + Frontend Flutter)
-
----
-
-## 📋 Travail Effectué
-
-Cette session a couvert deux grandes phases de travail :
-
-### Phase 1 : Corrections et Implémentation des TODOs ✅
-
-#### 1.1 Correction Critique - Race Condition Chat
-**Problème** : Les icônes de statut des messages (✓, ✓✓, ✓✓ bleu) ne s'affichaient pas.
-
-**Cause** : Les confirmations WebSocket de délivrance arrivaient AVANT que les messages ne soient ajoutés à la liste locale (race condition entre HTTP response et WebSocket event).
-
-**Solution** : Implémentation du pattern **Optimistic UI** dans `chat_bloc.dart`
-- Création d'un message temporaire avec ID temporaire immédiatement
-- Ajout à la liste AVANT la requête HTTP
-- Remplacement du message temporaire par le message serveur à la réponse
-
-**Fichiers modifiés:**
-- `lib/presentation/state_management/chat_bloc.dart`
-
-**Résultat** : ✅ Les statuts de message fonctionnent maintenant correctement
-
----
-
-#### 1.2 Implémentation des TODOs (13/21)
-
-| Fichier | TODOs Implémentés | Description |
-|---------|-------------------|-------------|
-| **social_header_widget.dart** | 3 | Copier lien, partage natif, signalement de post |
-| **share_post_dialog.dart** | 2 | Sélection d'amis, partage externe |
-| **media_upload_service.dart** | 3 | Parsing JSON, suppression média, génération miniature |
-| **edit_post_dialog.dart** | 1 | Documentation chargement média |
-| **create_post_dialog.dart** | 1 | Extraction URL depuis uploads |
-| **conversations_screen.dart** | 2 | Navigation notifications, recherche conversations |
-
-**Détails des implémentations:**
-
-1. **social_header_widget.dart**
-   - ✅ Copier le lien du post dans le presse-papiers
-   - ✅ Partage natif via Share.share()
-   - ✅ Dialogue de signalement avec 5 raisons
-
-2. **share_post_dialog.dart**
-   - ✅ Interface de sélection d'amis avec checkboxes
-   - ✅ Partage externe via Share API
-
-3. **media_upload_service.dart**
-   - ✅ Parsing JSON de la réponse backend
-   - ✅ Méthode deleteMedia() pour supprimer les médias
-   - ✅ Génération de miniature vidéo avec video_thumbnail
-
-4. **edit_post_dialog.dart**
-   - ✅ Documentation sur le chargement des médias existants
-
-5. **create_post_dialog.dart**
-   - ✅ Extraction automatique des URLs depuis les médias uploadés
-
-6. **conversations_screen.dart**
-   - ✅ Navigation vers écran de notifications depuis conversations
-   - ✅ ConversationSearchDelegate pour rechercher conversations par nom ou message
-
-**Documentation créée:**
-- `TODOS_IMPLEMENTED.md` (documentation complète de tous les TODOs)
-
----
-
-### Phase 2 : Préparation du Déploiement Production ✅
-
-#### 2.1 Infrastructure Backend
-
-**Fichiers créés:**
-
-1. **Dockerfile.prod** (Multi-stage build)
-   ```dockerfile
-   - Stage 1: Build avec Maven + UBI8 OpenJDK 17
-   - Stage 2: Runtime optimisé avec uber-jar
-   - Healthcheck intégré
-   - User non-root (185) pour sécurité
-   ```
-
-2. **.dockerignore**
-   ```
-   - Exclusion target/, tests, IDE, docs
-   - Optimisation du contexte Docker
-   ```
-
-3. **application-prod.properties**
-   ```properties
-   - Context path: /afterwork
-   - CORS: https://afterwork.lions.dev
-   - Health checks: /q/health/ready, /q/health/live
-   - Compression HTTP activée
-   ```
-
-4. **pom.xml** (Modifié)
-   ```xml
-   - testFailureIgnore: true
-   - skipTests: ${skipTests}
-   - Tests non-bloquants comme demandé
-   ```
-
-**Manifests Kubernetes créés:**
-
-1. **afterwork-configmap.yaml**
-   - Variables non-sensibles : DB_HOST, DB_PORT, DB_NAME, etc.
-
-2. **afterwork-secrets.yaml**
-   - Variables sensibles : DB_PASSWORD
-   - ⚠️ À modifier avant déploiement
-
-3. **afterwork-deployment.yaml**
-   - 2 replicas
-   - Resources: 512Mi-1Gi RAM, 250m-1000m CPU
-   - Health checks (liveness + readiness)
-   - Volume pour uploads temporaires
-
-4. **afterwork-service.yaml**
-   - Type: ClusterIP
-   - SessionAffinity: ClientIP (pour WebSocket)
-
-5. **afterwork-ingress.yaml**
-   - Host: api.lions.dev
-   - Path: /afterwork(/|$)(.*)
-   - TLS/SSL via Let's Encrypt
-   - CORS configuré
-   - Support WebSocket
-   - Rewrite target: /$2
-
-**Scripts de déploiement:**
-
-1. **deploy.ps1** (Script PowerShell complet)
-   ```powershell
-   Actions disponibles:
-   - build    : Build Maven + Docker
-   - push     : Push vers registry
-   - deploy   : Déploiement K8s
-   - all      : Tout en une fois
-   - rollback : Retour arrière
-   - status   : Statut du déploiement
-   ```
-
-**Documentation:**
-
-1. **DEPLOYMENT.md** (~566 lignes)
-   - Guide complet avec prérequis
-   - Structure Kubernetes détaillée
-   - Troubleshooting
-   - Monitoring et sécurité
-   - Checklist de déploiement
-
-2. **QUICK_DEPLOY.md**
-   - Commandes copier-coller
-   - 3 méthodes de déploiement
-   - Vérifications rapides
-
-3. **DEPLOYMENT_STATUS.md**
-   - Statut actuel de la préparation
-   - Tests effectués
-   - Prochaines étapes
-
----
-
-#### 2.2 Configuration Frontend Flutter
-
-**Fichiers créés:**
-
-1. **build-prod.ps1**
-   ```powershell
-   - Build avec --dart-define pour API_BASE_URL
-   - Support APK, AAB, iOS, Web
-   - Configuration : https://api.lions.dev/afterwork
-   ```
-
-**Fichiers existants (vérifiés):**
-
-1. **lib/core/constants/env_config.dart**
-   - Support --dart-define pour API_BASE_URL
-   - Validation des configurations
-   - Gestion environnements (dev, staging, prod)
-
----
-
-## 🧪 Tests Effectués
-
-### Build Maven
-```bash
-✅ mvn clean package -DskipTests
-   - BUILD SUCCESS (44.759s)
-   - JAR standard créé (189K)
-
-✅ mvn clean package -DskipTests -Dquarkus.package.type=uber-jar
-   - BUILD SUCCESS (59.644s)
-   - Uber-jar créé (73M) ← Nécessaire pour Docker
-```
-
-### Warnings (Non-bloquants)
-```
-⚠️ quarkus.micrometer.* (extension manquante)
-⚠️ quarkus.smallrye-health.* (extension manquante)
-⚠️ quarkus.http.body.multipart.* (extension manquante)
-
-Note: Ces warnings n'empêchent pas le fonctionnement.
-      Les health checks Quarkus fonctionnent avec les chemins par défaut.
-```
-
----
-
-## 📊 Récapitulatif des Fichiers
-
-### Backend - Nouveaux Fichiers
-```
-mic-after-work-server-impl-quarkus-main/
-├── Dockerfile.prod                         ✅ NOUVEAU
-├── .dockerignore                           ✅ NOUVEAU
-├── deploy.ps1                              ✅ NOUVEAU
-├── DEPLOYMENT.md                           ✅ NOUVEAU
-├── QUICK_DEPLOY.md                         ✅ NOUVEAU
-├── DEPLOYMENT_STATUS.md                    ✅ NOUVEAU
-├── SESSION_COMPLETE.md                     ✅ NOUVEAU (ce fichier)
-├── src/main/resources/
-│   └── application-prod.properties         ✅ NOUVEAU
-└── kubernetes/
-    ├── afterwork-configmap.yaml            ✅ NOUVEAU
-    ├── afterwork-secrets.yaml              ✅ NOUVEAU
-    ├── afterwork-deployment.yaml           ✅ NOUVEAU
-    ├── afterwork-service.yaml              ✅ NOUVEAU
-    └── afterwork-ingress.yaml              ✅ NOUVEAU
-```
-
-### Backend - Fichiers Modifiés
-```
-├── pom.xml                                 ✅ MODIFIÉ (tests non-bloquants)
-```
-
-### Frontend - Nouveaux Fichiers
-```
-afterwork/
-└── build-prod.ps1                          ✅ NOUVEAU
-```
-
-### Frontend - Fichiers Modifiés
-```
-afterwork/lib/
-├── presentation/
-│   ├── state_management/
-│   │   └── chat_bloc.dart                  ✅ MODIFIÉ (Optimistic UI)
-│   ├── widgets/
-│   │   └── social_header_widget.dart       ✅ MODIFIÉ (share, report)
-│   └── screens/
-│       ├── dialogs/
-│       │   ├── share_post_dialog.dart      ✅ MODIFIÉ (friend selection)
-│       │   ├── create_post_dialog.dart     ✅ MODIFIÉ (URL extraction)
-│       │   └── edit_post_dialog.dart       ✅ MODIFIÉ (documentation)
-│       └── chat/
-│           └── conversations_screen.dart    ✅ MODIFIÉ (search, navigation)
-└── data/
-    └── services/
-        └── media_upload_service.dart        ✅ MODIFIÉ (JSON, delete, thumbnail)
-```
-
-### Documentation
-```
-afterwork/
-└── TODOS_IMPLEMENTED.md                    ✅ NOUVEAU
-```
-
----
-
-## 🎯 URLs de Production
-
-### Backend
-- **API Base** : `https://api.lions.dev/afterwork`
-- **Health Ready** : `https://api.lions.dev/afterwork/q/health/ready`
-- **Health Live** : `https://api.lions.dev/afterwork/q/health/live`
-- **Métriques** : `https://api.lions.dev/afterwork/q/health/metrics`
-
-### WebSocket
-- **Notifications** : `wss://api.lions.dev/afterwork/ws/notifications/{userId}`
-- **Chat** : `wss://api.lions.dev/afterwork/ws/chat/{userId}`
-
----
-
-## 🚀 Prochaines Étapes
-
-### Pour Déployer l'API Backend
-
-```powershell
-# 1. Modifier le secret
-notepad C:\Users\dadyo\PersonalProjects\mic-after-work-server-impl-quarkus-main\kubernetes\afterwork-secrets.yaml
-# Changer: DB_PASSWORD: "CHANGE_ME_IN_PRODUCTION"
-
-# 2. Déployer
-cd C:\Users\dadyo\PersonalProjects\mic-after-work-server-impl-quarkus-main
-.\deploy.ps1 -Action all -Version 1.0.0
-
-# 3. Vérifier
-.\deploy.ps1 -Action status
-curl https://api.lions.dev/afterwork/q/health/ready
-```
-
-### Pour Builder l'Application Flutter
-
-```powershell
-cd C:\Users\dadyo\PersonalProjects\lions-workspace\afterwork
-
-# Build APK production
-.\build-prod.ps1 -Target apk
-
-# Artefacts dans:
-# build/app/outputs/flutter-apk/app-arm64-v8a-release.apk
-```
-
----
-
-## 📈 Statistiques
-
-| Catégorie | Quantité |
-|-----------|----------|
-| **Fichiers créés** | 14 |
-| **Fichiers modifiés** | 8 |
-| **TODOs implémentés** | 13 |
-| **Bugs corrigés** | 1 (race condition) |
-| **Lignes de documentation** | ~800 |
-| **Manifests K8s** | 5 |
-| **Scripts d'automatisation** | 2 |
-
----
-
-## ✅ Checklist Finale
-
-### Préparation Complétée
-- [x] Build Maven fonctionnel
-- [x] Uber-jar généré (73M)
-- [x] Tests non-bloquants
-- [x] Dockerfile.prod créé
-- [x] Manifests Kubernetes créés
-- [x] Scripts de déploiement créés
-- [x] Documentation complète
-- [x] Configuration frontend prête
-- [x] Race condition corrigée
-- [x] TODOs majeurs implémentés
-
-### Reste à Faire (Par l'utilisateur)
-- [ ] Modifier le mot de passe DB dans afterwork-secrets.yaml
-- [ ] Exécuter le déploiement (deploy.ps1 ou lionesctl)
-- [ ] Vérifier que l'API est accessible
-- [ ] Builder l'application Flutter
-- [ ] Tester l'application en production
-
----
-
-## 📚 Documentation Disponible
-
-1. **SESSION_COMPLETE.md** (ce fichier)
-   - Récapitulatif complet de la session
-   - Tous les changements effectués
-
-2. **DEPLOYMENT.md**
-   - Guide complet de déploiement
-   - ~566 lignes
-
-3. **QUICK_DEPLOY.md**
-   - Guide rapide avec commandes
-   - Troubleshooting
-
-4. **DEPLOYMENT_STATUS.md**
-   - Statut actuel
-   - Tests effectués
-
-5. **TODOS_IMPLEMENTED.md**
-   - Documentation des TODOs
-   - Détails d'implémentation
-
----
-
-## 🎉 Conclusion
-
-### ✅ Tous les Objectifs Atteints
-
-1. **Race Condition Corrigée**
-   - Les statuts de message s'affichent correctement
-   - Pattern Optimistic UI implémenté
-
-2. **TODOs Implémentés**
-   - 13 TODOs majeurs complétés
-   - Fonctionnalités sociales enrichies
-   - Gestion média améliorée
-
-3. **Infrastructure de Déploiement Complète**
-   - Backend prêt pour production
-   - Frontend configuré pour HTTPS
-   - Documentation exhaustive
-   - Scripts d'automatisation
-
-### 🚀 L'Application AfterWork est Prête pour la Production!
-
-**L'API peut être déployée sur le VPS en exécutant simplement:**
-```powershell
-.\deploy.ps1 -Action all -Version 1.0.0
-```
-
----
-
-**Fin de la Session**
-**Temps total estimé de travail** : ~3-4 heures
-**Résultat** : ✅ Succès complet

deploy.ps1

@@ -1,302 +0,0 @@
-# ====================================================================
-# AfterWork Server - Script de Déploiement Production
-# ====================================================================
-# Ce script automatise le processus de build et déploiement
-# de l'API AfterWork sur le VPS via Kubernetes.
-# ====================================================================
-
-param(
-    [ValidateSet("build", "push", "deploy", "all", "rollback", "status")]
-    [string]$Action = "all",
-
-    [string]$Version = "1.0.0",
-
-    [string]$Registry = "registry.lions.dev",
-
-    [switch]$SkipTests,
-
-    [switch]$Force
-)
-
-$ErrorActionPreference = "Stop"
-
-# Couleurs
-function Write-Info { param($msg) Write-Host $msg -ForegroundColor Cyan }
-function Write-Success { param($msg) Write-Host $msg -ForegroundColor Green }
-function Write-Warning { param($msg) Write-Host $msg -ForegroundColor Yellow }
-function Write-Error { param($msg) Write-Host $msg -ForegroundColor Red }
-
-# Variables
-$AppName = "afterwork-api"
-$Namespace = "applications"
-$ImageName = "$Registry/${AppName}:$Version"
-$ImageLatest = "$Registry/${AppName}:latest"
-
-Write-Info "======================================================================"
-Write-Info "  AfterWork Server - Déploiement Production"
-Write-Info "======================================================================"
-Write-Host ""
-Write-Info "Configuration:"
-Write-Host "  - Action: $Action"
-Write-Host "  - Version: $Version"
-Write-Host "  - Registry: $Registry"
-Write-Host "  - Image: $ImageName"
-Write-Host "  - Namespace: $Namespace"
-Write-Host ""
-
-# ======================================================================
-# Build Maven
-# ======================================================================
-function Build-Application {
-    Write-Info "[1/5] Build Maven..."
-
-    $mavenArgs = "clean", "package", "-Dquarkus.package.type=uber-jar"
-    if ($SkipTests) {
-        $mavenArgs += "-DskipTests"
-    } else {
-        $mavenArgs += "-DtestFailureIgnore=true"
-    }
-
-    & mvn $mavenArgs
-    if ($LASTEXITCODE -ne 0) {
-        Write-Error "Erreur lors du build Maven"
-        exit 1
-    }
-
-    # Vérifier que le JAR existe
-    $jar = Get-ChildItem -Path "target" -Filter "*-runner.jar" | Select-Object -First 1
-    if (-not $jar) {
-        Write-Error "JAR runner non trouvé dans target/"
-        exit 1
-    }
-
-    Write-Success "Build Maven réussi : $($jar.Name)"
-}
-
-# ======================================================================
-# Build Docker Image
-# ======================================================================
-function Build-DockerImage {
-    Write-Info "[2/5] Build Docker Image..."
-
-    docker build -f Dockerfile.prod -t $ImageName -t $ImageLatest .
-    if ($LASTEXITCODE -ne 0) {
-        Write-Error "Erreur lors du build Docker"
-        exit 1
-    }
-
-    Write-Success "Image Docker créée : $ImageName"
-}
-
-# ======================================================================
-# Push vers Registry
-# ======================================================================
-function Push-ToRegistry {
-    Write-Info "[3/5] Push vers Registry..."
-
-    # Vérifier si on est connecté au registry
-    $loginTest = docker login $Registry 2>&1
-    if ($LASTEXITCODE -ne 0 -and -not $loginTest.ToString().Contains("Succeeded")) {
-        Write-Warning "Connexion au registry nécessaire..."
-        docker login $Registry
-        if ($LASTEXITCODE -ne 0) {
-            Write-Error "Échec de connexion au registry"
-            exit 1
-        }
-    }
-
-    # Push des images
-    docker push $ImageName
-    if ($LASTEXITCODE -ne 0) {
-        Write-Error "Erreur lors du push de $ImageName"
-        exit 1
-    }
-
-    docker push $ImageLatest
-    if ($LASTEXITCODE -ne 0) {
-        Write-Error "Erreur lors du push de $ImageLatest"
-        exit 1
-    }
-
-    Write-Success "Images pushées vers $Registry"
-}
-
-# ======================================================================
-# Déploiement Kubernetes
-# ======================================================================
-function Deploy-ToKubernetes {
-    Write-Info "[4/5] Déploiement Kubernetes..."
-
-    # Vérifier que kubectl est disponible
-    $kubectlCheck = kubectl version --client 2>&1
-    if ($LASTEXITCODE -ne 0) {
-        Write-Error "kubectl n'est pas installé ou configuré"
-        exit 1
-    }
-
-    # Créer le namespace si nécessaire
-    Write-Info "Création du namespace $Namespace..."
-    kubectl create namespace $Namespace --dry-run=client -o yaml | kubectl apply -f -
-
-    # Appliquer les manifests
-    Write-Info "Application des ConfigMaps et Secrets..."
-    kubectl apply -f kubernetes/afterwork-configmap.yaml
-    if ($LASTEXITCODE -ne 0) {
-        Write-Warning "ConfigMap déjà existante ou erreur"
-    }
-
-    if (-not $Force) {
-        Write-Warning "⚠️  ATTENTION : Vérifiez que les secrets sont correctement configurés !"
-        Write-Warning "   Fichier : kubernetes/afterwork-secrets.yaml"
-        $confirm = Read-Host "Continuer le déploiement? (o/N)"
-        if ($confirm -ne "o" -and $confirm -ne "O") {
-            Write-Warning "Déploiement annulé"
-            exit 0
-        }
-    }
-
-    kubectl apply -f kubernetes/afterwork-secrets.yaml
-    if ($LASTEXITCODE -ne 0) {
-        Write-Error "Erreur lors de l'application des secrets"
-        exit 1
-    }
-
-    Write-Info "Déploiement de l'application..."
-    kubectl apply -f kubernetes/afterwork-deployment.yaml
-    if ($LASTEXITCODE -ne 0) {
-        Write-Error "Erreur lors du déploiement"
-        exit 1
-    }
-
-    kubectl apply -f kubernetes/afterwork-service.yaml
-    if ($LASTEXITCODE -ne 0) {
-        Write-Error "Erreur lors de la création du service"
-        exit 1
-    }
-
-    kubectl apply -f kubernetes/afterwork-ingress.yaml
-    if ($LASTEXITCODE -ne 0) {
-        Write-Error "Erreur lors de la création de l'ingress"
-        exit 1
-    }
-
-    Write-Success "Déploiement Kubernetes réussi"
-
-    # Attendre que le déploiement soit prêt
-    Write-Info "Attente du rollout..."
-    kubectl rollout status deployment/$AppName -n $Namespace --timeout=5m
-    if ($LASTEXITCODE -ne 0) {
-        Write-Warning "Timeout ou erreur lors du rollout"
-    }
-}
-
-# ======================================================================
-# Vérification du déploiement
-# ======================================================================
-function Verify-Deployment {
-    Write-Info "[5/5] Vérification du déploiement..."
-
-    # Status des pods
-    Write-Info "Pods:"
-    kubectl get pods -n $Namespace -l app=$AppName
-
-    # Status du service
-    Write-Info "`nService:"
-    kubectl get svc -n $Namespace $AppName
-
-    # Status de l'ingress
-    Write-Info "`nIngress:"
-    kubectl get ingress -n $Namespace $AppName
-
-    # Test health check
-    Write-Info "`nTest Health Check..."
-    Start-Sleep -Seconds 5
-
-    try {
-        $response = Invoke-WebRequest -Uri "https://api.lions.dev/afterwork/q/health/ready" -UseBasicParsing -TimeoutSec 10
-        if ($response.StatusCode -eq 200) {
-            Write-Success "✓ API accessible : https://api.lions.dev/afterwork"
-            Write-Success "✓ Health check : OK"
-        } else {
-            Write-Warning "⚠ Health check retourné : $($response.StatusCode)"
-        }
-    } catch {
-        Write-Warning "⚠ Impossible de joindre l'API (normal si DNS pas encore propagé)"
-        Write-Info "   Vérifiez manuellement : https://api.lions.dev/afterwork/q/health"
-    }
-
-    Write-Success "`nDéploiement terminé avec succès !"
-}
-
-# ======================================================================
-# Rollback
-# ======================================================================
-function Rollback-Deployment {
-    Write-Warning "Rollback du déploiement..."
-
-    kubectl rollout undo deployment/$AppName -n $Namespace
-    if ($LASTEXITCODE -ne 0) {
-        Write-Error "Erreur lors du rollback"
-        exit 1
-    }
-
-    kubectl rollout status deployment/$AppName -n $Namespace
-    Write-Success "Rollback réussi"
-}
-
-# ======================================================================
-# Status
-# ======================================================================
-function Get-Status {
-    Write-Info "Status de $AppName..."
-
-    Write-Info "`nPods:"
-    kubectl get pods -n $Namespace -l app=$AppName
-
-    Write-Info "`nDéploiement:"
-    kubectl get deployment -n $Namespace $AppName
-
-    Write-Info "`nService:"
-    kubectl get svc -n $Namespace $AppName
-
-    Write-Info "`nIngress:"
-    kubectl get ingress -n $Namespace $AppName
-
-    Write-Info "`nLogs récents (20 dernières lignes):"
-    kubectl logs -n $Namespace -l app=$AppName --tail=20
-}
-
-# ======================================================================
-# Exécution selon l'action
-# ======================================================================
-
-switch ($Action) {
-    "build" {
-        Build-Application
-        Build-DockerImage
-    }
-    "push" {
-        Push-ToRegistry
-    }
-    "deploy" {
-        Deploy-ToKubernetes
-        Verify-Deployment
-    }
-    "all" {
-        Build-Application
-        Build-DockerImage
-        Push-ToRegistry
-        Deploy-ToKubernetes
-        Verify-Deployment
-    }
-    "rollback" {
-        Rollback-Deployment
-    }
-    "status" {
-        Get-Status
-    }
-}
-
-Write-Info "`n======================================================================"
-Write-Info "Terminé!"
-Write-Info "======================================================================"

kubernetes/afterwork-configmap.yaml

@@ -1,12 +0,0 @@
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: afterwork-config
-  namespace: applications
-data:
-  DB_HOST: "postgresql"
-  DB_PORT: "5432"
-  DB_NAME: "afterwork_db"
-  DB_USERNAME: "afterwork"
-  QUARKUS_PROFILE: "prod"
-  TZ: "Africa/Douala"

kubernetes/afterwork-deployment.yaml

@@ -1,79 +0,0 @@
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: afterwork-api
-  namespace: applications
-  labels:
-    app: afterwork-api
-    version: "1.0.0"
-    environment: production
-spec:
-  replicas: 2
-  strategy:
-    type: RollingUpdate
-    rollingUpdate:
-      maxSurge: 1
-      maxUnavailable: 0
-  selector:
-    matchLabels:
-      app: afterwork-api
-  template:
-    metadata:
-      labels:
-        app: afterwork-api
-        version: "1.0.0"
-      annotations:
-        prometheus.io/scrape: "true"
-        prometheus.io/port: "8080"
-        prometheus.io/path: "/afterwork/q/metrics"
-    spec:
-      containers:
-      - name: afterwork-api
-        image: registry.lions.dev/lionsdev/mic-after-work-server-impl-quarkus-main:d659416
-        imagePullPolicy: Always
-        ports:
-        - containerPort: 8080
-          name: http
-          protocol: TCP
-        envFrom:
-        - configMapRef:
-            name: afterwork-config
-        - secretRef:
-            name: afterwork-secrets
-        resources:
-          requests:
-            memory: "512Mi"
-            cpu: "250m"
-          limits:
-            memory: "1Gi"
-            cpu: "1000m"
-        livenessProbe:
-          httpGet:
-            path: /afterwork/q/health/live
-            port: 8080
-            scheme: HTTP
-          initialDelaySeconds: 60
-          periodSeconds: 30
-          timeoutSeconds: 10
-          successThreshold: 1
-          failureThreshold: 3
-        readinessProbe:
-          httpGet:
-            path: /afterwork/q/health/ready
-            port: 8080
-            scheme: HTTP
-          initialDelaySeconds: 30
-          periodSeconds: 10
-          timeoutSeconds: 5
-          successThreshold: 1
-          failureThreshold: 3
-        volumeMounts:
-        - name: temp-uploads
-          mountPath: /tmp/uploads
-      volumes:
-      - name: temp-uploads
-        emptyDir:
-          sizeLimit: 1Gi
-      imagePullSecrets:
-      - name: lionsregistry-secret
-      restartPolicy: Always

kubernetes/afterwork-ingress.yaml

@@ -1,69 +0,0 @@
-apiVersion: networking.k8s.io/v1
-kind: Ingress
-metadata:
-  name: mic-after-work-server-impl-quarkus-main-ingress
-  namespace: applications
-  labels:
-    app: mic-after-work-server-impl-quarkus-main
-  annotations:
-    # SSL/TLS
-    cert-manager.io/cluster-issuer: "letsencrypt-prod"
-    nginx.ingress.kubernetes.io/ssl-redirect: "false"
-    nginx.ingress.kubernetes.io/force-ssl-redirect: "false"
-
-    # Metadata
-    description: "Ingress for afterwork-api application on api.lions.dev/afterwork"
-    kubernetes.io/ingress.class: nginx
-    lionsctl.lions.dev/deployed-by: lionsctl
-    lionsctl.lions.dev/domain: api.lions.dev
-    lionsctl.lions.dev/path: /afterwork
-
-    # Proxy settings
-    nginx.ingress.kubernetes.io/proxy-body-size: "50m"
-    nginx.ingress.kubernetes.io/proxy-buffering: "on"
-    nginx.ingress.kubernetes.io/proxy-connect-timeout: "60"
-    nginx.ingress.kubernetes.io/proxy-read-timeout: "300"
-    nginx.ingress.kubernetes.io/proxy-send-timeout: "300"
-
-    # WebSocket support
-    nginx.ingress.kubernetes.io/proxy-http-version: "1.1"
-    nginx.ingress.kubernetes.io/websocket-services: "mic-after-work-server-impl-quarkus-main-service"
-
-    # Security headers and CORS
-    nginx.ingress.kubernetes.io/enable-cors: "true"
-    nginx.ingress.kubernetes.io/cors-allow-origin: "*"
-    nginx.ingress.kubernetes.io/cors-allow-methods: "GET, POST, PUT, DELETE, OPTIONS, PATCH"
-    nginx.ingress.kubernetes.io/cors-allow-credentials: "true"
-    nginx.ingress.kubernetes.io/cors-allow-headers: "DNT,X-CustomHeader,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Authorization"
-    nginx.ingress.kubernetes.io/cors-expose-headers: "Content-Length,Content-Range,Content-Disposition"
-    nginx.ingress.kubernetes.io/cors-max-age: "86400"
-
-    # Compression
-    nginx.ingress.kubernetes.io/enable-compression: "true"
-    nginx.ingress.kubernetes.io/compression-types: "text/plain,text/css,application/json,application/javascript,text/xml,application/xml,application/xml+rss,text/javascript"
-
-    # Rate limiting
-    nginx.ingress.kubernetes.io/rate-limit: "1000"
-    nginx.ingress.kubernetes.io/rate-limit-window: "1m"
-
-    # Rewrite (important pour /afterwork)
-    nginx.ingress.kubernetes.io/use-regex: "true"
-    nginx.ingress.kubernetes.io/rewrite-target: /$2
-
-spec:
-  ingressClassName: nginx
-  tls:
-  - hosts:
-    - api.lions.dev
-    secretName: api-lions-dev-tls
-  rules:
-  - host: api.lions.dev
-    http:
-      paths:
-      - path: /afterwork(/|$)(.*)
-        pathType: ImplementationSpecific
-        backend:
-          service:
-            name: mic-after-work-server-impl-quarkus-main-service
-            port:
-              number: 80

kubernetes/afterwork-secrets.yaml

@@ -1,13 +0,0 @@
-apiVersion: v1
-kind: Secret
-metadata:
-  name: afterwork-secrets
-  namespace: applications
-  labels:
-    app: afterwork-api
-    component: secrets
-type: Opaque
-stringData:
-  # Base de données PostgreSQL
-  # Pattern cohérent avec unionflow et btpxpress
-  DB_PASSWORD: "AfterWork2025!"

kubernetes/afterwork-service.yaml

@@ -1,20 +0,0 @@
-apiVersion: v1
-kind: Service
-metadata:
-  name: afterwork-api
-  namespace: applications
-  labels:
-    app: afterwork-api
-spec:
-  type: ClusterIP
-  sessionAffinity: ClientIP
-  sessionAffinityConfig:
-    clientIP:
-      timeoutSeconds: 10800
-  ports:
-  - port: 8080
-    targetPort: 8080
-    protocol: TCP
-    name: http
-  selector:
-    app: afterwork-api

mvnw

@@ -19,7 +19,7 @@
 # ----------------------------------------------------------------------------
 
 # ----------------------------------------------------------------------------
-# Apache Maven Wrapper startup batch script, version 3.3.2
+# Apache Maven Wrapper startup batch script, version 3.2.0
 #
 # Required ENV vars:
 # ------------------
@@ -33,84 +33,75 @@
 #   MAVEN_SKIP_RC - flag to disable loading of mavenrc files
 # ----------------------------------------------------------------------------
 
-if [ -z "$MAVEN_SKIP_RC" ]; then
+if [ -z "$MAVEN_SKIP_RC" ] ; then
 
-  if [ -f /usr/local/etc/mavenrc ]; then
+  if [ -f /usr/local/etc/mavenrc ] ; then
     . /usr/local/etc/mavenrc
   fi
 
-  if [ -f /etc/mavenrc ]; then
+  if [ -f /etc/mavenrc ] ; then
     . /etc/mavenrc
   fi
 
-  if [ -f "$HOME/.mavenrc" ]; then
+  if [ -f "$HOME/.mavenrc" ] ; then
     . "$HOME/.mavenrc"
   fi
 
 fi
 
 # OS specific support.  $var _must_ be set to either true or false.
-cygwin=false
+cygwin=false;
-darwin=false
+darwin=false;
 mingw=false
 case "$(uname)" in
-CYGWIN*) cygwin=true ;;
+  CYGWIN*) cygwin=true ;;
-MINGW*) mingw=true ;;
+  MINGW*) mingw=true;;
-Darwin*)
+  Darwin*) darwin=true
-  darwin=true
     # Use /usr/libexec/java_home if available, otherwise fall back to /Library/Java/Home
     # See https://developer.apple.com/library/mac/qa/qa1170/_index.html
     if [ -z "$JAVA_HOME" ]; then
       if [ -x "/usr/libexec/java_home" ]; then
-      JAVA_HOME="$(/usr/libexec/java_home)"
+        JAVA_HOME="$(/usr/libexec/java_home)"; export JAVA_HOME
-      export JAVA_HOME
       else
-      JAVA_HOME="/Library/Java/Home"
+        JAVA_HOME="/Library/Java/Home"; export JAVA_HOME
-      export JAVA_HOME
       fi
     fi
     ;;
 esac
 
-if [ -z "$JAVA_HOME" ]; then
+if [ -z "$JAVA_HOME" ] ; then
-  if [ -r /etc/gentoo-release ]; then
+  if [ -r /etc/gentoo-release ] ; then
     JAVA_HOME=$(java-config --jre-home)
   fi
 fi
 
 # For Cygwin, ensure paths are in UNIX format before anything is touched
-if $cygwin; then
+if $cygwin ; then
-  [ -n "$JAVA_HOME" ] \
+  [ -n "$JAVA_HOME" ] &&
-    && JAVA_HOME=$(cygpath --unix "$JAVA_HOME")
+    JAVA_HOME=$(cygpath --unix "$JAVA_HOME")
-  [ -n "$CLASSPATH" ] \
+  [ -n "$CLASSPATH" ] &&
-    && CLASSPATH=$(cygpath --path --unix "$CLASSPATH")
+    CLASSPATH=$(cygpath --path --unix "$CLASSPATH")
 fi
 
 # For Mingw, ensure paths are in UNIX format before anything is touched
-if $mingw; then
+if $mingw ; then
-  [ -n "$JAVA_HOME" ] && [ -d "$JAVA_HOME" ] \
+  [ -n "$JAVA_HOME" ] && [ -d "$JAVA_HOME" ] &&
-    && JAVA_HOME="$(
+    JAVA_HOME="$(cd "$JAVA_HOME" || (echo "cannot cd into $JAVA_HOME."; exit 1); pwd)"
-      cd "$JAVA_HOME" || (
-        echo "cannot cd into $JAVA_HOME." >&2
-        exit 1
-      )
-      pwd
-    )"
 fi
 
 if [ -z "$JAVA_HOME" ]; then
   javaExecutable="$(which javac)"
-  if [ -n "$javaExecutable" ] && ! [ "$(expr "$javaExecutable" : '\([^ ]*\)')" = "no" ]; then
+  if [ -n "$javaExecutable" ] && ! [ "$(expr "\"$javaExecutable\"" : '\([^ ]*\)')" = "no" ]; then
     # readlink(1) is not available as standard on Solaris 10.
     readLink=$(which readlink)
     if [ ! "$(expr "$readLink" : '\([^ ]*\)')" = "no" ]; then
-      if $darwin; then
+      if $darwin ; then
-        javaHome="$(dirname "$javaExecutable")"
+        javaHome="$(dirname "\"$javaExecutable\"")"
-        javaExecutable="$(cd "$javaHome" && pwd -P)/javac"
+        javaExecutable="$(cd "\"$javaHome\"" && pwd -P)/javac"
       else
-        javaExecutable="$(readlink -f "$javaExecutable")"
+        javaExecutable="$(readlink -f "\"$javaExecutable\"")"
       fi
-      javaHome="$(dirname "$javaExecutable")"
+      javaHome="$(dirname "\"$javaExecutable\"")"
       javaHome=$(expr "$javaHome" : '\(.*\)/bin')
       JAVA_HOME="$javaHome"
       export JAVA_HOME
@@ -118,60 +109,52 @@ if [ -z "$JAVA_HOME" ]; then
   fi
 fi
 
-if [ -z "$JAVACMD" ]; then
+if [ -z "$JAVACMD" ] ; then
-  if [ -n "$JAVA_HOME" ]; then
+  if [ -n "$JAVA_HOME"  ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ]; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
       # IBM's JDK on AIX uses strange locations for the executables
       JAVACMD="$JAVA_HOME/jre/sh/java"
     else
       JAVACMD="$JAVA_HOME/bin/java"
     fi
   else
-    JAVACMD="$(
+    JAVACMD="$(\unset -f command 2>/dev/null; \command -v java)"
-      \unset -f command 2>/dev/null
-      \command -v java
-    )"
   fi
 fi
 
-if [ ! -x "$JAVACMD" ]; then
+if [ ! -x "$JAVACMD" ] ; then
   echo "Error: JAVA_HOME is not defined correctly." >&2
   echo "  We cannot execute $JAVACMD" >&2
   exit 1
 fi
 
-if [ -z "$JAVA_HOME" ]; then
+if [ -z "$JAVA_HOME" ] ; then
-  echo "Warning: JAVA_HOME environment variable is not set." >&2
+  echo "Warning: JAVA_HOME environment variable is not set."
 fi
 
 # traverses directory structure from process work directory to filesystem root
 # first directory with .mvn subdirectory is considered project base directory
 find_maven_basedir() {
-  if [ -z "$1" ]; then
+  if [ -z "$1" ]
-    echo "Path not specified to find_maven_basedir" >&2
+  then
+    echo "Path not specified to find_maven_basedir"
     return 1
   fi
 
   basedir="$1"
   wdir="$1"
-  while [ "$wdir" != '/' ]; do
+  while [ "$wdir" != '/' ] ; do
-    if [ -d "$wdir"/.mvn ]; then
+    if [ -d "$wdir"/.mvn ] ; then
       basedir=$wdir
       break
     fi
     # workaround for JBEAP-8937 (on Solaris 10/Sparc)
     if [ -d "${wdir}" ]; then
-      wdir=$(
+      wdir=$(cd "$wdir/.." || exit 1; pwd)
-        cd "$wdir/.." || exit 1
-        pwd
-      )
     fi
     # end of workaround
   done
-  printf '%s' "$(
+  printf '%s' "$(cd "$basedir" || exit 1; pwd)"
-    cd "$basedir" || exit 1
-    pwd
-  )"
 }
 
 # concatenates all lines of a file
@@ -182,7 +165,7 @@ concat_lines() {
     # enabled. Otherwise, we may read lines that are delimited with
     # \r\n and produce $'-Xarg\r' rather than -Xarg due to word
     # splitting rules.
-    tr -s '\r\n' ' ' <"$1"
+    tr -s '\r\n' ' ' < "$1"
   fi
 }
 
@@ -194,11 +177,10 @@ log() {
 
 BASE_DIR=$(find_maven_basedir "$(dirname "$0")")
 if [ -z "$BASE_DIR" ]; then
-  exit 1
+  exit 1;
 fi
 
-MAVEN_PROJECTBASEDIR=${MAVEN_BASEDIR:-"$BASE_DIR"}
+MAVEN_PROJECTBASEDIR=${MAVEN_BASEDIR:-"$BASE_DIR"}; export MAVEN_PROJECTBASEDIR
-export MAVEN_PROJECTBASEDIR
 log "$MAVEN_PROJECTBASEDIR"
 
 ##########################################################################################
@@ -212,26 +194,23 @@ else
     log "Couldn't find $wrapperJarPath, downloading it ..."
 
     if [ -n "$MVNW_REPOURL" ]; then
-    wrapperUrl="$MVNW_REPOURL/org/apache/maven/wrapper/maven-wrapper/3.3.2/maven-wrapper-3.3.2.jar"
+      wrapperUrl="$MVNW_REPOURL/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar"
     else
-    wrapperUrl="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.3.2/maven-wrapper-3.3.2.jar"
+      wrapperUrl="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar"
     fi
     while IFS="=" read -r key value; do
       # Remove '\r' from value to allow usage on windows as IFS does not consider '\r' as a separator ( considers space, tab, new line ('\n'), and custom '=' )
       safeValue=$(echo "$value" | tr -d '\r')
-    case "$key" in wrapperUrl)
+      case "$key" in (wrapperUrl) wrapperUrl="$safeValue"; break ;;
-      wrapperUrl="$safeValue"
-      break
-      ;;
       esac
-  done <"$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.properties"
+    done < "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.properties"
     log "Downloading from: $wrapperUrl"
 
     if $cygwin; then
       wrapperJarPath=$(cygpath --path --windows "$wrapperJarPath")
     fi
 
-  if command -v wget >/dev/null; then
+    if command -v wget > /dev/null; then
         log "Found wget ... using wget"
         [ "$MVNW_VERBOSE" = true ] && QUIET="" || QUIET="--quiet"
         if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
@@ -239,7 +218,7 @@ else
         else
             wget $QUIET --http-user="$MVNW_USERNAME" --http-password="$MVNW_PASSWORD" "$wrapperUrl" -O "$wrapperJarPath" || rm -f "$wrapperJarPath"
         fi
-  elif command -v curl >/dev/null; then
+    elif command -v curl > /dev/null; then
         log "Found curl ... using curl"
         [ "$MVNW_VERBOSE" = true ] && QUIET="" || QUIET="--silent"
         if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
@@ -275,25 +254,22 @@ fi
 # If specified, validate the SHA-256 sum of the Maven wrapper jar file
 wrapperSha256Sum=""
 while IFS="=" read -r key value; do
-  case "$key" in wrapperSha256Sum)
+  case "$key" in (wrapperSha256Sum) wrapperSha256Sum=$value; break ;;
-    wrapperSha256Sum=$value
-    break
-    ;;
   esac
-done <"$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.properties"
+done < "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.properties"
 if [ -n "$wrapperSha256Sum" ]; then
   wrapperSha256Result=false
-  if command -v sha256sum >/dev/null; then
+  if command -v sha256sum > /dev/null; then
-    if echo "$wrapperSha256Sum  $wrapperJarPath" | sha256sum -c >/dev/null 2>&1; then
+    if echo "$wrapperSha256Sum  $wrapperJarPath" | sha256sum -c > /dev/null 2>&1; then
       wrapperSha256Result=true
     fi
-  elif command -v shasum >/dev/null; then
+  elif command -v shasum > /dev/null; then
-    if echo "$wrapperSha256Sum  $wrapperJarPath" | shasum -a 256 -c >/dev/null 2>&1; then
+    if echo "$wrapperSha256Sum  $wrapperJarPath" | shasum -a 256 -c > /dev/null 2>&1; then
       wrapperSha256Result=true
     fi
   else
-    echo "Checksum validation was requested but neither 'sha256sum' or 'shasum' are available." >&2
+    echo "Checksum validation was requested but neither 'sha256sum' or 'shasum' are available."
-    echo "Please install either command, or disable validation by removing 'wrapperSha256Sum' from your maven-wrapper.properties." >&2
+    echo "Please install either command, or disable validation by removing 'wrapperSha256Sum' from your maven-wrapper.properties."
     exit 1
   fi
   if [ $wrapperSha256Result = false ]; then
@@ -308,12 +284,12 @@ MAVEN_OPTS="$(concat_lines "$MAVEN_PROJECTBASEDIR/.mvn/jvm.config") $MAVEN_OPTS"
 
 # For Cygwin, switch paths to Windows format before running java
 if $cygwin; then
-  [ -n "$JAVA_HOME" ] \
+  [ -n "$JAVA_HOME" ] &&
-    && JAVA_HOME=$(cygpath --path --windows "$JAVA_HOME")
+    JAVA_HOME=$(cygpath --path --windows "$JAVA_HOME")
-  [ -n "$CLASSPATH" ] \
+  [ -n "$CLASSPATH" ] &&
-    && CLASSPATH=$(cygpath --path --windows "$CLASSPATH")
+    CLASSPATH=$(cygpath --path --windows "$CLASSPATH")
-  [ -n "$MAVEN_PROJECTBASEDIR" ] \
+  [ -n "$MAVEN_PROJECTBASEDIR" ] &&
-    && MAVEN_PROJECTBASEDIR=$(cygpath --path --windows "$MAVEN_PROJECTBASEDIR")
+    MAVEN_PROJECTBASEDIR=$(cygpath --path --windows "$MAVEN_PROJECTBASEDIR")
 fi
 
 # Provide a "standardized" way to retrieve the CLI args that will

mvnw.cmd

@@ -18,7 +18,7 @@
 @REM ----------------------------------------------------------------------------
 
 @REM ----------------------------------------------------------------------------
-@REM Apache Maven Wrapper startup batch script, version 3.3.2
+@REM Apache Maven Wrapper startup batch script, version 3.2.0
 @REM
 @REM Required ENV vars:
 @REM JAVA_HOME - location of a JDK home dir
@@ -59,22 +59,22 @@ set ERROR_CODE=0
 @REM ==== START VALIDATION ====
 if not "%JAVA_HOME%" == "" goto OkJHome
 
-echo. >&2
+echo.
 echo Error: JAVA_HOME not found in your environment. >&2
 echo Please set the JAVA_HOME variable in your environment to match the >&2
 echo location of your Java installation. >&2
-echo. >&2
+echo.
 goto error
 
 :OkJHome
 if exist "%JAVA_HOME%\bin\java.exe" goto init
 
-echo. >&2
+echo.
 echo Error: JAVA_HOME is set to an invalid directory. >&2
 echo JAVA_HOME = "%JAVA_HOME%" >&2
 echo Please set the JAVA_HOME variable in your environment to match the >&2
 echo location of your Java installation. >&2
-echo. >&2
+echo.
 goto error
 
 @REM ==== END VALIDATION ====
@@ -119,7 +119,7 @@ SET MAVEN_JAVA_EXE="%JAVA_HOME%\bin\java.exe"
 set WRAPPER_JAR="%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.jar"
 set WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
 
-set WRAPPER_URL="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.3.2/maven-wrapper-3.3.2.jar"
+set WRAPPER_URL="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar"
 
 FOR /F "usebackq tokens=1,2 delims==" %%A IN ("%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.properties") DO (
     IF "%%A"=="wrapperUrl" SET WRAPPER_URL=%%B
@@ -133,7 +133,7 @@ if exist %WRAPPER_JAR% (
     )
 ) else (
     if not "%MVNW_REPOURL%" == "" (
-        SET WRAPPER_URL="%MVNW_REPOURL%/org/apache/maven/wrapper/maven-wrapper/3.3.2/maven-wrapper-3.3.2.jar"
+        SET WRAPPER_URL="%MVNW_REPOURL%/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar"
     )
     if "%MVNW_VERBOSE%" == "true" (
         echo Couldn't find %WRAPPER_JAR%, downloading it ...
@@ -160,12 +160,11 @@ FOR /F "usebackq tokens=1,2 delims==" %%A IN ("%MAVEN_PROJECTBASEDIR%\.mvn\wrapp
 )
 IF NOT %WRAPPER_SHA_256_SUM%=="" (
     powershell -Command "&{"^
-       "Import-Module $PSHOME\Modules\Microsoft.PowerShell.Utility -Function Get-FileHash;"^
        "$hash = (Get-FileHash \"%WRAPPER_JAR%\" -Algorithm SHA256).Hash.ToLower();"^
        "If('%WRAPPER_SHA_256_SUM%' -ne $hash){"^
-       "  Write-Error 'Error: Failed to validate Maven wrapper SHA-256, your Maven wrapper might be compromised.';"^
+       "  Write-Output 'Error: Failed to validate Maven wrapper SHA-256, your Maven wrapper might be compromised.';"^
-       "  Write-Error 'Investigate or delete %WRAPPER_JAR% to attempt a clean download.';"^
+       "  Write-Output 'Investigate or delete %WRAPPER_JAR% to attempt a clean download.';"^
-       "  Write-Error 'If you updated your Maven version, you need to update the specified wrapperSha256Sum property.';"^
+       "  Write-Output 'If you updated your Maven version, you need to update the specified wrapperSha256Sum property.';"^
        "  exit 1;"^
        "}"^
        "}"

pom.xml

@@ -1,8 +1,10 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
-    <groupId>dev.lions</groupId>
+  <groupId>com.lions.dev</groupId>
-    <artifactId>mic-after-work-server-impl-quarkus-main</artifactId>
+  <artifactId>mic-after-work-server</artifactId>
   <version>1.0.0-SNAPSHOT</version>
 
   <properties>
@@ -12,10 +14,9 @@
     <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
     <quarkus.platform.artifact-id>quarkus-bom</quarkus.platform.artifact-id>
     <quarkus.platform.group-id>io.quarkus.platform</quarkus.platform.group-id>
-        <quarkus.platform.version>3.16.3</quarkus.platform.version>
+    <quarkus.platform.version>3.13.0</quarkus.platform.version>
-        <quarkus.package.type>uber-jar</quarkus.package.type>
     <skipITs>true</skipITs>
-        <surefire-plugin.version>3.5.0</surefire-plugin.version>
+    <surefire-plugin.version>3.2.5</surefire-plugin.version>
   </properties>
 
   <dependencyManagement>
@@ -31,33 +32,33 @@
   </dependencyManagement>
 
   <dependencies>
+    <!-- Jakarta Bean Validation -->
     <dependency>
-            <groupId>io.quarkus</groupId>
+      <groupId>org.hibernate.validator</groupId>
-            <artifactId>quarkus-hibernate-orm</artifactId>
+      <artifactId>hibernate-validator</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>jakarta.el</groupId>
+      <artifactId>jakarta.el-api</artifactId>
+      <version>5.0.0</version>
     </dependency>
     <dependency>
       <groupId>io.quarkus</groupId>
-            <artifactId>quarkus-hibernate-orm-panache</artifactId>
+      <artifactId>quarkus-jdbc-postgresql</artifactId>
+      <version>3.13.0</version>  <!-- Utilise la même version de Quarkus -->
     </dependency>
     <dependency>
       <groupId>io.quarkus</groupId>
-            <artifactId>quarkus-smallrye-openapi</artifactId>
+      <artifactId>quarkus-smallrye-jwt</artifactId>
     </dependency>
     <dependency>
-            <groupId>io.quarkus</groupId>
+      <groupId>org.springframework.security</groupId>
-            <artifactId>quarkus-rest</artifactId>
+      <artifactId>spring-security-core</artifactId>
+      <version>6.3.4</version>
     </dependency>
     <dependency>
-            <groupId>io.quarkus</groupId>
+      <groupId>com.fasterxml.jackson.datatype</groupId>
-            <artifactId>quarkus-rest-jackson</artifactId>
+      <artifactId>jackson-datatype-jsr310</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.quarkus</groupId>
-            <artifactId>quarkus-hibernate-validator</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.quarkus</groupId>
-            <artifactId>quarkus-logging-json</artifactId>
     </dependency>
     <dependency>
       <groupId>io.quarkiverse.groovy</groupId>
@@ -66,41 +67,27 @@
     </dependency>
     <dependency>
       <groupId>io.quarkus</groupId>
-            <artifactId>quarkus-jdbc-postgresql</artifactId>
+      <artifactId>quarkus-smallrye-openapi</artifactId>
     </dependency>
     <dependency>
       <groupId>io.quarkus</groupId>
-            <artifactId>quarkus-jdbc-h2</artifactId>
+      <artifactId>quarkus-rest-jackson</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>io.quarkus</groupId>
+      <artifactId>quarkus-hibernate-orm-panache</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>io.quarkus</groupId>
+      <artifactId>quarkus-jdbc-oracle</artifactId>
     </dependency>
     <dependency>
       <groupId>io.quarkus</groupId>
       <artifactId>quarkus-arc</artifactId>
     </dependency>
-        <!-- WebSockets Next (remplace quarkus-websockets) -->
     <dependency>
       <groupId>io.quarkus</groupId>
-            <artifactId>quarkus-websockets-next</artifactId>
+      <artifactId>quarkus-hibernate-orm</artifactId>
-        </dependency>
-        <!-- Kafka Reactive Messaging -->
-        <dependency>
-            <groupId>io.quarkus</groupId>
-            <artifactId>quarkus-messaging-kafka</artifactId>
-        </dependency>
-        <!-- JSON Serialization pour Kafka -->
-        <dependency>
-            <groupId>io.quarkus</groupId>
-            <artifactId>quarkus-jsonb</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.projectlombok</groupId>
-            <artifactId>lombok</artifactId>
-            <version>1.18.30</version>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>at.favre.lib</groupId>
-            <artifactId>bcrypt</artifactId>
-            <version>0.10.2</version>
     </dependency>
     <dependency>
       <groupId>io.quarkus</groupId>
@@ -112,6 +99,13 @@
       <artifactId>rest-assured</artifactId>
       <scope>test</scope>
     </dependency>
+
+    <dependency>
+      <groupId>org.projectlombok</groupId>
+      <artifactId>lombok</artifactId>
+      <version>1.18.34</version>
+      <scope>provided</scope>
+    </dependency>
   </dependencies>
 
   <build>
@@ -136,7 +130,9 @@
         <artifactId>maven-compiler-plugin</artifactId>
         <version>${compiler-plugin.version}</version>
         <configuration>
-                    <parameters>true</parameters>
+          <compilerArgs>
+            <arg>-parameters</arg>
+          </compilerArgs>
         </configuration>
       </plugin>
       <plugin>
@@ -147,9 +143,6 @@
             <java.util.logging.manager>org.jboss.logmanager.LogManager</java.util.logging.manager>
             <maven.home>${maven.home}</maven.home>
           </systemPropertyVariables>
-                    <!-- Ne pas bloquer le build si les tests échouent -->
-                    <testFailureIgnore>true</testFailureIgnore>
-                    <skipTests>${skipTests}</skipTests>
         </configuration>
       </plugin>
       <plugin>
@@ -165,7 +158,8 @@
         </executions>
         <configuration>
           <systemPropertyVariables>
-                        <native.image.path>${project.build.directory}/${project.build.finalName}-runner</native.image.path>
+            <native.image.path>${project.build.directory}/${project.build.finalName}-runner
+            </native.image.path>
             <java.util.logging.manager>org.jboss.logmanager.LogManager</java.util.logging.manager>
             <maven.home>${maven.home}</maven.home>
           </systemPropertyVariables>

src/main/docker/Dockerfile.jvm

@@ -7,11 +7,11 @@
 #
 # Then, build the image with:
 #
-# docker build -f src/main/docker/Dockerfile.jvm -t quarkus/mic-after-work-server-impl-quarkus-main-jvm .
+# docker build -f src/main/docker/Dockerfile.jvm -t quarkus/mic-after-work-jvm .
 #
 # Then run the container using:
 #
-# docker run -i --rm -p 8080:8080 quarkus/mic-after-work-server-impl-quarkus-main-jvm
+# docker run -i --rm -p 8080:8080 quarkus/mic-after-work-jvm
 #
 # If you want to include the debug port into your docker image
 # you will have to expose the debug port (default 5005 being the default) like this :  EXPOSE 8080 5005.
@@ -20,7 +20,7 @@
 #
 # Then run the container using :
 #
-# docker run -i --rm -p 8080:8080 quarkus/mic-after-work-server-impl-quarkus-main-jvm
+# docker run -i --rm -p 8080:8080 quarkus/mic-after-work-jvm
 #
 # This image uses the `run-java.sh` script to run the application.
 # This scripts computes the command line to execute your Java application, and
@@ -77,7 +77,7 @@
 #   accessed directly. (example: "foo.example.com,bar.example.com")
 #
 ###
-FROM registry.access.redhat.com/ubi8/openjdk-17:1.20
+FROM registry.access.redhat.com/ubi8/openjdk-17:1.19
 
 ENV LANGUAGE='en_US:en'
 

src/main/docker/Dockerfile.legacy-jar

@@ -7,11 +7,11 @@
 #
 # Then, build the image with:
 #
-# docker build -f src/main/docker/Dockerfile.legacy-jar -t quarkus/mic-after-work-server-impl-quarkus-main-legacy-jar .
+# docker build -f src/main/docker/Dockerfile.legacy-jar -t quarkus/mic-after-work-legacy-jar .
 #
 # Then run the container using:
 #
-# docker run -i --rm -p 8080:8080 quarkus/mic-after-work-server-impl-quarkus-main-legacy-jar
+# docker run -i --rm -p 8080:8080 quarkus/mic-after-work-legacy-jar
 #
 # If you want to include the debug port into your docker image
 # you will have to expose the debug port (default 5005 being the default) like this :  EXPOSE 8080 5005.
@@ -20,7 +20,7 @@
 #
 # Then run the container using :
 #
-# docker run -i --rm -p 8080:8080 quarkus/mic-after-work-server-impl-quarkus-main-legacy-jar
+# docker run -i --rm -p 8080:8080 quarkus/mic-after-work-legacy-jar
 #
 # This image uses the `run-java.sh` script to run the application.
 # This scripts computes the command line to execute your Java application, and
@@ -77,7 +77,7 @@
 #   accessed directly. (example: "foo.example.com,bar.example.com")
 #
 ###
-FROM registry.access.redhat.com/ubi8/openjdk-17:1.20
+FROM registry.access.redhat.com/ubi8/openjdk-17:1.19
 
 ENV LANGUAGE='en_US:en'
 

src/main/docker/Dockerfile.native

@@ -7,14 +7,14 @@
 #
 # Then, build the image with:
 #
-# docker build -f src/main/docker/Dockerfile.native -t quarkus/mic-after-work-server-impl-quarkus-main .
+# docker build -f src/main/docker/Dockerfile.native -t quarkus/mic-after-work .
 #
 # Then run the container using:
 #
-# docker run -i --rm -p 8080:8080 quarkus/mic-after-work-server-impl-quarkus-main
+# docker run -i --rm -p 8080:8080 quarkus/mic-after-work
 #
 ###
-FROM registry.access.redhat.com/ubi8/ubi-minimal:8.10
+FROM registry.access.redhat.com/ubi8/ubi-minimal:8.9
 WORKDIR /work/
 RUN chown 1001 /work \
     && chmod "g+rwX" /work \

src/main/docker/Dockerfile.native-micro

@@ -10,11 +10,11 @@
 #
 # Then, build the image with:
 #
-# docker build -f src/main/docker/Dockerfile.native-micro -t quarkus/mic-after-work-server-impl-quarkus-main .
+# docker build -f src/main/docker/Dockerfile.native-micro -t quarkus/mic-after-work .
 #
 # Then run the container using:
 #
-# docker run -i --rm -p 8080:8080 quarkus/mic-after-work-server-impl-quarkus-main
+# docker run -i --rm -p 8080:8080 quarkus/mic-after-work
 #
 ###
 FROM quay.io/quarkus/quarkus-micro-image:2.0

src/main/docker/docker-compose.yml

@@ -1,26 +1,33 @@
+version: '3.8'
+
 services:
+  # Service pour la base de données PostgreSQL
   db:
     image: postgres:13
     container_name: afterwork_db
     environment:
-      POSTGRES_USER: "${DB_USERNAME}"
+      POSTGRES_USER: ${DB_USERNAME}
-      POSTGRES_PASSWORD: "${DB_PASSWORD}"
+      POSTGRES_PASSWORD: ${DB_PASSWORD}
-      POSTGRES_DB: "${DB_NAME}"
+      POSTGRES_DB: ${DB_NAME}
+    ports:
+      - "5432:5432"
     networks:
       - afterwork-network
     volumes:
       - db_data:/var/lib/postgresql/data
-    restart: unless-stopped
 
+  # Service pour l'application Quarkus
   app:
-    image: dahoudg/afterwork-quarkus:latest
+    build:
+      context: .
+      dockerfile: src/main/docker/Dockerfile.jvm
     container_name: afterwork-quarkus
     environment:
-      DB_USERNAME: "${DB_USERNAME}"
+      DB_USERNAME: ${DB_USERNAME}
-      DB_PASSWORD: "${DB_PASSWORD}"
+      DB_PASSWORD: ${DB_PASSWORD}
-      DB_HOST: "${DB_HOST}"
+      DB_HOST: db
-      DB_PORT: "${DB_PORT}"
+      DB_PORT: 5432
-      DB_NAME: "${DB_NAME}"
+      DB_NAME: ${DB_NAME}
       JAVA_OPTS_APPEND: "-Dquarkus.http.host=0.0.0.0"
     ports:
       - "8080:8080"
@@ -28,8 +35,8 @@ services:
       - db
     networks:
       - afterwork-network
-    restart: unless-stopped
 
+  # Service pour Swagger UI
   swagger-ui:
     image: swaggerapi/swagger-ui
     container_name: afterwork-swagger-ui
@@ -41,7 +48,6 @@ services:
       - app
     networks:
       - afterwork-network
-    restart: unless-stopped
 
 networks:
   afterwork-network:

src/main/java/com/lions/dev/dto/events/ChatMessageEvent.java

@@ -1,75 +0,0 @@
-package com.lions.dev.dto.events;
-
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.Setter;
-import java.util.UUID;
-
-/**
- * Événement de message chat publié dans Kafka.
- * 
- * Utilisé pour garantir la livraison des messages même si le destinataire
- * est temporairement déconnecté. Le message est persisté dans Kafka et
- * délivré dès la reconnexion.
- */
-@Getter
-@Setter
-@NoArgsConstructor
-@AllArgsConstructor
-public class ChatMessageEvent {
-    
-    /**
-     * ID de la conversation (utilisé comme clé Kafka pour garantir l'ordre).
-     */
-    private String conversationId;
-    
-    /**
-     * ID de l'expéditeur.
-     */
-    private String senderId;
-    
-    /**
-     * ID du destinataire.
-     */
-    private String recipientId;
-    
-    /**
-     * Contenu du message.
-     */
-    private String content;
-    
-    /**
-     * ID unique du message.
-     */
-    private String messageId;
-    
-    /**
-     * Timestamp de création.
-     */
-    private Long timestamp;
-    
-    /**
-     * Type d'événement (message, typing, read_receipt, delivery_confirmation).
-     */
-    private String eventType;
-    
-    /**
-     * Données additionnelles (pour typing indicators, read receipts, etc.).
-     */
-    private java.util.Map<String, Object> metadata;
-    
-    /**
-     * Constructeur pour un message standard.
-     */
-    public ChatMessageEvent(String conversationId, String senderId, String recipientId, 
-                           String content, String messageId) {
-        this.conversationId = conversationId;
-        this.senderId = senderId;
-        this.recipientId = recipientId;
-        this.content = content;
-        this.messageId = messageId;
-        this.eventType = "message";
-        this.timestamp = System.currentTimeMillis();
-    }
-}

src/main/java/com/lions/dev/dto/events/NotificationEvent.java

@@ -1,52 +0,0 @@
-package com.lions.dev.dto.events;
-
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.Setter;
-import java.util.Map;
-import java.util.UUID;
-
-/**
- * Événement de notification publié dans Kafka.
- * 
- * Utilisé pour découpler les services métier des WebSockets.
- * Les services publient dans Kafka, et un bridge consomme depuis Kafka
- * pour envoyer via WebSocket aux clients connectés.
- */
-@Getter
-@Setter
-@NoArgsConstructor
-@AllArgsConstructor
-public class NotificationEvent {
-    
-    /**
-     * ID de l'utilisateur destinataire (utilisé comme clé Kafka pour routing).
-     */
-    private String userId;
-    
-    /**
-     * Type de notification (friend_request, friend_request_accepted, event_reminder, etc.).
-     */
-    private String type;
-    
-    /**
-     * Données de la notification (contenu spécifique au type).
-     */
-    private Map<String, Object> data;
-    
-    /**
-     * Timestamp de création de l'événement.
-     */
-    private Long timestamp;
-    
-    /**
-     * Constructeur simplifié (timestamp auto-généré).
-     */
-    public NotificationEvent(String userId, String type, Map<String, Object> data) {
-        this.userId = userId;
-        this.type = type;
-        this.data = data;
-        this.timestamp = System.currentTimeMillis();
-    }
-}

src/main/java/com/lions/dev/dto/events/PresenceEvent.java

@@ -1,48 +0,0 @@
-package com.lions.dev.dto.events;
-
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.Setter;
-
-/**
- * Événement de présence (online/offline) publié dans Kafka.
- * 
- * Utilisé pour notifier les amis quand un utilisateur se connecte/déconnecte.
- */
-@Getter
-@Setter
-@NoArgsConstructor
-@AllArgsConstructor
-public class PresenceEvent {
-    
-    /**
-     * ID de l'utilisateur concerné.
-     */
-    private String userId;
-    
-    /**
-     * Statut (online, offline).
-     */
-    private String status;
-    
-    /**
-     * Timestamp de dernière activité.
-     */
-    private Long lastSeen;
-    
-    /**
-     * Timestamp de l'événement.
-     */
-    private Long timestamp;
-    
-    /**
-     * Constructeur simplifié.
-     */
-    public PresenceEvent(String userId, String status, Long lastSeen) {
-        this.userId = userId;
-        this.status = status;
-        this.lastSeen = lastSeen;
-        this.timestamp = System.currentTimeMillis();
-    }
-}

src/main/java/com/lions/dev/dto/events/ReactionEvent.java

@@ -1,63 +0,0 @@
-package com.lions.dev.dto.events;
-
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.Setter;
-import java.util.Map;
-
-/**
- * Événement de réaction (like, comment, share) publié dans Kafka.
- * 
- * Utilisé pour notifier en temps réel les réactions sur les posts,
- * stories et événements.
- */
-@Getter
-@Setter
-@NoArgsConstructor
-@AllArgsConstructor
-public class ReactionEvent {
-    
-    /**
-     * ID du post/story/event concerné (utilisé comme clé Kafka).
-     */
-    private String targetId;
-    
-    /**
-     * Type de cible (post, story, event).
-     */
-    private String targetType;
-    
-    /**
-     * ID de l'utilisateur qui réagit.
-     */
-    private String userId;
-    
-    /**
-     * Type de réaction (like, comment, share).
-     */
-    private String reactionType;
-    
-    /**
-     * Données additionnelles (contenu du commentaire, etc.).
-     */
-    private Map<String, Object> data;
-    
-    /**
-     * Timestamp de création.
-     */
-    private Long timestamp;
-    
-    /**
-     * Constructeur simplifié.
-     */
-    public ReactionEvent(String targetId, String targetType, String userId, 
-                         String reactionType, Map<String, Object> data) {
-        this.targetId = targetId;
-        this.targetType = targetType;
-        this.userId = userId;
-        this.reactionType = reactionType;
-        this.data = data;
-        this.timestamp = System.currentTimeMillis();
-    }
-}

src/main/java/com/lions/dev/dto/request/chat/SendMessageRequestDTO.java

@@ -1,34 +0,0 @@
-package com.lions.dev.dto.request.chat;
-
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.Setter;
-
-import java.util.UUID;
-
-/**
- * DTO pour l'envoi d'un message.
- */
-@Getter
-@Setter
-@NoArgsConstructor
-public class SendMessageRequestDTO {
-
-  private UUID senderId; // L'ID de l'expéditeur
-  private UUID recipientId; // L'ID du destinataire
-  private String content; // Le contenu du message
-  private String messageType; // Le type de message (text, image, video, file)
-  private String mediaUrl; // L'URL du média (optionnel)
-
-  /**
-   * Valide les données du DTO.
-   *
-   * @return true si les données sont valides, false sinon
-   */
-  public boolean isValid() {
-    return senderId != null
-        && recipientId != null
-        && content != null
-        && !content.trim().isEmpty();
-  }
-}

src/main/java/com/lions/dev/dto/request/establishment/EstablishmentCreateRequestDTO.java

@@ -1,85 +0,0 @@
-package com.lions.dev.dto.request.establishment;
-
-import jakarta.validation.constraints.NotNull;
-import jakarta.validation.constraints.Size;
-import lombok.Getter;
-import lombok.Setter;
-import java.util.UUID;
-
-/**
- * DTO pour la création d'un établissement.
- * 
- * Version 2.0 - Architecture refactorée avec nommage standardisé.
- * Conforme à l'architecture de données AfterWork v2.0 (Ultra-Compétitive).
- * 
- * Seuls les responsables d'établissement peuvent créer des établissements.
- */
-@Getter
-@Setter
-public class EstablishmentCreateRequestDTO {
-
-  @NotNull(message = "Le nom de l'établissement est obligatoire.")
-  @Size(min = 2, max = 200, message = "Le nom doit comporter entre 2 et 200 caractères.")
-  private String name;
-
-  @NotNull(message = "Le type d'établissement est obligatoire.")
-  private String type;
-
-  @NotNull(message = "L'adresse est obligatoire.")
-  private String address;
-
-  @NotNull(message = "La ville est obligatoire.")
-  private String city;
-
-  @NotNull(message = "Le code postal est obligatoire.")
-  private String postalCode;
-
-  private String description;
-  private String phoneNumber;
-  private String website;
-  private String priceRange;
-  private String verificationStatus = "PENDING"; // v2.0 - Par défaut PENDING
-  private Double latitude;
-  private Double longitude;
-
-  @NotNull(message = "L'identifiant du responsable est obligatoire.")
-  private UUID managerId;
-
-  // Champs dépréciés (v1.0) - conservés pour compatibilité mais ignorés
-  /**
-   * @deprecated Supprimé en v2.0 (utiliser manager.email à la place).
-   */
-  @Deprecated
-  private String email;
-
-  /**
-   * @deprecated Supprimé en v2.0 (utiliser establishment_media à la place).
-   */
-  @Deprecated
-  private String imageUrl;
-
-  /**
-   * @deprecated Utiliser averageRating calculé depuis reviews à la place.
-   */
-  @Deprecated
-  private Double rating;
-
-  /**
-   * @deprecated Supprimé en v2.0.
-   */
-  @Deprecated
-  private Integer capacity;
-
-  /**
-   * @deprecated Supprimé en v2.0 (utiliser establishment_amenities à la place).
-   */
-  @Deprecated
-  private String amenities;
-
-  /**
-   * @deprecated Supprimé en v2.0 (utiliser business_hours à la place).
-   */
-  @Deprecated
-  private String openingHours;
-}
-

src/main/java/com/lions/dev/dto/request/establishment/EstablishmentMediaRequestDTO.java

@@ -1,31 +0,0 @@
-package com.lions.dev.dto.request.establishment;
-
-import jakarta.validation.constraints.NotBlank;
-import jakarta.validation.constraints.NotNull;
-import lombok.Getter;
-import lombok.Setter;
-
-/**
- * DTO pour la requête d'upload d'un média d'établissement.
- * 
- * Version 2.0 - Architecture refactorée avec nommage standardisé.
- */
-@Getter
-@Setter
-public class EstablishmentMediaRequestDTO {
-
-    @NotBlank(message = "L'URL du média est obligatoire")
-    private String mediaUrl;
-
-    @NotBlank(message = "Le type de média est obligatoire")
-    private String mediaType; // PHOTO ou VIDEO
-
-    private String name; // Nom du fichier (fileName) - optionnel, peut être extrait de mediaUrl si non fourni
-
-    private String thumbnailUrl; // Optionnel, pour les vidéos
-
-    private Integer displayOrder = 0; // Ordre d'affichage (par défaut 0)
-
-    private String uploadedByUserId; // ID de l'utilisateur qui upload (optionnel, peut être extrait du contexte)
-}
-

src/main/java/com/lions/dev/dto/request/establishment/EstablishmentRatingRequestDTO.java

@@ -1,25 +0,0 @@
-package com.lions.dev.dto.request.establishment;
-
-import jakarta.validation.constraints.Max;
-import jakarta.validation.constraints.Min;
-import jakarta.validation.constraints.NotNull;
-import jakarta.validation.constraints.Size;
-import lombok.Getter;
-import lombok.Setter;
-
-/**
- * DTO pour soumettre ou modifier une note d'établissement.
- */
-@Getter
-@Setter
-public class EstablishmentRatingRequestDTO {
-
-    @NotNull(message = "La note est obligatoire.")
-    @Min(value = 1, message = "La note doit être au moins 1 étoile.")
-    @Max(value = 5, message = "La note ne peut pas dépasser 5 étoiles.")
-    private Integer rating; // Note de 1 à 5
-
-    @Size(max = 2000, message = "Le commentaire ne peut pas dépasser 2000 caractères.")
-    private String comment; // Commentaire optionnel
-}
-

src/main/java/com/lions/dev/dto/request/establishment/EstablishmentUpdateRequestDTO.java

@@ -1,34 +0,0 @@
-package com.lions.dev.dto.request.establishment;
-
-import jakarta.validation.constraints.Size;
-import lombok.Getter;
-import lombok.Setter;
-
-/**
- * DTO pour la mise à jour d'un établissement.
- */
-@Getter
-@Setter
-public class EstablishmentUpdateRequestDTO {
-
-  @Size(min = 2, max = 200, message = "Le nom doit comporter entre 2 et 200 caractères.")
-  private String name;
-
-  private String type;
-  private String address;
-  private String city;
-  private String postalCode;
-  private String description;
-  private String phoneNumber;
-  private String email;
-  private String website;
-  private String imageUrl;
-  private Double rating;
-  private String priceRange;
-  private Integer capacity;
-  private String amenities;
-  private String openingHours;
-  private Double latitude;
-  private Double longitude;
-}
-

src/main/java/com/lions/dev/dto/request/events/EventCreateRequestDTO.java

@@ -9,10 +9,6 @@ import java.time.LocalDateTime;
 
 /**
  * DTO pour la création d'un événement.
- * 
- * Version 2.0 - Architecture refactorée avec nommage standardisé.
- * Conforme à l'architecture de données AfterWork v2.0 (Ultra-Compétitive).
- * 
  * Ce DTO est utilisé dans les requêtes de création d'événements, envoyant les informations
  * nécessaires comme le titre, les dates, la description, le créateur, et d'autres attributs.
  */
@@ -32,45 +28,15 @@ public class EventCreateRequestDTO {
   @NotNull(message = "La date de fin est obligatoire.")
   private LocalDateTime endDate; // Date de fin de l'événement
 
-  private UUID establishmentId; // v2.0 - ID de l'établissement où se déroule l'événement
+  private String location; // Lieu de l'événement
   private String category; // Catégorie de l'événement
   private String link; // Lien d'information supplémentaire
   private String imageUrl; // URL de l'image associée à l'événement
 
-  private Integer maxParticipants; // Nombre maximum de participants autorisés
-  private String tags; // Tags/mots-clés associés à l'événement (séparés par des virgules)
-  private String organizer; // Nom de l'organisateur de l'événement
-  private Integer participationFee; // Frais de participation en centimes
-  private Boolean isPrivate = false; // v2.0 - Indique si l'événement est privé
-  private Boolean waitlistEnabled = false; // v2.0 - Indique si la liste d'attente est activée
-  private String privacyRules; // Règles de confidentialité de l'événement
-  private String transportInfo; // Informations sur les transports disponibles
-  private String accommodationInfo; // Informations sur l'hébergement
-  private String accessibilityInfo; // Informations sur l'accessibilité
-  private String parkingInfo; // Informations sur le parking
-  private String securityProtocol; // Protocole de sécurité de l'événement
-
   @NotNull(message = "L'identifiant du créateur est obligatoire.")
   private UUID creatorId; // Identifiant du créateur de l'événement
 
-  // Champ déprécié (v1.0) - conservé pour compatibilité mais ignoré
-  /**
-   * @deprecated Supprimé en v2.0 (utiliser establishmentId à la place).
-   */
-  @Deprecated
-  private String location;
-
   public EventCreateRequestDTO() {
     System.out.println("[LOG] DTO de requête de création d'événement initialisé.");
   }
-
-  /**
-   * Méthode pour obtenir le lieu (compatibilité v1.0 et v2.0).
-   * Retourne null car location est déprécié en v2.0.
-   *
-   * @return Le lieu (null en v2.0, utiliser establishmentId à la place).
-   */
-  public String getLocation() {
-    return location; // Retourne null en v2.0
-  }
 }

src/main/java/com/lions/dev/dto/request/events/EventReadManyByIdRequestDTO.java

@@ -16,10 +16,7 @@ import lombok.Setter;
 @AllArgsConstructor
 public class EventReadManyByIdRequestDTO {
 
-  private UUID id; // v2.0 - Identifiant de l'utilisateur pour lequel on souhaite obtenir les événements
+  private UUID userId; // Identifiant de l'utilisateur pour lequel on souhaite obtenir les événements
-
-  private Integer page = 0; // v2.0 - Numéro de la page (0-indexé)
-  private Integer size = 10; // v2.0 - Taille de la page
 
   // Ajoutez ici d'autres critères de filtre si besoin, comme une plage de dates, un statut, etc.
 }

src/main/java/com/lions/dev/dto/request/social/SocialPostCreateRequestDTO.java

@@ -1,35 +0,0 @@
-package com.lions.dev.dto.request.social;
-
-import jakarta.validation.constraints.NotBlank;
-import jakarta.validation.constraints.NotNull;
-import jakarta.validation.constraints.Size;
-import java.util.UUID;
-import lombok.Getter;
-import lombok.Setter;
-
-/**
- * DTO pour la création d'un post social.
- * 
- * Ce DTO est utilisé dans les requêtes de création de posts sociaux,
- * envoyant les informations nécessaires comme le contenu, l'utilisateur
- * créateur, et optionnellement une image.
- */
-@Getter
-@Setter
-public class SocialPostCreateRequestDTO {
-
-  @NotBlank(message = "Le contenu du post est obligatoire.")
-  @Size(max = 2000, message = "Le contenu ne peut pas dépasser 2000 caractères.")
-  private String content; // Le contenu textuel du post
-
-  @NotNull(message = "L'identifiant de l'utilisateur est obligatoire.")
-  private UUID creatorId; // v2.0 - L'ID de l'utilisateur créateur
-
-  @Size(max = 500, message = "L'URL de l'image ne peut pas dépasser 500 caractères.")
-  private String imageUrl; // URL de l'image (optionnel)
-
-  public SocialPostCreateRequestDTO() {
-    System.out.println("[LOG] DTO de requête de création de post social initialisé.");
-  }
-}
-

src/main/java/com/lions/dev/dto/request/story/StoryCreateRequestDTO.java

@@ -1,39 +0,0 @@
-package com.lions.dev.dto.request.story;
-
-import com.lions.dev.entity.story.MediaType;
-import jakarta.validation.constraints.NotBlank;
-import jakarta.validation.constraints.NotNull;
-import jakarta.validation.constraints.Size;
-import java.util.UUID;
-import lombok.Getter;
-import lombok.Setter;
-
-/**
- * DTO pour la création d'une story.
- *
- * Ce DTO est utilisé dans les requêtes de création de stories,
- * envoyant les informations nécessaires comme le média, le type et l'utilisateur.
- */
-@Getter
-@Setter
-public class StoryCreateRequestDTO {
-
-  @NotNull(message = "L'identifiant de l'utilisateur est obligatoire.")
-  private UUID creatorId; // v2.0 - L'ID de l'utilisateur créateur
-
-  @NotNull(message = "Le type de média est obligatoire.")
-  private MediaType mediaType; // Type de média (IMAGE ou VIDEO)
-
-  @NotBlank(message = "L'URL du média est obligatoire.")
-  @Size(max = 500, message = "L'URL du média ne peut pas dépasser 500 caractères.")
-  private String mediaUrl; // URL du média
-
-  @Size(max = 500, message = "L'URL du thumbnail ne peut pas dépasser 500 caractères.")
-  private String thumbnailUrl; // URL du thumbnail (optionnel, pour les vidéos)
-
-  private Integer durationSeconds; // Durée en secondes (optionnel, pour les vidéos)
-
-  public StoryCreateRequestDTO() {
-    System.out.println("[LOG] DTO de requête de création de story initialisé.");
-  }
-}

src/main/java/com/lions/dev/dto/request/users/UserAuthenticateRequestDTO.java

@@ -9,10 +9,6 @@ import org.slf4j.LoggerFactory;
 
 /**
  * DTO pour la requête d'authentification de l'utilisateur.
- * 
- * Version 2.0 - Architecture refactorée avec nommage standardisé.
- * Conforme à l'architecture de données AfterWork v2.0 (Ultra-Compétitive).
- * 
  * Utilisé pour encapsuler les informations nécessaires lors de l'authentification d'un utilisateur.
  */
 @Getter
@@ -29,16 +25,9 @@ public class UserAuthenticateRequestDTO {
   private String email;
 
   /**
-   * Mot de passe hashé de l'utilisateur (v2.0).
+   * Mot de passe de l'utilisateur en texte clair.
-   * Format standardisé pour l'authentification.
+   * Ce champ sera haché avant d'être utilisé pour l'authentification.
    */
-  private String password_hash; // v2.0
-
-  /**
-   * Mot de passe de l'utilisateur en texte clair (v1.0 - déprécié).
-   * @deprecated Utiliser {@link #password_hash} à la place.
-   */
-  @Deprecated
   private String motDePasse;
 
   /**
@@ -48,15 +37,6 @@ public class UserAuthenticateRequestDTO {
     logger.info("UserAuthenticateRequestDTO - DTO pour l'authentification initialisé");
   }
 
-  /**
-   * Méthode pour obtenir le mot de passe (compatibilité v1.0 et v2.0).
-   *
-   * @return Le mot de passe (password_hash ou motDePasse).
-   */
-  public String getPassword() {
-    return password_hash != null ? password_hash : motDePasse;
-  }
-
   // Méthode personnalisée pour loguer les détails de la requête
   public void logRequestDetails() {
     logger.info("Authentification demandée pour l'email: {}", email);

src/main/java/com/lions/dev/dto/request/users/UserCreateRequestDTO.java

@@ -7,25 +7,21 @@ import lombok.Getter;
 import lombok.Setter;
 
 /**
- * DTO pour la création d'un utilisateur.
+ * DTO pour la création et l'authentification d'un utilisateur.
- * 
+ * Ce DTO est utilisé dans les requêtes pour créer ou authentifier un utilisateur,
- * Version 2.0 - Architecture refactorée avec nommage standardisé.
+ * contenant les informations comme le nom, les prénoms, l'email, et le mot de passe.
- * Conforme à l'architecture de données AfterWork v2.0 (Ultra-Compétitive).
- * 
- * Ce DTO est utilisé dans les requêtes pour créer un utilisateur,
- * contenant les informations comme le prénom, le nom, l'email, et le mot de passe.
  */
 @Getter
 @Setter
 public class UserCreateRequestDTO {
 
-  @NotNull(message = "Le prénom est obligatoire.")
+  @NotNull(message = "Le nom est obligatoire.")
-  @Size(min = 1, max = 100, message = "Le prénom doit comporter entre 1 et 100 caractères.")
+  @Size(min = 1, max = 100, message = "Le nom doit comporter entre 1 et 100 caractères.")
-  private String firstName; // v2.0
+  private String nom;
 
-  @NotNull(message = "Le nom de famille est obligatoire.")
+  @NotNull(message = "Les prénoms sont obligatoires.")
-  @Size(min = 1, max = 100, message = "Le nom de famille doit comporter entre 1 et 100 caractères.")
+  @Size(min = 1, max = 100, message = "Les prénoms doivent comporter entre 1 et 100 caractères.")
-  private String lastName; // v2.0
+  private String prenoms;
 
   @NotNull(message = "L'adresse email est obligatoire.")
   @Email(message = "Veuillez fournir une adresse email valide.")
@@ -33,86 +29,11 @@ public class UserCreateRequestDTO {
 
   @NotNull(message = "Le mot de passe est obligatoire.")
   @Size(min = 6, message = "Le mot de passe doit comporter au moins 6 caractères.")
-  private String password; // v2.0 - sera hashé en passwordHash
+  private String motDePasse;
 
   private String profileImageUrl;
 
-  private String bio; // v2.0
-
-  private Integer loyaltyPoints = 0; // v2.0
-
-  /**
-   * Préférences utilisateur (v2.0).
-   * 
-   * Structure attendue:
-   * {
-   *   "preferredCategory": "RESTAURANT" | "BAR" | "CLUB" | "CAFE" | "EVENT" | null,
-   *   "notifications": {
-   *     "email": boolean,
-   *     "push": boolean
-   *   },
-   *   "language": "fr" | "en" | "es"
-   * }
-   * 
-   * Exemple:
-   * {
-   *   "preferredCategory": "RESTAURANT",
-   *   "notifications": {
-   *     "email": true,
-   *     "push": true
-   *   },
-   *   "language": "fr"
-   * }
-   */
-  private java.util.Map<String, Object> preferences; // v2.0
-
   // Ajout du rôle avec validation
   @NotNull(message = "Le rôle est obligatoire.")
-  private String role; // Rôle de l'utilisateur (par exemple : ADMIN, USER, MANAGER, etc.)
+  private String role;  // Rôle de l'utilisateur (par exemple : ADMIN, USER, etc.)
-
-  // Champs de compatibilité v1.0 (dépréciés mais supportés pour migration progressive)
-  /**
-   * @deprecated Utiliser {@link #firstName} à la place.
-   */
-  @Deprecated
-  private String prenoms;
-
-  /**
-   * @deprecated Utiliser {@link #lastName} à la place.
-   */
-  @Deprecated
-  private String nom;
-
-  /**
-   * @deprecated Utiliser {@link #password} à la place.
-   */
-  @Deprecated
-  private String motDePasse;
-
-  /**
-   * Méthode pour obtenir le prénom (compatibilité v1.0 et v2.0).
-   *
-   * @return Le prénom (firstName ou prenoms).
-   */
-  public String getFirstName() {
-    return firstName != null ? firstName : prenoms;
-  }
-
-  /**
-   * Méthode pour obtenir le nom de famille (compatibilité v1.0 et v2.0).
-   *
-   * @return Le nom de famille (lastName ou nom).
-   */
-  public String getLastName() {
-    return lastName != null ? lastName : nom;
-  }
-
-  /**
-   * Méthode pour obtenir le mot de passe (compatibilité v1.0 et v2.0).
-   *
-   * @return Le mot de passe (password ou motDePasse).
-   */
-  public String getPassword() {
-    return password != null ? password : motDePasse;
-  }
 }

src/main/java/com/lions/dev/dto/response/chat/ConversationResponseDTO.java

@@ -1,54 +0,0 @@
-package com.lions.dev.dto.response.chat;
-
-import com.lions.dev.entity.chat.Conversation;
-import com.lions.dev.entity.users.Users;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.Setter;
-
-import java.time.LocalDateTime;
-import java.util.UUID;
-
-/**
- * DTO de réponse pour une conversation.
- */
-@Getter
-@Setter
-@NoArgsConstructor
-public class ConversationResponseDTO {
-
-  private UUID id;
-  private UUID participantId;
-  private String participantFirstName;
-  private String participantLastName;
-  private String participantProfileImageUrl;
-  private String lastMessage;
-  private LocalDateTime lastMessageTimestamp;
-  private int unreadCount;
-  private boolean isTyping;
-
-  /**
-   * Constructeur depuis une entité Conversation.
-   *
-   * @param conversation La conversation
-   * @param currentUser L'utilisateur actuel (pour déterminer l'autre utilisateur)
-   */
-  public ConversationResponseDTO(Conversation conversation, Users currentUser) {
-    this.id = conversation.getId();
-
-    // Déterminer l'autre utilisateur
-    Users otherUser = conversation.getOtherUser(currentUser);
-    if (otherUser != null) {
-      this.participantId = otherUser.getId();
-      // v2.0 - Utiliser les nouveaux noms de champs
-      this.participantFirstName = otherUser.getFirstName();
-      this.participantLastName = otherUser.getLastName();
-      this.participantProfileImageUrl = otherUser.getProfileImageUrl();
-    }
-
-    this.lastMessage = conversation.getLastMessageContent();
-    this.lastMessageTimestamp = conversation.getLastMessageTimestamp();
-    this.unreadCount = conversation.getUnreadCountForUser(currentUser);
-    this.isTyping = false; // Par défaut, pas en train de taper
-  }
-}

src/main/java/com/lions/dev/dto/response/chat/MessageResponseDTO.java

@@ -1,50 +0,0 @@
-package com.lions.dev.dto.response.chat;
-
-import com.lions.dev.entity.chat.Message;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.Setter;
-
-import java.time.LocalDateTime;
-import java.util.UUID;
-
-/**
- * DTO de réponse pour un message.
- */
-@Getter
-@Setter
-@NoArgsConstructor
-public class MessageResponseDTO {
-
-  private UUID id;
-  private UUID conversationId;
-  private UUID senderId;
-  private String senderFirstName;
-  private String senderLastName;
-  private String senderProfileImageUrl;
-  private String content;
-  private String attachmentType;
-  private String attachmentUrl;
-  private boolean isRead;
-  private boolean isDelivered;
-  private LocalDateTime timestamp;
-
-  /**
-   * Constructeur depuis une entité Message (v2.0).
-   */
-  public MessageResponseDTO(Message message) {
-    this.id = message.getId();
-    this.conversationId = message.getConversation().getId();
-    this.senderId = message.getSender().getId();
-    // v2.0 - Utiliser les nouveaux noms de champs
-    this.senderFirstName = message.getSender().getFirstName();
-    this.senderLastName = message.getSender().getLastName();
-    this.senderProfileImageUrl = message.getSender().getProfileImageUrl();
-    this.content = message.getContent();
-    this.attachmentType = message.getMessageType();
-    this.attachmentUrl = message.getMediaUrl();
-    this.isRead = message.isRead();
-    this.isDelivered = message.isDelivered();
-    this.timestamp = message.getCreatedAt();
-  }
-}

src/main/java/com/lions/dev/dto/response/comments/CommentResponseDTO.java

@@ -64,9 +64,8 @@ public class CommentResponseDTO {
       this.id = comment.getId();                     // Identifiant unique du commentaire
       this.texte = comment.getText();                 // Texte du commentaire
       this.userId = comment.getUser().getId();        // Identifiant de l'utilisateur (auteur du commentaire)
-      // v2.0 - Utiliser les nouveaux noms de champs
+      this.userNom = comment.getUser().getNom();      // Nom de l'utilisateur
-      this.userNom = comment.getUser().getLastName();      // Nom de famille de l'utilisateur (v2.0)
+      this.userPrenoms = comment.getUser().getPrenoms(); // Prénom de l'utilisateur
-      this.userPrenoms = comment.getUser().getFirstName(); // Prénom de l'utilisateur (v2.0)
     }
   }
 }

src/main/java/com/lions/dev/dto/response/establishment/EstablishmentMediaResponseDTO.java

@@ -1,67 +0,0 @@
-package com.lions.dev.dto.response.establishment;
-
-import com.lions.dev.entity.establishment.EstablishmentMedia;
-import lombok.Getter;
-
-import java.time.LocalDateTime;
-import java.util.UUID;
-
-/**
- * DTO pour renvoyer les informations d'un média d'établissement.
- */
-@Getter
-public class EstablishmentMediaResponseDTO {
-
-    private String id;
-    private String establishmentId;
-    private String mediaUrl;
-    private String mediaType; // "PHOTO" ou "VIDEO"
-    private String thumbnailUrl;
-    private MediaUploaderDTO uploadedBy;
-    private LocalDateTime uploadedAt;
-    private Integer displayOrder;
-
-    /**
-     * Constructeur qui transforme une entité EstablishmentMedia en DTO.
-     *
-     * @param media Le média à convertir en DTO.
-     */
-    public EstablishmentMediaResponseDTO(EstablishmentMedia media) {
-        this.id = media.getId().toString();
-        this.establishmentId = media.getEstablishment().getId().toString();
-        this.mediaUrl = media.getMediaUrl();
-        this.mediaType = media.getMediaType().name();
-        this.thumbnailUrl = media.getThumbnailUrl();
-        this.uploadedAt = media.getUploadedAt();
-        this.displayOrder = media.getDisplayOrder();
-
-        if (media.getUploadedBy() != null) {
-            // v2.0 - Utiliser les nouveaux noms de champs
-            this.uploadedBy = new MediaUploaderDTO(
-                    media.getUploadedBy().getId().toString(),
-                    media.getUploadedBy().getFirstName(),
-                    media.getUploadedBy().getLastName(),
-                    media.getUploadedBy().getProfileImageUrl()
-            );
-        }
-    }
-
-    /**
-     * DTO interne pour les informations de l'uploader.
-     */
-    @Getter
-    public static class MediaUploaderDTO {
-        private final String id;
-        private final String firstName;
-        private final String lastName;
-        private final String profileImageUrl;
-
-        public MediaUploaderDTO(String id, String firstName, String lastName, String profileImageUrl) {
-            this.id = id;
-            this.firstName = firstName;
-            this.lastName = lastName;
-            this.profileImageUrl = profileImageUrl;
-        }
-    }
-}
-

src/main/java/com/lions/dev/dto/response/establishment/EstablishmentRatingResponseDTO.java

@@ -1,37 +0,0 @@
-package com.lions.dev.dto.response.establishment;
-
-import com.lions.dev.entity.establishment.EstablishmentRating;
-import lombok.Getter;
-
-import java.time.LocalDateTime;
-
-/**
- * DTO pour renvoyer les informations d'une note d'établissement.
- */
-@Getter
-public class EstablishmentRatingResponseDTO {
-
-    private String id;
-    private String establishmentId;
-    private String userId;
-    private Integer rating;
-    private String comment;
-    private LocalDateTime ratedAt;
-    private LocalDateTime updatedAt;
-
-    /**
-     * Constructeur qui transforme une entité EstablishmentRating en DTO.
-     *
-     * @param rating La note à convertir en DTO.
-     */
-    public EstablishmentRatingResponseDTO(EstablishmentRating rating) {
-        this.id = rating.getId().toString();
-        this.establishmentId = rating.getEstablishment().getId().toString();
-        this.userId = rating.getUser().getId().toString();
-        this.rating = rating.getRating();
-        this.comment = rating.getComment();
-        this.ratedAt = rating.getRatedAt();
-        this.updatedAt = rating.getUpdatedAt();
-    }
-}
-

src/main/java/com/lions/dev/dto/response/establishment/EstablishmentRatingStatsResponseDTO.java

@@ -1,30 +0,0 @@
-package com.lions.dev.dto.response.establishment;
-
-import lombok.Getter;
-
-import java.util.Map;
-
-/**
- * DTO pour renvoyer les statistiques de notation d'un établissement.
- */
-@Getter
-public class EstablishmentRatingStatsResponseDTO {
-
-    private Double averageRating; // Note moyenne (0.0 à 5.0)
-    private Integer totalRatings; // Nombre total de notes
-    private Map<Integer, Integer> distribution; // Distribution par étoile {5: 10, 4: 5, ...}
-
-    /**
-     * Constructeur pour créer les statistiques de notation.
-     *
-     * @param averageRating La note moyenne
-     * @param totalRatings Le nombre total de notes
-     * @param distribution La distribution des notes par étoile
-     */
-    public EstablishmentRatingStatsResponseDTO(Double averageRating, Integer totalRatings, Map<Integer, Integer> distribution) {
-        this.averageRating = averageRating;
-        this.totalRatings = totalRatings;
-        this.distribution = distribution;
-    }
-}
-

src/main/java/com/lions/dev/dto/response/establishment/EstablishmentResponseDTO.java

@@ -1,143 +0,0 @@
-package com.lions.dev.dto.response.establishment;
-
-import com.lions.dev.entity.establishment.Establishment;
-import com.lions.dev.entity.establishment.MediaType;
-import lombok.Getter;
-import java.time.LocalDateTime;
-import java.util.UUID;
-
-/**
- * DTO pour renvoyer les informations d'un établissement.
- * 
- * Version 2.0 - Architecture refactorée avec nommage standardisé.
- * Conforme à l'architecture de données AfterWork v2.0 (Ultra-Compétitive).
- * 
- * Ce DTO est utilisé pour structurer les données retournées dans les réponses
- * après les opérations sur les établissements (création, récupération, mise à jour).
- */
-@Getter
-public class EstablishmentResponseDTO {
-
-  private String id;
-  private String name;
-  private String type;
-  private String address;
-  private String city;
-  private String postalCode;
-  private String description;
-  private String phoneNumber;
-  private String website;
-  private Double averageRating; // Note moyenne calculée
-  private Integer totalReviewsCount; // v2.0 - renommé depuis totalRatingsCount
-  private String priceRange;
-  private String verificationStatus; // v2.0 - PENDING, VERIFIED, REJECTED
-  private Double latitude;
-  private Double longitude;
-  private String managerId;
-  private String managerEmail;
-  private String managerFirstName; // v2.0
-  private String managerLastName; // v2.0
-  private String mainImageUrl; // v2.0 - URL de l'image principale (premier média avec displayOrder 0)
-  private LocalDateTime createdAt;
-  private LocalDateTime updatedAt;
-
-  // Champs dépréciés (v1.0) - conservés pour compatibilité
-  /**
-   * @deprecated Utiliser {@link #averageRating} à la place.
-   */
-  @Deprecated
-  private Double rating;
-
-  /**
-   * @deprecated Supprimé en v2.0 (utiliser manager.email à la place).
-   */
-  @Deprecated
-  private String email;
-
-  /**
-   * @deprecated Supprimé en v2.0 (utiliser establishment_media à la place).
-   */
-  @Deprecated
-  private String imageUrl;
-
-  /**
-   * @deprecated Supprimé en v2.0.
-   */
-  @Deprecated
-  private Integer capacity;
-
-  /**
-   * @deprecated Supprimé en v2.0 (utiliser establishment_amenities à la place).
-   */
-  @Deprecated
-  private String amenities;
-
-  /**
-   * @deprecated Supprimé en v2.0 (utiliser business_hours à la place).
-   */
-  @Deprecated
-  private String openingHours;
-
-  /**
-   * @deprecated Utiliser {@link #totalReviewsCount} à la place.
-   */
-  @Deprecated
-  private Integer totalRatingsCount;
-
-  /**
-   * Constructeur qui transforme une entité Establishment en DTO (v2.0).
-   *
-   * @param establishment L'établissement à convertir en DTO.
-   */
-  public EstablishmentResponseDTO(Establishment establishment) {
-    this.id = establishment.getId().toString();
-    this.name = establishment.getName();
-    this.type = establishment.getType();
-    this.address = establishment.getAddress();
-    this.city = establishment.getCity();
-    this.postalCode = establishment.getPostalCode();
-    this.description = establishment.getDescription();
-    this.phoneNumber = establishment.getPhoneNumber();
-    this.website = establishment.getWebsite();
-    this.averageRating = establishment.getAverageRating();
-    this.totalReviewsCount = establishment.getTotalReviewsCount(); // v2.0
-    this.priceRange = establishment.getPriceRange();
-    this.verificationStatus = establishment.getVerificationStatus(); // v2.0
-    this.latitude = establishment.getLatitude();
-    this.longitude = establishment.getLongitude();
-    
-    if (establishment.getManager() != null) {
-      this.managerId = establishment.getManager().getId().toString();
-      this.managerEmail = establishment.getManager().getEmail();
-      this.managerFirstName = establishment.getManager().getFirstName(); // v2.0
-      this.managerLastName = establishment.getManager().getLastName(); // v2.0
-    }
-    
-    // Récupérer l'image principale (premier média photo avec displayOrder 0 ou le premier disponible)
-    if (establishment.getMedias() != null && !establishment.getMedias().isEmpty()) {
-      this.mainImageUrl = establishment.getMedias().stream()
-          .filter(media -> media.getMediaType() == MediaType.PHOTO)
-          .sorted((a, b) -> Integer.compare(
-              a.getDisplayOrder() != null ? a.getDisplayOrder() : Integer.MAX_VALUE,
-              b.getDisplayOrder() != null ? b.getDisplayOrder() : Integer.MAX_VALUE))
-          .map(media -> media.getMediaUrl())
-          .findFirst()
-          .orElse(null);
-    } else {
-      this.mainImageUrl = null;
-    }
-    
-    this.createdAt = establishment.getCreatedAt();
-    this.updatedAt = establishment.getUpdatedAt();
-
-    // Compatibilité v1.0 - valeurs null pour les champs dépréciés
-    this.rating = null;
-    this.email = null;
-    this.imageUrl = null;
-    this.capacity = null;
-    this.amenities = null;
-    this.openingHours = null;
-    this.totalRatingsCount = this.totalReviewsCount; // Alias pour compatibilité
-  }
-}
-

src/main/java/com/lions/dev/dto/response/events/EventCreateResponseDTO.java

@@ -1,16 +1,10 @@
 package com.lions.dev.dto.response.events;
 
 import com.lions.dev.entity.events.Events;
-import com.lions.dev.repository.UsersRepository;
 import java.time.LocalDateTime;
-import java.util.UUID;
 
 /**
  * DTO pour renvoyer les informations d'un événement.
- * 
- * Version 2.0 - Architecture refactorée avec nommage standardisé.
- * Conforme à l'architecture de données AfterWork v2.0 (Ultra-Compétitive).
- * 
  * Ce DTO est utilisé pour structurer les données retournées dans les réponses
  * après les opérations sur les événements (création, récupération).
  */
@@ -22,89 +16,33 @@ public class EventCreateResponseDTO {
   private String description; // Description de l'événement
   private LocalDateTime startDate; // Date de début de l'événement
   private LocalDateTime endDate; // Date de fin de l'événement
-  private String establishmentId; // v2.0 - ID de l'établissement où se déroule l'événement
+  private String location; // Lieu de l'événement
-  private String establishmentName; // v2.0 - Nom de l'établissement
   private String category; // Catégorie de l'événement
   private String link; // Lien vers plus d'informations
   private String imageUrl; // URL d'une image pour l'événement
-  private String creatorId; // ID du créateur de l'événement
   private String creatorEmail; // Email du créateur de l'événement
-  private String creatorFirstName; // v2.0 - Prénom du créateur de l'événement
+  private String creatorFirstName; // Prénom du créateur de l'événement
-  private String creatorLastName; // v2.0 - Nom de famille du créateur de l'événement
+  private String creatorLastName; // Nom de famille du création de l'événement
-  private String status; // Statut de l'événement (OPEN, CLOSED, CANCELLED, COMPLETED)
+  private String status; // Statut de l'événement
-  private Boolean isPrivate; // v2.0 - Indique si l'événement est privé
-  private Boolean waitlistEnabled; // v2.0 - Indique si la liste d'attente est activée
-  private Integer maxParticipants; // Nombre maximum de participants autorisés
-  private Integer participationFee; // Frais de participation en centimes
-  private Long reactionsCount; // ✅ Nombre de réactions (utilisateurs qui ont cet événement en favori)
-  private Boolean isFavorite; // ✅ Indique si l'utilisateur actuel a cet événement en favori (optionnel, dépend du contexte)
-
-  // Champ déprécié (v1.0) - conservé pour compatibilité
-  /**
-   * @deprecated Utiliser {@link #establishmentId} et {@link #establishmentName} à la place.
-   */
-  @Deprecated
-  private String location;
 
   /**
-   * Constructeur qui transforme une entité Events en DTO (v2.0).
+   * Constructeur qui transforme une entité Events en DTO.
-   * Utilise UsersRepository pour calculer reactionsCount et isFavorite.
    *
    * @param event L'événement à convertir en DTO.
-   * @param usersRepository Le repository pour compter les réactions (peut être null).
-   * @param currentUserId L'ID de l'utilisateur actuel pour vérifier isFavorite (peut être null).
    */
-  public EventCreateResponseDTO(Events event, UsersRepository usersRepository, UUID currentUserId) {
+  public EventCreateResponseDTO(Events event) {
     this.id = event.getId().toString();
     this.title = event.getTitle();
     this.description = event.getDescription();
     this.startDate = event.getStartDate();
     this.endDate = event.getEndDate();
+    this.location = event.getLocation();
     this.category = event.getCategory();
     this.link = event.getLink();
     this.imageUrl = event.getImageUrl();
-    this.status = event.getStatus();
-    this.isPrivate = event.getIsPrivate(); // v2.0
-    this.waitlistEnabled = event.getWaitlistEnabled(); // v2.0
-    this.maxParticipants = event.getMaxParticipants();
-    this.participationFee = event.getParticipationFee();
-    
-    // ✅ Calculer reactionsCount si usersRepository est fourni
-    if (usersRepository != null) {
-      this.reactionsCount = usersRepository.countUsersWithFavoriteEvent(event.getId());
-    } else {
-      this.reactionsCount = 0L;
-    }
-    
-    // ✅ Vérifier isFavorite si currentUserId est fourni
-    if (currentUserId != null && usersRepository != null) {
-      this.isFavorite = usersRepository.hasUserFavoriteEvent(currentUserId, event.getId());
-    } else {
-      this.isFavorite = null;
-    }
-    
-    // v2.0 - Informations sur l'établissement
-    if (event.getEstablishment() != null) {
-      this.establishmentId = event.getEstablishment().getId().toString();
-      this.establishmentName = event.getEstablishment().getName();
-      this.location = event.getLocation(); // Méthode qui retourne l'adresse de l'établissement
-    }
-    
-    // v2.0 - Informations sur le créateur
-    if (event.getCreator() != null) {
-      this.creatorId = event.getCreator().getId().toString();
     this.creatorEmail = event.getCreator().getEmail();
-      this.creatorFirstName = event.getCreator().getFirstName(); // v2.0
+    this.creatorFirstName = event.getCreator().getPrenoms();
-      this.creatorLastName = event.getCreator().getLastName(); // v2.0
+    this.creatorLastName = event.getCreator().getNom();
-    }
+    this.status = event.getStatus();
-  }
-
-  /**
-   * Constructeur simplifié sans calcul de réactions (pour compatibilité).
-   *
-   * @param event L'événement à convertir en DTO.
-   */
-  public EventCreateResponseDTO(Events event) {
-    this(event, null, null);
   }
 }

src/main/java/com/lions/dev/dto/response/events/EventReadManyByIdResponseDTO.java

@@ -27,7 +27,7 @@ public class EventReadManyByIdResponseDTO {
   private String profileImageUrl; // URL de l'image de profil de l'utilisateur qui a criané l'événement
 
   /**
-   * Constructeur qui transforme une entité Events en DTO de réponse (v2.0).
+   * Constructeur qui transforme une entité Events en DTO de réponse.
    *
    * @param event L'événement à convertir en DTO.
    */
@@ -37,16 +37,14 @@ public class EventReadManyByIdResponseDTO {
     this.description = event.getDescription();
     this.startDate = event.getStartDate();
     this.endDate = event.getEndDate();
-    // v2.0 - Utiliser getLocation() qui retourne l'adresse de l'établissement
     this.location = event.getLocation();
     this.category = event.getCategory();
     this.link = event.getLink();
     this.imageUrl = event.getImageUrl();
     this.status = event.getStatus();
     this.creatorEmail = event.getCreator().getEmail();
-    // v2.0 - Utiliser les nouveaux noms de champs
+    this.creatorFirstName = event.getCreator().getPrenoms();
-    this.creatorFirstName = event.getCreator().getFirstName();
+    this.creatorLastName = event.getCreator().getNom();
-    this.creatorLastName = event.getCreator().getLastName();
     this.profileImageUrl = event.getCreator().getProfileImageUrl();
   }
 }

src/main/java/com/lions/dev/dto/response/friends/FriendshipReadStatusResponseDTO.java

@@ -36,12 +36,11 @@ public class FriendshipReadStatusResponseDTO {
   public FriendshipReadStatusResponseDTO(Friendship friendship) {
     this.friendshipId = friendship.getId();
     this.userId = friendship.getUser().getId();
-    // v2.0 - Utiliser les nouveaux noms de champs
+    this.userNom = friendship.getUser().getNom();
-    this.userNom = friendship.getUser().getLastName();
+    this.userPrenoms = friendship.getUser().getPrenoms();
-    this.userPrenoms = friendship.getUser().getFirstName();
     this.friendId = friendship.getFriend().getId();
-    this.friendNom = friendship.getFriend().getLastName();
+    this.friendNom = friendship.getFriend().getNom();
-    this.friendPrenoms = friendship.getFriend().getFirstName();
+    this.friendPrenoms = friendship.getFriend().getPrenoms();
     this.status = friendship.getStatus();
     this.createdAt = friendship.getCreatedAt();
   }

src/main/java/com/lions/dev/dto/response/notifications/NotificationResponseDTO.java

@@ -1,52 +0,0 @@
-package com.lions.dev.dto.response.notifications;
-
-import com.lions.dev.entity.notification.Notification;
-import java.time.LocalDateTime;
-import java.util.UUID;
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.Setter;
-
-/**
- * DTO (Data Transfer Object) pour la réponse d'une notification.
- * 
- * Cette classe sert de représentation simplifiée d'une notification
- * pour la réponse de l'API.
- */
-@Getter
-@Setter
-@NoArgsConstructor
-@AllArgsConstructor
-public class NotificationResponseDTO {
-
-  private UUID id;
-  private String title;
-  private String message;
-  private String type;
-  private boolean isRead;
-  private LocalDateTime timestamp;
-  private UUID userId;
-  private UUID eventId; // Optionnel
-  private String metadata; // Optionnel
-
-  /**
-   * Constructeur à partir d'une entité Notification.
-   *
-   * @param notification L'entité Notification
-   */
-  public NotificationResponseDTO(Notification notification) {
-    if (notification != null) {
-      this.id = notification.getId();
-      this.title = notification.getTitle();
-      this.message = notification.getMessage();
-      this.type = notification.getType();
-      this.isRead = notification.isRead();
-      this.timestamp = notification.getCreatedAt();
-      this.userId = notification.getUser() != null ? notification.getUser().getId() : null;
-      this.eventId = notification.getEvent() != null ? notification.getEvent().getId() : null;
-      this.metadata = notification.getMetadata();
-    }
-  }
-}
-

src/main/java/com/lions/dev/dto/response/social/SocialPostResponseDTO.java

@@ -1,57 +0,0 @@
-package com.lions.dev.dto.response.social;
-
-import com.lions.dev.entity.social.SocialPost;
-import java.time.LocalDateTime;
-import java.util.UUID;
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.Setter;
-
-/**
- * DTO (Data Transfer Object) pour la réponse d'un post social.
- * 
- * Cette classe sert de représentation simplifiée d'un post social
- * pour la réponse de l'API.
- */
-@Getter
-@Setter
-@NoArgsConstructor
-@AllArgsConstructor
-public class SocialPostResponseDTO {
-
-  private UUID id;
-  private String content;
-  private UUID userId;
-  private String userFirstName;
-  private String userLastName;
-  private String userProfileImageUrl;
-  private LocalDateTime timestamp;
-  private String imageUrl; // Optionnel
-  private int likesCount;
-  private int commentsCount;
-  private int sharesCount;
-
-  /**
-   * Constructeur à partir d'une entité SocialPost (v2.0).
-   *
-   * @param post L'entité SocialPost
-   */
-  public SocialPostResponseDTO(SocialPost post) {
-    if (post != null) {
-      this.id = post.getId();
-      this.content = post.getContent();
-      this.userId = post.getUser() != null ? post.getUser().getId() : null;
-      // v2.0 - Utiliser les nouveaux noms de champs
-      this.userFirstName = post.getUser() != null ? post.getUser().getFirstName() : null;
-      this.userLastName = post.getUser() != null ? post.getUser().getLastName() : null;
-      this.userProfileImageUrl = post.getUser() != null ? post.getUser().getProfileImageUrl() : null;
-      this.timestamp = post.getCreatedAt();
-      this.imageUrl = post.getImageUrl();
-      this.likesCount = post.getLikesCount();
-      this.commentsCount = post.getCommentsCount();
-      this.sharesCount = post.getSharesCount();
-    }
-  }
-}
-

src/main/java/com/lions/dev/dto/response/story/StoryResponseDTO.java

@@ -1,78 +0,0 @@
-package com.lions.dev.dto.response.story;
-
-import com.lions.dev.entity.story.MediaType;
-import com.lions.dev.entity.story.Story;
-import java.time.LocalDateTime;
-import java.util.UUID;
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.Setter;
-
-/**
- * DTO (Data Transfer Object) pour la réponse d'une story.
- *
- * Cette classe sert de représentation simplifiée d'une story
- * pour la réponse de l'API.
- */
-@Getter
-@Setter
-@NoArgsConstructor
-@AllArgsConstructor
-public class StoryResponseDTO {
-
-  private UUID id;
-  private UUID userId;
-  private String userFirstName;
-  private String userLastName;
-  private String userProfileImageUrl;
-  private boolean userIsVerified;
-  private MediaType mediaType;
-  private String mediaUrl;
-  private String thumbnailUrl;
-  private Integer durationSeconds;
-  private LocalDateTime createdAt;
-  private LocalDateTime expiresAt;
-  private boolean isActive;
-  private int viewsCount;
-  private boolean hasViewed; // Indique si l'utilisateur actuel a vu cette story
-
-  /**
-   * Constructeur à partir d'une entité Story.
-   *
-   * @param story L'entité Story
-   */
-  public StoryResponseDTO(Story story) {
-    if (story != null) {
-      this.id = story.getId();
-      this.userId = story.getUser() != null ? story.getUser().getId() : null;
-      // v2.0 - Utiliser les nouveaux noms de champs
-      this.userFirstName = story.getUser() != null ? story.getUser().getFirstName() : null;
-      this.userLastName = story.getUser() != null ? story.getUser().getLastName() : null;
-      this.userProfileImageUrl = story.getUser() != null ? story.getUser().getProfileImageUrl() : null;
-      this.userIsVerified = story.getUser() != null && story.getUser().isVerified();
-      this.mediaType = story.getMediaType();
-      this.mediaUrl = story.getMediaUrl();
-      this.thumbnailUrl = story.getThumbnailUrl();
-      this.durationSeconds = story.getDurationSeconds();
-      this.createdAt = story.getCreatedAt();
-      this.expiresAt = story.getExpiresAt();
-      this.isActive = story.isActive();
-      this.viewsCount = story.getViewsCount();
-      this.hasViewed = false; // Par défaut, sera mis à jour par la logique métier
-    }
-  }
-
-  /**
-   * Constructeur à partir d'une entité Story avec indication si l'utilisateur l'a vue.
-   *
-   * @param story L'entité Story
-   * @param viewerId L'ID de l'utilisateur actuel
-   */
-  public StoryResponseDTO(Story story, UUID viewerId) {
-    this(story);
-    if (story != null && viewerId != null) {
-      this.hasViewed = story.hasBeenViewedBy(viewerId);
-    }
-  }
-}

src/main/java/com/lions/dev/dto/response/users/FriendSuggestionResponseDTO.java

@@ -1,103 +0,0 @@
-package com.lions.dev.dto.response.users;
-
-import com.lions.dev.entity.users.Users;
-import java.util.UUID;
-
-/**
- * DTO de réponse pour les suggestions d'amis.
- *
- * Ce DTO contient les informations essentielles d'un utilisateur suggéré,
- * incluant le nombre d'amis communs pour justifier la suggestion.
- */
-public class FriendSuggestionResponseDTO {
-
-  private UUID userId;
-  private String nom;
-  private String prenoms;
-  private String email;
-  private String profileImageUrl;
-  private int mutualFriendsCount;
-  private String suggestionReason;
-
-  /**
-   * Constructeur par défaut.
-   */
-  public FriendSuggestionResponseDTO() {
-  }
-
-  /**
-   * Constructeur à partir d'un utilisateur (v2.0).
-   *
-   * @param user L'utilisateur suggéré
-   * @param mutualFriendsCount Le nombre d'amis en commun
-   * @param reason La raison de la suggestion
-   */
-  public FriendSuggestionResponseDTO(Users user, int mutualFriendsCount, String reason) {
-    this.userId = user.getId();
-    // v2.0 - Utiliser les nouveaux noms de champs
-    this.nom = user.getLastName(); // Compatibilité v1.0
-    this.prenoms = user.getFirstName(); // Compatibilité v1.0
-    this.email = user.getEmail();
-    this.profileImageUrl = user.getProfileImageUrl();
-    this.mutualFriendsCount = mutualFriendsCount;
-    this.suggestionReason = reason;
-  }
-
-  // Getters et Setters
-
-  public UUID getUserId() {
-    return userId;
-  }
-
-  public void setUserId(UUID userId) {
-    this.userId = userId;
-  }
-
-  public String getNom() {
-    return nom;
-  }
-
-  public void setNom(String nom) {
-    this.nom = nom;
-  }
-
-  public String getPrenoms() {
-    return prenoms;
-  }
-
-  public void setPrenoms(String prenoms) {
-    this.prenoms = prenoms;
-  }
-
-  public String getEmail() {
-    return email;
-  }
-
-  public void setEmail(String email) {
-    this.email = email;
-  }
-
-  public String getProfileImageUrl() {
-    return profileImageUrl;
-  }
-
-  public void setProfileImageUrl(String profileImageUrl) {
-    this.profileImageUrl = profileImageUrl;
-  }
-
-  public int getMutualFriendsCount() {
-    return mutualFriendsCount;
-  }
-
-  public void setMutualFriendsCount(int mutualFriendsCount) {
-    this.mutualFriendsCount = mutualFriendsCount;
-  }
-
-  public String getSuggestionReason() {
-    return suggestionReason;
-  }
-
-  public void setSuggestionReason(String suggestionReason) {
-    this.suggestionReason = suggestionReason;
-  }
-}

src/main/java/com/lions/dev/dto/response/users/UserAuthenticateResponseDTO.java

@@ -10,33 +10,30 @@ import org.slf4j.LoggerFactory;
 
 /**
  * DTO pour la réponse d'authentification de l'utilisateur.
- * 
- * Version 2.0 - Architecture refactorée avec nommage standardisé.
- * Conforme à l'architecture de données AfterWork v2.0 (Ultra-Compétitive).
- * 
  * Utilisé pour renvoyer les informations nécessaires après l'authentification réussie d'un utilisateur.
  */
 @Getter
 @Setter
+@AllArgsConstructor
 @NoArgsConstructor
 public class UserAuthenticateResponseDTO {
 
   private static final Logger logger = LoggerFactory.getLogger(UserAuthenticateResponseDTO.class);
 
   /**
-   * Identifiant unique de l'utilisateur authentifié (v2.0).
+   * Identifiant unique de l'utilisateur authentifié.
    */
-  private UUID id; // v2.0
+  private UUID userId;
 
   /**
-   * Prénom de l'utilisateur (v2.0).
+   * Nom de l'utilisateur.
    */
-  private String firstName; // v2.0
+  private String nom;
 
   /**
-   * Nom de famille de l'utilisateur (v2.0).
+   * Prénom de l'utilisateur.
    */
-  private String lastName; // v2.0
+  private String prenoms;
 
   /**
    * Adresse email de l'utilisateur.
@@ -48,49 +45,6 @@ public class UserAuthenticateResponseDTO {
    */
   private String role;
 
-  // Champs de compatibilité v1.0 (dépréciés)
-  /**
-   * @deprecated Utiliser {@link #id} à la place.
-   */
-  @Deprecated
-  private UUID userId;
-
-  /**
-   * @deprecated Utiliser {@link #lastName} à la place.
-   */
-  @Deprecated
-  private String nom;
-
-  /**
-   * @deprecated Utiliser {@link #firstName} à la place.
-   */
-  @Deprecated
-  private String prenoms;
-
-  /**
-   * Constructeur v2.0.
-   */
-  public UserAuthenticateResponseDTO(UUID id, String firstName, String lastName, String email, String role) {
-    this.id = id;
-    this.firstName = firstName;
-    this.lastName = lastName;
-    this.email = email;
-    this.role = role;
-    // Compatibilité v1.0
-    this.userId = id;
-    this.nom = lastName;
-    this.prenoms = firstName;
-  }
-
-  /**
-   * Constructeur de compatibilité v1.0 (déprécié).
-   * @deprecated Utiliser le constructeur avec firstName et lastName à la place.
-   */
-  @Deprecated
-  public UserAuthenticateResponseDTO(UUID userId, String prenoms, String nom, String email, String role, boolean deprecated) {
-    this(userId, prenoms, nom, email, role);
-  }
-
   /**
    * Log de création de l'objet DTO.
    */
@@ -99,10 +53,9 @@ public class UserAuthenticateResponseDTO {
   }
 
   /**
-   * Méthode personnalisée pour loguer les détails de la réponse (v2.0).
+   * Méthode personnalisée pour loguer les détails de la réponse.
    */
   public void logResponseDetails() {
-    logger.info("[LOG] Réponse d'authentification - Utilisateur: {} {}, Email: {}, Rôle: {}, ID: {}", 
+    logger.info("[LOG] Réponse d'authentification - Utilisateur: {}, {}, Email: {}, Rôle: {}, ID: {}", prenoms, nom, email, role, userId);
-        firstName, lastName, email, role, id);
   }
 }

src/main/java/com/lions/dev/dto/response/users/UserCreateResponseDTO.java

@@ -6,66 +6,30 @@ import lombok.Getter;
 
 /**
  * DTO pour renvoyer les informations d'un utilisateur.
- * 
- * Version 2.0 - Architecture refactorée avec nommage standardisé.
- * Conforme à l'architecture de données AfterWork v2.0 (Ultra-Compétitive).
- * 
  * Ce DTO est utilisé pour structurer les données retournées dans les réponses
  * après les opérations sur les utilisateurs (création, récupération).
  */
 @Getter
 public class UserCreateResponseDTO {
 
-  private UUID id; // v2.0 - Identifiant unique de l'utilisateur
+  private UUID uuid;  // Identifiant unique de l'utilisateur
-  private String firstName; // v2.0 - Prénom de l'utilisateur
+  private String nom; // Nom de l'utilisateur
-  private String lastName; // v2.0 - Nom de famille de l'utilisateur
+  private String prenoms; // Prénoms de l'utilisateur
   private String email; // Email de l'utilisateur
-  private String role; // Rôle de l'utilisateur
+  private String role; // Roğe de l'utilisateur
-  private String profileImageUrl; // URL de l'image de profil de l'utilisateur
+  private String profileImageUrl; // Url de l'image de profil de l'utilisateur
-  private String bio; // v2.0 - Biographie courte
-  private Integer loyaltyPoints; // v2.0 - Points de fidélité
-  private java.util.Map<String, Object> preferences; // v2.0 - Préférences utilisateur
-
-  // Champs de compatibilité v1.0 (dépréciés)
   /**
-   * @deprecated Utiliser {@link #id} à la place.
+   * Constructeur qui transforme une entité Users en DTO.
-   */
-  @Deprecated
-  private UUID uuid;
-
-  /**
-   * @deprecated Utiliser {@link #lastName} à la place.
-   */
-  @Deprecated
-  private String nom;
-
-  /**
-   * @deprecated Utiliser {@link #firstName} à la place.
-   */
-  @Deprecated
-  private String prenoms;
-
-  /**
-   * Constructeur qui transforme une entité Users en DTO (v2.0).
    *
    * @param user L'utilisateur à convertir en DTO.
    */
   public UserCreateResponseDTO(Users user) {
-    this.id = user.getId(); // v2.0
+    this.uuid = user.getId();
-    this.firstName = user.getFirstName(); // v2.0
+    this.nom = user.getNom();
-    this.lastName = user.getLastName(); // v2.0
+    this.prenoms = user.getPrenoms();
     this.email = user.getEmail();
     this.role = user.getRole();
     this.profileImageUrl = user.getProfileImageUrl();
-    this.bio = user.getBio(); // v2.0
-    this.loyaltyPoints = user.getLoyaltyPoints(); // v2.0
-    this.preferences = user.getPreferences(); // v2.0
-
-    // Compatibilité v1.0
-    this.uuid = this.id;
-    this.nom = this.lastName;
-    this.prenoms = this.firstName;
-
     System.out.println("[LOG] DTO créé pour l'utilisateur : " + this.email);
   }
 }

src/main/java/com/lions/dev/dto/response/users/UserResponseDTO.java

@@ -9,10 +9,6 @@ import lombok.Setter;
 
 /**
  * DTO (Data Transfer Object) pour l'utilisateur.
- * 
- * Version 2.0 - Architecture refactorée avec nommage standardisé.
- * Conforme à l'architecture de données AfterWork v2.0 (Ultra-Compétitive).
- * 
  * <p>
  * Cette classe sert de représentation simplifiée d'un utilisateur, avec un ensemble d'informations nécessaires à 
  * la réponse de l'API. Elle est utilisée pour transférer des données entre le backend (serveur) et le frontend (client)
@@ -31,14 +27,14 @@ public class UserResponseDTO {
   private UUID id;
 
   /**
-   * Prénom de l'utilisateur (v2.0).
+   * Nom de famille de l'utilisateur. C'est une donnée importante pour l'affichage du profil.
    */
-  private String firstName;
+  private String nom;
 
   /**
-   * Nom de famille de l'utilisateur (v2.0).
+   * Prénom(s) de l'utilisateur. Représente le ou les prénoms associés à l'utilisateur.
    */
-  private String lastName;
+  private String prenoms;
 
   /**
    * Adresse email de l'utilisateur. C'est une donnée souvent utilisée pour les communications.
@@ -52,47 +48,7 @@ public class UserResponseDTO {
   private String profileImageUrl;
 
   /**
-   * Biographie courte de l'utilisateur (v2.0).
+   * Constructeur de DTO à partir d'une entité Users.
-   */
-  private String bio;
-
-  /**
-   * Points de fidélité accumulés (v2.0).
-   */
-  private Integer loyaltyPoints;
-
-  /**
-   * Préférences utilisateur en JSON (v2.0).
-   */
-  private java.util.Map<String, Object> preferences;
-
-  /**
-   * Rôle de l'utilisateur (ADMIN, USER, MANAGER, etc.).
-   */
-  private String role;
-
-  /**
-   * Indique si l'utilisateur est vérifié (compte officiel).
-   */
-  private boolean isVerified;
-
-  /**
-   * Indique si l'utilisateur est actuellement en ligne.
-   */
-  private boolean isOnline;
-
-  /**
-   * Dernière fois que l'utilisateur était en ligne.
-   */
-  private java.time.LocalDateTime lastSeen;
-
-  /**
-   * Date de création du compte.
-   */
-  private java.time.LocalDateTime createdAt;
-
-  /**
-   * Constructeur de DTO à partir d'une entité Users (v2.0).
    * <p>
    * Ce constructeur prend une entité {@link Users} et extrait les données nécessaires pour
    * peupler les champs du DTO. Cette transformation permet de transférer des données sans exposer
@@ -103,28 +59,11 @@ public class UserResponseDTO {
    */
   public UserResponseDTO(Users user) {
     if (user != null) {
-      this.id = user.getId();
+      this.id = user.getId();                      // Identifiant unique de l'utilisateur
-      this.firstName = user.getFirstName();        // v2.0
+      this.nom = user.getNom();                    // Nom de famille
-      this.lastName = user.getLastName();          // v2.0
+      this.prenoms = user.getPrenoms();            // Prénom(s)
-      this.email = user.getEmail();
+      this.email = user.getEmail();                // Email
-      this.profileImageUrl = user.getProfileImageUrl();
+      this.profileImageUrl = user.getProfileImageUrl(); // URL de l'image de profil
-      this.bio = user.getBio();                    // v2.0
-      this.loyaltyPoints = user.getLoyaltyPoints(); // v2.0
-      this.preferences = user.getPreferences();    // v2.0
-      this.role = user.getRole();
-      this.isVerified = user.isVerified();
-      this.isOnline = user.isOnline();
-      this.lastSeen = user.getLastSeen();
-      this.createdAt = user.getCreatedAt();
     }
   }
-
-  /**
-   * Retourne le nom complet de l'utilisateur (v2.0).
-   *
-   * @return Le nom complet (firstName + lastName).
-   */
-  public String getFullName() {
-    return (firstName != null ? firstName : "") + " " + (lastName != null ? lastName : "").trim();
-  }
 }

src/main/java/com/lions/dev/entity/booking/Booking.java

@@ -1,105 +0,0 @@
-package com.lions.dev.entity.booking;
-
-import com.lions.dev.entity.BaseEntity;
-import com.lions.dev.entity.establishment.Establishment;
-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;
-
-/**
- * Entité représentant une réservation d'établissement.
- * 
- * Version 2.0 - Architecture refactorée.
- * Conforme à l'architecture de données AfterWork v2.0 (Ultra-Compétitive).
- * 
- * Cette entité remplace/étend Reservation avec plus de détails et de flexibilité.
- */
-@Entity
-@Table(name = "bookings")
-@Getter
-@Setter
-@NoArgsConstructor
-@ToString
-public class Booking extends BaseEntity {
-
-  @ManyToOne(fetch = FetchType.LAZY)
-  @JoinColumn(name = "establishment_id", nullable = false)
-  private Establishment establishment; // L'établissement concerné par la réservation
-
-  @ManyToOne(fetch = FetchType.LAZY)
-  @JoinColumn(name = "user_id", nullable = false)
-  private Users user; // L'utilisateur qui a fait la réservation
-
-  @Column(name = "reservation_time", nullable = false)
-  private LocalDateTime reservationTime; // Date et heure de la réservation
-
-  @Column(name = "guest_count", nullable = false)
-  private Integer guestCount = 1; // Nombre de convives
-
-  @Column(name = "status", nullable = false, length = 20)
-  private String status = "PENDING"; // Statut: PENDING, CONFIRMED, CANCELLED, COMPLETED
-
-  @Column(name = "special_requests", columnDefinition = "TEXT")
-  private String specialRequests; // Demandes spéciales (allergies, préférences, etc.)
-
-  @Column(name = "table_number", length = 20)
-  private String tableNumber; // Numéro de table assigné (si applicable)
-
-  /**
-   * Constructeur pour créer une réservation.
-   *
-   * @param establishment L'établissement concerné
-   * @param user L'utilisateur qui fait la réservation
-   * @param reservationTime La date et heure de la réservation
-   * @param guestCount Le nombre de convives
-   */
-  public Booking(Establishment establishment, Users user, LocalDateTime reservationTime, Integer guestCount) {
-    this.establishment = establishment;
-    this.user = user;
-    this.reservationTime = reservationTime;
-    this.guestCount = guestCount;
-    this.status = "PENDING";
-  }
-
-  /**
-   * Vérifie si la réservation est confirmée.
-   *
-   * @return true si la réservation est confirmée, false sinon.
-   */
-  public boolean isConfirmed() {
-    return "CONFIRMED".equalsIgnoreCase(this.status);
-  }
-
-  /**
-   * Vérifie si la réservation est en attente.
-   *
-   * @return true si la réservation est en attente, false sinon.
-   */
-  public boolean isPending() {
-    return "PENDING".equalsIgnoreCase(this.status);
-  }
-
-  /**
-   * Vérifie si la réservation est annulée.
-   *
-   * @return true si la réservation est annulée, false sinon.
-   */
-  public boolean isCancelled() {
-    return "CANCELLED".equalsIgnoreCase(this.status);
-  }
-
-  /**
-   * Vérifie si la réservation est complétée.
-   *
-   * @return true si la réservation est complétée, false sinon.
-   */
-  public boolean isCompleted() {
-    return "COMPLETED".equalsIgnoreCase(this.status);
-  }
-}
-

src/main/java/com/lions/dev/entity/chat/Conversation.java

@@ -1,131 +0,0 @@
-package com.lions.dev.entity.chat;
-
-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.ArrayList;
-import java.util.List;
-
-/**
- * Entité représentant une conversation entre deux utilisateurs.
- *
- * Une conversation contient tous les messages échangés entre deux utilisateurs.
- * Elle garde une trace du dernier message et du timestamp de la dernière activité.
- *
- * Tous les logs nécessaires pour la traçabilité sont intégrés.
- */
-@Entity
-@Table(name = "conversations")
-@Getter
-@Setter
-@NoArgsConstructor
-@ToString(exclude = {"messages"})
-public class Conversation extends BaseEntity {
-
-  @ManyToOne(fetch = FetchType.LAZY)
-  @JoinColumn(name = "user1_id", nullable = false)
-  private Users user1; // Premier utilisateur de la conversation
-
-  @ManyToOne(fetch = FetchType.LAZY)
-  @JoinColumn(name = "user2_id", nullable = false)
-  private Users user2; // Deuxième utilisateur de la conversation
-
-  @Column(name = "last_message_content", length = 500)
-  private String lastMessageContent; // Contenu du dernier message
-
-  @Column(name = "last_message_timestamp")
-  private LocalDateTime lastMessageTimestamp; // Timestamp du dernier message
-
-  @ManyToOne(fetch = FetchType.LAZY)
-  @JoinColumn(name = "last_message_sender_id")
-  private Users lastMessageSender; // Expéditeur du dernier message
-
-  @Column(name = "unread_count_user1")
-  private int unreadCountUser1 = 0; // Nombre de messages non lus pour user1
-
-  @Column(name = "unread_count_user2")
-  private int unreadCountUser2 = 0; // Nombre de messages non lus pour user2
-
-  @OneToMany(mappedBy = "conversation", cascade = CascadeType.ALL, orphanRemoval = true)
-  private List<Message> messages = new ArrayList<>(); // Liste des messages de la conversation
-
-  /**
-   * Constructeur avec les deux utilisateurs.
-   */
-  public Conversation(Users user1, Users user2) {
-    this.user1 = user1;
-    this.user2 = user2;
-    this.lastMessageTimestamp = LocalDateTime.now();
-    System.out.println("[LOG] Conversation créée entre " + user1.getEmail() + " et " + user2.getEmail());
-  }
-
-  /**
-   * Met à jour les informations du dernier message.
-   */
-  public void updateLastMessage(Message message) {
-    this.lastMessageContent = message.getContent();
-    this.lastMessageTimestamp = LocalDateTime.now();
-    this.lastMessageSender = message.getSender();
-
-    // Incrémenter le compteur de non-lus pour le destinataire
-    if (message.getSender() != null && user1 != null && message.getSender().getId().equals(user1.getId())) {
-      unreadCountUser2++;
-    } else if (message.getSender() != null && user2 != null && message.getSender().getId().equals(user2.getId())) {
-      unreadCountUser1++;
-    }
-
-    System.out.println("[LOG] Dernier message mis à jour pour la conversation " + this.getId());
-  }
-
-  /**
-   * Marque tous les messages comme lus pour un utilisateur.
-   */
-  public void markAllAsReadForUser(Users user) {
-    if (user != null && user1 != null && user.getId().equals(user1.getId())) {
-      unreadCountUser1 = 0;
-      System.out.println("[LOG] Messages marqués comme lus pour user1 dans la conversation " + this.getId());
-    } else if (user != null && user2 != null && user.getId().equals(user2.getId())) {
-      unreadCountUser2 = 0;
-      System.out.println("[LOG] Messages marqués comme lus pour user2 dans la conversation " + this.getId());
-    }
-  }
-
-  /**
-   * Récupère le nombre de messages non lus pour un utilisateur.
-   */
-  public int getUnreadCountForUser(Users user) {
-    if (user != null && user1 != null && user.getId().equals(user1.getId())) {
-      return unreadCountUser1;
-    } else if (user != null && user2 != null && user.getId().equals(user2.getId())) {
-      return unreadCountUser2;
-    }
-    return 0;
-  }
-
-  /**
-   * Récupère l'autre utilisateur de la conversation.
-   */
-  public Users getOtherUser(Users user) {
-    if (user != null && user1 != null && user.getId().equals(user1.getId())) {
-      return user2;
-    } else if (user != null && user2 != null && user.getId().equals(user2.getId())) {
-      return user1;
-    }
-    return null;
-  }
-
-  /**
-   * Vérifie si un utilisateur fait partie de cette conversation.
-   */
-  public boolean containsUser(Users user) {
-    if (user == null) return false;
-    return (user1 != null && user.getId().equals(user1.getId())) || 
-           (user2 != null && user.getId().equals(user2.getId()));
-  }
-}

src/main/java/com/lions/dev/entity/chat/Message.java

@@ -1,103 +0,0 @@
-package com.lions.dev.entity.chat;
-
-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;
-
-/**
- * Entité représentant un message dans le système de messagerie AfterWork.
- *
- * Chaque message appartient à une conversation et a un expéditeur et un destinataire.
- * Les messages peuvent être de type texte, image, ou autres types de médias.
- *
- * Tous les logs nécessaires pour la traçabilité sont intégrés.
- */
-@Entity
-@Table(name = "messages")
-@Getter
-@Setter
-@NoArgsConstructor
-@ToString
-public class Message extends BaseEntity {
-
-  @ManyToOne(fetch = FetchType.LAZY)
-  @JoinColumn(name = "conversation_id", nullable = false)
-  private Conversation conversation; // La conversation à laquelle appartient ce message
-
-  @ManyToOne(fetch = FetchType.LAZY)
-  @JoinColumn(name = "sender_id", nullable = false)
-  private Users sender; // L'utilisateur qui a envoyé le message
-
-  @Column(name = "content", nullable = false, length = 5000)
-  private String content; // Le contenu du message
-
-  @Column(name = "message_type", nullable = false, length = 50)
-  private String messageType = "text"; // Le type de message (text, image, video, file)
-
-  @Column(name = "media_url", length = 500)
-  private String mediaUrl; // URL du média (si applicable)
-
-  @Column(name = "is_read", nullable = false)
-  private boolean isRead = false; // Indique si le message a été lu
-
-  @Column(name = "is_delivered", nullable = false)
-  private boolean isDelivered = false; // Indique si le message a été délivré
-
-  /**
-   * Constructeur avec les paramètres essentiels.
-   */
-  public Message(Conversation conversation, Users sender, String content) {
-    this.conversation = conversation;
-    this.sender = sender;
-    this.content = content;
-    this.messageType = "text";
-    this.isRead = false;
-    this.isDelivered = false;
-    System.out.println("[LOG] Message créé par " + sender.getEmail() + " dans la conversation " + conversation.getId());
-  }
-
-  /**
-   * Marque le message comme lu.
-   */
-  public void markAsRead() {
-    if (!this.isRead) {
-      this.isRead = true;
-      System.out.println("[LOG] Message " + this.getId() + " marqué comme lu");
-    }
-  }
-
-  /**
-   * Marque le message comme délivré.
-   */
-  public void markAsDelivered() {
-    if (!this.isDelivered) {
-      this.isDelivered = true;
-      System.out.println("[LOG] Message " + this.getId() + " marqué comme délivré");
-    }
-  }
-
-  /**
-   * Vérifie si le message contient un média.
-   */
-  public boolean hasMedia() {
-    return this.mediaUrl != null && !this.mediaUrl.isEmpty();
-  }
-
-  /**
-   * Vérifie si le message est un message texte.
-   */
-  public boolean isTextMessage() {
-    return "text".equalsIgnoreCase(this.messageType);
-  }
-
-  /**
-   * Vérifie si le message est une image.
-   */
-  public boolean isImageMessage() {
-    return "image".equalsIgnoreCase(this.messageType);
-  }
-}

src/main/java/com/lions/dev/entity/establishment/BusinessHours.java

@@ -1,90 +0,0 @@
-package com.lions.dev.entity.establishment;
-
-import com.lions.dev.entity.BaseEntity;
-import jakarta.persistence.*;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.Setter;
-import lombok.ToString;
-
-import java.time.LocalDateTime;
-
-/**
- * Entité représentant les horaires d'ouverture d'un établissement.
- * 
- * Version 2.0 - Architecture refactorée.
- * Conforme à l'architecture de données AfterWork v2.0 (Ultra-Compétitive).
- * 
- * Cette entité permet de gérer les horaires d'ouverture par jour de la semaine,
- * ainsi que les exceptions (fermetures temporaires, jours fériés, etc.).
- */
-@Entity
-@Table(name = "business_hours")
-@Getter
-@Setter
-@NoArgsConstructor
-@ToString
-public class BusinessHours extends BaseEntity {
-
-  @ManyToOne(fetch = FetchType.LAZY)
-  @JoinColumn(name = "establishment_id", nullable = false)
-  private Establishment establishment; // L'établissement concerné
-
-  @Column(name = "day_of_week", nullable = false, length = 20)
-  private String dayOfWeek; // Jour de la semaine: MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
-
-  @Column(name = "open_time", nullable = false, length = 5)
-  private String openTime; // Heure d'ouverture (format HH:MM, ex: "09:00")
-
-  @Column(name = "close_time", nullable = false, length = 5)
-  private String closeTime; // Heure de fermeture (format HH:MM, ex: "18:00")
-
-  @Column(name = "is_closed", nullable = false)
-  private Boolean isClosed = false; // Indique si l'établissement est fermé ce jour
-
-  @Column(name = "is_exception", nullable = false)
-  private Boolean isException = false; // Indique si c'est un jour exceptionnel (fermeture temporaire, jour férié, etc.)
-
-  @Column(name = "exception_date")
-  private LocalDateTime exceptionDate; // Date de l'exception (si is_exception = true)
-
-  /**
-   * Constructeur pour créer des horaires d'ouverture standard.
-   *
-   * @param establishment L'établissement concerné
-   * @param dayOfWeek Le jour de la semaine
-   * @param openTime L'heure d'ouverture (format HH:MM)
-   * @param closeTime L'heure de fermeture (format HH:MM)
-   */
-  public BusinessHours(Establishment establishment, String dayOfWeek, String openTime, String closeTime) {
-    this.establishment = establishment;
-    this.dayOfWeek = dayOfWeek;
-    this.openTime = openTime;
-    this.closeTime = closeTime;
-    this.isClosed = false;
-    this.isException = false;
-  }
-
-  /**
-   * Constructeur pour créer un jour de fermeture.
-   *
-   * @param establishment L'établissement concerné
-   * @param dayOfWeek Le jour de la semaine
-   */
-  public BusinessHours(Establishment establishment, String dayOfWeek) {
-    this.establishment = establishment;
-    this.dayOfWeek = dayOfWeek;
-    this.isClosed = true;
-    this.isException = false;
-  }
-
-  /**
-   * Vérifie si l'établissement est ouvert ce jour.
-   *
-   * @return true si l'établissement est ouvert, false sinon.
-   */
-  public boolean isOpen() {
-    return !isClosed;
-  }
-}
-

src/main/java/com/lions/dev/entity/establishment/Establishment.java

@@ -1,113 +0,0 @@
-package com.lions.dev.entity.establishment;
-
-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;
-
-/**
- * Entité représentant un établissement dans le système AfterWork.
- * 
- * Version 2.0 - Architecture refactorée avec nommage standardisé.
- * Conforme à l'architecture de données AfterWork v2.0 (Ultra-Compétitive).
- * 
- * Un établissement est un lieu physique (bar, restaurant, club, etc.)
- * où peuvent se dérouler des événements Afterwork.
- * Seuls les responsables d'établissement peuvent créer et gérer des établissements.
- */
-@Entity
-@Table(name = "establishments")
-@Getter
-@Setter
-@NoArgsConstructor
-@ToString
-public class Establishment extends BaseEntity {
-
-  @Column(name = "name", nullable = false)
-  private String name; // Le nom de l'établissement
-
-  @Column(name = "type", nullable = false)
-  private String type; // Type d'établissement (bar, restaurant, club, etc.)
-
-  @Column(name = "address", nullable = false)
-  private String address; // Adresse de l'établissement
-
-  @Column(name = "city", nullable = false)
-  private String city; // Ville de l'établissement
-
-  @Column(name = "postal_code", nullable = false)
-  private String postalCode; // Code postal
-
-  @Column(name = "description", length = 2000)
-  private String description; // Description de l'établissement
-
-  @Column(name = "phone_number")
-  private String phoneNumber; // Numéro de téléphone
-
-  @Column(name = "website")
-  private String website; // Site web
-
-  @Column(name = "average_rating")
-  private Double averageRating; // Note moyenne calculée (0.0 à 5.0)
-
-  @Column(name = "total_reviews_count")
-  private Integer totalReviewsCount; // Nombre total d'avis (v2.0 - renommé depuis total_ratings_count)
-
-  @Column(name = "price_range")
-  private String priceRange; // Fourchette de prix (LOW, MEDIUM, HIGH, PREMIUM)
-
-  @Column(name = "verification_status", nullable = false)
-  private String verificationStatus = "PENDING"; // Statut de vérification: PENDING, VERIFIED, REJECTED (v2.0)
-
-  @Column(name = "latitude")
-  private Double latitude; // Latitude pour la géolocalisation
-
-  @Column(name = "longitude")
-  private Double longitude; // Longitude pour la géolocalisation
-
-  @ManyToOne(fetch = FetchType.LAZY)
-  @JoinColumn(name = "manager_id", nullable = false)
-  private Users manager; // Le responsable de l'établissement
-
-  // Relations avec les médias et les notes
-  @OneToMany(mappedBy = "establishment", cascade = CascadeType.ALL, orphanRemoval = true)
-  private java.util.List<EstablishmentMedia> medias = new java.util.ArrayList<>(); // Liste des médias de l'établissement
-
-  @OneToMany(mappedBy = "establishment", cascade = CascadeType.ALL, orphanRemoval = true)
-  private java.util.List<EstablishmentRating> ratings = new java.util.ArrayList<>(); // Liste des notes de l'établissement (v1.0 - à migrer vers Review)
-
-  /**
-   * Vérifie si l'établissement est vérifié.
-   *
-   * @return true si l'établissement est vérifié, false sinon.
-   */
-  public boolean isVerified() {
-    return "VERIFIED".equalsIgnoreCase(this.verificationStatus);
-  }
-
-  /**
-   * Vérifie si l'établissement est en attente de vérification.
-   *
-   * @return true si l'établissement est en attente, false sinon.
-   */
-  public boolean isPending() {
-    return "PENDING".equalsIgnoreCase(this.verificationStatus);
-  }
-
-  /**
-   * Constructeur pour créer un établissement avec les informations de base.    
-   */
-  public Establishment(String name, String type, String address, String city, 
-                       String postalCode, Users manager) {
-    this.name = name;
-    this.type = type;
-    this.address = address;
-    this.city = city;
-    this.postalCode = postalCode;
-    this.manager = manager;
-  }
-}
-

src/main/java/com/lions/dev/entity/establishment/EstablishmentAmenity.java

@@ -1,98 +0,0 @@
-package com.lions.dev.entity.establishment;
-
-import jakarta.persistence.*;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.Setter;
-import lombok.ToString;
-
-import java.time.LocalDateTime;
-import java.util.UUID;
-
-/**
- * Entité représentant un équipement d'un établissement.
- * 
- * Version 2.0 - Architecture refactorée.
- * Conforme à l'architecture de données AfterWork v2.0 (Ultra-Compétitive).
- * 
- * Cette entité fait la liaison entre un établissement et un type d'équipement,
- * avec la possibilité d'ajouter des détails supplémentaires.
- */
-@Entity
-@Table(name = "establishment_amenities")
-@Getter
-@Setter
-@NoArgsConstructor
-@ToString
-@IdClass(EstablishmentAmenityId.class)
-public class EstablishmentAmenity {
-
-  @Id
-  @Column(name = "establishment_id", nullable = false)
-  private UUID establishmentId; // ID de l'établissement
-
-  @Id
-  @Column(name = "amenity_id", nullable = false)
-  private UUID amenityId; // ID du type d'équipement (référence à amenity_types)
-
-  @Column(name = "details", length = 500)
-  private String details; // Détails supplémentaires (ex: "Parking gratuit pour 20 voitures")
-
-  @Column(name = "created_at", nullable = false, updatable = false)
-  private LocalDateTime createdAt = LocalDateTime.now(); // Date de création
-
-  @ManyToOne(fetch = FetchType.LAZY)
-  @JoinColumn(name = "establishment_id", insertable = false, updatable = false)
-  private Establishment establishment; // L'établissement concerné
-
-  /**
-   * Constructeur pour créer une liaison établissement-équipement.
-   *
-   * @param establishmentId L'ID de l'établissement
-   * @param amenityId L'ID du type d'équipement
-   * @param details Les détails supplémentaires (optionnel)
-   */
-  public EstablishmentAmenity(UUID establishmentId, UUID amenityId, String details) {
-    this.establishmentId = establishmentId;
-    this.amenityId = amenityId;
-    this.details = details;
-    this.createdAt = LocalDateTime.now();
-  }
-
-  @PrePersist
-  protected void onCreate() {
-    if (createdAt == null) {
-      createdAt = LocalDateTime.now();
-    }
-  }
-}
-
-/**
- * Classe composite pour la clé primaire de EstablishmentAmenity.
- */
-@Getter
-@Setter
-@NoArgsConstructor
-class EstablishmentAmenityId implements java.io.Serializable {
-  private UUID establishmentId;
-  private UUID amenityId;
-
-  public EstablishmentAmenityId(UUID establishmentId, UUID amenityId) {
-    this.establishmentId = establishmentId;
-    this.amenityId = amenityId;
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) return true;
-    if (o == null || getClass() != o.getClass()) return false;
-    EstablishmentAmenityId that = (EstablishmentAmenityId) o;
-    return establishmentId.equals(that.establishmentId) && amenityId.equals(that.amenityId);
-  }
-
-  @Override
-  public int hashCode() {
-    return establishmentId.hashCode() + amenityId.hashCode();
-  }
-}
-

src/main/java/com/lions/dev/entity/establishment/EstablishmentMedia.java

@@ -1,61 +0,0 @@
-package com.lions.dev.entity.establishment;
-
-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;
-
-/**
- * Entité représentant un média (photo ou vidéo) associé à un établissement.
- * 
- * Un établissement peut avoir plusieurs médias pour promouvoir son établissement.
- * Les médias sont uploadés par le responsable de l'établissement.
- */
-@Entity
-@Table(name = "establishment_media")
-@Getter
-@Setter
-@NoArgsConstructor
-@ToString
-public class EstablishmentMedia extends BaseEntity {
-
-    @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "establishment_id", nullable = false)
-    private Establishment establishment; // L'établissement auquel ce média appartient
-
-    @Column(name = "media_url", nullable = false, length = 1000)
-    private String mediaUrl; // URL du média (photo ou vidéo)
-
-    @Enumerated(EnumType.STRING)
-    @Column(name = "media_type", nullable = false)
-    private MediaType mediaType; // Type de média (PHOTO ou VIDEO)
-
-    @Column(name = "thumbnail_url", length = 1000)
-    private String thumbnailUrl; // URL de la miniature (pour les vidéos)
-
-    @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "uploaded_by", nullable = false)
-    private Users uploadedBy; // L'utilisateur qui a uploadé le média
-
-    @Column(name = "uploaded_at", nullable = false)
-    private java.time.LocalDateTime uploadedAt; // Date et heure d'upload
-
-    @Column(name = "display_order", nullable = false)
-    private Integer displayOrder = 0; // Ordre d'affichage dans la galerie
-
-    /**
-     * Constructeur pour créer un média avec les informations de base.
-     */
-    public EstablishmentMedia(Establishment establishment, String mediaUrl, MediaType mediaType, Users uploadedBy) {
-        this.establishment = establishment;
-        this.mediaUrl = mediaUrl;
-        this.mediaType = mediaType;
-        this.uploadedBy = uploadedBy;
-        this.uploadedAt = java.time.LocalDateTime.now();
-        this.displayOrder = 0;
-    }
-}
-

src/main/java/com/lions/dev/entity/establishment/EstablishmentRating.java

@@ -1,72 +0,0 @@
-package com.lions.dev.entity.establishment;
-
-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;
-
-/**
- * Entité représentant une note donnée par un utilisateur à un établissement.
- * 
- * Chaque utilisateur ne peut avoir qu'une seule note par établissement.
- * La note est un entier entre 1 et 5 (étoiles).
- */
-@Entity
-@Table(
-    name = "establishment_ratings",
-    uniqueConstraints = {
-        @UniqueConstraint(
-            name = "uk_establishment_user_rating",
-            columnNames = {"establishment_id", "user_id"}
-        )
-    }
-)
-@Getter
-@Setter
-@NoArgsConstructor
-@ToString
-public class EstablishmentRating extends BaseEntity {
-
-    @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "establishment_id", nullable = false)
-    private Establishment establishment; // L'établissement noté
-
-    @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "user_id", nullable = false)
-    private Users user; // L'utilisateur qui a donné la note
-
-    @Column(name = "rating", nullable = false)
-    private Integer rating; // Note donnée (1 à 5 étoiles)
-
-    @Column(name = "comment", length = 2000)
-    private String comment; // Commentaire optionnel accompagnant la note
-
-    @Column(name = "rated_at", nullable = false, updatable = false)
-    private java.time.LocalDateTime ratedAt; // Date et heure de création de la note
-
-    @Column(name = "updated_at")
-    private java.time.LocalDateTime updatedAt; // Date et heure de dernière modification
-
-    /**
-     * Constructeur pour créer une note avec les informations de base.
-     */
-    public EstablishmentRating(Establishment establishment, Users user, Integer rating) {
-        this.establishment = establishment;
-        this.user = user;
-        this.rating = rating;
-        this.ratedAt = java.time.LocalDateTime.now();
-    }
-
-    /**
-     * Met à jour la note et la date de modification.
-     */
-    public void updateRating(Integer newRating, String newComment) {
-        this.rating = newRating;
-        this.comment = newComment;
-        this.updatedAt = java.time.LocalDateTime.now();
-    }
-}
-

src/main/java/com/lions/dev/entity/establishment/MediaType.java

@@ -1,10 +0,0 @@
-package com.lions.dev.entity.establishment;
-
-/**
- * Enum représentant le type de média pour un établissement.
- */
-public enum MediaType {
-    PHOTO,
-    VIDEO
-}
-

src/main/java/com/lions/dev/entity/establishment/Review.java

@@ -1,92 +0,0 @@
-package com.lions.dev.entity.establishment;
-
-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.util.HashMap;
-import java.util.Map;
-
-/**
- * Entité représentant un avis (review) sur un établissement.
- * 
- * Version 2.0 - Architecture refactorée.
- * Conforme à l'architecture de données AfterWork v2.0 (Ultra-Compétitive).
- * 
- * Cette entité remplace EstablishmentRating avec des fonctionnalités plus avancées,
- * incluant des notes par critères et la vérification des visites.
- */
-@Entity
-@Table(name = "reviews",
-       uniqueConstraints = @UniqueConstraint(columnNames = {"user_id", "establishment_id"}))
-@Getter
-@Setter
-@NoArgsConstructor
-@ToString
-public class Review extends BaseEntity {
-
-  @ManyToOne(fetch = FetchType.LAZY)
-  @JoinColumn(name = "user_id", nullable = false)
-  private Users user; // L'utilisateur qui a écrit l'avis
-
-  @ManyToOne(fetch = FetchType.LAZY)
-  @JoinColumn(name = "establishment_id", nullable = false)
-  private Establishment establishment; // L'établissement concerné
-
-  @Column(name = "overall_rating", nullable = false)
-  private Integer overallRating; // Note globale (1-5)
-
-  @Column(name = "comment", columnDefinition = "TEXT")
-  private String comment; // Commentaire libre de l'utilisateur
-
-  @Column(name = "criteria_ratings", nullable = false)
-  @org.hibernate.annotations.JdbcTypeCode(org.hibernate.type.SqlTypes.JSON)
-  private Map<String, Integer> criteriaRatings = new HashMap<>(); // Notes par critères (ex: {"ambiance": 4, "service": 5})
-
-  @Column(name = "is_verified_visit", nullable = false)
-  private Boolean isVerifiedVisit = false; // Indique si l'avis est lié à une visite vérifiée (réservation complétée)
-
-  /**
-   * Constructeur pour créer un avis.
-   *
-   * @param user L'utilisateur qui écrit l'avis
-   * @param establishment L'établissement concerné
-   * @param overallRating La note globale (1-5)
-   * @param comment Le commentaire (optionnel)
-   */
-  public Review(Users user, Establishment establishment, Integer overallRating, String comment) {
-    this.user = user;
-    this.establishment = establishment;
-    this.overallRating = overallRating;
-    this.comment = comment;
-    this.criteriaRatings = new HashMap<>();
-    this.isVerifiedVisit = false;
-  }
-
-  /**
-   * Ajoute une note pour un critère spécifique.
-   *
-   * @param criteria Le nom du critère (ex: "ambiance", "service", "qualité")
-   * @param rating La note (1-5)
-   */
-  public void addCriteriaRating(String criteria, Integer rating) {
-    if (rating >= 1 && rating <= 5) {
-      this.criteriaRatings.put(criteria, rating);
-    }
-  }
-
-  /**
-   * Retourne la note pour un critère spécifique.
-   *
-   * @param criteria Le nom du critère
-   * @return La note, ou null si le critère n'existe pas
-   */
-  public Integer getCriteriaRating(String criteria) {
-    return this.criteriaRatings.get(criteria);
-  }
-}
-

src/main/java/com/lions/dev/entity/events/Events.java

@@ -16,12 +16,8 @@ import java.util.Set;
 
 /**
  * Entité représentant un événement dans le système AfterWork.
- * 
- * Version 2.0 - Architecture refactorée avec nommage standardisé.
- * Conforme à l'architecture de données AfterWork v2.0 (Ultra-Compétitive).
- * 
  * Chaque événement possède un titre, une description, une date de début, une date de fin,
- * un créateur, une catégorie, un établissement, une URL d'image, et des participants.
+ * un créateur, une catégorie, un lieu, une URL d'image, et des participants.
  * Tous les logs et commentaires nécessaires pour la traçabilité et la documentation sont inclus.
  */
 @Entity
@@ -44,9 +40,8 @@ public class Events extends BaseEntity {
   @Column(name = "end_date", nullable = false)
   private LocalDateTime endDate; // La date de fin de l'événement
 
-  @ManyToOne(fetch = FetchType.LAZY)
+  @Column(name = "location")
-  @JoinColumn(name = "establishment_id")
+  private String location; // Le lieu de l'événement
-  private com.lions.dev.entity.establishment.Establishment establishment; // L'établissement où se déroule l'événement (v2.0)
 
   @Column(name = "category")
   private String category; // La catégorie de l'événement
@@ -58,43 +53,7 @@ public class Events extends BaseEntity {
   private String imageUrl; // URL d'une image associée à l'événement
 
   @Column(name = "status", nullable = false)
-  private String status = "OPEN"; // Le statut de l'événement (OPEN, CLOSED, CANCELLED, COMPLETED) (v2.0)
+  private String status = "ouvert"; // Le statut de l'événement (en cours, terminé, annulé, etc.)
-
-  @Column(name = "max_participants")
-  private Integer maxParticipants; // Nombre maximum de participants autorisés
-
-  @Column(name = "tags", length = 500)
-  private String tags; // Tags/mots-clés associés à l'événement (séparés par des virgules)
-
-  @Column(name = "organizer", length = 200)
-  private String organizer; // Nom de l'organisateur de l'événement
-
-  @Column(name = "participation_fee")
-  private Integer participationFee; // Frais de participation en centimes
-
-  @Column(name = "is_private", nullable = false)
-  private Boolean isPrivate = false; // Indique si l'événement est privé (v2.0)
-
-  @Column(name = "waitlist_enabled", nullable = false)
-  private Boolean waitlistEnabled = false; // Indique si la liste d'attente est activée (v2.0)
-
-  @Column(name = "privacy_rules", length = 1000)
-  private String privacyRules; // Règles de confidentialité de l'événement
-
-  @Column(name = "transport_info", length = 1000)
-  private String transportInfo; // Informations sur les transports disponibles
-
-  @Column(name = "accommodation_info", length = 1000)
-  private String accommodationInfo; // Informations sur l'hébergement
-
-  @Column(name = "accessibility_info", length = 1000)
-  private String accessibilityInfo; // Informations sur l'accessibilité
-
-  @Column(name = "parking_info", length = 1000)
-  private String parkingInfo; // Informations sur le parking
-
-  @Column(name = "security_protocol", length = 1000)
-  private String securityProtocol; // Protocole de sécurité de l'événement
 
   @ManyToOne(fetch = FetchType.LAZY)
   @JoinColumn(name = "creator_id", nullable = false)
@@ -142,44 +101,13 @@ public class Events extends BaseEntity {
   }
 
   /**
-   * Ferme l'événement en changeant son statut (v2.0).
+   * Ferme l'événement en changeant son statut.
    */
   public void setClosed(boolean closed) {
-    this.status = closed ? "CLOSED" : "OPEN";
+    this.status = closed ? "fermé" : "ouvert";
     System.out.println("[LOG] Statut de l'événement mis à jour : " + this.title + " - " + this.status);
   }
 
-  /**
-   * Vérifie si l'événement est ouvert (v2.0).
-   *
-   * @return true si l'événement est ouvert, false sinon.
-   */
-  public boolean isOpen() {
-    return "OPEN".equalsIgnoreCase(this.status);
-  }
-
-  /**
-   * Vérifie si l'événement est fermé (v2.0).
-   *
-   * @return true si l'événement est fermé, false sinon.
-   */
-  public boolean isClosed() {
-    return "CLOSED".equalsIgnoreCase(this.status);
-  }
-
-  /**
-   * Retourne le lieu de l'événement depuis l'établissement associé (v2.0).
-   * Méthode de compatibilité pour remplacer l'ancien champ location.
-   *
-   * @return L'adresse de l'établissement, ou null si aucun établissement n'est associé.
-   */
-  public String getLocation() {
-    if (establishment != null) {
-      return establishment.getAddress() + ", " + establishment.getCity();
-    }
-    return null;
-  }
-
   @OneToMany(fetch = FetchType.LAZY, mappedBy = "event")
   private List<Comment> comments; // Liste des commentaires associés à l'événement
 

src/main/java/com/lions/dev/entity/notification/Notification.java

@@ -1,97 +0,0 @@
-package com.lions.dev.entity.notification;
-
-import com.lions.dev.entity.BaseEntity;
-import com.lions.dev.entity.events.Events;
-import com.lions.dev.entity.users.Users;
-import jakarta.persistence.*;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.Setter;
-import lombok.ToString;
-
-/**
- * Entité représentant une notification dans le système AfterWork.
- * 
- * Les notifications peuvent être de différents types :
- * - event : Notification liée à un événement
- * - friend : Notification liée à une demande d'ami
- * - reminder : Rappel d'événement
- * - other : Autres types de notifications
- * 
- * Tous les logs nécessaires pour la traçabilité sont intégrés.
- */
-@Entity
-@Table(name = "notifications")
-@Getter
-@Setter
-@NoArgsConstructor
-@ToString
-public class Notification extends BaseEntity {
-
-  @Column(name = "title", nullable = false, length = 200)
-  private String title; // Le titre de la notification
-
-  @Column(name = "message", nullable = false, length = 1000)
-  private String message; // Le message de la notification
-
-  @Column(name = "type", nullable = false, length = 50)
-  private String type; // Le type de notification (event, friend, reminder, other)
-
-  @Column(name = "is_read", nullable = false)
-  private boolean isRead = false; // Indique si la notification a été lue
-
-  @ManyToOne(fetch = FetchType.LAZY)
-  @JoinColumn(name = "user_id", nullable = false)
-  private Users user; // L'utilisateur destinataire de la notification
-
-  @ManyToOne(fetch = FetchType.LAZY)
-  @JoinColumn(name = "event_id")
-  private Events event; // L'événement associé (optionnel)
-
-  @Column(name = "metadata", length = 2000)
-  private String metadata; // Métadonnées supplémentaires au format JSON (optionnel)
-
-  /**
-   * Constructeur avec les paramètres essentiels.
-   */
-  public Notification(String title, String message, String type, Users user) {
-    this.title = title;
-    this.message = message;
-    this.type = type;
-    this.user = user;
-    this.isRead = false;
-    System.out.println("[LOG] Notification créée : " + title + " pour l'utilisateur " + user.getEmail());
-  }
-
-  /**
-   * Marque la notification comme lue.
-   */
-  public void markAsRead() {
-    if (!this.isRead) {
-      this.isRead = true;
-      System.out.println("[LOG] Notification marquée comme lue : " + this.title);
-    }
-  }
-
-  /**
-   * Vérifie si la notification est liée à un événement.
-   */
-  public boolean isEventNotification() {
-    return "event".equalsIgnoreCase(this.type) && this.event != null;
-  }
-
-  /**
-   * Vérifie si la notification est liée à une demande d'ami.
-   */
-  public boolean isFriendNotification() {
-    return "friend".equalsIgnoreCase(this.type);
-  }
-
-  /**
-   * Vérifie si la notification est un rappel.
-   */
-  public boolean isReminderNotification() {
-    return "reminder".equalsIgnoreCase(this.type);
-  }
-}
-

src/main/java/com/lions/dev/entity/promotion/Promotion.java

@@ -1,119 +0,0 @@
-package com.lions.dev.entity.promotion;
-
-import com.lions.dev.entity.BaseEntity;
-import com.lions.dev.entity.establishment.Establishment;
-import jakarta.persistence.*;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.Setter;
-import lombok.ToString;
-
-import java.time.LocalDateTime;
-
-/**
- * Entité représentant une promotion ou une offre spéciale d'un établissement.
- * 
- * Version 2.0 - Architecture refactorée.
- * Conforme à l'architecture de données AfterWork v2.0 (Ultra-Compétitive).
- * 
- * Cette entité permet de gérer les promotions, happy hours, et offres spéciales
- * avec différents types de réductions et codes promo.
- */
-@Entity
-@Table(name = "promotions")
-@Getter
-@Setter
-@NoArgsConstructor
-@ToString
-public class Promotion extends BaseEntity {
-
-  @ManyToOne(fetch = FetchType.LAZY)
-  @JoinColumn(name = "establishment_id", nullable = false)
-  private Establishment establishment; // L'établissement qui propose la promotion
-
-  @Column(name = "title", nullable = false, length = 200)
-  private String title; // Titre de la promotion (ex: "Happy Hour", "Menu du jour")
-
-  @Column(name = "description", columnDefinition = "TEXT")
-  private String description; // Description détaillée de la promotion
-
-  @Column(name = "promo_code", length = 50, unique = true)
-  private String promoCode; // Code promo optionnel (ex: "HAPPY2024")
-
-  @Column(name = "discount_type", nullable = false, length = 20)
-  private String discountType; // Type de réduction: PERCENTAGE, FIXED_AMOUNT, FREE_ITEM
-
-  @Column(name = "discount_value", nullable = false)
-  private java.math.BigDecimal discountValue; // Valeur de la réduction (pourcentage, montant fixe, etc.)
-
-  @Column(name = "valid_from", nullable = false)
-  private LocalDateTime validFrom; // Date de début de validité
-
-  @Column(name = "valid_until", nullable = false)
-  private LocalDateTime validUntil; // Date de fin de validité
-
-  @Column(name = "is_active", nullable = false)
-  private Boolean isActive = true; // Indique si la promotion est active
-
-  /**
-   * Constructeur pour créer une promotion.
-   *
-   * @param establishment L'établissement qui propose la promotion
-   * @param title Le titre de la promotion
-   * @param description La description
-   * @param discountType Le type de réduction
-   * @param discountValue La valeur de la réduction
-   * @param validFrom La date de début
-   * @param validUntil La date de fin
-   */
-  public Promotion(Establishment establishment, String title, String description,
-                   String discountType, java.math.BigDecimal discountValue,
-                   LocalDateTime validFrom, LocalDateTime validUntil) {
-    this.establishment = establishment;
-    this.title = title;
-    this.description = description;
-    this.discountType = discountType;
-    this.discountValue = discountValue;
-    this.validFrom = validFrom;
-    this.validUntil = validUntil;
-    this.isActive = true;
-  }
-
-  /**
-   * Vérifie si la promotion est actuellement valide.
-   *
-   * @return true si la promotion est active et dans sa période de validité, false sinon.
-   */
-  public boolean isValid() {
-    LocalDateTime now = LocalDateTime.now();
-    return isActive && now.isAfter(validFrom) && now.isBefore(validUntil);
-  }
-
-  /**
-   * Vérifie si la promotion est expirée.
-   *
-   * @return true si la promotion est expirée, false sinon.
-   */
-  public boolean isExpired() {
-    return LocalDateTime.now().isAfter(validUntil);
-  }
-
-  /**
-   * Vérifie si la promotion est une réduction en pourcentage.
-   *
-   * @return true si c'est un pourcentage, false sinon.
-   */
-  public boolean isPercentage() {
-    return "PERCENTAGE".equalsIgnoreCase(this.discountType);
-  }
-
-  /**
-   * Vérifie si la promotion est un montant fixe.
-   *
-   * @return true si c'est un montant fixe, false sinon.
-   */
-  public boolean isFixedAmount() {
-    return "FIXED_AMOUNT".equalsIgnoreCase(this.discountType);
-  }
-}
-

src/main/java/com/lions/dev/entity/reaction/Reaction.java

@@ -2,6 +2,7 @@ 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;
@@ -9,66 +10,58 @@ import lombok.Setter;
 import lombok.ToString;
 
 /**
- * Entité représentant une réaction d'un utilisateur à un contenu.
+ * 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.
  *
- * Version 2.0 - Architecture refactorée.
+ * Cette entité est liée à l'utilisateur qui réagit et à l'événement auquel la réaction est associée.
- * Conforme à l'architecture de données AfterWork v2.0 (Ultra-Compétitive).
+ * Tous les logs et commentaires sont inclus pour la traçabilité.
- * 
- * Cette entité remplace les compteurs de réactions simples avec un système
- * plus flexible permettant différents types de réactions sur différents contenus.
  */
 @Entity
-@Table(name = "reactions",
+@Table(name = "reactions")
-       uniqueConstraints = @UniqueConstraint(columnNames = {"user_id", "target_type", "target_id"}))
 @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 réagi
+  private Users user; // L'utilisateur qui a effectué la réaction
 
-  @Column(name = "reaction_type", nullable = false, length = 20)
+  @ManyToOne(fetch = FetchType.LAZY)
-  private String reactionType; // Type de réaction: LIKE, LOVE, HAHA, WOW, SAD, ANGRY
+  @JoinColumn(name = "event_id", nullable = false)
-
+  private Events event; // L'événement auquel la réaction est associée
-  @Column(name = "target_type", nullable = false, length = 20)
-  private String targetType; // Type de contenu ciblé: POST, EVENT, COMMENT, REVIEW
-
-  @Column(name = "target_id", nullable = false)
-  private java.util.UUID targetId; // ID du contenu ciblé (post_id, event_id, comment_id, review_id)
 
   /**
-   * Constructeur pour créer une réaction.
+   * Associe une réaction à un utilisateur et un événement.
    *
-   * @param user L'utilisateur qui réagit
+   * @param user L'utilisateur qui réagit.
-   * @param reactionType Le type de réaction (LIKE, LOVE, HAHA, WOW, SAD, ANGRY)
+   * @param event L'événement auquel la réaction est liée.
-   * @param targetType Le type de contenu (POST, EVENT, COMMENT, REVIEW)
+   * @param reactionType Le type de réaction.
-   * @param targetId L'ID du contenu ciblé
    */
-  public Reaction(Users user, String reactionType, String targetType, java.util.UUID targetId) {
+  public Reaction(Users user, Events event, ReactionType reactionType) {
     this.user = user;
+    this.event = event;
     this.reactionType = reactionType;
-    this.targetType = targetType;
+    System.out.println("[LOG] Nouvelle réaction ajoutée : " + reactionType + " par l'utilisateur : " + user.getEmail() + " à l'événement : " + event.getTitle());
-    this.targetId = targetId;
   }
 
   /**
-   * Vérifie si la réaction est un "like".
+   * Modifie le type de réaction de l'utilisateur pour cet événement.
    *
-   * @return true si c'est un like, false sinon.
+   * @param newReactionType Le nouveau type de réaction.
    */
-  public boolean isLike() {
+  public void updateReaction(ReactionType newReactionType) {
-    return "LIKE".equalsIgnoreCase(this.reactionType);
+    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;
-
-  /**
-   * Vérifie si la réaction est un "love".
-   *
-   * @return true si c'est un love, false sinon.
-   */
-  public boolean isLove() {
-    return "LOVE".equalsIgnoreCase(this.reactionType);
   }
 }

src/main/java/com/lions/dev/entity/social/SocialPost.java

@@ -1,92 +0,0 @@
-package com.lions.dev.entity.social;
-
-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;
-
-/**
- * Entité représentant un post social dans le système AfterWork.
- * 
- * Un post social contient du contenu textuel, optionnellement une image,
- * et des statistiques d'interaction (likes, comments, shares).
- * 
- * Tous les logs nécessaires pour la traçabilité sont intégrés.
- */
-@Entity
-@Table(name = "social_posts")
-@Getter
-@Setter
-@NoArgsConstructor
-@ToString
-public class SocialPost extends BaseEntity {
-
-  @Column(name = "content", nullable = false, length = 2000)
-  private String content; // Le contenu textuel du post
-
-  @ManyToOne(fetch = FetchType.LAZY)
-  @JoinColumn(name = "user_id", nullable = false)
-  private Users user; // L'utilisateur créateur du post
-
-  @Column(name = "image_url", length = 500)
-  private String imageUrl; // URL de l'image associée (optionnel)
-
-  @Column(name = "likes_count", nullable = false)
-  private int likesCount = 0; // Nombre de likes
-
-  @Column(name = "comments_count", nullable = false)
-  private int commentsCount = 0; // Nombre de commentaires
-
-  @Column(name = "shares_count", nullable = false)
-  private int sharesCount = 0; // Nombre de partages
-
-  /**
-   * Constructeur avec les paramètres essentiels.
-   */
-  public SocialPost(String content, Users user) {
-    this.content = content;
-    this.user = user;
-    this.likesCount = 0;
-    this.commentsCount = 0;
-    this.sharesCount = 0;
-    System.out.println("[LOG] Post social créé par l'utilisateur : " + user.getEmail());
-  }
-
-  /**
-   * Incrémente le nombre de likes.
-   */
-  public void incrementLikes() {
-    this.likesCount++;
-    System.out.println("[LOG] Like ajouté au post ID : " + this.getId() + " (total: " + this.likesCount + ")");
-  }
-
-  /**
-   * Décrémente le nombre de likes.
-   */
-  public void decrementLikes() {
-    if (this.likesCount > 0) {
-      this.likesCount--;
-      System.out.println("[LOG] Like retiré du post ID : " + this.getId() + " (total: " + this.likesCount + ")");
-    }
-  }
-
-  /**
-   * Incrémente le nombre de commentaires.
-   */
-  public void incrementComments() {
-    this.commentsCount++;
-    System.out.println("[LOG] Commentaire ajouté au post ID : " + this.getId() + " (total: " + this.commentsCount + ")");
-  }
-
-  /**
-   * Incrémente le nombre de partages.
-   */
-  public void incrementShares() {
-    this.sharesCount++;
-    System.out.println("[LOG] Partage ajouté au post ID : " + this.getId() + " (total: " + this.sharesCount + ")");
-  }
-}
-

src/main/java/com/lions/dev/entity/story/MediaType.java

@@ -1,9 +0,0 @@
-package com.lions.dev.entity.story;
-
-/**
- * Enumération représentant les types de médias supportés dans les stories.
- */
-public enum MediaType {
-  IMAGE,  // Story contenant une image
-  VIDEO   // Story contenant une vidéo
-}

src/main/java/com/lions/dev/entity/story/Story.java

@@ -1,117 +0,0 @@
-package com.lions.dev.entity.story;
-
-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;
-import java.util.UUID;
-
-/**
- * Entité représentant une story dans le système AfterWork.
- *
- * Une story est un contenu éphémère (24h) partagé par un utilisateur.
- * Elle peut contenir une image ou une vidéo avec des métadonnées associées.
- *
- * Tous les logs nécessaires pour la traçabilité sont intégrés.
- */
-@Entity
-@Table(name = "stories")
-@Getter
-@Setter
-@NoArgsConstructor
-@ToString
-public class Story extends BaseEntity {
-
-  @ManyToOne(fetch = FetchType.LAZY)
-  @JoinColumn(name = "user_id", nullable = false)
-  private Users user; // L'utilisateur créateur de la story
-
-  @Enumerated(EnumType.STRING)
-  @Column(name = "media_type", nullable = false, length = 20)
-  private MediaType mediaType; // Type de média (IMAGE ou VIDEO)
-
-  @Column(name = "media_url", nullable = false, length = 500)
-  private String mediaUrl; // URL du média (image ou vidéo)
-
-  @Column(name = "thumbnail_url", length = 500)
-  private String thumbnailUrl; // URL du thumbnail (pour les vidéos principalement)
-
-  @Column(name = "duration_seconds")
-  private Integer durationSeconds; // Durée en secondes (pour les vidéos)
-
-  @Column(name = "expires_at", nullable = false)
-  private LocalDateTime expiresAt; // Date d'expiration (24h après création)
-
-  @Column(name = "is_active", nullable = false)
-  private boolean isActive = true; // Indique si la story est active (non expirée)
-
-  @Column(name = "views_count", nullable = false)
-  private int viewsCount = 0; // Nombre de vues
-
-  @ElementCollection
-  @CollectionTable(name = "story_views", joinColumns = @JoinColumn(name = "story_id"))
-  @Column(name = "viewer_id")
-  private Set<UUID> viewerIds = new HashSet<>(); // IDs des utilisateurs qui ont vu la story
-
-  /**
-   * Constructeur avec les paramètres essentiels.
-   */
-  public Story(Users user, MediaType mediaType, String mediaUrl) {
-    this.user = user;
-    this.mediaType = mediaType;
-    this.mediaUrl = mediaUrl;
-    this.expiresAt = LocalDateTime.now().plusHours(24); // Expire après 24h
-    this.isActive = true;
-    this.viewsCount = 0;
-    System.out.println("[LOG] Story créée par l'utilisateur : " + user.getEmail());
-  }
-
-  /**
-   * Marque une story comme vue par un utilisateur.
-   *
-   * @param viewerId L'ID de l'utilisateur qui voit la story
-   * @return true si c'est une nouvelle vue, false si l'utilisateur avait déjà vu la story
-   */
-  public boolean markAsViewed(UUID viewerId) {
-    if (viewerIds.add(viewerId)) {
-      this.viewsCount++;
-      System.out.println("[LOG] Story ID : " + this.getId() + " vue par l'utilisateur ID : " + viewerId + " (total: " + this.viewsCount + ")");
-      return true;
-    }
-    return false;
-  }
-
-  /**
-   * Vérifie si la story est expirée.
-   *
-   * @return true si la story est expirée, false sinon
-   */
-  public boolean isExpired() {
-    return LocalDateTime.now().isAfter(this.expiresAt);
-  }
-
-  /**
-   * Désactive la story (si expirée ou supprimée manuellement).
-   */
-  public void deactivate() {
-    this.isActive = false;
-    System.out.println("[LOG] Story ID : " + this.getId() + " désactivée");
-  }
-
-  /**
-   * Vérifie si un utilisateur a déjà vu cette story.
-   *
-   * @param viewerId L'ID de l'utilisateur
-   * @return true si l'utilisateur a vu la story, false sinon
-   */
-  public boolean hasBeenViewedBy(UUID viewerId) {
-    return viewerIds.contains(viewerId);
-  }
-}

src/main/java/com/lions/dev/entity/users/Users.java

@@ -3,22 +3,16 @@ package com.lions.dev.entity.users;
 import com.lions.dev.entity.BaseEntity;
 import com.lions.dev.entity.events.Events;
 import jakarta.persistence.*;
-import jakarta.persistence.JoinTable;
-import jakarta.persistence.ManyToMany;
 import java.util.HashSet;
 import java.util.Set;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
 import lombok.ToString;
-import at.favre.lib.crypto.bcrypt.BCrypt;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
 
 /**
  * Représentation de l'entité Utilisateur dans le système AfterWork.
- * 
- * Version 2.0 - Architecture refactorée avec nommage standardisé.
- * Conforme à l'architecture de données AfterWork v2.0 (Ultra-Compétitive).
- * 
  * 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.
  *
@@ -32,17 +26,17 @@ import at.favre.lib.crypto.bcrypt.BCrypt;
 @ToString
 public class Users extends BaseEntity {
 
-  @Column(name = "first_name", nullable = false, length = 100)
+  @Column(name = "nom", nullable = false, length = 100)
-  private String firstName; // Le prénom de l'utilisateur (v2.0)
+  private String nom; // Le nom de l'utilisateur
 
-  @Column(name = "last_name", nullable = false, length = 100)
+  @Column(name = "prenoms", nullable = false, length = 100)
-  private String lastName; // Le nom de famille de l'utilisateur (v2.0)
+  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 = "password_hash", nullable = false)
+  @Column(name = "mot_de_passe", nullable = false)
-  private String passwordHash; // Mot de passe haché avec BCrypt (v2.0)
+  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.)
@@ -50,80 +44,34 @@ public class Users extends BaseEntity {
   @Column(name = "profile_image_url")
   private String profileImageUrl;  // L'URL de l'image de profil de l'utilisateur
 
-  @Column(name = "bio", length = 500)
+  @Column(name = "preferred_category")
-  private String bio; // Biographie courte de l'utilisateur (v2.0)
+  private String preferredCategory; // La catégorie préférée de l'utilisateur
-
-  @Column(name = "loyalty_points", nullable = false)
-  private Integer loyaltyPoints = 0; // Points de fidélité accumulés (v2.0)
-
-  @Column(name = "preferences", nullable = false)
-  @org.hibernate.annotations.JdbcTypeCode(org.hibernate.type.SqlTypes.JSON)
-  private java.util.Map<String, Object> preferences = new java.util.HashMap<>(); // Préférences utilisateur en JSON (v2.0)
-
-  @Column(name = "is_verified", nullable = false)
-  private boolean isVerified = false; // Indique si l'utilisateur est vérifié (compte officiel)
-
-  @Column(name = "is_online", nullable = false)
-  private boolean isOnline = false; // Indique si l'utilisateur est actuellement en ligne
-
-  @Column(name = "last_seen")
-  private java.time.LocalDateTime lastSeen; // Dernière fois que l'utilisateur était en ligne
 
   // Utilisation de BCrypt pour hacher les mots de passe de manière sécurisée
-  // private static final BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
+  private static final BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
 
   /**
-   * Hache le mot de passe avec BCrypt et le stocke dans l'attribut `passwordHash`.
+   * Hache le mot de passe avec BCrypt et le stocke dans l'attribut `motDePasse`.
-   * Version 2.0 - Utilise passwordHash au lieu de motDePasse.
    *
-   * @param password Le mot de passe en texte clair à hacher.
+   * @param motDePasse Le mot de passe en texte clair à hacher.
    */
-  public void setPassword(String password) {
+  public void setMotDePasse(String motDePasse) {
-    this.passwordHash = BCrypt.withDefaults().hashToString(12, password.toCharArray());
+    this.motDePasse = encoder.encode(motDePasse);
     System.out.println("[LOG] Mot de passe haché pour l'utilisateur : " + this.email);
   }
 
-  /**
-   * Définit directement le hash du mot de passe (pour compatibilité).
-   *
-   * @param passwordHash Le hash du mot de passe.
-   */
-  public void setPasswordHash(String passwordHash) {
-    this.passwordHash = passwordHash;
-  }
-
   /**
    * Vérifie que le mot de passe fourni correspond au mot de passe haché de l'utilisateur.
-   * Version 2.0 - Utilise passwordHash au lieu de motDePasse.
    *
-   * @param password Le mot de passe en texte clair à vérifier.
+   * @param motDePasse Le mot de passe en texte clair à vérifier.
    * @return true si le mot de passe est correct, false sinon.
    */
-  public boolean verifyPassword(String password) {
+  public boolean verifierMotDePasse(String motDePasse) {
-    BCrypt.Result result = BCrypt.verifyer().verify(password.toCharArray(), this.passwordHash);
+    boolean isValid = encoder.matches(motDePasse, this.motDePasse);
-    boolean isValid = result.verified;
     System.out.println("[LOG] Vérification du mot de passe pour l'utilisateur : " + this.email + " - Résultat : " + isValid);
     return isValid;
   }
 
-  /**
-   * Méthode de compatibilité avec l'ancienne API (dépréciée).
-   * @deprecated Utiliser {@link #setPassword(String)} à la place.
-   */
-  @Deprecated
-  public void setMotDePasse(String motDePasse) {
-    setPassword(motDePasse);
-  }
-
-  /**
-   * Méthode de compatibilité avec l'ancienne API (dépréciée).
-   * @deprecated Utiliser {@link #verifyPassword(String)} à la place.
-   */
-  @Deprecated
-  public boolean verifierMotDePasse(String motDePasse) {
-    return verifyPassword(motDePasse);
-  }
-
   /**
    * Vérifie si l'utilisateur a le rôle d'administrateur.
    *
@@ -135,12 +83,8 @@ public class Users extends BaseEntity {
     return isAdmin;
   }
 
-  @ManyToMany(fetch = FetchType.LAZY)
+  @OneToMany(fetch = FetchType.LAZY)
-  @JoinTable(
+  @JoinColumn(name = "favorite_events")
-      name = "user_favorite_events",
-      joinColumns = @JoinColumn(name = "user_id"),
-      inverseJoinColumns = @JoinColumn(name = "event_id")
-  )
   private Set<Events> favoriteEvents = new HashSet<>(); // Liste des événements favoris
 
   /**
@@ -153,26 +97,6 @@ public class Users extends BaseEntity {
     System.out.println("[LOG] Événement ajouté aux favoris pour l'utilisateur : " + this.email);
   }
 
-  /**
-   * Retire un événement des favoris de l'utilisateur.
-   *
-   * @param event L'événement à retirer.
-   */
-  public void removeFavoriteEvent(Events event) {
-    favoriteEvents.remove(event);
-    System.out.println("[LOG] Événement retiré des favoris pour l'utilisateur : " + this.email);
-  }
-
-  /**
-   * Vérifie si un événement est dans les favoris de l'utilisateur.
-   *
-   * @param event L'événement à vérifier.
-   * @return true si l'événement est favori, false sinon.
-   */
-  public boolean hasFavoriteEvent(Events event) {
-    return favoriteEvents.contains(event);
-  }
-
   /**
    * Retourne la liste des événements favoris de l'utilisateur.
    *
@@ -184,60 +108,23 @@ public class Users extends BaseEntity {
   }
 
   /**
-   * Retourne la catégorie préférée de l'utilisateur depuis preferences (v2.0).
+   * Retourne la catégorie préférée de l'utilisateur.
    *
-   * @return La catégorie préférée de l'utilisateur, ou null si non définie.
+   * @return La catégorie préférée de l'utilisateur.
    */
   public String getPreferredCategory() {
-    if (preferences != null && preferences.containsKey("preferred_category")) {
+    System.out.println("[LOG] Récupération de la catégorie préférée pour l'utilisateur : " + this.email);
-      Object category = preferences.get("preferred_category");
+    return preferredCategory;
-      return category != null ? category.toString() : null;
-    }
-    return null;
   }
 
   /**
-   * Définit la catégorie préférée de l'utilisateur dans preferences (v2.0).
+   * Définit la catégorie préférée de l'utilisateur.
    *
    * @param category La catégorie à définir.
    */
   public void setPreferredCategory(String category) {
-    if (preferences == null) {
+    this.preferredCategory = category;
-      preferences = new java.util.HashMap<>();
-    }
-    if (category != null) {
-      preferences.put("preferred_category", category);
-    } else {
-      preferences.remove("preferred_category");
-    }
     System.out.println("[LOG] Catégorie préférée définie pour l'utilisateur : " + this.email + " - Catégorie : " + category);
   }
 
-  /**
-   * Retourne le nom complet de l'utilisateur (v2.0).
-   *
-   * @return Le nom complet (firstName + lastName).
-   */
-  public String getFullName() {
-    return (firstName != null ? firstName : "") + " " + (lastName != null ? lastName : "").trim();
-  }
-
-  /**
-   * Met à jour la présence de l'utilisateur (marque comme en ligne et met à jour lastSeen).
-   */
-  public void updatePresence() {
-    this.isOnline = true;
-    this.lastSeen = java.time.LocalDateTime.now();
-    System.out.println("[LOG] Présence mise à jour pour l'utilisateur : " + this.email + " - Online: true");
-  }
-
-  /**
-   * Marque l'utilisateur comme hors ligne.
-   */
-  public void setOffline() {
-    this.isOnline = false;
-    this.lastSeen = java.time.LocalDateTime.now();
-    System.out.println("[LOG] Utilisateur marqué hors ligne : " + this.email);
-  }
-
 }

src/main/java/com/lions/dev/repository/ConversationRepository.java

@@ -1,118 +0,0 @@
-package com.lions.dev.repository;
-
-import com.lions.dev.entity.chat.Conversation;
-import com.lions.dev.entity.users.Users;
-import io.quarkus.hibernate.orm.panache.PanacheRepositoryBase;
-import io.quarkus.panache.common.Sort;
-import jakarta.enterprise.context.ApplicationScoped;
-
-import java.util.List;
-import java.util.Optional;
-import java.util.UUID;
-
-/**
- * Repository pour la gestion des conversations.
- *
- * Ce repository gère les opérations CRUD sur les conversations,
- * avec des méthodes de recherche pour trouver les conversations d'un utilisateur.
- */
-@ApplicationScoped
-public class ConversationRepository implements PanacheRepositoryBase<Conversation, UUID> {
-
-  /**
-   * Trouve une conversation entre deux utilisateurs.
-   *
-   * @param user1 Le premier utilisateur
-   * @param user2 Le deuxième utilisateur
-   * @return La conversation si elle existe, null sinon
-   */
-  public Conversation findBetweenUsers(Users user1, Users user2) {
-    System.out.println("[LOG] Recherche de conversation entre " + user1.getEmail() + " et " + user2.getEmail());
-
-    // Une conversation peut avoir user1 et user2 dans n'importe quel ordre
-    return find("(user1 = ?1 and user2 = ?2) or (user1 = ?2 and user2 = ?1)", user1, user2)
-        .firstResult();
-  }
-
-  /**
-   * Trouve ou crée une conversation entre deux utilisateurs.
-   *
-   * @param user1 Le premier utilisateur
-   * @param user2 Le deuxième utilisateur
-   * @return La conversation (existante ou nouvellement créée)
-   */
-  public Conversation findOrCreate(Users user1, Users user2) {
-    Conversation conversation = findBetweenUsers(user1, user2);
-
-    if (conversation == null) {
-      conversation = new Conversation(user1, user2);
-      persist(conversation);
-      System.out.println("[LOG] Nouvelle conversation créée avec l'ID : " + conversation.getId());
-    } else {
-      System.out.println("[LOG] Conversation existante trouvée avec l'ID : " + conversation.getId());
-    }
-
-    return conversation;
-  }
-
-  /**
-   * Récupère toutes les conversations d'un utilisateur.
-   *
-   * @param user L'utilisateur
-   * @return Liste des conversations triées par date du dernier message
-   */
-  public List<Conversation> findByUser(Users user) {
-    System.out.println("[LOG] Récupération des conversations pour l'utilisateur : " + user.getEmail());
-    return find("user1 = ?1 or user2 = ?1", Sort.by("lastMessageTimestamp", Sort.Direction.Descending), user)
-        .list();
-  }
-
-  /**
-   * Récupère toutes les conversations d'un utilisateur avec un nombre de messages non lus > 0.
-   *
-   * @param userId L'ID de l'utilisateur
-   * @return Liste des conversations avec des messages non lus
-   */
-  public List<Conversation> findConversationsWithUnreadMessages(UUID userId) {
-    System.out.println("[LOG] Récupération des conversations avec messages non lus pour l'utilisateur ID : " + userId);
-
-    return find(
-        "(user1.id = ?1 and unreadCountUser1 > 0) or (user2.id = ?1 and unreadCountUser2 > 0)",
-        Sort.by("lastMessageTimestamp", Sort.Direction.Descending),
-        userId
-    ).list();
-  }
-
-  /**
-   * Compte le nombre total de messages non lus pour un utilisateur (tous les conversations).
-   *
-   * @param userId L'ID de l'utilisateur
-   * @return Le nombre total de messages non lus
-   */
-  public long countTotalUnreadMessages(UUID userId) {
-    List<Conversation> conversations = find("user1.id = ?1 or user2.id = ?1", userId).list();
-
-    long total = 0;
-    for (Conversation conv : conversations) {
-      if (conv.getUser1().getId().equals(userId)) {
-        total += conv.getUnreadCountUser1();
-      } else {
-        total += conv.getUnreadCountUser2();
-      }
-    }
-
-    System.out.println("[LOG] Total de messages non lus pour l'utilisateur " + userId + " : " + total);
-    return total;
-  }
-
-  /**
-   * Supprime une conversation.
-   *
-   * @param conversationId L'ID de la conversation
-   * @return true si la conversation a été supprimée, false sinon
-   */
-  public boolean deleteConversation(UUID conversationId) {
-    System.out.println("[LOG] Suppression de la conversation ID : " + conversationId);
-    return deleteById(conversationId);
-  }
-}

src/main/java/com/lions/dev/repository/EstablishmentMediaRepository.java

@@ -1,35 +0,0 @@
-package com.lions.dev.repository;
-
-import com.lions.dev.entity.establishment.EstablishmentMedia;
-import io.quarkus.hibernate.orm.panache.PanacheRepositoryBase;
-import jakarta.enterprise.context.ApplicationScoped;
-
-import java.util.List;
-import java.util.UUID;
-
-/**
- * Repository Panache pour les médias d'établissements.
- */
-@ApplicationScoped
-public class EstablishmentMediaRepository implements PanacheRepositoryBase<EstablishmentMedia, UUID> {
-
-    /**
-     * Récupère tous les médias d'un établissement, triés par ordre d'affichage.
-     *
-     * @param establishmentId L'ID de l'établissement
-     * @return Liste des médias de l'établissement
-     */
-    public List<EstablishmentMedia> findByEstablishmentId(UUID establishmentId) {
-        return find("establishment.id = ?1 ORDER BY displayOrder ASC", establishmentId).list();
-    }
-
-    /**
-     * Supprime tous les médias d'un établissement.
-     *
-     * @param establishmentId L'ID de l'établissement
-     */
-    public void deleteByEstablishmentId(UUID establishmentId) {
-        delete("establishment.id = ?1", establishmentId);
-    }
-}
-

src/main/java/com/lions/dev/repository/EstablishmentRatingRepository.java

@@ -1,93 +0,0 @@
-package com.lions.dev.repository;
-
-import com.lions.dev.entity.establishment.EstablishmentRating;
-import io.quarkus.hibernate.orm.panache.PanacheRepositoryBase;
-import jakarta.enterprise.context.ApplicationScoped;
-
-import java.util.List;
-import java.util.Map;
-import java.util.UUID;
-import java.util.stream.Collectors;
-
-/**
- * Repository Panache pour les notations d'établissements.
- */
-@ApplicationScoped
-public class EstablishmentRatingRepository implements PanacheRepositoryBase<EstablishmentRating, UUID> {
-
-    /**
-     * Récupère la note d'un utilisateur pour un établissement.
-     * Utilise un fetch join pour charger les relations establishment et user en une seule requête.
-     *
-     * @param establishmentId L'ID de l'établissement
-     * @param userId L'ID de l'utilisateur
-     * @return La note de l'utilisateur ou null si pas encore noté
-     */
-    public EstablishmentRating findByEstablishmentIdAndUserId(UUID establishmentId, UUID userId) {
-        List<EstablishmentRating> results = getEntityManager()
-                .createQuery(
-                    "SELECT r FROM EstablishmentRating r " +
-                    "JOIN FETCH r.establishment " +
-                    "JOIN FETCH r.user " +
-                    "WHERE r.establishment.id = :establishmentId AND r.user.id = :userId",
-                    EstablishmentRating.class
-                )
-                .setParameter("establishmentId", establishmentId)
-                .setParameter("userId", userId)
-                .getResultList();
-        return results.isEmpty() ? null : results.get(0);
-    }
-
-    /**
-     * Récupère toutes les notes d'un établissement.
-     *
-     * @param establishmentId L'ID de l'établissement
-     * @return Liste des notes de l'établissement
-     */
-    public List<EstablishmentRating> findByEstablishmentId(UUID establishmentId) {
-        return find("establishment.id = ?1 ORDER BY ratedAt DESC", establishmentId).list();
-    }
-
-    /**
-     * Calcule la note moyenne d'un établissement.
-     *
-     * @param establishmentId L'ID de l'établissement
-     * @return La note moyenne (0.0 si aucune note)
-     */
-    public Double calculateAverageRating(UUID establishmentId) {
-        List<EstablishmentRating> ratings = findByEstablishmentId(establishmentId);
-        if (ratings.isEmpty()) {
-            return 0.0;
-        }
-        return ratings.stream()
-                .mapToInt(EstablishmentRating::getRating)
-                .average()
-                .orElse(0.0);
-    }
-
-    /**
-     * Calcule la distribution des notes pour un établissement.
-     *
-     * @param establishmentId L'ID de l'établissement
-     * @return Map avec clé = nombre d'étoiles (1-5), valeur = nombre de notes
-     */
-    public Map<Integer, Integer> calculateRatingDistribution(UUID establishmentId) {
-        List<EstablishmentRating> ratings = findByEstablishmentId(establishmentId);
-        return ratings.stream()
-                .collect(Collectors.groupingBy(
-                        EstablishmentRating::getRating,
-                        Collectors.collectingAndThen(Collectors.counting(), Long::intValue)
-                ));
-    }
-
-    /**
-     * Compte le nombre total de notes pour un établissement.
-     *
-     * @param establishmentId L'ID de l'établissement
-     * @return Le nombre total de notes
-     */
-    public Long countByEstablishmentId(UUID establishmentId) {
-        return count("establishment.id = ?1", establishmentId);
-    }
-}
-

src/main/java/com/lions/dev/repository/EstablishmentRepository.java

@@ -1,88 +0,0 @@
-package com.lions.dev.repository;
-
-import com.lions.dev.entity.establishment.Establishment;
-import io.quarkus.hibernate.orm.panache.PanacheRepositoryBase;
-import jakarta.enterprise.context.ApplicationScoped;
-import java.util.List;
-import java.util.UUID;
-import org.jboss.logging.Logger;
-
-/**
- * Repository pour l'entité Establishment.
- * Ce repository gère les opérations de base (CRUD) sur les établissements.
- */
-@ApplicationScoped
-public class EstablishmentRepository implements PanacheRepositoryBase<Establishment, UUID> {
-
-  private static final Logger LOG = Logger.getLogger(EstablishmentRepository.class);
-
-  /**
-   * Récupère tous les établissements gérés par un responsable.
-   *
-   * @param managerId L'ID du responsable.
-   * @return Une liste d'établissements gérés par ce responsable.
-   */
-  public List<Establishment> findByManagerId(UUID managerId) {
-    LOG.info("[LOG] Récupération des établissements du responsable : " + managerId);
-    List<Establishment> establishments = list("manager.id = ?1", managerId);
-    LOG.info("[LOG] Nombre d'établissements trouvés pour le responsable " + managerId + " : " + establishments.size());
-    return establishments;
-  }
-
-  /**
-   * Recherche des établissements par nom ou ville.
-   *
-   * @param query Le terme de recherche.
-   * @return Une liste d'établissements correspondant à la recherche.
-   */
-  public List<Establishment> searchByNameOrCity(String query) {
-    LOG.info("[LOG] Recherche d'établissements avec la requête : " + query);
-    String searchPattern = "%" + query.toLowerCase() + "%";
-    List<Establishment> establishments = list(
-        "LOWER(name) LIKE ?1 OR LOWER(city) LIKE ?1", 
-        searchPattern
-    );
-    LOG.info("[LOG] Nombre d'établissements trouvés : " + establishments.size());
-    return establishments;
-  }
-
-  /**
-   * Filtre les établissements par type.
-   *
-   * @param type Le type d'établissement.
-   * @return Une liste d'établissements du type spécifié.
-   */
-  public List<Establishment> findByType(String type) {
-    LOG.info("[LOG] Filtrage des établissements par type : " + type);
-    List<Establishment> establishments = list("type = ?1", type);
-    LOG.info("[LOG] Nombre d'établissements trouvés : " + establishments.size());
-    return establishments;
-  }
-
-  /**
-   * Filtre les établissements par ville.
-   *
-   * @param city La ville.
-   * @return Une liste d'établissements dans cette ville.
-   */
-  public List<Establishment> findByCity(String city) {
-    LOG.info("[LOG] Filtrage des établissements par ville : " + city);
-    List<Establishment> establishments = list("city = ?1", city);
-    LOG.info("[LOG] Nombre d'établissements trouvés : " + establishments.size());
-    return establishments;
-  }
-
-  /**
-   * Filtre les établissements par fourchette de prix.
-   *
-   * @param priceRange La fourchette de prix.
-   * @return Une liste d'établissements avec cette fourchette de prix.
-   */
-  public List<Establishment> findByPriceRange(String priceRange) {
-    LOG.info("[LOG] Filtrage des établissements par fourchette de prix : " + priceRange);
-    List<Establishment> establishments = list("priceRange = ?1", priceRange);
-    LOG.info("[LOG] Nombre d'établissements trouvés : " + establishments.size());
-    return establishments;
-  }
-}
-

src/main/java/com/lions/dev/repository/EventsRepository.java

@@ -2,8 +2,6 @@ package com.lions.dev.repository;
 
 import com.lions.dev.entity.events.Events;
 import io.quarkus.hibernate.orm.panache.PanacheRepositoryBase;
-import io.quarkus.panache.common.Page;
-import io.quarkus.panache.common.Sort;
 import jakarta.enterprise.context.ApplicationScoped;
 import java.time.LocalDateTime;
 import java.util.List;
@@ -51,33 +49,4 @@ public class EventsRepository implements PanacheRepositoryBase<Events, UUID> {
     LOG.info("[LOG] Nombre d'événements trouvés entre les dates " + startDate + " et " + endDate + " : " + events.size());
     return events;
   }
-
-  /**
-   * Récupère les événements créés par l'utilisateur et ses amis (relations d'amitié acceptées).
-   *
-   * @param userId L'ID de l'utilisateur
-   * @param friendIds Liste des IDs des amis de l'utilisateur
-   * @param page Le numéro de la page (0-indexé)
-   * @param size La taille de la page
-   * @return Liste paginée des événements de l'utilisateur et de ses amis
-   */
-  public List<Events> findEventsByFriends(UUID userId, List<UUID> friendIds, int page, int size) {
-    LOG.info("[LOG] Récupération des événements des amis pour l'utilisateur ID : " + userId);
-
-    if (friendIds == null || friendIds.isEmpty()) {
-      LOG.info("[LOG] Aucun ami trouvé pour l'utilisateur ID : " + userId);
-      return List.of();
-    }
-
-    // Récupérer les événements de l'utilisateur ET de ses amis
-    List<UUID> allUserIds = new java.util.ArrayList<>(friendIds);
-    allUserIds.add(userId);
-
-    List<Events> events = find("creator.id IN ?1", Sort.by("createdAt", Sort.Direction.Descending), allUserIds)
-        .page(Page.of(page, size))
-        .list();
-
-    LOG.info("[LOG] " + events.size() + " événement(s) récupéré(s) des amis");
-    return events;
-  }
 }

src/main/java/com/lions/dev/repository/FriendshipRepository.java

@@ -95,44 +95,4 @@ public class FriendshipRepository implements PanacheRepositoryBase<Friendship, U
     logger.infof("Nombre de relations récupérées pour l'utilisateur %s avec le statut %s : %d", user.getId(), status, friendships.size());
     return friendships;
   }
-
-  /**
-   * Récupérer les demandes d'amitié envoyées par un utilisateur (où l'utilisateur est l'expéditeur).
-   *
-   * @param user L'utilisateur qui a envoyé les demandes.
-   * @param status Le statut des relations d'amitié à filtrer (PENDING, etc.).
-   * @param page Le numéro de la page à récupérer.
-   * @param size La taille de la page (nombre d'éléments).
-   * @return Une liste paginée de relations d'amitié envoyées.
-   */
-  public List<Friendship> findSentRequestsByUser(Users user, FriendshipStatus status, int page, int size) {
-    logger.infof("Récupération des demandes d'amitié envoyées par l'utilisateur %s avec le statut %s, page %d, taille %d", user.getId(), status, page, size);
-
-    List<Friendship> friendships = find("user = ?1 AND status = ?2", user, status)
-        .page(page, size)
-        .list();
-
-    logger.infof("Nombre de demandes envoyées récupérées pour l'utilisateur %s : %d", user.getId(), friendships.size());
-    return friendships;
-  }
-
-  /**
-   * Récupérer les demandes d'amitié reçues par un utilisateur (où l'utilisateur est le destinataire).
-   *
-   * @param user L'utilisateur qui a reçu les demandes.
-   * @param status Le statut des relations d'amitié à filtrer (PENDING, etc.).
-   * @param page Le numéro de la page à récupérer.
-   * @param size La taille de la page (nombre d'éléments).
-   * @return Une liste paginée de relations d'amitié reçues.
-   */
-  public List<Friendship> findReceivedRequestsByUser(Users user, FriendshipStatus status, int page, int size) {
-    logger.infof("Récupération des demandes d'amitié reçues par l'utilisateur %s avec le statut %s, page %d, taille %d", user.getId(), status, page, size);
-
-    List<Friendship> friendships = find("friend = ?1 AND status = ?2", user, status)
-        .page(page, size)
-        .list();
-
-    logger.infof("Nombre de demandes reçues récupérées pour l'utilisateur %s : %d", user.getId(), friendships.size());
-    return friendships;
-  }
 }

src/main/java/com/lions/dev/repository/MessageRepository.java

@@ -1,92 +0,0 @@
-package com.lions.dev.repository;
-
-import com.lions.dev.entity.chat.Conversation;
-import com.lions.dev.entity.chat.Message;
-import io.quarkus.hibernate.orm.panache.PanacheRepositoryBase;
-import io.quarkus.panache.common.Page;
-import io.quarkus.panache.common.Sort;
-import jakarta.enterprise.context.ApplicationScoped;
-
-import java.util.List;
-import java.util.UUID;
-
-/**
- * Repository pour la gestion des messages.
- *
- * Ce repository gère les opérations CRUD sur les messages,
- * avec des méthodes de recherche et de pagination.
- */
-@ApplicationScoped
-public class MessageRepository implements PanacheRepositoryBase<Message, UUID> {
-
-  /**
-   * Récupère tous les messages d'une conversation avec pagination.
-   *
-   * @param conversationId L'ID de la conversation
-   * @param page Le numéro de la page (0-indexé)
-   * @param size La taille de la page
-   * @return Liste paginée des messages triés par date (du plus récent au plus ancien)
-   */
-  public List<Message> findByConversationId(UUID conversationId, int page, int size) {
-    System.out.println("[LOG] Récupération des messages pour la conversation ID : " + conversationId);
-    return find("conversation.id = ?1", Sort.by("createdAt", Sort.Direction.Descending), conversationId)
-        .page(Page.of(page, size))
-        .list();
-  }
-
-  /**
-   * Récupère tous les messages d'une conversation (sans pagination).
-   *
-   * @param conversation La conversation
-   * @return Liste de tous les messages triés par date
-   */
-  public List<Message> findByConversation(Conversation conversation) {
-    System.out.println("[LOG] Récupération de tous les messages pour la conversation ID : " + conversation.getId());
-    return find("conversation = ?1", Sort.by("createdAt", Sort.Direction.Ascending), conversation).list();
-  }
-
-  /**
-   * Compte le nombre de messages non lus dans une conversation pour un destinataire.
-   *
-   * @param conversationId L'ID de la conversation
-   * @param recipientId L'ID du destinataire
-   * @return Le nombre de messages non lus
-   */
-  public long countUnreadMessages(UUID conversationId, UUID recipientId) {
-    return count("conversation.id = ?1 and sender.id != ?2 and isRead = false", conversationId, recipientId);
-  }
-
-  /**
-   * Marque tous les messages comme lus pour un destinataire dans une conversation.
-   *
-   * @param conversationId L'ID de la conversation
-   * @param recipientId L'ID du destinataire
-   * @return Le nombre de messages mis à jour
-   */
-  public int markAllAsRead(UUID conversationId, UUID recipientId) {
-    System.out.println("[LOG] Marquage de tous les messages comme lus pour la conversation " + conversationId);
-    return update("isRead = true where conversation.id = ?1 and sender.id != ?2 and isRead = false", conversationId, recipientId);
-  }
-
-  /**
-   * Récupère le dernier message d'une conversation.
-   *
-   * @param conversationId L'ID de la conversation
-   * @return Le dernier message ou null
-   */
-  public Message findLastMessage(UUID conversationId) {
-    return find("conversation.id = ?1", Sort.by("createdAt", Sort.Direction.Descending), conversationId)
-        .firstResult();
-  }
-
-  /**
-   * Supprime tous les messages d'une conversation.
-   *
-   * @param conversationId L'ID de la conversation
-   * @return Le nombre de messages supprimés
-   */
-  public long deleteByConversationId(UUID conversationId) {
-    System.out.println("[LOG] Suppression de tous les messages pour la conversation " + conversationId);
-    return delete("conversation.id = ?1", conversationId);
-  }
-}

src/main/java/com/lions/dev/repository/NotificationRepository.java

@@ -1,104 +0,0 @@
-package com.lions.dev.repository;
-
-import com.lions.dev.entity.notification.Notification;
-import io.quarkus.hibernate.orm.panache.PanacheRepositoryBase;
-import io.quarkus.panache.common.Page;
-import io.quarkus.panache.common.Sort;
-import jakarta.enterprise.context.ApplicationScoped;
-import java.util.List;
-import java.util.UUID;
-
-/**
- * Repository pour l'entité Notification.
- * 
- * Ce repository gère les opérations de base (CRUD) sur les notifications
- * ainsi que des méthodes personnalisées pour récupérer les notifications
- * par utilisateur, par statut de lecture, etc.
- * 
- * Utilisation de Panache pour simplifier les opérations sur la base de données.
- */
-@ApplicationScoped
-public class NotificationRepository implements PanacheRepositoryBase<Notification, UUID> {
-
-  /**
-   * Récupère toutes les notifications d'un utilisateur.
-   *
-   * @param userId L'ID de l'utilisateur
-   * @return Liste des notifications de l'utilisateur, triées par date de création décroissante
-   */
-  public List<Notification> findByUserId(UUID userId) {
-    System.out.println("[LOG] Récupération des notifications pour l'utilisateur ID : " + userId);
-    List<Notification> notifications = find("user.id", Sort.by("createdAt", Sort.Direction.Descending), userId).list();
-    System.out.println("[LOG] " + notifications.size() + " notification(s) trouvée(s) pour l'utilisateur ID : " + userId);
-    return notifications;
-  }
-
-  /**
-   * Récupère toutes les notifications non lues d'un utilisateur.
-   *
-   * @param userId L'ID de l'utilisateur
-   * @return Liste des notifications non lues de l'utilisateur
-   */
-  public List<Notification> findUnreadByUserId(UUID userId) {
-    System.out.println("[LOG] Récupération des notifications non lues pour l'utilisateur ID : " + userId);
-    List<Notification> notifications = find("user.id = ?1 AND isRead = false", Sort.by("createdAt", Sort.Direction.Descending), userId).list();
-    System.out.println("[LOG] " + notifications.size() + " notification(s) non lue(s) trouvée(s) pour l'utilisateur ID : " + userId);
-    return notifications;
-  }
-
-  /**
-   * Récupère les notifications d'un utilisateur avec pagination.
-   *
-   * @param userId L'ID de l'utilisateur
-   * @param page Le numéro de la page (0-indexé)
-   * @param size La taille de la page
-   * @return Liste paginée des notifications
-   */
-  public List<Notification> findByUserIdWithPagination(UUID userId, int page, int size) {
-    System.out.println("[LOG] Récupération paginée des notifications pour l'utilisateur ID : " + userId + " (page: " + page + ", size: " + size + ")");
-    List<Notification> notifications = find("user.id", Sort.by("createdAt", Sort.Direction.Descending), userId)
-        .page(Page.of(page, size))
-        .list();
-    System.out.println("[LOG] " + notifications.size() + " notification(s) récupérée(s) pour la page " + page);
-    return notifications;
-  }
-
-  /**
-   * Compte le nombre de notifications non lues d'un utilisateur.
-   *
-   * @param userId L'ID de l'utilisateur
-   * @return Le nombre de notifications non lues
-   */
-  public long countUnreadByUserId(UUID userId) {
-    long count = count("user.id = ?1 AND isRead = false", userId);
-    System.out.println("[LOG] " + count + " notification(s) non lue(s) pour l'utilisateur ID : " + userId);
-    return count;
-  }
-
-  /**
-   * Marque toutes les notifications d'un utilisateur comme lues.
-   *
-   * @param userId L'ID de l'utilisateur
-   * @return Le nombre de notifications mises à jour
-   */
-  public int markAllAsReadByUserId(UUID userId) {
-    System.out.println("[LOG] Marquage de toutes les notifications comme lues pour l'utilisateur ID : " + userId);
-    int updated = update("isRead = true WHERE user.id = ?1", userId);
-    System.out.println("[LOG] " + updated + " notification(s) marquée(s) comme lue(s)");
-    return updated;
-  }
-
-  /**
-   * Supprime toutes les notifications lues d'un utilisateur.
-   *
-   * @param userId L'ID de l'utilisateur
-   * @return Le nombre de notifications supprimées
-   */
-  public long deleteReadByUserId(UUID userId) {
-    System.out.println("[LOG] Suppression des notifications lues pour l'utilisateur ID : " + userId);
-    long deleted = delete("user.id = ?1 AND isRead = true", userId);
-    System.out.println("[LOG] " + deleted + " notification(s) supprimée(s)");
-    return deleted;
-  }
-}
-

src/main/java/com/lions/dev/repository/SocialPostRepository.java

@@ -1,109 +0,0 @@
-package com.lions.dev.repository;
-
-import com.lions.dev.entity.social.SocialPost;
-import io.quarkus.hibernate.orm.panache.PanacheRepositoryBase;
-import io.quarkus.panache.common.Page;
-import io.quarkus.panache.common.Sort;
-import jakarta.enterprise.context.ApplicationScoped;
-import java.util.List;
-import java.util.UUID;
-
-/**
- * Repository pour l'entité SocialPost.
- * 
- * Ce repository gère les opérations de base (CRUD) sur les posts sociaux
- * ainsi que des méthodes personnalisées pour la recherche et la pagination.
- * 
- * Utilisation de Panache pour simplifier les opérations sur la base de données.
- */
-@ApplicationScoped
-public class SocialPostRepository implements PanacheRepositoryBase<SocialPost, UUID> {
-
-  /**
-   * Récupère tous les posts avec pagination, triés par date de création décroissante.
-   *
-   * @param page Le numéro de la page (0-indexé)
-   * @param size La taille de la page
-   * @return Liste paginée des posts
-   */
-  public List<SocialPost> findAllWithPagination(int page, int size) {
-    System.out.println("[LOG] Récupération paginée des posts (page: " + page + ", size: " + size + ")");
-    List<SocialPost> posts = findAll(Sort.by("createdAt", Sort.Direction.Descending))
-        .page(Page.of(page, size))
-        .list();
-    System.out.println("[LOG] " + posts.size() + " post(s) récupéré(s)");
-    return posts;
-  }
-
-  /**
-   * Récupère tous les posts d'un utilisateur.
-   *
-   * @param userId L'ID de l'utilisateur
-   * @return Liste des posts de l'utilisateur
-   */
-  public List<SocialPost> findByUserId(UUID userId) {
-    System.out.println("[LOG] Récupération des posts pour l'utilisateur ID : " + userId);
-    List<SocialPost> posts = find("user.id", Sort.by("createdAt", Sort.Direction.Descending), userId).list();
-    System.out.println("[LOG] " + posts.size() + " post(s) trouvé(s) pour l'utilisateur ID : " + userId);
-    return posts;
-  }
-
-  /**
-   * Recherche des posts par contenu (recherche textuelle).
-   *
-   * @param query Le terme de recherche
-   * @return Liste des posts correspondant à la recherche
-   */
-  public List<SocialPost> searchByContent(String query) {
-    System.out.println("[LOG] Recherche de posts avec la requête : " + query);
-    String searchPattern = "%" + query.toLowerCase() + "%";
-    List<SocialPost> posts = find("LOWER(content) LIKE ?1", Sort.by("createdAt", Sort.Direction.Descending), searchPattern).list();
-    System.out.println("[LOG] " + posts.size() + " post(s) trouvé(s) pour la requête : " + query);
-    return posts;
-  }
-
-  /**
-   * Récupère les posts les plus populaires (par nombre de likes).
-   *
-   * @param limit Le nombre maximum de posts à retourner
-   * @return Liste des posts les plus populaires
-   */
-  public List<SocialPost> findPopularPosts(int limit) {
-    System.out.println("[LOG] Récupération des " + limit + " posts les plus populaires");
-    List<SocialPost> posts = findAll(Sort.by("likesCount", Sort.Direction.Descending))
-        .page(0, limit)
-        .list();
-    System.out.println("[LOG] " + posts.size() + " post(s) populaire(s) récupéré(s)");
-    return posts;
-  }
-
-  /**
-   * Récupère les posts des amis d'un utilisateur (relations d'amitié acceptées).
-   *
-   * @param userId L'ID de l'utilisateur
-   * @param friendIds Liste des IDs des amis de l'utilisateur
-   * @param page Le numéro de la page (0-indexé)
-   * @param size La taille de la page
-   * @return Liste paginée des posts des amis
-   */
-  public List<SocialPost> findPostsByFriends(UUID userId, List<UUID> friendIds, int page, int size) {
-    System.out.println("[LOG] Récupération des posts des amis pour l'utilisateur ID : " + userId);
-
-    if (friendIds == null || friendIds.isEmpty()) {
-      System.out.println("[LOG] Aucun ami trouvé pour l'utilisateur ID : " + userId);
-      return List.of();
-    }
-
-    // Récupérer les posts de l'utilisateur ET de ses amis
-    List<UUID> allUserIds = new java.util.ArrayList<>(friendIds);
-    allUserIds.add(userId);
-
-    List<SocialPost> posts = find("user.id IN ?1", Sort.by("createdAt", Sort.Direction.Descending), allUserIds)
-        .page(Page.of(page, size))
-        .list();
-
-    System.out.println("[LOG] " + posts.size() + " post(s) récupéré(s) des amis");
-    return posts;
-  }
-}
-

src/main/java/com/lions/dev/repository/StoryRepository.java

@@ -1,134 +0,0 @@
-package com.lions.dev.repository;
-
-import com.lions.dev.entity.story.Story;
-import io.quarkus.hibernate.orm.panache.PanacheRepositoryBase;
-import io.quarkus.panache.common.Sort;
-import jakarta.enterprise.context.ApplicationScoped;
-import java.time.LocalDateTime;
-import java.util.List;
-import java.util.UUID;
-
-/**
- * Repository pour l'entité Story.
- *
- * Ce repository gère les opérations de base (CRUD) sur les stories
- * ainsi que des méthodes personnalisées pour gérer l'expiration et les vues.
- *
- * Utilisation de Panache pour simplifier les opérations sur la base de données.
- */
-@ApplicationScoped
-public class StoryRepository implements PanacheRepositoryBase<Story, UUID> {
-
-  /**
-   * Récupère toutes les stories actives (non expirées), triées par date de création décroissante.
-   *
-   * @return Liste des stories actives
-   */
-  public List<Story> findAllActive() {
-    return findAllActive(0, Integer.MAX_VALUE);
-  }
-
-  /**
-   * Récupère toutes les stories actives (non expirées) avec pagination, triées par date de création décroissante.
-   *
-   * @param page Le numéro de la page (0-indexé)
-   * @param size La taille de la page
-   * @return Liste paginée des stories actives
-   */
-  public List<Story> findAllActive(int page, int size) {
-    System.out.println("[LOG] Récupération de toutes les stories actives (page: " + page + ", size: " + size + ")");
-    List<Story> stories = find("isActive = true AND expiresAt > ?1",
-        Sort.by("createdAt", Sort.Direction.Descending),
-        LocalDateTime.now())
-        .page(page, size)
-        .list();
-    System.out.println("[LOG] " + stories.size() + " story(ies) active(s) récupérée(s)");
-    return stories;
-  }
-
-  /**
-   * Récupère toutes les stories actives d'un utilisateur.
-   *
-   * @param userId L'ID de l'utilisateur
-   * @return Liste des stories actives de l'utilisateur
-   */
-  public List<Story> findActiveByUserId(UUID userId) {
-    return findActiveByUserId(userId, 0, Integer.MAX_VALUE);
-  }
-
-  /**
-   * Récupère toutes les stories actives d'un utilisateur avec pagination.
-   *
-   * @param userId L'ID de l'utilisateur
-   * @param page Le numéro de la page (0-indexé)
-   * @param size La taille de la page
-   * @return Liste paginée des stories actives de l'utilisateur
-   */
-  public List<Story> findActiveByUserId(UUID userId, int page, int size) {
-    System.out.println("[LOG] Récupération des stories actives pour l'utilisateur ID : " + userId + " (page: " + page + ", size: " + size + ")");
-    List<Story> stories = find("user.id = ?1 AND isActive = true AND expiresAt > ?2",
-        Sort.by("createdAt", Sort.Direction.Descending),
-        userId,
-        LocalDateTime.now())
-        .page(page, size)
-        .list();
-    System.out.println("[LOG] " + stories.size() + " story(ies) active(s) trouvée(s) pour l'utilisateur ID : " + userId);
-    return stories;
-  }
-
-  /**
-   * Récupère toutes les stories (actives et inactives) d'un utilisateur.
-   *
-   * @param userId L'ID de l'utilisateur
-   * @return Liste de toutes les stories de l'utilisateur
-   */
-  public List<Story> findAllByUserId(UUID userId) {
-    System.out.println("[LOG] Récupération de toutes les stories pour l'utilisateur ID : " + userId);
-    List<Story> stories = find("user.id", Sort.by("createdAt", Sort.Direction.Descending), userId).list();
-    System.out.println("[LOG] " + stories.size() + " story(ies) trouvée(s) pour l'utilisateur ID : " + userId);
-    return stories;
-  }
-
-  /**
-   * Récupère toutes les stories expirées qui sont encore marquées comme actives.
-   * Utile pour un job de nettoyage périodique.
-   *
-   * @return Liste des stories expirées
-   */
-  public List<Story> findExpiredStories() {
-    System.out.println("[LOG] Récupération des stories expirées");
-    List<Story> stories = find("isActive = true AND expiresAt <= ?1", LocalDateTime.now()).list();
-    System.out.println("[LOG] " + stories.size() + " story(ies) expirée(s) trouvée(s)");
-    return stories;
-  }
-
-  /**
-   * Marque toutes les stories expirées comme inactives.
-   * Cette méthode doit être appelée périodiquement par un job.
-   *
-   * @return Le nombre de stories désactivées
-   */
-  public int deactivateExpiredStories() {
-    System.out.println("[LOG] Désactivation des stories expirées");
-    int updated = update("isActive = false WHERE isActive = true AND expiresAt <= ?1", LocalDateTime.now());
-    System.out.println("[LOG] " + updated + " story(ies) désactivée(s)");
-    return updated;
-  }
-
-  /**
-   * Récupère les stories les plus vues.
-   *
-   * @param limit Le nombre maximum de stories à retourner
-   * @return Liste des stories les plus vues
-   */
-  public List<Story> findMostViewedStories(int limit) {
-    System.out.println("[LOG] Récupération des " + limit + " stories les plus vues");
-    List<Story> stories = find("isActive = true AND expiresAt > ?1",
-        Sort.by("viewsCount", Sort.Direction.Descending),
-        LocalDateTime.now())
-        .page(0, limit)
-        .list();
-    System.out.println("[LOG] " + stories.size() + " story(ies) populaire(s) récupérée(s)");
-    return stories;
-  }
-}

src/main/java/com/lions/dev/repository/UsersRepository.java

@@ -1,11 +1,8 @@
 package com.lions.dev.repository;
 
-import com.lions.dev.entity.events.Events;
 import com.lions.dev.entity.users.Users;
 import io.quarkus.hibernate.orm.panache.PanacheRepositoryBase;
 import jakarta.enterprise.context.ApplicationScoped;
-import jakarta.persistence.EntityManager;
-import jakarta.persistence.PersistenceContext;
 import java.util.Optional;
 import java.util.UUID;
 
@@ -18,43 +15,6 @@ import java.util.UUID;
 @ApplicationScoped
 public class UsersRepository implements PanacheRepositoryBase<Users, UUID> {
 
-  @PersistenceContext
-  EntityManager entityManager;
-
-  /**
-   * Compte le nombre d'utilisateurs qui ont un événement en favori.
-   *
-   * @param eventId L'ID de l'événement
-   * @return Le nombre d'utilisateurs qui ont cet événement en favori
-   */
-  public long countUsersWithFavoriteEvent(UUID eventId) {
-    // ✅ Utiliser la table de jointure user_favorite_events
-    return entityManager.createQuery(
-        "SELECT COUNT(u) FROM Users u JOIN u.favoriteEvents e WHERE e.id = :eventId",
-        Long.class
-    )
-    .setParameter("eventId", eventId)
-    .getSingleResult();
-  }
-
-  /**
-   * Vérifie si un utilisateur a un événement en favori.
-   *
-   * @param userId L'ID de l'utilisateur
-   * @param eventId L'ID de l'événement
-   * @return true si l'utilisateur a cet événement en favori, false sinon
-   */
-  public boolean hasUserFavoriteEvent(UUID userId, UUID eventId) {
-    Long count = entityManager.createQuery(
-        "SELECT COUNT(u) FROM Users u JOIN u.favoriteEvents e WHERE u.id = :userId AND e.id = :eventId",
-        Long.class
-    )
-    .setParameter("userId", userId)
-    .setParameter("eventId", eventId)
-    .getSingleResult();
-    return count > 0;
-  }
-
   /**
    * Recherche un utilisateur par son adresse email.
    *

src/main/java/com/lions/dev/resource/EstablishmentMediaResource.java

@@ -1,172 +0,0 @@
-package com.lions.dev.resource;
-
-import com.lions.dev.dto.request.establishment.EstablishmentMediaRequestDTO;
-import com.lions.dev.dto.response.establishment.EstablishmentMediaResponseDTO;
-import com.lions.dev.entity.establishment.EstablishmentMedia;
-import com.lions.dev.entity.establishment.MediaType;
-import com.lions.dev.service.EstablishmentMediaService;
-import jakarta.inject.Inject;
-import jakarta.transaction.Transactional;
-import jakarta.validation.Valid;
-import jakarta.ws.rs.*;
-import jakarta.ws.rs.core.Response;
-import org.eclipse.microprofile.openapi.annotations.Operation;
-import org.eclipse.microprofile.openapi.annotations.tags.Tag;
-import org.jboss.logging.Logger;
-
-import java.util.List;
-import java.util.UUID;
-import java.util.stream.Collectors;
-
-/**
- * Ressource REST pour la gestion des médias d'établissements.
- * Cette classe expose des endpoints pour uploader, récupérer et supprimer des médias.
- */
-@Path("/establishments/{establishmentId}/media")
-@Produces(jakarta.ws.rs.core.MediaType.APPLICATION_JSON)
-@Consumes(jakarta.ws.rs.core.MediaType.APPLICATION_JSON)
-@Tag(name = "Establishment Media", description = "Opérations liées aux médias des établissements")
-public class EstablishmentMediaResource {
-
-    @Inject
-    EstablishmentMediaService mediaService;
-
-    private static final Logger LOG = Logger.getLogger(EstablishmentMediaResource.class);
-
-    /**
-     * Récupère tous les médias d'un établissement.
-     */
-    @GET
-    @Operation(summary = "Récupérer tous les médias d'un établissement",
-               description = "Retourne la liste de tous les médias (photos et vidéos) d'un établissement")
-    public Response getEstablishmentMedia(@PathParam("establishmentId") String establishmentId) {
-        LOG.info("Récupération des médias pour l'établissement : " + establishmentId);
-
-        try {
-            UUID id = UUID.fromString(establishmentId);
-            List<EstablishmentMedia> medias = mediaService.getMediaByEstablishmentId(id);
-            List<EstablishmentMediaResponseDTO> responseDTOs = medias.stream()
-                    .map(EstablishmentMediaResponseDTO::new)
-                    .collect(Collectors.toList());
-            return Response.ok(responseDTOs).build();
-        } catch (IllegalArgumentException e) {
-            LOG.error("ID d'établissement invalide : " + establishmentId);
-            return Response.status(Response.Status.BAD_REQUEST)
-                    .entity("ID d'établissement invalide")
-                    .build();
-        } catch (Exception e) {
-            LOG.error("Erreur lors de la récupération des médias", e);
-            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-                    .entity("Erreur lors de la récupération des médias")
-                    .build();
-        }
-    }
-
-    /**
-     * Upload un nouveau média pour un établissement.
-     * Accepte un body JSON avec les informations du média.
-     */
-    @POST
-    @Transactional
-    @Operation(summary = "Uploader un média pour un établissement",
-               description = "Upload un nouveau média (photo ou vidéo) pour un établissement")
-    public Response uploadMedia(
-            @PathParam("establishmentId") String establishmentId,
-            @Valid EstablishmentMediaRequestDTO requestDTO,
-            @QueryParam("uploadedByUserId") String uploadedByUserIdStr) {
-        LOG.info("Upload d'un média pour l'établissement : " + establishmentId);
-
-        try {
-            UUID id = UUID.fromString(establishmentId);
-            
-            // Utiliser uploadedByUserId du query param ou du DTO
-            String userIdStr = uploadedByUserIdStr != null && !uploadedByUserIdStr.isEmpty() 
-                    ? uploadedByUserIdStr 
-                    : requestDTO.getUploadedByUserId();
-            
-            if (userIdStr == null || userIdStr.isEmpty()) {
-                LOG.error("uploadedByUserId est obligatoire");
-                return Response.status(Response.Status.BAD_REQUEST)
-                        .entity("L'ID de l'utilisateur (uploadedByUserId) est obligatoire")
-                        .build();
-            }
-            
-            UUID uploadedByUserId = UUID.fromString(userIdStr);
-
-            // Valider le type de média
-            MediaType mediaType;
-            try {
-                mediaType = MediaType.valueOf(requestDTO.getMediaType().toUpperCase());
-            } catch (IllegalArgumentException e) {
-                return Response.status(Response.Status.BAD_REQUEST)
-                        .entity("Type de média invalide. Utilisez PHOTO ou VIDEO")
-                        .build();
-            }
-
-            // Appeler le service avec displayOrder
-            EstablishmentMedia media = mediaService.uploadMedia(
-                    id, 
-                    requestDTO.getMediaUrl(), 
-                    mediaType, 
-                    uploadedByUserId, 
-                    requestDTO.getThumbnailUrl(),
-                    requestDTO.getDisplayOrder() != null ? requestDTO.getDisplayOrder() : 0
-            );
-            
-            EstablishmentMediaResponseDTO responseDTO = new EstablishmentMediaResponseDTO(media);
-            return Response.status(Response.Status.CREATED).entity(responseDTO).build();
-        } catch (IllegalArgumentException e) {
-            LOG.error("Paramètres invalides : " + e.getMessage(), e);
-            return Response.status(Response.Status.BAD_REQUEST)
-                    .entity("Paramètres invalides : " + e.getMessage())
-                    .build();
-        } catch (RuntimeException e) {
-            LOG.error("Erreur lors de l'upload du média : " + e.getMessage(), e);
-            return Response.status(Response.Status.BAD_REQUEST)
-                    .entity(e.getMessage())
-                    .build();
-        } catch (Exception e) {
-            LOG.error("Erreur inattendue lors de l'upload du média", e);
-            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-                    .entity("Erreur lors de l'upload du média")
-                    .build();
-        }
-    }
-
-    /**
-     * Supprime un média d'un établissement.
-     */
-    @DELETE
-    @Path("/{mediaId}")
-    @Transactional
-    @Operation(summary = "Supprimer un média d'un établissement",
-               description = "Supprime un média spécifique d'un établissement")
-    public Response deleteMedia(
-            @PathParam("establishmentId") String establishmentId,
-            @PathParam("mediaId") String mediaId) {
-        LOG.info("Suppression du média " + mediaId + " de l'établissement " + establishmentId);
-
-        try {
-            UUID establishmentUuid = UUID.fromString(establishmentId);
-            UUID mediaUuid = UUID.fromString(mediaId);
-            mediaService.deleteMedia(establishmentUuid, mediaUuid);
-            return Response.status(Response.Status.NO_CONTENT).build();
-        } catch (IllegalArgumentException e) {
-            LOG.error("ID invalide : " + e.getMessage());
-            return Response.status(Response.Status.BAD_REQUEST)
-                    .entity("ID invalide")
-                    .build();
-        } catch (RuntimeException e) {
-            LOG.error("Erreur lors de la suppression du média : " + e.getMessage());
-            return Response.status(Response.Status.BAD_REQUEST)
-                    .entity(e.getMessage())
-                    .build();
-        } catch (Exception e) {
-            LOG.error("Erreur inattendue lors de la suppression du média", e);
-            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-                    .entity("Erreur lors de la suppression du média")
-                    .build();
-        }
-    }
-}
-

src/main/java/com/lions/dev/resource/EstablishmentRatingResource.java

@@ -1,233 +0,0 @@
-package com.lions.dev.resource;
-
-import com.lions.dev.dto.request.establishment.EstablishmentRatingRequestDTO;
-import com.lions.dev.dto.response.establishment.EstablishmentRatingResponseDTO;
-import com.lions.dev.dto.response.establishment.EstablishmentRatingStatsResponseDTO;
-import com.lions.dev.entity.establishment.EstablishmentRating;
-import com.lions.dev.service.EstablishmentRatingService;
-import jakarta.inject.Inject;
-import jakarta.transaction.Transactional;
-import jakarta.validation.Valid;
-import jakarta.ws.rs.*;
-import jakarta.ws.rs.core.MediaType;
-import jakarta.ws.rs.core.Response;
-import org.eclipse.microprofile.openapi.annotations.Operation;
-import org.eclipse.microprofile.openapi.annotations.tags.Tag;
-import org.jboss.logging.Logger;
-
-import java.util.Map;
-import java.util.UUID;
-
-/**
- * Ressource REST pour la gestion des notations d'établissements.
- * Cette classe expose des endpoints pour soumettre, modifier et récupérer les notes.
- */
-@Path("/establishments/{establishmentId}/ratings")
-@Produces(MediaType.APPLICATION_JSON)
-@Consumes(MediaType.APPLICATION_JSON)
-@Tag(name = "Establishment Ratings", description = "Opérations liées aux notations des établissements")
-public class EstablishmentRatingResource {
-
-    @Inject
-    EstablishmentRatingService ratingService;
-
-    private static final Logger LOG = Logger.getLogger(EstablishmentRatingResource.class);
-
-    /**
-     * Soumet une nouvelle note pour un établissement.
-     */
-    @POST
-    @Transactional
-    @Operation(summary = "Soumettre une note pour un établissement",
-               description = "Soumet une nouvelle note (1 à 5 étoiles) pour un établissement")
-    public Response submitRating(
-            @PathParam("establishmentId") String establishmentId,
-            @QueryParam("userId") String userIdStr,
-            @Valid EstablishmentRatingRequestDTO requestDTO) {
-        LOG.info("Soumission d'une note pour l'établissement " + establishmentId + " par l'utilisateur " + userIdStr);
-
-        try {
-            UUID id = UUID.fromString(establishmentId);
-            UUID userId = UUID.fromString(userIdStr);
-
-            EstablishmentRating rating = ratingService.submitRating(id, userId, requestDTO);
-            EstablishmentRatingResponseDTO responseDTO = new EstablishmentRatingResponseDTO(rating);
-            return Response.status(Response.Status.CREATED).entity(responseDTO).build();
-        } catch (IllegalArgumentException e) {
-            LOG.error("ID invalide : " + e.getMessage());
-            return Response.status(Response.Status.BAD_REQUEST)
-                    .entity("ID invalide : " + e.getMessage())
-                    .build();
-        } catch (RuntimeException e) {
-            LOG.error("Erreur lors de la soumission de la note : " + e.getMessage());
-            return Response.status(Response.Status.BAD_REQUEST)
-                    .entity(e.getMessage())
-                    .build();
-        } catch (Exception e) {
-            LOG.error("Erreur inattendue lors de la soumission de la note", e);
-            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-                    .entity("Erreur lors de la soumission de la note")
-                    .build();
-        }
-    }
-
-    /**
-     * Met à jour une note existante.
-     */
-    @PUT
-    @Transactional
-    @Operation(summary = "Modifier une note existante",
-               description = "Met à jour une note existante pour un établissement")
-    public Response updateRating(
-            @PathParam("establishmentId") String establishmentId,
-            @QueryParam("userId") String userIdStr,
-            @Valid EstablishmentRatingRequestDTO requestDTO) {
-        LOG.info("Mise à jour de la note pour l'établissement " + establishmentId + " par l'utilisateur " + userIdStr);
-
-        try {
-            UUID id = UUID.fromString(establishmentId);
-            UUID userId = UUID.fromString(userIdStr);
-
-            EstablishmentRating rating = ratingService.updateRating(id, userId, requestDTO);
-            EstablishmentRatingResponseDTO responseDTO = new EstablishmentRatingResponseDTO(rating);
-            return Response.ok(responseDTO).build();
-        } catch (IllegalArgumentException e) {
-            LOG.error("ID invalide : " + e.getMessage());
-            return Response.status(Response.Status.BAD_REQUEST)
-                    .entity("ID invalide : " + e.getMessage())
-                    .build();
-        } catch (RuntimeException e) {
-            LOG.error("Erreur lors de la mise à jour de la note : " + e.getMessage());
-            return Response.status(Response.Status.BAD_REQUEST)
-                    .entity(e.getMessage())
-                    .build();
-        } catch (Exception e) {
-            LOG.error("Erreur inattendue lors de la mise à jour de la note", e);
-            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-                    .entity("Erreur lors de la mise à jour de la note")
-                    .build();
-        }
-    }
-
-    /**
-     * Récupère les statistiques de notation d'un établissement.
-     * Doit être déclaré avant les endpoints génériques GET pour la résolution correcte par JAX-RS.
-     */
-    @GET
-    @Path("/stats")
-    @Operation(summary = "Récupérer les statistiques de notation",
-               description = "Récupère les statistiques de notation d'un établissement (moyenne, total, distribution)")
-    public Response getRatingStats(@PathParam("establishmentId") String establishmentId) {
-        LOG.info("Récupération des statistiques de notation pour l'établissement " + establishmentId);
-
-        try {
-            UUID id = UUID.fromString(establishmentId);
-            Map<String, Object> stats = ratingService.getRatingStats(id);
-
-            EstablishmentRatingStatsResponseDTO responseDTO = new EstablishmentRatingStatsResponseDTO(
-                    (Double) stats.get("averageRating"),
-                    (Integer) stats.get("totalRatingsCount"),
-                    (Map<Integer, Integer>) stats.get("ratingDistribution")
-            );
-            return Response.ok(responseDTO).build();
-        } catch (IllegalArgumentException e) {
-            LOG.error("ID invalide : " + e.getMessage());
-            return Response.status(Response.Status.BAD_REQUEST)
-                    .entity("ID invalide : " + e.getMessage())
-                    .build();
-        } catch (Exception e) {
-            LOG.error("Erreur inattendue lors de la récupération des statistiques", e);
-            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-                    .entity("Erreur lors de la récupération des statistiques")
-                    .build();
-        }
-    }
-
-    /**
-     * Récupère la note d'un utilisateur pour un établissement (via path parameter).
-     * Endpoint alternatif pour compatibilité.
-     */
-    @GET
-    @Path("/users/{userId}")
-    @Operation(summary = "Récupérer la note d'un utilisateur (path parameter)",
-               description = "Récupère la note donnée par un utilisateur spécifique pour un établissement (via path parameter)")
-    public Response getUserRatingByPath(
-            @PathParam("establishmentId") String establishmentId,
-            @PathParam("userId") String userIdStr) {
-        LOG.info("Récupération de la note de l'utilisateur " + userIdStr + " pour l'établissement " + establishmentId);
-
-        try {
-            UUID id = UUID.fromString(establishmentId);
-            UUID userId = UUID.fromString(userIdStr);
-
-            EstablishmentRating rating = ratingService.getUserRating(id, userId);
-            if (rating == null) {
-                return Response.status(Response.Status.NOT_FOUND)
-                        .entity("Note non trouvée")
-                        .build();
-            }
-
-            EstablishmentRatingResponseDTO responseDTO = new EstablishmentRatingResponseDTO(rating);
-            return Response.ok(responseDTO).build();
-        } catch (IllegalArgumentException e) {
-            LOG.error("ID invalide : " + e.getMessage(), e);
-            return Response.status(Response.Status.BAD_REQUEST)
-                    .entity("ID invalide : " + e.getMessage())
-                    .build();
-        } catch (Exception e) {
-            LOG.error("Erreur inattendue lors de la récupération de la note", e);
-            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-                    .entity("Erreur lors de la récupération de la note")
-                    .build();
-        }
-    }
-
-    /**
-     * Récupère la note d'un utilisateur pour un établissement (via query parameter).
-     * Endpoint utilisé par le frontend Flutter.
-     * Doit être déclaré en dernier car c'est l'endpoint le plus générique.
-     */
-    @GET
-    @Operation(summary = "Récupérer la note d'un utilisateur",
-               description = "Récupère la note donnée par un utilisateur spécifique pour un établissement (via query parameter userId)")
-    public Response getUserRatingByQuery(
-            @PathParam("establishmentId") String establishmentId,
-            @QueryParam("userId") String userIdStr) {
-        LOG.info("Récupération de la note de l'utilisateur " + userIdStr + " pour l'établissement " + establishmentId);
-
-        // Si userId n'est pas fourni, retourner une erreur
-        if (userIdStr == null || userIdStr.isEmpty()) {
-            LOG.warn("userId manquant dans la requête");
-            return Response.status(Response.Status.BAD_REQUEST)
-                    .entity("Le paramètre userId est requis")
-                    .build();
-        }
-
-        try {
-            UUID id = UUID.fromString(establishmentId);
-            UUID userId = UUID.fromString(userIdStr);
-
-            EstablishmentRating rating = ratingService.getUserRating(id, userId);
-            if (rating == null) {
-                // Retourner 404 si la note n'existe pas
-                return Response.status(Response.Status.NOT_FOUND)
-                        .entity("Note non trouvée")
-                        .build();
-            }
-
-            EstablishmentRatingResponseDTO responseDTO = new EstablishmentRatingResponseDTO(rating);
-            return Response.ok(responseDTO).build();
-        } catch (IllegalArgumentException e) {
-            LOG.error("ID invalide : " + e.getMessage(), e);
-            return Response.status(Response.Status.BAD_REQUEST)
-                    .entity("ID invalide : " + e.getMessage())
-                    .build();
-        } catch (Exception e) {
-            LOG.error("Erreur inattendue lors de la récupération de la note", e);
-            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-                    .entity("Erreur lors de la récupération de la note")
-                    .build();
-        }
-    }
-}
-

src/main/java/com/lions/dev/resource/EstablishmentResource.java

@@ -1,288 +0,0 @@
-package com.lions.dev.resource;
-
-import com.lions.dev.dto.request.establishment.EstablishmentCreateRequestDTO;
-import com.lions.dev.dto.request.establishment.EstablishmentUpdateRequestDTO;
-import com.lions.dev.dto.response.establishment.EstablishmentResponseDTO;
-import com.lions.dev.entity.establishment.Establishment;
-import com.lions.dev.entity.users.Users;
-import com.lions.dev.repository.UsersRepository;
-import com.lions.dev.service.EstablishmentService;
-import jakarta.inject.Inject;
-import jakarta.transaction.Transactional;
-import jakarta.validation.Valid;
-import jakarta.ws.rs.*;
-import jakarta.ws.rs.core.MediaType;
-import jakarta.ws.rs.core.Response;
-import org.eclipse.microprofile.openapi.annotations.Operation;
-import org.eclipse.microprofile.openapi.annotations.tags.Tag;
-import org.jboss.logging.Logger;
-
-import java.util.List;
-import java.util.UUID;
-import java.util.stream.Collectors;
-
-/**
- * Ressource REST pour la gestion des établissements dans le système AfterWork.
- * Cette classe expose des endpoints pour créer, récupérer, mettre à jour et supprimer des établissements.
- * Seuls les responsables d'établissement peuvent créer et gérer des établissements.
- */
-@Path("/establishments")
-@Produces(MediaType.APPLICATION_JSON)
-@Consumes(MediaType.APPLICATION_JSON)
-@Tag(name = "Establishments", description = "Opérations liées à la gestion des établissements")
-public class EstablishmentResource {
-
-  @Inject
-  EstablishmentService establishmentService;
-
-  @Inject
-  UsersRepository usersRepository;
-
-  private static final Logger LOG = Logger.getLogger(EstablishmentResource.class);
-
-  // *********** Création d'un établissement ***********
-
-  @POST
-  @Transactional
-  @Operation(summary = "Créer un nouvel établissement", 
-             description = "Crée un nouvel établissement. Seuls les responsables d'établissement peuvent créer des établissements.")
-  public Response createEstablishment(@Valid EstablishmentCreateRequestDTO requestDTO) {
-    LOG.info("[LOG] Tentative de création d'un nouvel établissement : " + requestDTO.getName());
-    
-    try {
-      // Vérifier que managerId est fourni
-      if (requestDTO.getManagerId() == null) {
-        LOG.error("[ERROR] managerId est obligatoire pour créer un établissement");
-        return Response.status(Response.Status.BAD_REQUEST)
-            .entity("L'identifiant du responsable (managerId) est obligatoire")
-            .build();
-      }
-
-      // Récupérer le responsable
-      Users manager = usersRepository.findById(requestDTO.getManagerId());
-      if (manager == null) {
-        LOG.error("[ERROR] Responsable non trouvé avec l'ID : " + requestDTO.getManagerId());
-        return Response.status(Response.Status.BAD_REQUEST)
-            .entity("Responsable non trouvé avec l'ID fourni")
-            .build();
-      }
-
-      // Créer l'établissement
-      Establishment establishment = new Establishment();
-      establishment.setName(requestDTO.getName());
-      establishment.setType(requestDTO.getType());
-      establishment.setAddress(requestDTO.getAddress());
-      establishment.setCity(requestDTO.getCity());
-      establishment.setPostalCode(requestDTO.getPostalCode());
-      establishment.setDescription(requestDTO.getDescription());
-      establishment.setPhoneNumber(requestDTO.getPhoneNumber());
-      establishment.setWebsite(requestDTO.getWebsite());
-      establishment.setPriceRange(requestDTO.getPriceRange());
-      establishment.setLatitude(requestDTO.getLatitude());
-      establishment.setLongitude(requestDTO.getLongitude());
-
-      Establishment createdEstablishment = establishmentService.createEstablishment(establishment, requestDTO.getManagerId());
-      LOG.info("[LOG] Établissement créé avec succès : " + createdEstablishment.getName());
-      
-      EstablishmentResponseDTO responseDTO = new EstablishmentResponseDTO(createdEstablishment);
-      return Response.status(Response.Status.CREATED).entity(responseDTO).build();
-    } catch (RuntimeException e) {
-      LOG.error("[ERROR] Erreur lors de la création de l'établissement : " + e.getMessage());
-      return Response.status(Response.Status.BAD_REQUEST)
-          .entity(e.getMessage())
-          .build();
-    } catch (Exception e) {
-      LOG.error("[ERROR] Erreur inattendue lors de la création de l'établissement", e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("Erreur lors de la création de l'établissement")
-          .build();
-    }
-  }
-
-  // *********** Récupération de tous les établissements ***********
-
-  @GET
-  @Operation(summary = "Récupérer tous les établissements", 
-             description = "Retourne la liste de tous les établissements disponibles")
-  public Response getAllEstablishments() {
-    LOG.info("[LOG] Récupération de tous les établissements");
-    try {
-      List<Establishment> establishments = establishmentService.getAllEstablishments();
-      List<EstablishmentResponseDTO> responseDTOs = establishments.stream()
-          .map(EstablishmentResponseDTO::new)
-          .collect(Collectors.toList());
-      return Response.ok(responseDTOs).build();
-    } catch (Exception e) {
-      LOG.error("[ERROR] Erreur lors de la récupération des établissements", e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("Erreur lors de la récupération des établissements")
-          .build();
-    }
-  }
-
-  // *********** Récupération d'un établissement par ID ***********
-
-  @GET
-  @Path("/{id}")
-  @Operation(summary = "Récupérer un établissement par ID", 
-             description = "Retourne les détails de l'établissement demandé")
-  public Response getEstablishmentById(@PathParam("id") UUID id) {
-    LOG.info("[LOG] Récupération de l'établissement avec l'ID : " + id);
-    try {
-      Establishment establishment = establishmentService.getEstablishmentById(id);
-      EstablishmentResponseDTO responseDTO = new EstablishmentResponseDTO(establishment);
-      return Response.ok(responseDTO).build();
-    } catch (RuntimeException e) {
-      LOG.warn("[WARN] " + e.getMessage());
-      return Response.status(Response.Status.NOT_FOUND)
-          .entity(e.getMessage())
-          .build();
-    } catch (Exception e) {
-      LOG.error("[ERROR] Erreur lors de la récupération de l'établissement", e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("Erreur lors de la récupération de l'établissement")
-          .build();
-    }
-  }
-
-  // *********** Recherche d'établissements ***********
-
-  @GET
-  @Path("/search")
-  @Operation(summary = "Rechercher des établissements", 
-             description = "Recherche des établissements par nom ou ville")
-  public Response searchEstablishments(@QueryParam("q") String query) {
-    LOG.info("[LOG] Recherche d'établissements avec la requête : " + query);
-    try {
-      if (query == null || query.trim().isEmpty()) {
-        return Response.status(Response.Status.BAD_REQUEST)
-            .entity("Le paramètre de recherche 'q' est obligatoire")
-            .build();
-      }
-      List<Establishment> establishments = establishmentService.searchEstablishments(query);
-      List<EstablishmentResponseDTO> responseDTOs = establishments.stream()
-          .map(EstablishmentResponseDTO::new)
-          .collect(Collectors.toList());
-      return Response.ok(responseDTOs).build();
-    } catch (Exception e) {
-      LOG.error("[ERROR] Erreur lors de la recherche d'établissements", e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("Erreur lors de la recherche d'établissements")
-          .build();
-    }
-  }
-
-  // *********** Filtrage d'établissements ***********
-
-  @GET
-  @Path("/filter")
-  @Operation(summary = "Filtrer les établissements", 
-             description = "Filtre les établissements par type, fourchette de prix et/ou ville")
-  public Response filterEstablishments(
-      @QueryParam("type") String type,
-      @QueryParam("priceRange") String priceRange,
-      @QueryParam("city") String city) {
-    LOG.info("[LOG] Filtrage des établissements : type=" + type + ", priceRange=" + priceRange + ", city=" + city);
-    try {
-      List<Establishment> establishments = establishmentService.filterEstablishments(type, priceRange, city);
-      List<EstablishmentResponseDTO> responseDTOs = establishments.stream()
-          .map(EstablishmentResponseDTO::new)
-          .collect(Collectors.toList());
-      return Response.ok(responseDTOs).build();
-    } catch (Exception e) {
-      LOG.error("[ERROR] Erreur lors du filtrage des établissements", e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("Erreur lors du filtrage des établissements")
-          .build();
-    }
-  }
-
-  // *********** Récupération des établissements d'un responsable ***********
-
-  @GET
-  @Path("/manager/{managerId}")
-  @Operation(summary = "Récupérer les établissements d'un responsable", 
-             description = "Retourne tous les établissements gérés par un responsable")
-  public Response getEstablishmentsByManager(@PathParam("managerId") UUID managerId) {
-    LOG.info("[LOG] Récupération des établissements du responsable : " + managerId);
-    try {
-      List<Establishment> establishments = establishmentService.getEstablishmentsByManager(managerId);
-      List<EstablishmentResponseDTO> responseDTOs = establishments.stream()
-          .map(EstablishmentResponseDTO::new)
-          .collect(Collectors.toList());
-      return Response.ok(responseDTOs).build();
-    } catch (Exception e) {
-      LOG.error("[ERROR] Erreur lors de la récupération des établissements du responsable", e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("Erreur lors de la récupération des établissements du responsable")
-          .build();
-    }
-  }
-
-  // *********** Mise à jour d'un établissement ***********
-
-  @PUT
-  @Path("/{id}")
-  @Transactional
-  @Operation(summary = "Mettre à jour un établissement", 
-             description = "Met à jour les informations d'un établissement existant")
-  public Response updateEstablishment(
-      @PathParam("id") UUID id,
-      @Valid EstablishmentUpdateRequestDTO requestDTO) {
-    LOG.info("[LOG] Mise à jour de l'établissement avec l'ID : " + id);
-    try {
-      Establishment establishment = new Establishment();
-      establishment.setName(requestDTO.getName());
-      establishment.setType(requestDTO.getType());
-      establishment.setAddress(requestDTO.getAddress());
-      establishment.setCity(requestDTO.getCity());
-      establishment.setPostalCode(requestDTO.getPostalCode());
-      establishment.setDescription(requestDTO.getDescription());
-      establishment.setPhoneNumber(requestDTO.getPhoneNumber());
-      establishment.setWebsite(requestDTO.getWebsite());
-      establishment.setPriceRange(requestDTO.getPriceRange());
-      establishment.setLatitude(requestDTO.getLatitude());
-      establishment.setLongitude(requestDTO.getLongitude());
-
-      Establishment updatedEstablishment = establishmentService.updateEstablishment(id, establishment);
-      EstablishmentResponseDTO responseDTO = new EstablishmentResponseDTO(updatedEstablishment);
-      return Response.ok(responseDTO).build();
-    } catch (RuntimeException e) {
-      LOG.error("[ERROR] " + e.getMessage());
-      return Response.status(Response.Status.NOT_FOUND)
-          .entity(e.getMessage())
-          .build();
-    } catch (Exception e) {
-      LOG.error("[ERROR] Erreur lors de la mise à jour de l'établissement", e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("Erreur lors de la mise à jour de l'établissement")
-          .build();
-    }
-  }
-
-  // *********** Suppression d'un établissement ***********
-
-  @DELETE
-  @Path("/{id}")
-  @Transactional
-  @Operation(summary = "Supprimer un établissement", 
-             description = "Supprime un établissement du système")
-  public Response deleteEstablishment(@PathParam("id") UUID id) {
-    LOG.info("[LOG] Suppression de l'établissement avec l'ID : " + id);
-    try {
-      establishmentService.deleteEstablishment(id);
-      return Response.noContent().build();
-    } catch (RuntimeException e) {
-      LOG.error("[ERROR] " + e.getMessage());
-      return Response.status(Response.Status.NOT_FOUND)
-          .entity(e.getMessage())
-          .build();
-    } catch (Exception e) {
-      LOG.error("[ERROR] Erreur lors de la suppression de l'établissement", e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("Erreur lors de la suppression de l'établissement")
-          .build();
-    }
-  }
-}
-

src/main/java/com/lions/dev/resource/EventsResource.java

@@ -66,25 +66,11 @@ public class EventsResource {
   @Operation(summary = "Créer un nouvel événement", description = "Crée un nouvel événement et retourne ses détails")
   public Response createEvent(EventCreateRequestDTO eventCreateRequestDTO) {
     LOG.info("[LOG] Tentative de création d'un nouvel événement : " + eventCreateRequestDTO.getTitle());
-    
-    // Valider que creatorId est fourni
-    if (eventCreateRequestDTO.getCreatorId() == null) {
-      LOG.error("[ERROR] creatorId est obligatoire pour créer un événement");
-      return Response.status(Response.Status.BAD_REQUEST)
-          .entity("L'identifiant du créateur (creatorId) est obligatoire")
-          .build();
-    }
-    
-    // Récupérer le créateur par son ID
     Users creator = usersRepository.findById(eventCreateRequestDTO.getCreatorId());
     if (creator == null) {
       LOG.error("[ERROR] Créateur non trouvé avec l'ID : " + eventCreateRequestDTO.getCreatorId());
-      return Response.status(Response.Status.BAD_REQUEST)
+      return Response.status(Response.Status.BAD_REQUEST).entity("Créateur non trouvé").build();
-          .entity("Créateur non trouvé avec l'ID fourni")
-          .build();
     }
-    
-    // Créer l'événement
     Events event = eventService.createEvent(eventCreateRequestDTO, creator);
     LOG.info("[LOG] Événement créé avec succès : " + event.getTitle());
     EventCreateResponseDTO responseDTO = new EventCreateResponseDTO(event);
@@ -114,16 +100,10 @@ public class EventsResource {
   @Path("/{id}")
   @Transactional
   @Operation(summary = "Supprimer un événement", description = "Supprime un événement de la base de données")
-  public Response deleteEvent(@PathParam("id") UUID id, @QueryParam("userId") UUID userId) {
+  public Response deleteEvent(@PathParam("id") UUID id) {
-    LOG.info("Tentative de suppression de l'événement avec l'ID : " + id + " par l'utilisateur : " + userId);
+    LOG.info("Tentative de suppression de l'événement avec l'ID : " + id);
-    
-    if (userId == null) {
-      LOG.error("[ERROR] userId est obligatoire pour supprimer un événement");
-      return Response.status(Response.Status.BAD_REQUEST).entity("L'identifiant de l'utilisateur (userId) est obligatoire").build();
-    }
-    
     try {
-      boolean deleted = eventService.deleteEvent(id, userId);
+      boolean deleted = eventService.deleteEvent(id);
       if (deleted) {
         LOG.info("Événement supprimé avec succès.");
         return Response.noContent().build();
@@ -134,9 +114,6 @@ public class EventsResource {
     } catch (EventNotFoundException e) {
       LOG.error("[ERROR] Échec de la suppression : " + e.getMessage());
       return Response.status(Response.Status.NOT_FOUND).entity("Événement non trouvé.").build();
-    } catch (SecurityException e) {
-      LOG.error("[ERROR] Permissions insuffisantes : " + e.getMessage());
-      return Response.status(Response.Status.FORBIDDEN).entity(e.getMessage()).build();
     }
   }
 
@@ -189,31 +166,19 @@ public class EventsResource {
   @Path("/{id}")
   @Transactional
   @Operation(summary = "Mettre à jour un événement", description = "Modifie un événement existant")
-  public Response updateEvent(@PathParam("id") UUID id, @QueryParam("userId") UUID userId, EventUpdateRequestDTO eventUpdateRequestDTO) {
+  public Response updateEvent(@PathParam("id") UUID id, EventUpdateRequestDTO eventUpdateRequestDTO) {
-    LOG.info("[LOG] Tentative de mise à jour de l'événement avec l'ID : " + id + " par l'utilisateur : " + userId);
+    LOG.info("[LOG] Tentative de mise à jour de l'événement avec l'ID : " + id);
-    
-    if (userId == null) {
-      LOG.error("[ERROR] userId est obligatoire pour mettre à jour un événement");
-      return Response.status(Response.Status.BAD_REQUEST).entity("L'identifiant de l'utilisateur (userId) est obligatoire").build();
-    }
-    
     Events event = eventsRepository.findById(id);
     if (event == null) {
       LOG.warn("[LOG] Événement non trouvé avec l'ID : " + id);
       return Response.status(Response.Status.NOT_FOUND).entity("Événement non trouvé.").build();
     }
-    
-    // Vérifier que l'utilisateur est le créateur
-    if (!eventService.canModifyEvent(event, userId)) {
-      LOG.error("[ERROR] L'utilisateur " + userId + " n'a pas les permissions pour modifier l'événement " + id);
-      return Response.status(Response.Status.FORBIDDEN).entity("Vous n'avez pas les permissions pour modifier cet événement").build();
-    }
-    
     // Mise à jour des attributs de l'événement
     event.setTitle(eventUpdateRequestDTO.getTitle());
     event.setStartDate(eventUpdateRequestDTO.getStartDate());
     event.setEndDate(eventUpdateRequestDTO.getEndDate());
     event.setDescription(eventUpdateRequestDTO.getDescription());
+    event.setLocation(eventUpdateRequestDTO.getLocation());
     event.setCategory(eventUpdateRequestDTO.getCategory());
     event.setLink(eventUpdateRequestDTO.getLink());
     event.setImageUrl(eventUpdateRequestDTO.getImageUrl());
@@ -229,12 +194,10 @@ public class EventsResource {
   @Path("/created-by-user-and-friends")
   @Consumes("application/json")
   @Produces("application/json")
-  @Operation(summary = "Récupérer les événements créés par un utilisateur et ses amis", description = "Retourne la liste paginée des événements créés par un utilisateur spécifique et ses amis")
+  @Operation(summary = "Récupérer les événements créés par un utilisateur et ses amis", description = "Retourne la liste des événements créés par un utilisateur spécifique et ses amis")
   public Response getEventsCreatedByUserAndFriends(EventReadManyByIdRequestDTO requestDTO) {
-    UUID userId = requestDTO.getId();
+    UUID userId = requestDTO.getUserId();
-    int page = requestDTO.getPage() != null ? requestDTO.getPage() : 0;
+    LOG.info("[LOG] Récupération des événements pour l'utilisateur avec l'ID : " + userId + " et ses amis");
-    int size = requestDTO.getSize() != null ? requestDTO.getSize() : 10;
-    LOG.info("[LOG] Récupération des événements pour l'utilisateur avec l'ID : " + userId + " et ses amis (page: " + page + ", size: " + size + ")");
     Users user = usersRepository.findById(userId);
     if (user == null) {
       LOG.warn("[LOG] Utilisateur non trouvé avec l'ID : " + userId);
@@ -243,22 +206,18 @@ public class EventsResource {
     try {
       List<FriendshipReadFriendDetailsResponseDTO> friends = friendshipService.listFriends(userId, 0, Integer.MAX_VALUE);
       Set<UUID> friendIds = friends.stream().map(FriendshipReadFriendDetailsResponseDTO::getFriendId).collect(Collectors.toSet());
-      
+      //friendIds = friendIds.stream().distinct().collect(Collectors.toSet());
-      // IMPORTANT: Ajouter l'ID de l'utilisateur lui-même pour inclure ses propres événements
+      LOG.info("[LOG] IDs d'amis + utilisateur (taille attendue: " + friendIds.size() + ") : " + friendIds);
-      friendIds.add(userId);
+      if (friendIds.isEmpty()) {
-      
+        LOG.warn("[LOG] Aucun ami trouvé.");
-      LOG.info("[LOG] IDs d'amis + utilisateur (taille: " + friendIds.size() + ") : " + friendIds);
+        return Response.status(Response.Status.NOT_FOUND).entity("Aucun ami trouvé.").build();
-      
+      }
-      // Rechercher les événements créés par l'utilisateur et ses amis avec pagination
+      List<Events> events = eventsRepository.find("creator.id IN ?1", friendIds).list();
-      List<Events> events = eventsRepository.find("creator.id IN ?1 ORDER BY startDate DESC", friendIds)
-          .page(page, size)
-          .list();
       LOG.info("[LOG] Nombre d'événements récupérés dans la requête : " + events.size());
-      
+      if (events.isEmpty()) {
-      // ✅ Retourner avec reactionsCount et isFavorite pour l'utilisateur actuel
+        return Response.status(Response.Status.NOT_FOUND).entity("Aucun événement trouvé.").build();
-      List<EventCreateResponseDTO> responseDTOs = events.stream()
+      }
-          .map(event -> new EventCreateResponseDTO(event, usersRepository, userId))
+      List<EventReadManyByIdResponseDTO> responseDTOs = events.stream().map(EventReadManyByIdResponseDTO::new).toList();
-          .toList();
       return Response.ok(responseDTOs).build();
     } catch (Exception e) {
       LOG.error("[ERROR] Erreur de récupération des événements : ", e);
@@ -407,26 +366,13 @@ public class EventsResource {
   @Operation(
       summary = "Mettre à jour le statut d'un événement",
       description = "Modifie le statut d'un événement (ouvert, fermé, annulé, etc.)")
-  public Response updateEventStatus(@PathParam("id") UUID id, @QueryParam("status") String status, @QueryParam("userId") UUID userId) {
+  public Response updateEventStatus(@PathParam("id") UUID id, @QueryParam("status") String status) {
-    LOG.info("[LOG] Mise à jour du statut de l'événement avec l'ID : " + id + " par l'utilisateur : " + userId);
+    LOG.info("[LOG] Mise à jour du statut de l'événement avec l'ID : " + id);
-    
-    if (userId == null) {
-      LOG.error("[ERROR] userId est obligatoire pour mettre à jour le statut d'un événement");
-      return Response.status(Response.Status.BAD_REQUEST).entity("L'identifiant de l'utilisateur (userId) est obligatoire").build();
-    }
-    
     Events event = eventsRepository.findById(id);
     if (event == null) {
       LOG.warn("[LOG] Événement non trouvé avec l'ID : " + id);
       return Response.status(Response.Status.NOT_FOUND).entity("Événement non trouvé.").build();
     }
-    
-    // Vérifier que l'utilisateur est le créateur
-    if (!eventService.canModifyEvent(event, userId)) {
-      LOG.error("[ERROR] L'utilisateur " + userId + " n'a pas les permissions pour modifier le statut de l'événement " + id);
-      return Response.status(Response.Status.FORBIDDEN).entity("Vous n'avez pas les permissions pour modifier cet événement").build();
-    }
-    
     event.setStatus(status);
     eventsRepository.persist(event);
     LOG.info("[LOG] Statut de l'événement mis à jour avec succès : " + status);
@@ -447,17 +393,14 @@ public class EventsResource {
   @Operation(
       summary = "Récupérer les événements auxquels un utilisateur est inscrit",
       description = "Retourne la liste des événements auxquels un utilisateur spécifique est inscrit")
-  public Response getEventsByUser(
+  public Response getEventsByUser(@PathParam("userId") UUID userId) {
-      @PathParam("userId") UUID userId,
+    LOG.info("[LOG] Récupération des événements pour l'utilisateur avec l'ID : " + userId);
-      @QueryParam("page") @DefaultValue("0") int page,
-      @QueryParam("size") @DefaultValue("10") int size) {
-    LOG.info("[LOG] Récupération des événements pour l'utilisateur avec l'ID : " + userId + " (page: " + page + ", size: " + size + ")");
     Users user = usersRepository.findById(userId);
     if (user == null) {
       LOG.warn("[LOG] Utilisateur non trouvé avec l'ID : " + userId);
       return Response.status(Response.Status.NOT_FOUND).entity("Utilisateur non trouvé.").build();
     }
-    List<Events> events = eventService.findEventsByUser(user, page, size);
+    List<Events> events = eventService.findEventsByUser(user);
     if (events.isEmpty()) {
       LOG.warn("[LOG] Aucun événement trouvé pour l'utilisateur avec l'ID : " + userId);
       return Response.status(Response.Status.NOT_FOUND).entity("Aucun événement trouvé.").build();
@@ -480,13 +423,8 @@ public class EventsResource {
    */
   @PUT
   @Path("/{id}/image")
-  public Response updateEventImage(@PathParam("id") UUID id, @QueryParam("userId") UUID userId, String imageFilePath) {
+  public Response updateEventImage(@PathParam("id") UUID id, String imageFilePath) {
-    LOG.info("[LOG] Tentative de mise à jour de l'image pour l'événement avec l'ID : " + id + " par l'utilisateur : " + userId);
+    LOG.info("[LOG] Tentative de mise à jour de l'image pour l'événement avec l'ID : " + id);
-    
-    if (userId == null) {
-      LOG.error("[ERROR] userId est obligatoire pour mettre à jour l'image d'un événement");
-      return Response.status(Response.Status.BAD_REQUEST).entity("L'identifiant de l'utilisateur (userId) est obligatoire").build();
-    }
 
     try {
       if (imageFilePath == null || imageFilePath.isEmpty()) {
@@ -506,15 +444,9 @@ public class EventsResource {
         return Response.status(Response.Status.NOT_FOUND).entity("Événement non trouvé.").build();
       }
 
-      // Vérifier que l'utilisateur est le créateur
-      if (!eventService.canModifyEvent(event, userId)) {
-        LOG.error("[ERROR] L'utilisateur " + userId + " n'a pas les permissions pour modifier l'image de l'événement " + id);
-        return Response.status(Response.Status.FORBIDDEN).entity("Vous n'avez pas les permissions pour modifier cet événement").build();
-      }
-
       String imageUrl = file.getAbsolutePath();
       event.setImageUrl(imageUrl);
-      eventService.updateEvent(event, userId);
+      eventService.updateEvent(event);
 
       LOG.info("[LOG] Image de l'événement mise à jour avec succès pour : " + event.getTitle());
       return Response.ok("Image de l'événement mise à jour avec succès.").build();
@@ -529,13 +461,8 @@ public class EventsResource {
   @Path("/{id}/partial-update")
   @Transactional
   @Operation(summary = "Mettre à jour partiellement un événement", description = "Mise à jour partielle des informations d'un événement")
-  public Response partialUpdateEvent(@PathParam("id") UUID id, @QueryParam("userId") UUID userId, Map<String, Object> updates) {
+  public Response partialUpdateEvent(@PathParam("id") UUID id, Map<String, Object> updates) {
-    LOG.info("[LOG] Tentative de mise à jour partielle de l'événement avec l'ID : " + id + " par l'utilisateur : " + userId);
+    LOG.info("[LOG] Tentative de mise à jour partielle de l'événement avec l'ID : " + id);
-    
-    if (userId == null) {
-      LOG.error("[ERROR] userId est obligatoire pour mettre à jour un événement");
-      return Response.status(Response.Status.BAD_REQUEST).entity("L'identifiant de l'utilisateur (userId) est obligatoire").build();
-    }
 
     Events event = eventsRepository.findById(id);
     if (event == null) {
@@ -543,36 +470,9 @@ public class EventsResource {
       return Response.status(Response.Status.NOT_FOUND).entity("Événement non trouvé.").build();
     }
 
-    // Vérifier que l'utilisateur est le créateur
-    if (!eventService.canModifyEvent(event, userId)) {
-      LOG.error("[ERROR] L'utilisateur " + userId + " n'a pas les permissions pour modifier l'événement " + id);
-      return Response.status(Response.Status.FORBIDDEN).entity("Vous n'avez pas les permissions pour modifier cet événement").build();
-    }
-
-    // Mise à jour des champs dynamiquement
     updates.forEach((field, value) -> {
-      switch (field) {
+      // Mise à jour des champs dynamiquement, à adapter selon la structure de l'événement
-        case "title":
+      // Exemple d'utilisation de réflexion si applicable
-          event.setTitle(value != null ? value.toString() : null);
-          break;
-        case "description":
-          event.setDescription(value != null ? value.toString() : null);
-          break;
-        case "category":
-          event.setCategory(value != null ? value.toString() : null);
-          break;
-        case "link":
-          event.setLink(value != null ? value.toString() : null);
-          break;
-        case "imageUrl":
-          event.setImageUrl(value != null ? value.toString() : null);
-          break;
-        case "status":
-          event.setStatus(value != null ? value.toString() : null);
-          break;
-        default:
-          LOG.warn("[LOG] Champ inconnu ignoré lors de la mise à jour partielle : " + field);
-      }
     });
 
     eventsRepository.persist(event);
@@ -619,13 +519,8 @@ public class EventsResource {
   @Path("/{id}/cancel")
   @Transactional
   @Operation(summary = "Annuler un événement", description = "Annule un événement sans le supprimer.")
-  public Response cancelEvent(@PathParam("id") UUID id, @QueryParam("userId") UUID userId) {
+  public Response cancelEvent(@PathParam("id") UUID id) {
-    LOG.info("[LOG] Annulation de l'événement avec l'ID : " + id + " par l'utilisateur : " + userId);
+    LOG.info("[LOG] Annulation de l'événement avec l'ID : " + id);
-    
-    if (userId == null) {
-      LOG.error("[ERROR] userId est obligatoire pour annuler un événement");
-      return Response.status(Response.Status.BAD_REQUEST).entity("L'identifiant de l'utilisateur (userId) est obligatoire").build();
-    }
 
     Events event = eventsRepository.findById(id);
     if (event == null) {
@@ -633,12 +528,6 @@ public class EventsResource {
       return Response.status(Response.Status.NOT_FOUND).entity("Événement non trouvé.").build();
     }
 
-    // Vérifier que l'utilisateur est le créateur
-    if (!eventService.canModifyEvent(event, userId)) {
-      LOG.error("[ERROR] L'utilisateur " + userId + " n'a pas les permissions pour annuler l'événement " + id);
-      return Response.status(Response.Status.FORBIDDEN).entity("Vous n'avez pas les permissions pour annuler cet événement").build();
-    }
-
     event.setStatus("Annulé");
     eventsRepository.persist(event);
     LOG.info("[LOG] Événement annulé avec succès : " + event.getTitle());
@@ -765,9 +654,9 @@ public class EventsResource {
   @POST
   @Path("/{id}/favorite")
   @Transactional
-  @Operation(summary = "Toggle favori d'un événement", description = "Permet à un utilisateur d'ajouter ou retirer un événement de ses favoris (toggle).")
+  @Operation(summary = "Marquer un événement comme favori", description = "Permet à un utilisateur de marquer un événement comme favori.")
   public Response favoriteEvent(@PathParam("id") UUID eventId, @QueryParam("userId") UUID userId) {
-    LOG.info("[LOG] Toggle favori de l'événement " + eventId + " pour l'utilisateur ID : " + userId);
+    LOG.info("[LOG] Marquage de l'événement comme favori pour l'utilisateur ID : " + userId);
 
     Events event = eventsRepository.findById(eventId);
     Users user = usersRepository.findById(userId);
@@ -776,22 +665,9 @@ public class EventsResource {
       return Response.status(Response.Status.NOT_FOUND).entity("Événement ou utilisateur non trouvé.").build();
     }
 
-    // ✅ Toggle : ajouter si pas favori, retirer si déjà favori
-    boolean wasFavorite = user.hasFavoriteEvent(event);
-    if (wasFavorite) {
-      user.removeFavoriteEvent(event);
-      LOG.info("[LOG] Événement retiré des favoris pour l'utilisateur : " + user.getEmail());
-    } else {
     user.addFavoriteEvent(event);
-      LOG.info("[LOG] Événement ajouté aux favoris pour l'utilisateur : " + user.getEmail());
-    }
     usersRepository.persist(user);
-    
+    return Response.ok("Événement marqué comme favori.").build();
-    // Retourner un JSON avec le statut
-    Map<String, Object> response = new java.util.HashMap<>();
-    response.put("isFavorite", !wasFavorite);
-    response.put("message", wasFavorite ? "Événement retiré des favoris." : "Événement ajouté aux favoris.");
-    return Response.ok(response).build();
   }
 
   @GET
@@ -840,50 +716,6 @@ public class EventsResource {
     return Response.ok(responseDTOs).build();
   }
 
-  @POST
-  @Path("/{id}/comments")
-  @Transactional
-  @Operation(summary = "Ajouter un commentaire à un événement", description = "Crée un nouveau commentaire pour un événement.")
-  public Response addComment(
-      @PathParam("id") UUID eventId,
-      @QueryParam("userId") UUID userId,
-      Map<String, String> requestBody) {
-    LOG.info("[LOG] Ajout d'un commentaire à l'événement ID : " + eventId + " par l'utilisateur ID : " + userId);
-
-    Events event = eventsRepository.findById(eventId);
-    if (event == null) {
-      LOG.warn("[LOG] Événement non trouvé avec l'ID : " + eventId);
-      return Response.status(Response.Status.NOT_FOUND).entity("Événement non trouvé.").build();
-    }
-
-    Users user = usersRepository.findById(userId);
-    if (user == null) {
-      LOG.warn("[LOG] Utilisateur non trouvé avec l'ID : " + userId);
-      return Response.status(Response.Status.NOT_FOUND).entity("Utilisateur non trouvé.").build();
-    }
-
-    String text = requestBody.get("text");
-    if (text == null || text.trim().isEmpty()) {
-      LOG.warn("[LOG] Le texte du commentaire est vide");
-      return Response.status(Response.Status.BAD_REQUEST).entity("Le texte du commentaire est requis.").build();
-    }
-
-    try {
-      Comment comment = new Comment(user, event, text);
-      // Le commentaire sera automatiquement ajouté à la liste des commentaires de l'événement via la relation JPA
-      eventsRepository.persist(event);
-      
-      LOG.info("[LOG] Commentaire ajouté avec succès à l'événement : " + event.getTitle());
-      
-      CommentResponseDTO responseDTO = new CommentResponseDTO(comment);
-      return Response.status(Response.Status.CREATED).entity(responseDTO).build();
-    } catch (Exception e) {
-      LOG.error("[ERROR] Erreur lors de l'ajout du commentaire : " + e.getMessage(), e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("Erreur lors de l'ajout du commentaire.").build();
-    }
-  }
-
   @GET
   @Path("/recommendations/{userId}")
   @Operation(summary = "Recommander des événements basés sur les intérêts", description = "Retourne une liste d'événements recommandés pour un utilisateur.")
@@ -1002,39 +834,5 @@ public class EventsResource {
     return Response.ok("L'événement a été réouvert avec succès.").build();
   }
 
-  /**
-   * Endpoint pour récupérer les événements de l'utilisateur et de ses amis.
-   *
-   * @param userId L'ID de l'utilisateur
-   * @param page Le numéro de la page (0-indexé)
-   * @param size La taille de la page
-   * @return Liste paginée des événements de l'utilisateur et de ses amis
-   */
-  @GET
-  @Path("/friends/{userId}")
-  @Operation(
-      summary = "Récupérer les événements des amis",
-      description = "Retourne les événements créés par l'utilisateur et ses amis (relations d'amitié acceptées)")
-  public Response getEventsByFriends(
-      @PathParam("userId") UUID userId,
-      @QueryParam("page") @DefaultValue("0") int page,
-      @QueryParam("size") @DefaultValue("10") int size) {
-    LOG.info("[LOG] Récupération des événements des amis pour l'utilisateur ID : " + userId);
-
-    try {
-      List<Events> events = eventService.getEventsByFriends(userId, page, size);
-      List<EventCreateResponseDTO> responseDTOs = events.stream()
-          .map(EventCreateResponseDTO::new)
-          .collect(Collectors.toList());
-
-      return Response.ok(responseDTOs).build();
-    } catch (Exception e) {
-      LOG.error("[ERROR] Erreur lors de la récupération des événements des amis : " + e.getMessage(), e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("{\"message\": \"Erreur lors de la récupération des événements des amis.\"}")
-          .build();
-    }
-  }
-
 }
 

src/main/java/com/lions/dev/resource/FileUploadResource.java

@@ -2,25 +2,17 @@ package com.lions.dev.resource;
 
 import com.lions.dev.service.FileService;
 import jakarta.ws.rs.Consumes;
-import jakarta.ws.rs.GET;
 import jakarta.ws.rs.POST;
 import jakarta.ws.rs.Path;
-import jakarta.ws.rs.PathParam;
-import jakarta.ws.rs.Produces;
-import jakarta.ws.rs.core.Context;
 import jakarta.ws.rs.core.MediaType;
 import jakarta.ws.rs.core.Response;
-import jakarta.ws.rs.core.UriInfo;
 import org.jboss.logging.Logger;
 import org.jboss.resteasy.reactive.RestForm;
 import org.jboss.resteasy.reactive.multipart.FileUpload;
 import jakarta.inject.Inject;
 import java.io.IOException;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.UUID;
 
-@Path("/media")
+@Path("/upload")
 public class FileUploadResource {
 
   private static final Logger LOG = Logger.getLogger(FileUploadResource.class);
@@ -28,208 +20,17 @@ public class FileUploadResource {
   @Inject
   FileService fileService;
 
-  @Context
-  UriInfo uriInfo;
-
   @POST
-  @Path("/upload")
   @Consumes(MediaType.MULTIPART_FORM_DATA)
-  @Produces(MediaType.APPLICATION_JSON)
+  public Response uploadFile(@RestForm("file") FileUpload file) {
-  public Response uploadFile(
-      @RestForm("file") FileUpload file,
-      @RestForm("type") String type,
-      @RestForm("fileName") String fileName,
-      @RestForm("contentType") String contentType,
-      @RestForm("fileSize") String fileSize,
-      @RestForm("userId") String userId) {
-    
-    LOG.info("Début de l'upload de fichier");
-    LOG.infof("Type: %s, FileName: %s, ContentType: %s, FileSize: %s, UserId: %s", 
-        type, fileName, contentType, fileSize, userId);
-
-    if (file == null || file.uploadedFile() == null) {
-      LOG.error("Aucun fichier fourni dans la requête");
-      return Response.status(Response.Status.BAD_REQUEST)
-          .entity(createErrorResponse("Aucun fichier fourni"))
-          .build();
-    }
-
-    try {
-      // Générer un nom de fichier unique si nécessaire
-      String finalFileName = fileName != null && !fileName.isEmpty() 
-          ? fileName 
-          : generateUniqueFileName(file.fileName());
-      
-      // Déterminer le type de média
-      String mediaType = type != null && !type.isEmpty() 
-          ? type 
-          : determineMediaType(file.fileName());
-      
-      // Répertoire d'upload
     String uploadDir = "/tmp/uploads/";
 
-      // Sauvegarder le fichier
-      java.nio.file.Path savedFilePath = fileService.saveFile(
-          file.uploadedFile(), 
-          uploadDir, 
-          finalFileName
-      );
-      
-      LOG.infof("Fichier sauvegardé avec succès: %s", savedFilePath);
-      
-      // Construire l'URL du fichier
-      // Note: En production, vous devriez utiliser une URL publique (CDN, S3, etc.)
-      String fileUrl = buildFileUrl(finalFileName, uriInfo);
-      String thumbnailUrl = null;
-      
-      // Pour les vidéos, on pourrait générer un thumbnail ici
-      if ("video".equalsIgnoreCase(mediaType)) {
-        // TODO: Générer un thumbnail pour les vidéos
-        thumbnailUrl = fileUrl; // Placeholder
-      }
-      
-      // Construire la réponse JSON
-      Map<String, Object> response = new HashMap<>();
-      response.put("url", fileUrl);
-      response.put("fileName", finalFileName); // ✅ Ajout du fileName dans la réponse (DRY/WOU)
-      if (thumbnailUrl != null) {
-        response.put("thumbnailUrl", thumbnailUrl);
-      }
-      response.put("type", mediaType);
-      if (fileSize != null && !fileSize.isEmpty()) {
     try {
-          long size = Long.parseLong(fileSize);
+      Path savedFilePath = (jakarta.ws.rs.Path) fileService.saveFile(file.uploadedFile(), uploadDir, file.fileName());
-          // Pour les vidéos, on pourrait calculer la durée ici
+      return Response.ok("Fichier uploadé avec succès : " + savedFilePath).build();
-          // response.put("duration", durationInSeconds);
-        } catch (NumberFormatException e) {
-          LOG.warnf("Impossible de parser fileSize: %s", fileSize);
-        }
-      }
-      
-      LOG.infof("Upload réussi, URL: %s, FileName: %s", fileUrl, finalFileName);
-      
-      return Response.status(Response.Status.CREATED)
-          .entity(response)
-          .build();
-          
     } catch (IOException e) {
-      LOG.errorf(e, "Erreur lors de l'upload du fichier: %s", e.getMessage());
+      LOG.error("Erreur lors de l'upload du fichier", e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+      return Response.serverError().entity("Erreur lors de l'upload du fichier.").build();
-          .entity(createErrorResponse("Erreur lors de l'upload du fichier: " + e.getMessage()))
-          .build();
-    } catch (Exception e) {
-      LOG.errorf(e, "Erreur inattendue lors de l'upload: %s", e.getMessage());
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity(createErrorResponse("Erreur inattendue."))
-          .build();
     }
   }
-
-  /**
-   * Génère un nom de fichier unique.
-   */
-  private String generateUniqueFileName(String originalFileName) {
-    String extension = "";
-    int lastDot = originalFileName.lastIndexOf('.');
-    if (lastDot > 0) {
-      extension = originalFileName.substring(lastDot);
-    }
-    return UUID.randomUUID().toString() + extension;
-  }
-
-  /**
-   * Détermine le type de média basé sur l'extension du fichier.
-   */
-  private String determineMediaType(String fileName) {
-    if (fileName == null) {
-      return "image";
-    }
-    String lowerFileName = fileName.toLowerCase();
-    if (lowerFileName.endsWith(".mp4") || 
-        lowerFileName.endsWith(".mov") || 
-        lowerFileName.endsWith(".avi") || 
-        lowerFileName.endsWith(".mkv") || 
-        lowerFileName.endsWith(".m4v")) {
-      return "video";
-    }
-    return "image";
-  }
-
-  /**
-   * Construit l'URL du fichier.
-   * En production, cela devrait pointer vers un CDN ou un service de stockage.
-   */
-  private String buildFileUrl(String fileName, UriInfo uriInfo) {
-    // Construire l'URL de base à partir de l'URI de la requête
-    String baseUri = uriInfo.getBaseUri().toString();
-    // Retirer le slash final s'il existe
-    if (baseUri.endsWith("/")) {
-      baseUri = baseUri.substring(0, baseUri.length() - 1);
-    }
-    // Retourner une URL absolue
-    return baseUri + "/media/files/" + fileName;
-  }
-  
-  @GET
-  @Path("/files/{fileName}")
-  @Produces(MediaType.APPLICATION_OCTET_STREAM)
-  public Response getFile(@PathParam("fileName") String fileName) {
-    try {
-      java.nio.file.Path filePath = java.nio.file.Paths.get("/tmp/uploads/", fileName);
-      
-      if (!java.nio.file.Files.exists(filePath)) {
-        LOG.warnf("Fichier non trouvé: %s", fileName);
-        return Response.status(Response.Status.NOT_FOUND)
-            .entity(createErrorResponse("Fichier non trouvé"))
-            .build();
-      }
-      
-      // Déterminer le content-type
-      String contentType = determineContentType(fileName);
-      
-      return Response.ok(filePath.toFile())
-          .type(contentType)
-          .header("Content-Disposition", "inline; filename=\"" + fileName + "\"")
-          .build();
-          
-    } catch (Exception e) {
-      LOG.errorf(e, "Erreur lors de la récupération du fichier: %s", fileName);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity(createErrorResponse("Erreur lors de la récupération du fichier"))
-          .build();
-    }
-  }
-  
-  /**
-   * Détermine le content-type basé sur l'extension du fichier.
-   */
-  private String determineContentType(String fileName) {
-    if (fileName == null) {
-      return MediaType.APPLICATION_OCTET_STREAM;
-    }
-    String lowerFileName = fileName.toLowerCase();
-    if (lowerFileName.endsWith(".jpg") || lowerFileName.endsWith(".jpeg")) {
-      return "image/jpeg";
-    } else if (lowerFileName.endsWith(".png")) {
-      return "image/png";
-    } else if (lowerFileName.endsWith(".gif")) {
-      return "image/gif";
-    } else if (lowerFileName.endsWith(".mp4")) {
-      return "video/mp4";
-    } else if (lowerFileName.endsWith(".mov")) {
-      return "video/quicktime";
-    } else if (lowerFileName.endsWith(".avi")) {
-      return "video/x-msvideo";
-    }
-    return MediaType.APPLICATION_OCTET_STREAM;
-  }
-
-  /**
-   * Crée une réponse d'erreur JSON.
-   */
-  private Map<String, String> createErrorResponse(String message) {
-    Map<String, String> error = new HashMap<>();
-    error.put("error", message);
-    return error;
-  }
 }

src/main/java/com/lions/dev/resource/FriendshipResource.java

@@ -6,7 +6,6 @@ import com.lions.dev.dto.request.friends.FriendshipReadStatusRequestDTO;
 import com.lions.dev.dto.response.friends.FriendshipCreateOneResponseDTO;
 import com.lions.dev.dto.response.friends.FriendshipReadFriendDetailsResponseDTO;
 import com.lions.dev.dto.response.friends.FriendshipReadStatusResponseDTO;
-import com.lions.dev.entity.friends.FriendshipStatus;
 import com.lions.dev.exception.UserNotFoundException;
 import com.lions.dev.service.FriendshipService;
 import jakarta.inject.Inject;
@@ -253,54 +252,6 @@ public class FriendshipResource {
     }
   }
 
-  /**
-   * Récupérer les demandes d'amitié en attente pour un utilisateur.
-   *
-   * @param userId L'ID de l'utilisateur
-   * @param page Numéro de la page pour la pagination
-   * @param size Nombre d'éléments par page
-   * @return Liste des demandes d'amitié en attente
-   */
-  @GET
-  @Path("/pending/{userId}")
-  @Operation(
-      summary = "Récupérer les demandes d'amitié en attente",
-      description = "Retourne la liste des demandes d'amitié en attente pour un utilisateur")
-  @APIResponses({
-    @APIResponse(
-        responseCode = "200",
-        description = "Demandes d'amitié récupérées",
-        content =
-            @Content(
-                mediaType = MediaType.APPLICATION_JSON,
-                schema = @Schema(implementation = FriendshipReadStatusResponseDTO.class))),
-    @APIResponse(responseCode = "404", description = "Utilisateur non trouvé"),
-    @APIResponse(
-        responseCode = "500",
-        description = "Erreur lors de la récupération des demandes d'amitié")
-  })
-  public Response getPendingFriendRequests(
-      @PathParam("userId") UUID userId,
-      @QueryParam("page") @DefaultValue("0") int page,
-      @QueryParam("size") @DefaultValue("10") int size) {
-    logger.info("[LOG] Récupération des demandes d'amitié en attente pour l'utilisateur : " + userId);
-
-    try {
-      FriendshipReadStatusRequestDTO request = new FriendshipReadStatusRequestDTO(
-          userId, FriendshipStatus.PENDING, page + 1, size);
-      List<FriendshipReadStatusResponseDTO> friendships =
-          friendshipService.listFriendRequestsByStatus(request);
-      logger.info("[LOG] " + friendships.size() + " demandes d'amitié en attente récupérées avec succès.");
-      return Response.ok(friendships).build();
-    } catch (Exception e) {
-      logger.error(
-          "[ERROR] Erreur lors de la récupération des demandes d'amitié : " + e.getMessage(), e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("{\"message\": \"Erreur lors de la récupération des demandes d'amitié.\"}")
-          .build();
-    }
-  }
-
   /**
    * Récupérer les demandes d'amitié avec un statut spécifique.
    *
@@ -343,98 +294,6 @@ public class FriendshipResource {
     }
   }
 
-  /**
-   * Récupérer les demandes d'amitié envoyées par un utilisateur.
-   *
-   * @param userId ID de l'utilisateur.
-   * @param page Numéro de la page pour la pagination.
-   * @param size Nombre d'éléments par page.
-   * @return Liste des demandes d'amitié envoyées.
-   */
-  @GET
-  @Path("/sent/{userId}")
-  @Operation(
-      summary = "Récupérer les demandes d'amitié envoyées",
-      description = "Retourne la liste des demandes d'amitié envoyées par un utilisateur")
-  @APIResponses({
-    @APIResponse(
-        responseCode = "200",
-        description = "Demandes d'amitié envoyées récupérées",
-        content =
-            @Content(
-                mediaType = MediaType.APPLICATION_JSON,
-                schema = @Schema(implementation = FriendshipReadStatusResponseDTO.class))),
-    @APIResponse(responseCode = "404", description = "Utilisateur non trouvé"),
-    @APIResponse(
-        responseCode = "500",
-        description = "Erreur lors de la récupération des demandes d'amitié envoyées")
-  })
-  public Response getSentFriendRequests(
-      @PathParam("userId") UUID userId,
-      @QueryParam("page") @DefaultValue("0") int page,
-      @QueryParam("size") @DefaultValue("10") int size) {
-    logger.info("[LOG] Récupération des demandes d'amitié envoyées pour l'utilisateur : " + userId);
-
-    try {
-      List<FriendshipReadStatusResponseDTO> friendships =
-          friendshipService.listSentFriendRequests(userId, page + 1, size);
-      logger.info("[LOG] " + friendships.size() + " demandes d'amitié envoyées récupérées avec succès.");
-      return Response.ok(friendships).build();
-    } catch (Exception e) {
-      logger.error(
-          "[ERROR] Erreur lors de la récupération des demandes d'amitié envoyées : " + e.getMessage(), e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("{\"message\": \"Erreur lors de la récupération des demandes d'amitié envoyées.\"}")
-          .build();
-    }
-  }
-
-  /**
-   * Récupérer les demandes d'amitié reçues par un utilisateur.
-   *
-   * @param userId ID de l'utilisateur.
-   * @param page Numéro de la page pour la pagination.
-   * @param size Nombre d'éléments par page.
-   * @return Liste des demandes d'amitié reçues.
-   */
-  @GET
-  @Path("/received/{userId}")
-  @Operation(
-      summary = "Récupérer les demandes d'amitié reçues",
-      description = "Retourne la liste des demandes d'amitié reçues par un utilisateur")
-  @APIResponses({
-    @APIResponse(
-        responseCode = "200",
-        description = "Demandes d'amitié reçues récupérées",
-        content =
-            @Content(
-                mediaType = MediaType.APPLICATION_JSON,
-                schema = @Schema(implementation = FriendshipReadStatusResponseDTO.class))),
-    @APIResponse(responseCode = "404", description = "Utilisateur non trouvé"),
-    @APIResponse(
-        responseCode = "500",
-        description = "Erreur lors de la récupération des demandes d'amitié reçues")
-  })
-  public Response getReceivedFriendRequests(
-      @PathParam("userId") UUID userId,
-      @QueryParam("page") @DefaultValue("0") int page,
-      @QueryParam("size") @DefaultValue("10") int size) {
-    logger.info("[LOG] Récupération des demandes d'amitié reçues pour l'utilisateur : " + userId);
-
-    try {
-      List<FriendshipReadStatusResponseDTO> friendships =
-          friendshipService.listReceivedFriendRequests(userId, page + 1, size);
-      logger.info("[LOG] " + friendships.size() + " demandes d'amitié reçues récupérées avec succès.");
-      return Response.ok(friendships).build();
-    } catch (Exception e) {
-      logger.error(
-          "[ERROR] Erreur lors de la récupération des demandes d'amitié reçues : " + e.getMessage(), e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("{\"message\": \"Erreur lors de la récupération des demandes d'amitié reçues.\"}")
-          .build();
-    }
-  }
-
   /**
    * Récupère les détails complets d'un ami.
    *
@@ -486,53 +345,4 @@ public class FriendshipResource {
                      .build();
     }
   }
-
-  /**
-   * Récupérer les suggestions d'amis pour un utilisateur.
-   *
-   * @param userId ID de l'utilisateur.
-   * @param limit Nombre maximum de suggestions (optionnel, par défaut 10).
-   * @return Liste des suggestions d'amis.
-   */
-  @GET
-  @Path("/suggestions/{userId}")
-  @Operation(
-      summary = "Récupérer les suggestions d'amis",
-      description = "Retourne une liste d'utilisateurs suggérés comme amis potentiels basée sur les amis en commun")
-  @APIResponses({
-    @APIResponse(
-        responseCode = "200",
-        description = "Suggestions d'amis récupérées",
-        content =
-            @Content(
-                mediaType = MediaType.APPLICATION_JSON,
-                schema = @Schema(implementation = com.lions.dev.dto.response.users.FriendSuggestionResponseDTO.class))),
-    @APIResponse(responseCode = "404", description = "Utilisateur non trouvé"),
-    @APIResponse(
-        responseCode = "500",
-        description = "Erreur lors de la récupération des suggestions d'amis")
-  })
-  public Response getFriendSuggestions(
-      @PathParam("userId") UUID userId,
-      @QueryParam("limit") @DefaultValue("10") int limit) {
-    logger.info("[LOG] Récupération des suggestions d'amis pour l'utilisateur : " + userId);
-
-    try {
-      List<com.lions.dev.dto.response.users.FriendSuggestionResponseDTO> suggestions =
-          friendshipService.getFriendSuggestions(userId, limit);
-      logger.info("[LOG] " + suggestions.size() + " suggestions d'amis récupérées avec succès.");
-      return Response.ok(suggestions).build();
-    } catch (UserNotFoundException e) {
-      logger.error("[ERROR] Utilisateur non trouvé : " + e.getMessage());
-      return Response.status(Response.Status.NOT_FOUND)
-          .entity("{\"message\": \"Utilisateur non trouvé.\"}")
-          .build();
-    } catch (Exception e) {
-      logger.error(
-          "[ERROR] Erreur lors de la récupération des suggestions d'amis : " + e.getMessage(), e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("{\"message\": \"Erreur lors de la récupération des suggestions d'amis.\"}")
-          .build();
-    }
-  }
 }

src/main/java/com/lions/dev/resource/MessageResource.java

@@ -1,333 +0,0 @@
-package com.lions.dev.resource;
-
-import com.lions.dev.dto.request.chat.SendMessageRequestDTO;
-import com.lions.dev.dto.response.chat.ConversationResponseDTO;
-import com.lions.dev.dto.response.chat.MessageResponseDTO;
-import com.lions.dev.entity.chat.Conversation;
-import com.lions.dev.entity.chat.Message;
-import com.lions.dev.entity.users.Users;
-import com.lions.dev.repository.UsersRepository;
-import com.lions.dev.service.MessageService;
-import jakarta.inject.Inject;
-import jakarta.ws.rs.*;
-import jakarta.ws.rs.core.MediaType;
-import jakarta.ws.rs.core.Response;
-import org.eclipse.microprofile.openapi.annotations.Operation;
-import org.eclipse.microprofile.openapi.annotations.tags.Tag;
-import org.jboss.logging.Logger;
-
-import java.util.List;
-import java.util.UUID;
-import java.util.stream.Collectors;
-
-/**
- * Resource REST pour la gestion des messages et conversations.
- *
- * Cette classe expose les endpoints HTTP pour:
- * - Envoyer des messages
- * - Récupérer les conversations
- * - Récupérer les messages d'une conversation
- * - Marquer les messages comme lus
- * - Supprimer des messages et conversations
- */
-@Path("/messages")
-@Produces(MediaType.APPLICATION_JSON)
-@Consumes(MediaType.APPLICATION_JSON)
-@Tag(name = "Messages", description = "Gestion des messages et conversations")
-public class MessageResource {
-
-  private static final Logger LOG = Logger.getLogger(MessageResource.class);
-
-  @Inject
-  MessageService messageService;
-
-  @Inject
-  UsersRepository usersRepository;
-
-  /**
-   * Envoie un nouveau message.
-   *
-   * @param request Le DTO contenant les informations du message
-   * @return Le message créé
-   */
-  @POST
-  @Operation(summary = "Envoyer un message", description = "Envoie un nouveau message à un utilisateur")
-  public Response sendMessage(SendMessageRequestDTO request) {
-    LOG.info("[LOG] Réception d'une demande d'envoi de message");
-
-    try {
-      // Validation
-      if (!request.isValid()) {
-        return Response.status(Response.Status.BAD_REQUEST)
-            .entity("{\"message\": \"Données invalides\"}")
-            .build();
-      }
-
-      // Envoyer le message
-      Message message = messageService.sendMessage(
-          request.getSenderId(),
-          request.getRecipientId(),
-          request.getContent(),
-          request.getMessageType(),
-          request.getMediaUrl()
-      );
-
-      MessageResponseDTO response = new MessageResponseDTO(message);
-      return Response.status(Response.Status.CREATED).entity(response).build();
-
-    } catch (Exception e) {
-      LOG.error("[ERROR] Erreur lors de l'envoi du message : " + e.getMessage(), e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("{\"message\": \"Erreur lors de l'envoi du message\"}")
-          .build();
-    }
-  }
-
-  /**
-   * Récupère toutes les conversations d'un utilisateur.
-   *
-   * @param userId L'ID de l'utilisateur
-   * @return Liste des conversations
-   */
-  @GET
-  @Path("/conversations/{userId}")
-  @Operation(summary = "Récupérer les conversations", description = "Récupère toutes les conversations d'un utilisateur")
-  public Response getUserConversations(@PathParam("userId") UUID userId) {
-    LOG.info("[LOG] Récupération des conversations pour l'utilisateur ID : " + userId);
-
-    try {
-      Users user = usersRepository.findById(userId);
-      if (user == null) {
-        return Response.status(Response.Status.NOT_FOUND)
-            .entity("{\"message\": \"Utilisateur non trouvé\"}")
-            .build();
-      }
-
-      List<Conversation> conversations = messageService.getUserConversations(userId);
-      List<ConversationResponseDTO> response = conversations.stream()
-          .map(conv -> new ConversationResponseDTO(conv, user))
-          .collect(Collectors.toList());
-
-      return Response.ok(response).build();
-
-    } catch (Exception e) {
-      LOG.error("[ERROR] Erreur lors de la récupération des conversations : " + e.getMessage(), e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("{\"message\": \"Erreur lors de la récupération des conversations\"}")
-          .build();
-    }
-  }
-
-  /**
-   * Récupère les messages d'une conversation.
-   *
-   * @param conversationId L'ID de la conversation
-   * @param page Le numéro de la page (défaut: 0)
-   * @param size La taille de la page (défaut: 50)
-   * @return Liste des messages
-   */
-  @GET
-  @Path("/conversation/{conversationId}")
-  @Operation(summary = "Récupérer les messages", description = "Récupère les messages d'une conversation avec pagination")
-  public Response getConversationMessages(
-      @PathParam("conversationId") UUID conversationId,
-      @QueryParam("page") @DefaultValue("0") int page,
-      @QueryParam("size") @DefaultValue("50") int size) {
-    LOG.info("[LOG] Récupération des messages pour la conversation ID : " + conversationId);
-
-    try {
-      List<Message> messages = messageService.getConversationMessages(conversationId, page, size);
-      List<MessageResponseDTO> response = messages.stream()
-          .map(MessageResponseDTO::new)
-          .collect(Collectors.toList());
-
-      return Response.ok(response).build();
-
-    } catch (Exception e) {
-      LOG.error("[ERROR] Erreur lors de la récupération des messages : " + e.getMessage(), e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("{\"message\": \"Erreur lors de la récupération des messages\"}")
-          .build();
-    }
-  }
-
-  /**
-   * Récupère une conversation entre deux utilisateurs.
-   *
-   * @param user1Id L'ID du premier utilisateur
-   * @param user2Id L'ID du deuxième utilisateur
-   * @return La conversation
-   */
-  @GET
-  @Path("/conversation/between/{user1Id}/{user2Id}")
-  @Operation(summary = "Récupérer une conversation", description = "Récupère la conversation entre deux utilisateurs")
-  public Response getConversationBetweenUsers(
-      @PathParam("user1Id") UUID user1Id,
-      @PathParam("user2Id") UUID user2Id) {
-    LOG.info("[LOG] Recherche de conversation entre " + user1Id + " et " + user2Id);
-
-    try {
-      Users user1 = usersRepository.findById(user1Id);
-      if (user1 == null) {
-        return Response.status(Response.Status.NOT_FOUND)
-            .entity("{\"message\": \"Utilisateur non trouvé\"}")
-            .build();
-      }
-
-      Conversation conversation = messageService.getConversationBetweenUsers(user1Id, user2Id);
-
-      if (conversation == null) {
-        return Response.status(Response.Status.NOT_FOUND)
-            .entity("{\"message\": \"Conversation non trouvée\"}")
-            .build();
-      }
-
-      ConversationResponseDTO response = new ConversationResponseDTO(conversation, user1);
-      return Response.ok(response).build();
-
-    } catch (Exception e) {
-      LOG.error("[ERROR] Erreur lors de la récupération de la conversation : " + e.getMessage(), e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("{\"message\": \"Erreur lors de la récupération de la conversation\"}")
-          .build();
-    }
-  }
-
-  /**
-   * Marque un message comme lu.
-   *
-   * @param messageId L'ID du message
-   * @return Le message mis à jour
-   */
-  @PUT
-  @Path("/{messageId}/read")
-  @Operation(summary = "Marquer comme lu", description = "Marque un message comme lu")
-  public Response markMessageAsRead(@PathParam("messageId") UUID messageId) {
-    LOG.info("[LOG] Marquage du message comme lu : " + messageId);
-
-    try {
-      Message message = messageService.markMessageAsRead(messageId);
-      MessageResponseDTO response = new MessageResponseDTO(message);
-      return Response.ok(response).build();
-
-    } catch (Exception e) {
-      LOG.error("[ERROR] Erreur lors du marquage du message : " + e.getMessage(), e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("{\"message\": \"Erreur lors du marquage du message\"}")
-          .build();
-    }
-  }
-
-  /**
-   * Marque tous les messages d'une conversation comme lus.
-   *
-   * @param conversationId L'ID de la conversation
-   * @param userId L'ID de l'utilisateur
-   * @return Le nombre de messages marqués comme lus
-   */
-  @PUT
-  @Path("/conversation/{conversationId}/read/{userId}")
-  @Operation(summary = "Marquer tout comme lu", description = "Marque tous les messages d'une conversation comme lus")
-  public Response markAllMessagesAsRead(
-      @PathParam("conversationId") UUID conversationId,
-      @PathParam("userId") UUID userId) {
-    LOG.info("[LOG] Marquage de tous les messages comme lus pour la conversation " + conversationId);
-
-    try {
-      int count = messageService.markAllMessagesAsRead(conversationId, userId);
-      return Response.ok("{\"messagesMarkedAsRead\": " + count + "}").build();
-
-    } catch (Exception e) {
-      LOG.error("[ERROR] Erreur lors du marquage des messages : " + e.getMessage(), e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("{\"message\": \"Erreur lors du marquage des messages\"}")
-          .build();
-    }
-  }
-
-  /**
-   * Récupère le nombre total de messages non lus pour un utilisateur.
-   *
-   * @param userId L'ID de l'utilisateur
-   * @return Le nombre de messages non lus
-   */
-  @GET
-  @Path("/unread/count/{userId}")
-  @Operation(summary = "Compter les non lus", description = "Compte le nombre total de messages non lus")
-  public Response getTotalUnreadCount(@PathParam("userId") UUID userId) {
-    LOG.info("[LOG] Récupération du nombre de messages non lus pour l'utilisateur " + userId);
-
-    try {
-      long count = messageService.getTotalUnreadCount(userId);
-      return Response.ok("{\"unreadCount\": " + count + "}").build();
-
-    } catch (Exception e) {
-      LOG.error("[ERROR] Erreur lors du comptage des messages non lus : " + e.getMessage(), e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("{\"message\": \"Erreur lors du comptage\"}")
-          .build();
-    }
-  }
-
-  /**
-   * Supprime un message.
-   *
-   * @param messageId L'ID du message
-   * @return Confirmation de suppression
-   */
-  @DELETE
-  @Path("/{messageId}")
-  @Operation(summary = "Supprimer un message", description = "Supprime un message")
-  public Response deleteMessage(@PathParam("messageId") UUID messageId) {
-    LOG.info("[LOG] Suppression du message ID : " + messageId);
-
-    try {
-      boolean deleted = messageService.deleteMessage(messageId);
-
-      if (deleted) {
-        return Response.ok("{\"message\": \"Message supprimé avec succès\"}").build();
-      } else {
-        return Response.status(Response.Status.NOT_FOUND)
-            .entity("{\"message\": \"Message non trouvé\"}")
-            .build();
-      }
-
-    } catch (Exception e) {
-      LOG.error("[ERROR] Erreur lors de la suppression du message : " + e.getMessage(), e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("{\"message\": \"Erreur lors de la suppression\"}")
-          .build();
-    }
-  }
-
-  /**
-   * Supprime une conversation.
-   *
-   * @param conversationId L'ID de la conversation
-   * @return Confirmation de suppression
-   */
-  @DELETE
-  @Path("/conversation/{conversationId}")
-  @Operation(summary = "Supprimer une conversation", description = "Supprime une conversation et tous ses messages")
-  public Response deleteConversation(@PathParam("conversationId") UUID conversationId) {
-    LOG.info("[LOG] Suppression de la conversation ID : " + conversationId);
-
-    try {
-      boolean deleted = messageService.deleteConversation(conversationId);
-
-      if (deleted) {
-        return Response.ok("{\"message\": \"Conversation supprimée avec succès\"}").build();
-      } else {
-        return Response.status(Response.Status.NOT_FOUND)
-            .entity("{\"message\": \"Conversation non trouvée\"}")
-            .build();
-      }
-
-    } catch (Exception e) {
-      LOG.error("[ERROR] Erreur lors de la suppression de la conversation : " + e.getMessage(), e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("{\"message\": \"Erreur lors de la suppression\"}")
-          .build();
-    }
-  }
-}

src/main/java/com/lions/dev/resource/NotificationResource.java

@@ -1,247 +0,0 @@
-package com.lions.dev.resource;
-
-import com.lions.dev.dto.response.notifications.NotificationResponseDTO;
-import com.lions.dev.entity.notification.Notification;
-import com.lions.dev.service.NotificationService;
-import jakarta.inject.Inject;
-import jakarta.transaction.Transactional;
-import jakarta.ws.rs.*;
-import jakarta.ws.rs.core.MediaType;
-import jakarta.ws.rs.core.Response;
-import java.util.List;
-import java.util.UUID;
-import java.util.stream.Collectors;
-import org.eclipse.microprofile.openapi.annotations.Operation;
-import org.eclipse.microprofile.openapi.annotations.tags.Tag;
-import org.jboss.logging.Logger;
-
-/**
- * Ressource REST pour la gestion des notifications dans le système AfterWork.
- * 
- * Cette classe expose des endpoints pour créer, récupérer, mettre à jour
- * et supprimer des notifications.
- * 
- * Tous les logs nécessaires pour la traçabilité sont intégrés.
- */
-@Path("/notifications")
-@Produces(MediaType.APPLICATION_JSON)
-@Consumes(MediaType.APPLICATION_JSON)
-@Tag(name = "Notifications", description = "Opérations liées à la gestion des notifications")
-public class NotificationResource {
-
-  @Inject
-  NotificationService notificationService;
-
-  private static final Logger LOG = Logger.getLogger(NotificationResource.class);
-
-  /**
-   * Récupère toutes les notifications d'un utilisateur.
-   *
-   * @param userId L'ID de l'utilisateur
-   * @return Liste des notifications de l'utilisateur
-   */
-  @GET
-  @Path("/user/{userId}")
-  @Operation(
-      summary = "Récupérer les notifications d'un utilisateur",
-      description = "Retourne la liste de toutes les notifications d'un utilisateur, triées par date de création décroissante")
-  public Response getNotificationsByUserId(@PathParam("userId") UUID userId) {
-    LOG.info("[LOG] Récupération des notifications pour l'utilisateur ID : " + userId);
-
-    try {
-      List<Notification> notifications = notificationService.getNotificationsByUserId(userId);
-      List<NotificationResponseDTO> responseDTOs = notifications.stream()
-          .map(NotificationResponseDTO::new)
-          .collect(Collectors.toList());
-
-      LOG.info("[LOG] " + responseDTOs.size() + " notification(s) récupérée(s) pour l'utilisateur ID : " + userId);
-      return Response.ok(responseDTOs).build();
-    } catch (Exception e) {
-      LOG.error("[ERROR] Erreur lors de la récupération des notifications : " + e.getMessage(), e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("{\"message\": \"Erreur lors de la récupération des notifications.\"}")
-          .build();
-    }
-  }
-
-  /**
-   * Récupère les notifications d'un utilisateur avec pagination.
-   *
-   * @param userId L'ID de l'utilisateur
-   * @param page Le numéro de la page (0-indexé)
-   * @param size La taille de la page
-   * @return Liste paginée des notifications
-   */
-  @GET
-  @Path("/user/{userId}/paginated")
-  @Operation(
-      summary = "Récupérer les notifications d'un utilisateur avec pagination",
-      description = "Retourne une liste paginée des notifications d'un utilisateur")
-  public Response getNotificationsByUserIdWithPagination(
-      @PathParam("userId") UUID userId,
-      @QueryParam("page") @DefaultValue("0") int page,
-      @QueryParam("size") @DefaultValue("10") int size) {
-    LOG.info("[LOG] Récupération paginée des notifications pour l'utilisateur ID : " + userId);
-
-    try {
-      List<Notification> notifications = notificationService.getNotificationsByUserIdWithPagination(userId, page, size);
-      List<NotificationResponseDTO> responseDTOs = notifications.stream()
-          .map(NotificationResponseDTO::new)
-          .collect(Collectors.toList());
-
-      return Response.ok(responseDTOs).build();
-    } catch (Exception e) {
-      LOG.error("[ERROR] Erreur lors de la récupération paginée des notifications : " + e.getMessage(), e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("{\"message\": \"Erreur lors de la récupération des notifications.\"}")
-          .build();
-    }
-  }
-
-  /**
-   * Marque une notification comme lue.
-   *
-   * @param notificationId L'ID de la notification
-   * @return La notification mise à jour
-   */
-  @PUT
-  @Path("/{id}/read")
-  @Transactional
-  @Operation(
-      summary = "Marquer une notification comme lue",
-      description = "Marque une notification spécifique comme lue")
-  public Response markAsRead(@PathParam("id") UUID notificationId) {
-    LOG.info("[LOG] Marquage de la notification ID : " + notificationId + " comme lue");
-
-    try {
-      Notification notification = notificationService.markAsRead(notificationId);
-      NotificationResponseDTO responseDTO = new NotificationResponseDTO(notification);
-      return Response.ok(responseDTO).build();
-    } catch (IllegalArgumentException e) {
-      LOG.warn("[WARN] Notification non trouvée : " + e.getMessage());
-      return Response.status(Response.Status.NOT_FOUND)
-          .entity("{\"message\": \"Notification non trouvée.\"}")
-          .build();
-    } catch (Exception e) {
-      LOG.error("[ERROR] Erreur lors du marquage de la notification : " + e.getMessage(), e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("{\"message\": \"Erreur lors du marquage de la notification.\"}")
-          .build();
-    }
-  }
-
-  /**
-   * Marque toutes les notifications d'un utilisateur comme lues.
-   *
-   * @param userId L'ID de l'utilisateur
-   * @return Nombre de notifications mises à jour
-   */
-  @PUT
-  @Path("/user/{userId}/mark-all-read")
-  @Transactional
-  @Operation(
-      summary = "Marquer toutes les notifications comme lues",
-      description = "Marque toutes les notifications d'un utilisateur comme lues")
-  public Response markAllAsRead(@PathParam("userId") UUID userId) {
-    LOG.info("[LOG] Marquage de toutes les notifications comme lues pour l'utilisateur ID : " + userId);
-
-    try {
-      int updated = notificationService.markAllAsRead(userId);
-      return Response.ok("{\"message\": \"" + updated + " notification(s) marquée(s) comme lue(s).\"}").build();
-    } catch (Exception e) {
-      LOG.error("[ERROR] Erreur lors du marquage de toutes les notifications : " + e.getMessage(), e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("{\"message\": \"Erreur lors du marquage des notifications.\"}")
-          .build();
-    }
-  }
-
-  /**
-   * Supprime une notification.
-   *
-   * @param notificationId L'ID de la notification
-   * @return Réponse de confirmation
-   */
-  @DELETE
-  @Path("/{id}")
-  @Transactional
-  @Operation(
-      summary = "Supprimer une notification",
-      description = "Supprime une notification spécifique")
-  public Response deleteNotification(@PathParam("id") UUID notificationId) {
-    LOG.info("[LOG] Suppression de la notification ID : " + notificationId);
-
-    try {
-      boolean deleted = notificationService.deleteNotification(notificationId);
-      if (deleted) {
-        return Response.noContent().build();
-      } else {
-        return Response.status(Response.Status.NOT_FOUND)
-            .entity("{\"message\": \"Notification non trouvée.\"}")
-            .build();
-      }
-    } catch (Exception e) {
-      LOG.error("[ERROR] Erreur lors de la suppression de la notification : " + e.getMessage(), e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("{\"message\": \"Erreur lors de la suppression de la notification.\"}")
-          .build();
-    }
-  }
-
-  /**
-   * Récupère une notification par son ID.
-   *
-   * @param notificationId L'ID de la notification
-   * @return La notification trouvée
-   */
-  @GET
-  @Path("/{id}")
-  @Operation(
-      summary = "Récupérer une notification par ID",
-      description = "Retourne les détails d'une notification spécifique")
-  public Response getNotificationById(@PathParam("id") UUID notificationId) {
-    LOG.info("[LOG] Récupération de la notification ID : " + notificationId);
-
-    try {
-      Notification notification = notificationService.getNotificationById(notificationId);
-      NotificationResponseDTO responseDTO = new NotificationResponseDTO(notification);
-      return Response.ok(responseDTO).build();
-    } catch (IllegalArgumentException e) {
-      LOG.warn("[WARN] Notification non trouvée : " + e.getMessage());
-      return Response.status(Response.Status.NOT_FOUND)
-          .entity("{\"message\": \"Notification non trouvée.\"}")
-          .build();
-    } catch (Exception e) {
-      LOG.error("[ERROR] Erreur lors de la récupération de la notification : " + e.getMessage(), e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("{\"message\": \"Erreur lors de la récupération de la notification.\"}")
-          .build();
-    }
-  }
-
-  /**
-   * Compte le nombre de notifications non lues d'un utilisateur.
-   *
-   * @param userId L'ID de l'utilisateur
-   * @return Le nombre de notifications non lues
-   */
-  @GET
-  @Path("/user/{userId}/unread-count")
-  @Operation(
-      summary = "Compter les notifications non lues",
-      description = "Retourne le nombre de notifications non lues d'un utilisateur")
-  public Response getUnreadCount(@PathParam("userId") UUID userId) {
-    LOG.info("[LOG] Comptage des notifications non lues pour l'utilisateur ID : " + userId);
-
-    try {
-      long count = notificationService.countUnreadNotifications(userId);
-      return Response.ok("{\"count\": " + count + "}").build();
-    } catch (Exception e) {
-      LOG.error("[ERROR] Erreur lors du comptage des notifications : " + e.getMessage(), e);
-      return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
-          .entity("{\"message\": \"Erreur lors du comptage des notifications.\"}")
-          .build();
-    }
-  }
-}
-