/*
|
* 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.tools.utils;
|
|
import com.megatim.fdxcommons.model.enumeration.TypeDonnee;
|
import com.megatim.fdxcommons.model.integration.json.JsonStructure;
|
import com.megatim.fdxcommons.tools.database.queries.metadata.JsonSelectQueryResult;
|
import com.megatim.fdxcommons.tools.database.tables.appcolumns.FdxApiColumnDefinitions;
|
import com.megatim.fdxcommons.tools.database.tables.appcolumns.FdxConsultationColumnDefinitions;
|
import com.megatim.fdxcommons.tools.database.tables.appcolumns.TokenColumnDefinition;
|
import java.sql.Timestamp;
|
import java.time.LocalDateTime;
|
import java.time.format.DateTimeFormatter;
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.HashSet;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Optional;
|
import java.util.Set;
|
|
/**
|
*
|
* @author ASUS
|
*/
|
public class JsonDataUtil {
|
|
private final String tokenColumn = new TokenColumnDefinition().name();
|
private final FdxApiColumnDefinitions apiColumnDefinitions = new FdxApiColumnDefinitions();
|
private final FdxConsultationColumnDefinitions fdxConsColumnDefinitions = new FdxConsultationColumnDefinitions();
|
|
public JsonSelectQueryResult merge(Map<Long, Object> data, JsonStructure jsonStructure, boolean withCustomColumns) {
|
List<Map<String, Object>> finalData = mergeAll(data, jsonStructure, withCustomColumns);
|
return new JsonSelectQueryResult(lastIndexRead(data), mergeSimpleColumns(finalData, jsonStructure, withCustomColumns));
|
}
|
|
public Map<String, Set<Long>> tableToMatchingIndexes(Map<Long, Object> data, String rootTableName) {
|
Map<String, Set<Long>> tableToMatchingIndexes = new HashMap<>();
|
|
data.forEach((k, v) -> {
|
Set<Long> indexes = tableToMatchingIndexes.get(rootTableName);
|
if (indexes == null) {
|
indexes = new HashSet<>();
|
}
|
indexes.add(k);
|
tableToMatchingIndexes.put(rootTableName, indexes);
|
tableToMatchingIndexes(v, rootTableName, tableToMatchingIndexes);
|
});
|
return tableToMatchingIndexes;
|
}
|
|
private List<Map<String, Object>> mergeAll(Map<Long, Object> data, JsonStructure jsonStructure, boolean withCustomColumns) {
|
List<Map<String, Object>> finalData = new ArrayList<>();
|
for (Object value : data.values()) {
|
Map map = (Map) value;
|
finalData.add(mergeData(map, jsonStructure, withCustomColumns));
|
}
|
return finalData;
|
}
|
|
private List<Map<String, Object>> mergeSimpleColumns(List<Map<String, Object>> data, JsonStructure jsonStructure, boolean withCustomColumns) {
|
List<Map<String, Object>> finalData = new ArrayList<>();
|
|
for (Map<String, Object> datum : data) {
|
finalData.add(mergeSimpleColumns(datum, jsonStructure, withCustomColumns));
|
}
|
return finalData;
|
}
|
|
private Map<String, Object> mergeSimpleColumns(Map<String, Object> dataMap, JsonStructure jsonStructure, boolean withCustomColumns) {
|
Map<String, Object> finalData = new HashMap<>();
|
List<JsonStructure> fields = jsonStructure.getFields();
|
|
for (Map.Entry<String, Object> entry : dataMap.entrySet()) {
|
Optional<JsonStructure> optField = fields.stream().filter(p -> p.getName().equalsIgnoreCase(entry.getKey())).findFirst();
|
|
if (optField.isPresent()) {
|
JsonStructure field = optField.get();
|
|
if (field.isCollection()) {
|
List<Map<String, Object>> liste = (List) entry.getValue();
|
List<Object> finalValues = new ArrayList<>();
|
|
if (field.getTypeDonnee().equals(TypeDonnee.OBJET)) {
|
for (Map<String, Object> map : liste) {
|
finalValues.add(mergeSimpleColumns(map, field, withCustomColumns));
|
}
|
} else {
|
for (Map<String, Object> map : liste) {
|
for (Map.Entry<String, Object> e : map.entrySet()) {
|
finalValues.add(e.getValue());
|
}
|
}
|
}
|
finalData.put(entry.getKey(), finalValues);
|
} else if (field.getTypeDonnee().equals(TypeDonnee.OBJET)) {
|
Map<String, Object> map = null;
|
if (entry.getValue() != null) {
|
if (entry.getValue() instanceof List) {
|
map = (Map<String, Object>) ((List) entry.getValue()).get(0);
|
} else {
|
map = (Map<String, Object>) entry.getValue();
|
}
|
finalData.put(entry.getKey(), mergeSimpleColumns(map, field, withCustomColumns));
|
}
|
} else {
|
switch (field.getTypeDonnee()) {
|
case DATE:
|
Timestamp timestamp = Timestamp.valueOf(entry.getValue().toString());
|
LocalDateTime date = timestamp.toLocalDateTime();
|
DateTimeFormatter formatter = DateTimeFormatter.ofPattern(field.getFormatDate());
|
finalData.put(entry.getKey(), formatter.format(date));
|
break;
|
|
default:
|
finalData.put(entry.getKey(), entry.getValue());
|
break;
|
}
|
}
|
} else {
|
if (!entry.getKey().equalsIgnoreCase(tokenColumn) && withCustomColumns && (apiColumnDefinitions.isAppColumnDefinition(entry.getKey()) || fdxConsColumnDefinitions.isAppColumnDefinition(entry.getKey()))) {
|
finalData.put(entry.getKey(), entry.getValue());
|
}
|
}
|
}
|
return finalData;
|
}
|
|
private void tableToMatchingIndexes(Object data, String tableName, Map<String, Set<Long>> tableToMatchingIndexes) {
|
if (data instanceof Map) {
|
Map<Object, Object> dataMap = (Map) data;
|
|
for (Map.Entry<Object, Object> entry : dataMap.entrySet()) {
|
if (entry.getKey() instanceof Long) {
|
Long index = (Long) entry.getKey();
|
Set<Long> indexes = tableToMatchingIndexes.get(tableName);
|
|
if (indexes == null) {
|
indexes = new HashSet<>();
|
}
|
if (!indexes.contains(index)) {
|
indexes.add(index);
|
}
|
tableToMatchingIndexes.put(tableName, indexes);
|
tableToMatchingIndexes(entry.getValue(), tableName, tableToMatchingIndexes);
|
|
} else if (entry.getValue() instanceof Map) {
|
String newTableName = tableName + "_" + tableName(entry.getKey().toString());
|
tableToMatchingIndexes(entry.getValue(), newTableName, tableToMatchingIndexes);
|
|
}
|
}
|
}
|
}
|
|
private String tableName(String key) {
|
String[] array = key.split("\\.");
|
return (array[array.length - 1]).toLowerCase();
|
}
|
|
private Map<String, Object> mergeData(Map<Object, Object> dataMap, JsonStructure jsonStructure, boolean withCustomColumns) {
|
Map<String, Object> finalMap = new HashMap<>();
|
|
for (Map.Entry<Object, Object> entry : dataMap.entrySet()) {
|
|
if (entry.getKey() instanceof Long) {
|
finalMap = mergeData((Map) entry.getValue(), jsonStructure, withCustomColumns);
|
} else {
|
String key = cleanKey(entry.getKey().toString());
|
|
if (entry.getValue() instanceof Map) {
|
Map<Long, Object> map = (Map) entry.getValue();
|
finalMap.put(key, mergeAll(map, jsonStructure, withCustomColumns));
|
} else {
|
if (!key.equalsIgnoreCase(tokenColumn)) {
|
if (withCustomColumns) {
|
finalMap.put(key, entry.getValue());
|
} else {
|
if (!apiColumnDefinitions.isAppColumnDefinition(key) && !fdxConsColumnDefinitions.isAppColumnDefinition(key)) {
|
finalMap.put(key, entry.getValue());
|
}
|
}
|
}
|
}
|
}
|
}
|
return finalMap;
|
}
|
|
private String cleanKey(String key) {
|
String[] array = key.split("\\.");
|
return array[array.length - 1];
|
}
|
|
private int lastIndexRead(Map<Long, Object> data) {
|
Long max = 0L;
|
for (Long l : data.keySet()) {
|
if (l > max) {
|
max = l;
|
}
|
}
|
return Integer.parseInt(max + "");
|
}
|
}
|
