Versions stable (inachevée mais prête à un déploiement en prod)

src/main/java/dev/lions/exceptions/AnalyticsException.java

@@ -0,0 +1,17 @@
+package dev.lions.exceptions;
+
+/**
+ * Exception spécifique pour les erreurs liées au traitement des événements analytiques. Cette
+ * exception encapsule les erreurs qui surviennent lors de l'enregistrement, l'enrichissement ou la
+ * publication des événements d'analyse.
+ */
+public class AnalyticsException extends RuntimeException {
+
+  public AnalyticsException(String message) {
+    super(message);
+  }
+
+  public AnalyticsException(String message, Throwable cause) {
+    super(message, cause);
+  }
+}

src/main/java/dev/lions/exceptions/BusinessException.java

@@ -0,0 +1,12 @@
+package dev.lions.exceptions;
+
+public class BusinessException extends RuntimeException {
+
+  public BusinessException(String message) {
+    super(message);
+  }
+
+  public BusinessException(String message, Throwable cause) {
+    super(message, cause);
+  }
+}

src/main/java/dev/lions/exceptions/ConfigurationException.java

@@ -0,0 +1,29 @@
+package dev.lions.exceptions;
+
+/**
+ * Exception levée lorsqu'une erreur de configuration se produit.
+ * Cette exception encapsule les erreurs liées à la configuration
+ * de l'application, telles que des paramètres invalides ou des
+ * ressources indisponibles.
+ */
+public class ConfigurationException extends RuntimeException {
+
+  /**
+   * Crée une nouvelle instance de ConfigurationException avec un message.
+   *
+   * @param message Message décrivant l'erreur de configuration
+   */
+  public ConfigurationException(String message) {
+    super(message);
+  }
+
+  /**
+   * Crée une nouvelle instance de ConfigurationException avec un message et une cause.
+   *
+   * @param message Message décrivant l'erreur de configuration
+   * @param cause Cause à l'origine de l'exception
+   */
+  public ConfigurationException(String message, Throwable cause) {
+    super(message, cause);
+  }
+}

src/main/java/dev/lions/exceptions/DataTableException.java

@@ -0,0 +1,103 @@
+package dev.lions.exceptions;
+
+import lombok.Getter;
+
+/**
+ * Exception spécifique pour la gestion des erreurs liées aux tables de données.
+ * Cette exception encapsule les problèmes survenant lors de la manipulation,
+ * du tri ou du filtrage des données tabulaires.
+ *
+ * @author Lions Dev Team
+ * @version 1.0
+ */
+@Getter
+public class DataTableException extends BusinessException {
+
+  private static final long serialVersionUID = 1L;
+
+  /**
+   * Identifiant de la table concernée par l'erreur
+   * -- GETTER --
+   *  Récupère l'identifiant de la table concernée.
+   *
+   * @return Identifiant de la table ou null si non spécifié
+
+   */
+  private final String tableId;
+
+  /**
+   * Type d'opération ayant échoué
+   * -- GETTER --
+   *  Récupère l'opération ayant échoué.
+   *
+   * @return Type d'opération ou null si non spécifié
+
+   */
+  private final DataTableOperation operation;
+
+  /**
+   * Crée une nouvelle instance avec un message d'erreur.
+   *
+   * @param message Description détaillée de l'erreur
+   */
+  public DataTableException(String message) {
+    this(message, null, null, null);
+  }
+
+  /**
+   * Crée une nouvelle instance avec un message et une cause.
+   *
+   * @param message Description détaillée de l'erreur
+   * @param cause Cause originale de l'erreur
+   */
+  public DataTableException(String message, Throwable cause) {
+    this(message, cause, null, null);
+  }
+
+  /**
+   * Crée une nouvelle instance avec tous les détails de l'erreur.
+   *
+   * @param message Description détaillée de l'erreur
+   * @param cause Cause originale de l'erreur
+   * @param tableId Identifiant de la table concernée
+   * @param operation Opération ayant échoué
+   */
+  public DataTableException(String message, Throwable cause, String tableId, DataTableOperation operation) {
+    super(message, cause);
+    this.tableId = tableId;
+    this.operation = operation;
+  }
+
+  /**
+   * Types d'opérations pouvant échouer sur une table de données.
+   */
+  @Getter
+  public enum DataTableOperation {
+    SORT("Tri"),
+    FILTER("Filtrage"),
+    PAGINATION("Pagination"),
+    UPDATE("Mise à jour"),
+    LOAD("Chargement");
+
+    private final String label;
+
+    DataTableOperation(String label) {
+      this.label = label;
+    }
+
+  }
+
+  @Override
+  public String getMessage() {
+    StringBuilder message = new StringBuilder(super.getMessage());
+
+    if (tableId != null) {
+      message.append(" [Table: ").append(tableId).append("]");
+    }
+    if (operation != null) {
+      message.append(" [Opération: ").append(operation.getLabel()).append("]");
+    }
+
+    return message.toString();
+  }
+}

