Refactoring

src/main/java/dev/lions/unionflow/client/util/LazyDataModelBase.java

@@ -0,0 +1,143 @@
+package dev.lions.unionflow.client.util;
+
+import org.primefaces.model.LazyDataModel;
+import org.primefaces.model.SortMeta;
+import org.primefaces.model.SortOrder;
+import org.primefaces.model.FilterMeta;
+import org.jboss.logging.Logger;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * Classe de base pour les LazyDataModel PrimeFaces.
+ * 
+ * <p>Cette classe abstraite simplifie l'implémentation de LazyDataModel
+ * en fournissant des méthodes utilitaires pour la pagination, le tri et le filtrage.
+ * 
+ * <p>Les classes dérivées doivent implémenter:
+ * <ul>
+ *   <li>{@link #loadData(int, int, Map, Map)} - Charger les données depuis le backend</li>
+ *   <li>{@link #countData(Map)} - Compter le nombre total d'éléments</li>
+ * </ul>
+ *
+ * @param <T> Le type d'entité géré par ce modèle
+ * @author UnionFlow Team
+ * @version 1.0
+ */
+public abstract class LazyDataModelBase<T> extends LazyDataModel<T> {
+
+    private static final Logger LOG = Logger.getLogger(LazyDataModelBase.class);
+
+    /**
+     * Charge les données depuis le backend avec pagination, tri et filtrage.
+     * 
+     * @param first Le premier index (0-based)
+     * @param pageSize La taille de la page
+     * @param sortBy Map des critères de tri (field -> SortMeta)
+     * @param filters Map des filtres à appliquer (field -> FilterMeta)
+     * @return Liste des entités pour la page demandée
+     */
+    protected abstract List<T> loadData(int first, int pageSize, 
+                                       Map<String, SortMeta> sortBy, 
+                                       Map<String, FilterMeta> filters);
+
+    /**
+     * Compte le nombre total d'éléments correspondant aux filtres.
+     * 
+     * @param filters Map des filtres à appliquer
+     * @return Nombre total d'éléments
+     */
+    protected abstract int countData(Map<String, FilterMeta> filters);
+
+    @Override
+    public List<T> load(int first, int pageSize, 
+                       Map<String, SortMeta> sortBy, 
+                       Map<String, FilterMeta> filters) {
+        try {
+            LOG.debugf("Chargement données: first=%d, pageSize=%d, sortBy=%d, filters=%d", 
+                      first, pageSize, sortBy != null ? sortBy.size() : 0, 
+                      filters != null ? filters.size() : 0);
+
+            // Charger les données
+            List<T> data = loadData(first, pageSize, sortBy, filters);
+            
+            // Compter le total
+            int totalCount = countData(filters);
+            setRowCount(totalCount);
+
+            LOG.debugf("Données chargées: %d éléments sur %d total", data.size(), totalCount);
+            
+            return data;
+        } catch (Exception e) {
+            LOG.error("Erreur lors du chargement des données", e);
+            setRowCount(0);
+            return List.of();
+        }
+    }
+
+    @Override
+    public int count(Map<String, FilterMeta> filters) {
+        return countData(filters);
+    }
+
+    /**
+     * Convertit une SortMeta en String pour l'API backend.
+     * 
+     * @param sortMeta Critère de tri
+     * @return String au format "field:ASC" ou "field:DESC"
+     */
+    protected String sortMetaToString(SortMeta sortMeta) {
+        if (sortMeta == null) {
+            return null;
+        }
+        
+        String field = sortMeta.getField();
+        SortOrder order = sortMeta.getOrder();
+        String direction = (order == SortOrder.ASCENDING) ? "ASC" : "DESC";
+        
+        return field + ":" + direction;
+    }
+
+    /**
+     * Convertit une Map de SortMeta en liste de Strings.
+     * 
+     * @param sortBy Map des critères de tri (field -> SortMeta)
+     * @return Liste de Strings au format "field:ASC" ou "field:DESC"
+     */
+    protected List<String> sortMetaMapToStringList(Map<String, SortMeta> sortBy) {
+        if (sortBy == null || sortBy.isEmpty()) {
+            return List.of();
+        }
+        
+        return sortBy.values().stream()
+                .map(this::sortMetaToString)
+                .collect(Collectors.toList());
+    }
+
+    /**
+     * Extrait la valeur d'un filtre.
+     * 
+     * @param filterMeta Métadonnées du filtre
+     * @return Valeur du filtre ou null
+     */
+    protected Object getFilterValue(FilterMeta filterMeta) {
+        if (filterMeta == null) {
+            return null;
+        }
+        return filterMeta.getFilterValue();
+    }
+
+    /**
+     * Extrait la valeur d'un filtre comme String.
+     * 
+     * @param filterMeta Métadonnées du filtre
+     * @return Valeur du filtre comme String ou null
+     */
+    protected String getFilterValueAsString(FilterMeta filterMeta) {
+        Object value = getFilterValue(filterMeta);
+        return value != null ? value.toString() : null;
+    }
+}
+