From 23a46b4be35277e06ec89f48730eeb694e686be8 Mon Sep 17 00:00:00 2001
From: Kenmegne <stephanie.kenmegne@gmail.com>
Date: Thu, 18 Jun 2026 15:40:06 +0000
Subject: [PATCH] add fdx-commons and fdx-consultation
---
fdx-commons/fdxcommons-core-impl/src/main/java/com/megatim/fdxcommons/core/impl/db/validators/CriteriaQueryValidatorImpl.java | 244 ++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 244 insertions(+), 0 deletions(-)
diff --git a/fdx-commons/fdxcommons-core-impl/src/main/java/com/megatim/fdxcommons/core/impl/db/validators/CriteriaQueryValidatorImpl.java b/fdx-commons/fdxcommons-core-impl/src/main/java/com/megatim/fdxcommons/core/impl/db/validators/CriteriaQueryValidatorImpl.java
new file mode 100644
index 0000000..7a398f8
--- /dev/null
+++ b/fdx-commons/fdxcommons-core-impl/src/main/java/com/megatim/fdxcommons/core/impl/db/validators/CriteriaQueryValidatorImpl.java
@@ -0,0 +1,244 @@
+package com.megatim.fdxcommons.core.impl.db.validators;
+
+import static com.megatim.fdxcommons.model.enumeration.Operateur.*;
+import com.megatim.fdxcommons.model.enumeration.TypeDonnee;
+import com.megatim.fdxcommons.model.integration.ColumnDefinition;
+import com.megatim.fdxcommons.model.pojo.BetweenOperatorValues;
+import com.megatim.fdxcommons.model.pojo.CriteriaEntity;
+import com.megatim.fdxcommons.tools.exceptions.CommonApplicationValidationException;
+import java.math.BigDecimal;
+import java.sql.Timestamp;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeParseException;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import javax.enterprise.context.Dependent;
+import com.megatim.fdxcommons.core.ifaces.db.validators.CriteriaQueryValidator;
+
+/**
+ *
+ * @author lenovo
+ */
+@Dependent
+public class CriteriaQueryValidatorImpl implements CriteriaQueryValidator {
+
+ @Override
+ public List<String> validate(CriteriaEntity criterion, Map<String, ColumnDefinition> columnDefinitionsMap) {
+ List<String> errors = new ArrayList<>();
+// int index = 1;
+// String numeroElt = " : Elément numéro " + index;
+ TypeDonnee typeDonnee = null;
+
+ if (criterion != null && isNotEmptyCriteria(criterion)) {
+ if (criterion.getSubCriterias().isEmpty()) {
+ if (!validateCriteriaNomColonne(columnDefinitionsMap, criterion)) {
+ errors.add("Colonne '" + criterion.getNomColonne() + "' des critères de sélection est introuvable");
+
+ } else if ((typeDonnee = TypeDonnee.fromValeur(columnDefinitionsMap.get(criterion.getNomColonne().toLowerCase()).getTypeDonnee())) == null) {
+ errors.add("Le type de la colonne '" + criterion.getNomColonne() + "est introuvable");
+
+ } else if (!validateCriteriaEntityValue(criterion, typeDonnee)) {
+ errors.add("Type de données de la colonne " + criterion.getNomColonne() + " incorrect");
+ }
+ } else {
+ if (criterion.getCriteriaLogicConnector() == null) {
+ errors.add("Le connecteur logique est absent");
+ }
+ for (CriteriaEntity c : criterion.getSubCriterias()) {
+ errors.addAll(validate(c, columnDefinitionsMap));
+ }
+ }
+ }
+ return errors;
+ }
+
+ private boolean validateCriteriaNomColonne(Map<String, ColumnDefinition> columnDefinitionsMap, CriteriaEntity c) {
+ return c.getNomColonne() != null
+ && !c.getNomColonne().isEmpty()
+ && columnDefinitionsMap.containsKey(c.getNomColonne().toLowerCase());
+ }
+
+ private boolean validateCriteriaEntityValue(CriteriaEntity criteriaEntity, TypeDonnee typeDonnee) {
+ switch (criteriaEntity.getOperateur()) {
+ case LIKE:
+ return (criteriaEntity.getCriteriaValue() instanceof String) && columTypeIsString(typeDonnee);
+ case IN:
+ case NOT_IN:
+ return (criteriaEntity.getCriteriaValue() instanceof List<?>) && elementsOfList((List) criteriaEntity.getCriteriaValue(), typeDonnee);
+ case LOWER_OR_EQUALS_THAN:
+ case LOWER_THAN:
+ case GREATER_OR_EQUALS_THAN:
+ case GREATER_THAN:
+ case EQUALS:
+ case NOT_EQUALS:
+ return (criteriaEntity.getCriteriaValue() instanceof Comparable<?>) && criteriaValueHasCorrectType(criteriaEntity.getCriteriaValue(), typeDonnee);
+ case BETWEEN:
+ case NOT_BETWEEN:
+ BetweenOperatorValues betweenOperatorValues = getBetweenOperatorValues(criteriaEntity.getCriteriaValue());
+ criteriaEntity.setCriteriaValue(betweenOperatorValues);
+
+ return betweenOperatorValues != null
+ && criteriaValueHasCorrectType(betweenOperatorValues.getLowerBound(), typeDonnee)
+ && criteriaValueHasCorrectType(betweenOperatorValues.getUpperBound(), typeDonnee)
+ && betweenOperatorValuesAreCorrect(betweenOperatorValues, typeDonnee);
+ case IS_NULL:
+ case IS_NOT_NULL:
+ return criteriaEntity.getCriteriaValue() == null;
+ }
+ return false;
+ }
+
+ @Override
+ public BetweenOperatorValues getBetweenOperatorValues(Object value) {
+ BetweenOperatorValues betweenOperatorValues = null;
+ if (!(value instanceof LinkedHashMap)) {
+ throw new CommonApplicationValidationException("LinkedHashMap est attendu");
+ }
+ LinkedHashMap<String, String> map = (LinkedHashMap) value;
+ String lowerBound = null;
+ String upperBound = null;
+
+ for (String key : map.keySet()) {
+ if (key.equalsIgnoreCase("lowerBound")) {
+ lowerBound = map.get(key);
+ }
+ if (key.equalsIgnoreCase("upperBound")) {
+ upperBound = map.get(key);
+ }
+ }
+ StringBuilder message = new StringBuilder("");
+
+ if (lowerBound == null) {
+ message.append("Borne inférieure absente\n");
+ }
+ if (upperBound == null) {
+ message.append("Borne supérieure absente");
+ }
+ if (message.length() > 0) {
+ throw new CommonApplicationValidationException(message.toString());
+ }
+ betweenOperatorValues = new BetweenOperatorValues(lowerBound, upperBound);
+
+ return betweenOperatorValues;
+ }
+
+ /**
+ * Vérifier que le borne inférieure est bel et bien inférieure à la borne
+ * supérieure
+ *
+ * @param betweenOperatorValues
+ * @param columnType
+ * @return
+ */
+ private boolean betweenOperatorValuesAreCorrect(BetweenOperatorValues betweenOperatorValues, TypeDonnee typeDonnee) {
+ boolean result = false;
+ switch (typeDonnee) {
+
+ case NUMERIQUE:
+ try {
+ Long lowerBound = Long.valueOf(betweenOperatorValues.getLowerBound().toString());
+ Long upperBound = Long.valueOf(betweenOperatorValues.getUpperBound().toString());
+
+ result = lowerBound <= upperBound;
+ if (!result) {
+ throw new CommonApplicationValidationException("La borne inférieure ne peut être supérieure à la borne supérieure");
+ }
+ } catch (NumberFormatException ex) {
+ }
+ break;
+
+ case DECIMAL:
+ try {
+ BigDecimal lowerBound = new BigDecimal(betweenOperatorValues.getLowerBound().toString());
+ BigDecimal upperBound = new BigDecimal(betweenOperatorValues.getUpperBound().toString());
+
+ result = lowerBound.compareTo(upperBound) <= 0;
+ if (!result) {
+ throw new CommonApplicationValidationException("La borne inférieure ne peut être supérieure à la borne supérieure");
+ }
+ } catch (NumberFormatException ex) {
+ }
+ break;
+
+ case DATE:
+ try {
+ Timestamp lowerBound = Timestamp.valueOf(LocalDateTime.parse(betweenOperatorValues.getLowerBound().toString()));
+ Timestamp upperBound = Timestamp.valueOf(LocalDateTime.parse(betweenOperatorValues.getUpperBound().toString()));
+
+ result = lowerBound.before(upperBound);
+ if (!result) {
+ throw new CommonApplicationValidationException("La borne inférieure ne peut être supérieure à la borne supérieure");
+ }
+ } catch (DateTimeParseException ex) {
+ }
+ break;
+
+ default:
+ throw new CommonApplicationValidationException("L'opérarateur 'BETWEEN' n'est pas valable pour ce type de données " + typeDonnee);
+
+ }
+ return result;
+ }
+
+ private boolean elementsOfList(List<?> elements, TypeDonnee typeDonnee) {
+ boolean result = true;
+
+ for (Object elt : elements) {
+ result = criteriaValueHasCorrectType(elt, typeDonnee);
+
+ if (!result) {
+ break;
+ }
+ }
+ return result;
+ }
+
+ private boolean criteriaValueHasCorrectType(Object value, TypeDonnee typeDonnee) {
+ boolean result = false;
+
+ switch (typeDonnee) {
+ case NUMERIQUE:
+ try {
+ Long.valueOf(value.toString());
+ result = true;
+ } catch (NumberFormatException ex) {
+ }
+ break;
+
+ case DECIMAL:
+ try {
+ new BigDecimal(value.toString());
+ result = true;
+ } catch (Exception ex) {
+ }
+ break;
+
+ case DATE:
+ try {
+ Timestamp.valueOf(LocalDateTime.parse(value.toString()));
+ result = true;
+ } catch (IllegalArgumentException ex) {
+ }
+ break;
+
+ case ALPHANUMERIQUE:
+ result = value instanceof String;
+ break;
+
+ default:
+ throw new CommonApplicationValidationException("Type de données inconnu");
+ }
+ return result;
+ }
+
+ private boolean columTypeIsString(TypeDonnee typeDonnee) {
+ return typeDonnee.equals(TypeDonnee.ALPHANUMERIQUE);
+ }
+
+ private boolean isNotEmptyCriteria(CriteriaEntity c) {
+ return c.getNomColonne() != null && !c.getNomColonne().isEmpty() && c.getOperateur() != null
+ || c.getSubCriterias() != null && !c.getSubCriterias().isEmpty();
+ }
+}
--
Gitblit v1.10.0