src/main/java/dev/lions/exceptions/EmailException.java

@@ -0,0 +1,7 @@
+package dev.lions.exceptions;
+
+public class EmailException extends RuntimeException {
+  public EmailException(String message) {
+    super(message);
+  }
+}

src/main/java/dev/lions/exceptions/EventProcessingException.java

@@ -0,0 +1,21 @@
+package dev.lions.exceptions;
+
+/**
+ * Exception levée lors d'erreurs de traitement des événements.
+ * Permet de gérer de manière cohérente les erreurs dans le système événementiel.
+ */
+public class EventProcessingException extends RuntimeException {
+  private static final long serialVersionUID = 1L;
+
+  public EventProcessingException(String message) {
+    super(message);
+  }
+
+  public EventProcessingException(String message, Throwable cause) {
+    super(message, cause);
+  }
+
+  public EventProcessingException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
+    super(message, cause, enableSuppression, writableStackTrace);
+  }
+}

src/main/java/dev/lions/exceptions/EventPublicationException.java

@@ -0,0 +1,15 @@
+package dev.lions.exceptions;
+
+/**
+ * Exception levée lors d'erreurs de publication d'événements analytiques.
+ */
+public class EventPublicationException extends RuntimeException {
+
+  public EventPublicationException(String message) {
+    super(message);
+  }
+
+  public EventPublicationException(String message, Throwable cause) {
+    super(message, cause);
+  }
+}

src/main/java/dev/lions/exceptions/FileUploadException.java

