package com.megatim.fdxcommons.tools.database.queries.metadata;
|
|
import com.megatim.fdxcommons.model.enumeration.Operateur;
|
import com.megatim.fdxcommons.model.pojo.BetweenOperatorValues;
|
import com.megatim.fdxcommons.tools.database.exceptions.BadQueryCriteriaException;
|
import com.megatim.fdxcommons.tools.database.exceptions.LocalDateTimeValueParseError;
|
import com.megatim.fdxcommons.tools.database.tables.appcolumns.DateCreationColumnDefinition;
|
import java.math.BigDecimal;
|
import java.time.LocalDateTime;
|
import java.util.ArrayList;
|
import java.util.Collection;
|
import java.util.LinkedHashMap;
|
|
/**
|
*
|
* @author Gabuntu
|
*/
|
public class QueryCriteriaCorrectValue {
|
|
private final int dataType;
|
private final Object criteriaValue;
|
private final Operateur operateur;
|
private final String dateFormat;
|
private final boolean isDateActionColumn;
|
|
public QueryCriteriaCorrectValue(int dataType, Object criteriaValue, Operateur operateur, String dateFormat, boolean isDateActionColumn) {
|
this.dataType = dataType;
|
this.criteriaValue = criteriaValue;
|
this.operateur = operateur;
|
this.dateFormat = dateFormat;
|
this.isDateActionColumn = isDateActionColumn;
|
}
|
|
public Object value() throws LocalDateTimeValueParseError, BadQueryCriteriaException {
|
if (operateurWithBetween()) {
|
Object lowerBound = null;
|
Object upperBound = null;
|
|
if (criteriaValue instanceof BetweenOperatorValues) {
|
BetweenOperatorValues values = (BetweenOperatorValues) criteriaValue;
|
if (values != null) {
|
lowerBound = values.getLowerBound();
|
upperBound = values.getUpperBound();
|
}
|
} else {
|
LinkedHashMap map = (LinkedHashMap) criteriaValue;
|
|
if (map != null) {
|
lowerBound = map.get("lowerBound");
|
upperBound = map.get("upperBound");
|
}
|
}
|
if (lowerBound != null && upperBound != null) {
|
if (dataTypeIsInt()) {
|
return new BetweenOperatorValues(intValue(lowerBound), intValue(upperBound));
|
} else if (dataTypeIsDecimal()) {
|
return new BetweenOperatorValues(decimalValue(lowerBound), decimalValue(upperBound));
|
} else if (dataTypeIsString()) {
|
return new BetweenOperatorValues(stringValue(lowerBound), stringValue(upperBound));
|
} else if (dataTypeIsTimeStamp()) {
|
return new BetweenOperatorValues(dateValue(lowerBound), dateValue(upperBound));
|
}
|
}
|
} else if (operateurWithIn()) {
|
if (criteriaValue instanceof Collection<?>) {
|
Collection<?> collection = (Collection<?>) criteriaValue;
|
return collectionValues(collection);
|
}
|
} else if (operateurWithComparison()) {
|
if (dataTypeIsInt()) {
|
return intValue(criteriaValue);
|
} else if (dataTypeIsDecimal()) {
|
return decimalValue(criteriaValue);
|
} else if (dataTypeIsString()) {
|
return stringValue(criteriaValue);
|
} else if (dataTypeIsTimeStamp()) {
|
return dateValue(criteriaValue);
|
} else if(dataTypeIsBoolean()) {
|
return booleanValue(criteriaValue);
|
}
|
} else if (operateurWithLike()) {
|
if (dataTypeIsString()) {
|
return stringValue(criteriaValue);
|
}
|
|
} else if (operateurWithoutValue()) {
|
return null;
|
}
|
|
throw new BadQueryCriteriaException(
|
"Opérateur inconnu");
|
}
|
|
private boolean operateurWithoutValue() {
|
return this.operateur.equals(Operateur.IS_NOT_NULL)
|
|| this.operateur.equals(Operateur.IS_NULL);
|
}
|
|
private boolean operateurWithBetween() {
|
return this.operateur.equals(Operateur.BETWEEN)
|
|| this.operateur.equals(Operateur.NOT_BETWEEN);
|
}
|
|
private boolean operateurWithIn() {
|
return this.operateur.equals(Operateur.IN)
|
|| this.operateur.equals(Operateur.NOT_IN);
|
}
|
|
private boolean operateurWithComparison() {
|
return this.operateur.equals(Operateur.EQUALS)
|
|| this.operateur.equals(Operateur.NOT_EQUALS)
|
|| this.operateur.equals(Operateur.GREATER_OR_EQUALS_THAN)
|
|| this.operateur.equals(Operateur.GREATER_THAN)
|
|| this.operateur.equals(Operateur.LOWER_OR_EQUALS_THAN)
|
|| this.operateur.equals(Operateur.LOWER_THAN);
|
}
|
|
private boolean operateurWithLike() {
|
return this.operateur.equals(Operateur.LIKE);
|
}
|
|
private boolean dataTypeIsString() {
|
return this.dataType == 12;
|
}
|
|
private boolean dataTypeIsTimeStamp() {
|
return this.dataType == 93;
|
}
|
|
private boolean dataTypeIsInt() {
|
return this.dataType == 4 || this.dataType == 5 || this.dataType == -5;
|
}
|
|
private boolean dataTypeIsBoolean() {
|
return this.dataType == -7;
|
}
|
|
private boolean dataTypeIsDecimal() {
|
return this.dataType == 3;
|
}
|
|
private Collection<?> collectionValues(Collection<?> collection) throws LocalDateTimeValueParseError, BadQueryCriteriaException {
|
if (dataTypeIsInt()) {
|
return collectionOfInt(collection);
|
} else if (dataTypeIsDecimal()) {
|
return collectionOfBigDecimal(collection);
|
} else if (dataTypeIsTimeStamp()) {
|
return collectionOfLocalDateTime(collection);
|
} else if (dataTypeIsString()) {
|
return collectionOfString(collection);
|
}
|
throw new BadQueryCriteriaException("La valeur de ce critère doit une liste");
|
}
|
|
private Collection<String> collectionOfString(Collection<?> collection) throws BadQueryCriteriaException {
|
Collection<String> cleanValues = new ArrayList<>();
|
for (Object elt : collection) {
|
cleanValues.add(stringValue(elt));
|
}
|
return cleanValues;
|
}
|
|
private String stringValue(Object element) throws BadQueryCriteriaException {
|
if (!(element instanceof String)) {
|
throw new BadQueryCriteriaException("Les critères associés à cette requête sont incorrects.");
|
}
|
return (String) element;
|
}
|
|
private boolean booleanValue(Object element) throws BadQueryCriteriaException {
|
if (!(element instanceof Boolean)) {
|
throw new BadQueryCriteriaException("Les critères associés à cette requête sont incorrects.");
|
}
|
return (Boolean) element;
|
}
|
|
private Collection<LocalDateTime> collectionOfLocalDateTime(Collection<?> collection) throws LocalDateTimeValueParseError {
|
Collection cleanValues = new ArrayList<>();
|
for (Object element : collection) {
|
cleanValues.add(dateValue(element));
|
}
|
return cleanValues;
|
}
|
|
private LocalDateTime dateValue(Object value) throws LocalDateTimeValueParseError {
|
if (isDateActionColumn) {
|
if (!(value instanceof LocalDateTime)) {
|
throw new LocalDateTimeValueParseError("Impossible de parser la valeur " + value + " pour la colonne " + new DateCreationColumnDefinition().name());
|
}
|
return (LocalDateTime) value;
|
} else {
|
return new CriteriaLocalDateTimeValue(dateFormat, value).value();
|
}
|
}
|
|
private Long intValue(Object value) throws BadQueryCriteriaException {
|
try {
|
return Long.valueOf(value.toString());
|
} catch (Exception ex) {
|
throw new BadQueryCriteriaException("La valeur de ce critère doit être un nombre entier ");
|
}
|
}
|
|
private BigDecimal decimalValue(Object value) throws BadQueryCriteriaException {
|
try {
|
return new BigDecimal(value.toString());
|
} catch (Exception ex) {
|
throw new BadQueryCriteriaException("La valeur de ce critère doit être un nombre décimal ");
|
}
|
}
|
|
private Collection<BigDecimal> collectionOfBigDecimal(Collection<?> collection) throws BadQueryCriteriaException {
|
Collection cleanValues = new ArrayList<>();
|
for (Object element : collection) {
|
cleanValues.add(decimalValue(element));
|
}
|
return cleanValues;
|
}
|
|
private Collection<Long> collectionOfInt(Collection<?> collection) throws BadQueryCriteriaException {
|
Collection cleanValues = new ArrayList<>();
|
for (Object element : collection) {
|
cleanValues.add(intValue(element));
|
}
|
return cleanValues;
|
}
|
}
|
