/*
|
* Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
|
* Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
|
*/
|
package com.megatim.fdxcommons.core.impl.interceptor;
|
|
import com.google.gson.Gson;
|
import com.google.gson.internal.LinkedTreeMap;
|
import com.megatim.fdxcommons.core.ifaces.interceptor.LoggingInterceptorBinding;
|
import com.megatim.fdxcommons.core.ifaces.interceptor.InterceptorHandler;
|
import java.lang.reflect.Field;
|
import java.lang.reflect.InvocationTargetException;
|
import java.lang.reflect.Method;
|
import java.lang.reflect.Parameter;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Collection;
|
import java.util.List;
|
import java.util.Optional;
|
import java.util.regex.Matcher;
|
import java.util.regex.Pattern;
|
import java.util.stream.Collectors;
|
import javax.enterprise.context.Dependent;
|
import javax.ws.rs.core.MultivaluedMap;
|
|
/**
|
* {} : Les paramètres de requête sont entre accolades () : La valeur de retour
|
* entre les parenthèses [] : L'entité de requête est entre les crochets
|
*
|
* @author ASUS
|
*/
|
@Dependent
|
public class InterceptorHandlerImpl implements InterceptorHandler {
|
|
@Override
|
public String finalMessage(LoggingInterceptorBinding interceptorBinding, Parameter[] parameters, MultivaluedMap<String, String> queryParams, Object requestEntity, Object responseEntity) throws Exception {
|
//Recherche des références au paramètres de la requête
|
String message = infoFromPathParameters(interceptorBinding.message(), queryParams);
|
|
//Recherche des références aux éléments du tableau de paramètres
|
message = infoFromParameters(message, parameters, requestEntity);
|
|
//Recherche des références à la valeur de retour
|
return infoFromReturnValue(message, interceptorBinding.classe(), responseEntity);
|
}
|
|
private String infoFromPathParameters(String message, MultivaluedMap<String, String> queryParams) throws Exception {
|
if (!queryParams.isEmpty()) {
|
Pattern pattern = Pattern.compile("\\{\\S{1,}\\}");
|
Matcher matcher = pattern.matcher(message);
|
|
while (matcher.find()) {
|
String group = matcher.group();
|
String fieldName = group.substring(1, group.length() - 1);
|
|
if (queryParams.containsKey(fieldName)) {
|
message = message.replace(group, queryParams.getFirst(fieldName));
|
}
|
}
|
}
|
return message;
|
}
|
|
private String infoFromReturnValue(String message, Class<?> classe, Object dataToProcess) throws Exception {
|
Pattern pattern = Pattern.compile("\\(\\S{1,}\\)");
|
Matcher matcher = pattern.matcher(message);
|
|
while (matcher.find()) {
|
String group = matcher.group();
|
String fieldName = group.substring(1, group.length() - 1);
|
String[] fieldPath = fieldName.split("\\.");
|
String fieldValue = value(fieldPath, classe, dataToProcess);
|
message = message.replace(group, fieldValue);
|
}
|
|
return message;
|
}
|
|
private String infoFromParameters(String message, Parameter[] parameters, Object requestEntity) throws Exception {
|
if (parameters.length > 0) {
|
Pattern pattern = Pattern.compile("\\[\\d{1,}\\S*\\]");
|
Matcher matcher = pattern.matcher(message);
|
|
while (matcher.find()) {
|
String group = matcher.group();
|
String fieldName = group.substring(1, group.length() - 1);
|
String[] fieldPath = fieldName.split("\\.");
|
int index = Integer.parseInt(fieldPath[0]);
|
|
if (requestEntity != null && index < parameters.length) {
|
Object obj = new Gson().fromJson(requestEntity.toString(), parameters[index].getType());
|
String value = "";
|
|
if (fieldPath.length == 1) {
|
value = value(fieldPath, parameters[index].getType(), obj);
|
} else {
|
value = value(Arrays.copyOfRange(fieldPath, 1, fieldPath.length),
|
parameters[index].getType(), obj);
|
}
|
|
message = message.replace(group, value);
|
}
|
}
|
}
|
return message;
|
}
|
|
private String value(String[] fieldPath, Class<?> classe, Object dataToProcess) throws Exception {
|
|
if (dataToProcess instanceof Collection) {
|
return valueFromCollection(fieldPath, classe, (Collection) dataToProcess);
|
|
} else {
|
return valueFromField(fieldPath, classe, dataToProcess);
|
}
|
}
|
|
private String valueFromCollection(String[] fieldPath, Class<?> classe, Collection collection) throws Exception {
|
List<String> values = new ArrayList<>();
|
for (Object obj : collection) {
|
values.add(valueFromField(fieldPath, classe, obj));
|
}
|
return "[" + values.stream().collect(Collectors.joining(",")) + "]";
|
}
|
|
private String valueFromLinkedTreeMap(LinkedTreeMap dataToProcess, String field) {
|
return dataToProcess.get(field).toString();
|
}
|
|
private String valueFromField(String[] fieldPath, Class<?> classe, Object dataToProcess) throws NoSuchMethodException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
|
if (dataToProcess instanceof LinkedTreeMap) {
|
return valueFromLinkedTreeMap((LinkedTreeMap) dataToProcess, fieldPath[0]);
|
} else {
|
String methodName = "get" + (fieldPath[0].charAt(0) + "").toUpperCase() + fieldPath[0].substring(1);
|
Method method = classe.getMethod(methodName);
|
Object obj = method.invoke(classe.cast(dataToProcess));
|
|
if (fieldPath.length == 1) {
|
return obj.toString();
|
|
} else {
|
Class<?> classToParse = fieldType(fieldPath[0], classe);
|
return valueFromField(Arrays.copyOfRange(fieldPath, 1, fieldPath.length), classToParse, obj);
|
}
|
}
|
}
|
|
private Class<?> fieldType(String fieldName, Class<?> classe) {
|
Optional<Field> optionalField = Arrays.asList(classe.getDeclaredFields()).stream().filter(f -> f.getName().equals(fieldName)).findFirst();
|
|
if (optionalField.isPresent()) {
|
return optionalField.get().getType();
|
} else {
|
return null;
|
}
|
}
|
|
}
|