@@ -0,0 +1,135 @@
+package dev.lions.exceptions;
+
+import lombok.Builder;
+import lombok.Getter;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * Exception spécialisée pour la gestion des erreurs lors du téléchargement de fichiers.
+ * Cette classe encapsule les différents types d'erreurs pouvant survenir pendant
+ * le processus de téléchargement et de traitement des fichiers.
+ *
+ * @author Lions Dev Team
+ * @version 1.0
+ */
+@Slf4j
+public class FileUploadException extends BusinessException {
+
+  private static final long serialVersionUID = 1L;
+
+  /**
+   * Détails techniques de l'erreur de téléchargement
+   */
+  private final FileUploadErrorDetails errorDetails;
+
+  /**
+   * Crée une nouvelle instance avec un message d'erreur simple.
+   *
+   * @param message Description de l'erreur
+   */
+  public FileUploadException(String message) {
+    this(message, null, null);
+    log.error("Erreur de téléchargement : {}", message);
+  }
+
+  /**
+   * Crée une nouvelle instance avec un message et une cause.
+   *
+   * @param message Description de l'erreur
+   * @param cause Exception à l'origine de l'erreur
+   */
+  public FileUploadException(String message, Throwable cause) {
+    this(message, cause, null);
+    log.error("Erreur de téléchargement : {}", message, cause);
+  }
+
+  /**
+   * Crée une nouvelle instance avec tous les détails de l'erreur.
+   *
+   * @param message Description de l'erreur
+   * @param cause Exception à l'origine de l'erreur
+   * @param errorDetails Détails techniques de l'erreur
+   */
+  public FileUploadException(String message, Throwable cause, FileUploadErrorDetails errorDetails) {
+    super(message, cause);
+    this.errorDetails = errorDetails;
+    log.error("Erreur de téléchargement détaillée : {} - Détails : {}", message, errorDetails);
+  }
+
+  /**
+   * Récupère les détails techniques de l'erreur.
+   *
+   * @return Détails de l'erreur ou null si non disponibles
+   */
+  public FileUploadErrorDetails getErrorDetails() {
+    return errorDetails;
+  }
+
+  /**
+   * Classe interne représentant les détails techniques d'une erreur de téléchargement.
+   */
+  @Getter
+  @Builder
+  public static class FileUploadErrorDetails {
+    private final String fileName;
+    private final long fileSize;
+    private final String mimeType;
+    private final String uploadLocation;
+    private final String validationError;
+    private final String processingPhase;
+
+    @Override
+    public String toString() {
+      return String.format(
+          "FileUploadErrorDetails[fileName=%s, fileSize=%d, mimeType=%s, " +
+          "location=%s, error=%s, phase=%s]",
+          fileName, fileSize, mimeType, uploadLocation, validationError, processingPhase
+      );
+    }
+  }
+
+  /**
+   * Crée une instance d'exception pour un fichier trop volumineux.
+   *
+   * @param fileName Nom du fichier
+   * @param actualSize Taille réelle du fichier
+   * @param maxSize Taille maximale autorisée
+   * @return Instance de FileUploadException
+   */
+  public static FileUploadException fileTooLarge(String fileName, long actualSize, long maxSize) {
+    String message = String.format(
+        "Le fichier '%s' est trop volumineux (%d octets). Maximum autorisé : %d octets",
+        fileName, actualSize, maxSize
+    );
+
+    FileUploadErrorDetails details = FileUploadErrorDetails.builder()
+                                                           .fileName(fileName)
+                                                           .fileSize(actualSize)
+                                                           .validationError("FILE_TOO_LARGE")
+                                                           .processingPhase("VALIDATION")
+                                                           .build();
+
+    return new FileUploadException(message, null, details);
+  }
+
+  /**
+   * Crée une instance d'exception pour un type de fichier non autorisé.
+   *
+   * @param fileName Nom du fichier
+   * @param mimeType Type MIME du fichier
+   * @return Instance de FileUploadException
+   */
+  public static FileUploadException invalidFileType(String fileName, String mimeType) {
+    String message = String.format(
+        "Le type de fichier '%s' n'est pas autorisé pour '%s'",
+        mimeType, fileName
+    );
+
+    FileUploadErrorDetails details =
+        FileUploadErrorDetails.builder().fileName(fileName).mimeType(mimeType)
+                              .validationError("INVALID_FILE_TYPE").processingPhase("VALIDATION")
+                              .fileSize(-1).build();
+
+    return new FileUploadException(message, null, details);
+  }
+}

src/main/java/dev/lions/exceptions/FilterException.java

@@ -0,0 +1,158 @@
+package dev.lions.exceptions;
+
+import lombok.Builder;
+import lombok.Getter;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * Exception spécialisée pour la gestion des erreurs de filtrage.
+ * Cette classe encapsule les différentes erreurs pouvant survenir lors
+ * de l'application ou la manipulation des filtres de données.
+ *
+ * @author Lions Dev Team
+ * @version 1.0
+ */
+@Slf4j
+public class FilterException extends BusinessException {
+
+  private static final long serialVersionUID = 1L;
+
+  /**
+   * Contexte détaillé de l'erreur de filtrage
+   */
+  private final FilterContext filterContext;
+
+  /**
+   * Crée une nouvelle instance avec un message d'erreur simple.
+   *
+   * @param message Description de l'erreur
+   */
+  public FilterException(String message) {
+    this(message, null, null);
+    log.error("Erreur de filtrage : {}", message);
+  }
+
+  /**
+   * Crée une nouvelle instance avec un message et une cause.
+   *
+   * @param message Description de l'erreur
+   * @param cause Exception à l'origine de l'erreur
+   */
+  public FilterException(String message, Throwable cause) {
+    this(message, cause, null);
+    log.error("Erreur de filtrage : {}", message, cause);
+  }
+
+  /**
+   * Crée une nouvelle instance avec tous les détails de l'erreur.
+   *
+   * @param message Description de l'erreur
+   * @param cause Exception à l'origine de l'erreur
+   * @param context Contexte du filtrage au moment de l'erreur
+   */
+  public FilterException(String message, Throwable cause, FilterContext context) {
+    super(message, cause);
+    this.filterContext = context;
+    log.error("Erreur de filtrage détaillée : {} - Contexte : {}", message, context);
+  }
+
+  /**
+   * Récupère le contexte de l'erreur de filtrage.
+   *
+   * @return Contexte de l'erreur ou null si non disponible
+   */
+  public FilterContext getFilterContext() {
+    return filterContext;
+  }
+
+  /**
+   * Classe interne représentant le contexte d'une erreur de filtrage.
+   */
+  @Getter
+  @Builder
+  public static class FilterContext {
+    private final String field;
+    private final String operator;
+    private final String value;
+    private final String expectedType;
+    private final String actualType;
+    private final String validationError;
+
+    @Override
+    public String toString() {
+      return String.format(
+          "FilterContext[field=%s, operator=%s, value=%s, expectedType=%s, actualType=%s, error=%s]",
+          field, operator, value, expectedType, actualType, validationError
+      );
+    }
+  }
+
+  /**
+   * Crée une exception pour un champ de filtrage invalide.
+   *
+   * @param fieldName Nom du champ
+   * @param value Valeur invalide
+   * @param expectedType Type attendu
+   * @return Instance de FilterException
+   */
+  public static FilterException invalidFieldValue(String fieldName, String value, String expectedType) {
+    String message = String.format(
+        "Valeur invalide '%s' pour le champ '%s'. Type attendu : %s",
+        value, fieldName, expectedType
+    );
+
+    FilterContext context = FilterContext.builder()
+                                         .field(fieldName)
+                                         .value(value)
+                                         .expectedType(expectedType)
+                                         .validationError("INVALID_FIELD_VALUE")
+                                         .build();
+
+    return new FilterException(message, null, context);
+  }
+
+  /**
+   * Crée une exception pour un opérateur de filtre incompatible.
+   *
+   * @param operator Opérateur utilisé
+   * @param fieldName Nom du champ
+   * @param fieldType Type du champ
+   * @return Instance de FilterException
+   */
+  public static FilterException incompatibleOperator(String operator, String fieldName, String fieldType) {
+    String message = String.format(
+        "L'opérateur '%s' n'est pas compatible avec le champ '%s' de type %s",
+        operator, fieldName, fieldType
+    );
+
+    FilterContext context = FilterContext.builder()
+                                         .field(fieldName)
+                                         .operator(operator)
+                                         .expectedType(fieldType)
+                                         .validationError("INCOMPATIBLE_OPERATOR")
+                                         .build();
+
+    return new FilterException(message, null, context);
+  }
+
+  /**
+   * Crée une exception pour une expression de filtre invalide.
+   *
+   * @param expression Expression de filtre
+   * @param reason Raison de l'invalidité
+   * @return Instance de FilterException
+   */
+  public static FilterException invalidFilterExpression(String expression, String reason) {
+    String message = String.format(
+        "Expression de filtre invalide '%s' : %s",
+        expression, reason
+    );
+
+    FilterContext context = FilterContext.builder()
+                                         .value(expression)
+                                         .validationError("INVALID_FILTER_EXPRESSION")
+                                         .build();
+
+    return new FilterException(message, null, context);
+  }
+}

src/main/java/dev/lions/exceptions/ImageProcessingException.java

@@ -0,0 +1,11 @@
+package dev.lions.exceptions;
+
+public class ImageProcessingException extends BusinessException {
+  public ImageProcessingException(String message) {
+    super(message);
+  }
+
+  public ImageProcessingException(String message, Throwable cause) {
+    super(message, cause);
+  }
+}

src/main/java/dev/lions/exceptions/IndexingException.java

@@ -0,0 +1,27 @@
+package dev.lions.exceptions;
+
+/**
+ * Exception personnalisée pour les erreurs d'indexation Elasticsearch.
+ * Cette exception est levée lorsqu'une opération d'indexation échoue.
+ */
+public class IndexingException extends RuntimeException {
+
+  /**
+   * Crée une nouvelle instance avec un message d'erreur.
+   *
+   * @param message Le message décrivant l'erreur
+   */
+  public IndexingException(String message) {
+    super(message);
+  }
+
+  /**
+   * Crée une nouvelle instance avec un message et une cause.
+   *
+   * @param message Le message décrivant l'erreur
+   * @param cause La cause originale de l'erreur
+   */
+  public IndexingException(String message, Throwable cause) {
+    super(message, cause);
+  }
+}

src/main/java/dev/lions/exceptions/InitializationException.java

@@ -0,0 +1,210 @@
+package dev.lions.exceptions;
+
+import java.util.Map;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * Exception spécialisée pour la gestion des erreurs d'initialisation.
+ * Cette classe traite les erreurs survenant lors de l'initialisation
+ * des composants, services et ressources de l'application.
+ *
+ * @author Lions Dev Team
+ * @version 1.0
+ */
+@Slf4j
+public class InitializationException extends BusinessException {
+
+  private static final long serialVersionUID = 1L;
+
+  /**
+   * Contexte détaillé de l'erreur d'initialisation
+   */
+  private final InitializationContext context;
+
+  /**
+   * Phase d'initialisation durant laquelle l'erreur est survenue
+   */
+  private final InitializationPhase phase;
+
+  /**
+   * Crée une nouvelle instance avec un message d'erreur simple.
+   *
+   * @param message Description de l'erreur
+   */
+  public InitializationException(String message) {
+    this(message, null, null, null);
+    log.error("Erreur d'initialisation : {}", message);
+  }
+
+  /**
+   * Crée une nouvelle instance avec un message et une cause.
+   *
+   * @param message Description de l'erreur
+   * @param cause Exception à l'origine de l'erreur
+   */
+  public InitializationException(String message, Throwable cause) {
+    this(message, cause, null, null);
+    log.error("Erreur d'initialisation : {}", message, cause);
+  }
+
+  /**
+   * Crée une nouvelle instance avec tous les détails de l'erreur.
+   *
+   * @param message Description de l'erreur
+   * @param cause Exception à l'origine de l'erreur
+   * @param context Contexte de l'initialisation
+   * @param phase Phase d'initialisation
+   */
+  public InitializationException(String message, Throwable cause,
+                                 InitializationContext context, InitializationPhase phase) {
+    super(message, cause);
+    this.context = context;
+    this.phase = phase;
+    log.error("Erreur d'initialisation détaillée : {} - Phase : {} - Contexte : {}",
+              message, phase, context);
+  }
+
+  /**
+   * Récupère le contexte de l'erreur d'initialisation.
+   *
+   * @return Contexte de l'erreur ou null si non disponible
+   */
+  public InitializationContext getContext() {
+    return context;
+  }
+
+  /**
+   * Récupère la phase d'initialisation.
+   *
+   * @return Phase d'initialisation ou null si non disponible
+   */
+  public InitializationPhase getPhase() {
+    return phase;
+  }
+
+  /**
+   * Représente les différentes phases d'initialisation possibles.
+   */
+  public enum InitializationPhase {
+    CONFIGURATION("Configuration"),
+    RESOURCE_LOADING("Chargement des ressources"),
+    DATABASE("Base de données"),
+    DEPENDENCY_INJECTION("Injection de dépendances"),
+    SECURITY("Sécurité"),
+    CACHE("Cache"),
+    SERVICE_STARTUP("Démarrage des services");
+
+    private final String description;
+
+    InitializationPhase(String description) {
+      this.description = description;
+    }
+
+    public String getDescription() {
+      return description;
+    }
+  }
+
+  /**
+   * Classe interne représentant le contexte d'une erreur d'initialisation.
+   */
+  @Getter
+  @Builder
+  public static class InitializationContext {
+    private final String componentName;
+    private final String resourceName;
+    private final String configurationKey;
+    private final String expectedState;
+    private final String actualState;
+    private final Map<String, String> additionalInfo;
+
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder()
+          .append("InitializationContext[")
+          .append("component=").append(componentName)
+          .append(", resource=").append(resourceName)
+          .append(", config=").append(configurationKey);
+
+      if (expectedState != null) {
+        sb.append(", expected=").append(expectedState);
+      }
+      if (actualState != null) {
+        sb.append(", actual=").append(actualState);
+      }
+      if (additionalInfo != null && !additionalInfo.isEmpty()) {
+        sb.append(", info=").append(additionalInfo);
+      }
+
+      return sb.append("]").toString();
+    }
+  }
+
+  /**
+   * Crée une exception pour une ressource manquante.
+   *
+   * @param resourceName Nom de la ressource
+   * @param componentName Nom du composant
+   * @return Instance de InitializationException
+   */
+  public static InitializationException resourceNotFound(String resourceName, String componentName) {
+    String message = String.format(
+        "Ressource requise '%s' non trouvée pour le composant '%s'",
+        resourceName, componentName
+    );
+
+    InitializationContext context = InitializationContext.builder()
+                                                         .componentName(componentName)
+                                                         .resourceName(resourceName)
+                                                         .build();
+
+    return new InitializationException(message, null, context, InitializationPhase.RESOURCE_LOADING);
+  }
+
+  /**
+   * Crée une exception pour une configuration invalide.
+   *
+   * @param key Clé de configuration
+   * @param expectedValue Valeur attendue
+   * @param actualValue Valeur actuelle
+   * @return Instance de InitializationException
+   */
+  public static InitializationException invalidConfiguration(String key,
+                                                             String expectedValue, String actualValue) {
+    String message = String.format(
+        "Configuration invalide pour '%s'. Attendu : %s, Actuel : %s",
+        key, expectedValue, actualValue
+    );
+
+    InitializationContext context = InitializationContext.builder()
+                                                         .configurationKey(key)
+                                                         .expectedState(expectedValue)
+                                                         .actualState(actualValue)
+                                                         .build();
+
+    return new InitializationException(message, null, context, InitializationPhase.CONFIGURATION);
+  }
+
+  /**
+   * Crée une exception pour un échec de démarrage de service.
+   *
+   * @param serviceName Nom du service
+   * @param reason Raison de l'échec
+   * @return Instance de InitializationException
+   */
+  public static InitializationException serviceStartupFailure(String serviceName, String reason) {
+    String message = String.format(
+        "Échec du démarrage du service '%s' : %s",
+        serviceName, reason
+    );
+
+    InitializationContext context = InitializationContext.builder()
+                                                         .componentName(serviceName)
+                                                         .additionalInfo(Map.of("reason", reason))
+                                                         .build();
+
+    return new InitializationException(message, null, context, InitializationPhase.SERVICE_STARTUP);
+  }
+}

src/main/java/dev/lions/exceptions/JsonConversionException.java

@@ -0,0 +1,11 @@
+package dev.lions.exceptions;
+
+/**
+ * Exception spécifique pour les erreurs de conversion JSON.
+ */
+public class JsonConversionException extends RuntimeException {
+
+  public JsonConversionException(String message, Throwable cause) {
+    super(message, cause);
+  }
+}

src/main/java/dev/lions/exceptions/NavigationException.java

@@ -0,0 +1,7 @@
+package dev.lions.exceptions;
+
+public class NavigationException extends RuntimeException {
+  public NavigationException(String message) {
+    super(message);
+  }
+}

src/main/java/dev/lions/exceptions/NotificationException.java

@@ -0,0 +1,11 @@
+package dev.lions.exceptions;
+
+public class NotificationException extends BusinessException {
+  public NotificationException(String message) {
+    super(message);
+  }
+
+  public NotificationException(String message, Throwable cause) {  // Ajout du paramètre cause
+    super(message, cause);
+  }
+}

src/main/java/dev/lions/exceptions/RepositoryException.java

@@ -0,0 +1,14 @@
+package dev.lions.exceptions;
+
+/**
+ * Exception pour les erreurs de repository.
+ */
+public class RepositoryException extends RuntimeException {
+  public RepositoryException(String message) {
+    super(message);
+  }
+
+  public RepositoryException(String message, Throwable cause) {
+    super(message, cause);
+  }
+}

src/main/java/dev/lions/exceptions/StorageConfigurationException.java

@@ -0,0 +1,29 @@
+package dev.lions.exceptions;
+
+/**
+ * Exception levée lorsqu'une erreur de configuration de stockage se produit.
+ * Cette exception encapsule les erreurs liées à la configuration du stockage
+ * des fichiers, telles que des chemins de stockage invalides ou un espace
+ * de stockage insuffisant.
+ */
+public class StorageConfigurationException extends RuntimeException {
+
+  /**
+   * Crée une nouvelle instance de StorageConfigurationException avec un message.
+   *
+   * @param message Message décrivant l'erreur de configuration du stockage
+   */
+  public StorageConfigurationException(String message) {
+    super(message);
+  }
+
+  /**
+   * Crée une nouvelle instance de StorageConfigurationException avec un message et une cause.
+   *
+   * @param message Message décrivant l'erreur de configuration du stockage
+   * @param cause Cause à l'origine de l'exception
+   */
+  public StorageConfigurationException(String message, Throwable cause) {
+    super(message, cause);
+  }
+}

src/main/java/dev/lions/exceptions/TemplateException.java

@@ -0,0 +1,26 @@
+package dev.lions.exceptions;
+
+/**
+ * Exception pour les erreurs liées au traitement des templates.
+ */
+public class TemplateException extends RuntimeException {
+
+  /**
+   * Constructeur avec un message.
+   *
+   * @param message Message de l'erreur
+   */
+  public TemplateException(String message) {
+    super(message);
+  }
+
+  /**
+   * Constructeur avec un message et une cause.
+   *
+   * @param message Message de l'erreur
+   * @param cause   Cause de l'erreur
+   */
+  public TemplateException(String message, Throwable cause) {
+    super(message, cause);
+  }
+}

src/main/java/dev/lions/exceptions/TemplateProcessingException.java

@@ -0,0 +1,11 @@
+package dev.lions.exceptions;
+
+public class TemplateProcessingException extends Exception {
+  public TemplateProcessingException(String message) {
+    super(message);
+  }
+
+  public TemplateProcessingException(String message, Throwable cause) {
+    super(message, cause);
+  }
+}

src/main/java/dev/lions/exceptions/WebSocketException.java

@@ -0,0 +1,7 @@
+package dev.lions.exceptions;
+
+public class WebSocketException extends RuntimeException {
+  public WebSocketException(String message) {
+    super(message);
+  }
+}