/*
|
* 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.fdxconvert.util;
|
|
import com.megatim.dynamicjsonparser.enums.TypeDonnee;
|
import com.megatim.typefichier.validator.utilities.Constantes;
|
import com.megatim.fdxconvert.exceptions.ValidatorException;
|
import com.megatim.fdxconvert.pojo.ColumnDefinition;
|
import java.io.File;
|
import java.text.Normalizer;
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import javax.xml.parsers.DocumentBuilder;
|
import javax.xml.parsers.DocumentBuilderFactory;
|
import org.w3c.dom.Document;
|
import org.w3c.dom.NamedNodeMap;
|
import org.w3c.dom.Node;
|
import org.w3c.dom.NodeList;
|
|
/**
|
*
|
* @author ASUS
|
*/
|
public class ValidateurParser {
|
|
/**
|
* Méthode permettant d'extraire les éléments du validateur XML
|
*
|
* @param file : Fichier du validateur
|
* @param codeTypeFichier
|
* @return
|
* @throws Exception
|
*/
|
public static List<ColumnDefinition> retrieveFieldsFromValidator(File file, String codeTypeFichier) throws Exception {
|
|
Document doc = intialize(file);
|
|
NodeList entityList = doc.getElementsByTagName("entity"); //Liste des noeud <entity>
|
|
//Map qui stocke le champ à une position, ainsi que les caractéristiques de champ(typeDonnee, taille, index de debut d'extraction)
|
Map<Integer, Map<String, String>> mapParams = new HashMap<>();
|
|
int position = 1;
|
|
//Le validateur XML doit avoir au moins deux balises <entity> pour être conforme
|
if (entityList.getLength() >= 2) {
|
|
//Liste des noeud de type <validation> du deuxième Noeud <entity>
|
NodeList entityFileLineChildren = entityList.item(1).getChildNodes();
|
|
//Map qui contient champ set son nombe d'occurrence dans le fichier en cours de traitement
|
Map<String, Integer> mapFieldName = new HashMap<>();
|
|
//parcours de la balise <entity> pour récupérer ses enfants
|
for (int i = 0; i < entityFileLineChildren.getLength(); i++) {
|
|
if (entityFileLineChildren.item(i) != null && entityFileLineChildren.item(i).getAttributes() != null) {
|
|
//balise <validation>
|
Node validation = entityFileLineChildren.item(i);
|
|
if (validation != null) {
|
Map<String, String> mapAttributes = new HashMap<>();
|
|
//Liste des assertions de la balise <validation>
|
NodeList assertions = validation.getChildNodes();
|
|
for (int r = 0; r < assertions.getLength(); r++) {
|
|
Node assertion = assertions.item(r);
|
|
if (assertion != null && assertion.getAttributes() != null) {
|
NamedNodeMap assertionAttributes = assertion.getAttributes();
|
|
for (int q = 0; q < assertionAttributes.getLength(); q++) {
|
String assertionAttributeName = assertionAttributes.item(q).getNodeName();
|
String assertionAttributeValue = assertionAttributes.item(q).getNodeValue();
|
|
if (assertionAttributeName.equalsIgnoreCase(Constantes.ERROR_CODE)) {
|
String fieldName = constructFieldName(assertionAttributeValue, codeTypeFichier);
|
|
//Stocker le nbre d'occurrences trouvés dans la map
|
if (mapFieldName.containsKey(fieldName)) {
|
Integer nbOccurrences = mapFieldName.get(fieldName);
|
mapFieldName.replace(fieldName, nbOccurrences + 1);
|
|
} else {
|
mapFieldName.put(fieldName, 1);
|
}
|
Integer nbOccurrences = mapFieldName.get(fieldName);
|
String finalFieldName = nbOccurrences == 1 ? fieldName : fieldName + (nbOccurrences - 1);
|
|
mapAttributes.put(Constantes.FIELD_NAME, finalFieldName);
|
break;
|
}
|
}
|
//Liste des balises <param-value> de la balise <assertion>
|
NodeList params = assertion.getChildNodes();
|
|
for (int j = 0; j < params.getLength(); j++) {
|
|
if (params.item(j) != null && params.item(j).getAttributes() != null) {
|
|
//Les attributs de la balise <param-value>
|
NamedNodeMap attributesParamValue = params.item(j).getAttributes();
|
Integer positionAttribute = null;
|
|
for (int k = 0; k < attributesParamValue.getLength(); k++) {
|
|
String nodeValue = attributesParamValue.item(k).getNodeValue();
|
String nextNodeValue = attributesParamValue.item(++k).getNodeValue();
|
mapAttributes.put(nodeValue, nextNodeValue);
|
|
if (nodeValue.equals(Constantes.LIBELLE_TAILLE) && !nextNodeValue.equalsIgnoreCase(Constantes.EQUAL_PARAM)) {
|
mapAttributes.put(nodeValue, nextNodeValue);
|
|
} else if (nodeValue.equals(Constantes.LIBELLE_TYPE_DONNEE)) {
|
mapAttributes.put(nodeValue, nextNodeValue);
|
} else if (nodeValue.equals(Constantes.LIBELLE_POSITION)) {
|
positionAttribute = Integer.valueOf(nextNodeValue);
|
}
|
}
|
mapParams.put(positionAttribute != null ? positionAttribute : position, mapAttributes);
|
}
|
}
|
}
|
}
|
}
|
position++;
|
}
|
|
}
|
|
}
|
|
// mapParams.remove(mapParams.size());
|
List<ColumnDefinition> columnsDefinition = getColumnsDefinition(mapParams);
|
|
return columnsDefinition;
|
|
}
|
|
/**
|
* Méthode utilitaire pour extraire les données dans un fichier xml
|
*
|
* @param array
|
* @return
|
* @throws Exception
|
*/
|
private static Document intialize(File file) throws Exception {
|
|
/**
|
* Défini un factory qui aide à obtenir un parseur qui produit un arbre
|
* d'objets DOM à partir d'un document XML.
|
*/
|
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
|
|
/**
|
* création d'un objet du builder pour parser le fichier XML.
|
*/
|
DocumentBuilder db = dbf.newDocumentBuilder();
|
|
Document doc = db.parse(file);
|
|
doc.getDocumentElement().normalize();
|
|
return doc;
|
}
|
|
/**
|
* Méthode qui met les informations du validateur dans un ColumnDefinition
|
* pour utilisation future
|
*
|
* @param mapStructure
|
* @return
|
*/
|
private static List<ColumnDefinition> getColumnsDefinition(Map<Integer, Map<String, String>> mapStructure) throws ValidatorException {
|
List<ColumnDefinition> columns = new ArrayList<>();
|
|
for (Integer key : mapStructure.keySet()) {
|
ColumnDefinition column = new ColumnDefinition();
|
Map<String, String> value = mapStructure.get(key);
|
column.setPosition(key);
|
|
if (value.get(Constantes.LIBELLE_TAILLE) != null) {
|
column.setTaille(Integer.parseInt(value.get(Constantes.LIBELLE_TAILLE)));
|
}
|
column.setName(value.get(Constantes.FIELD_NAME));
|
column.setTypeDonnee(TypeDonnee.fromValeur(value.get(Constantes.LIBELLE_TYPE_DONNEE)).getValue());
|
|
if (column.getTypeDonnee().equalsIgnoreCase(TypeDonnee.DECIMAL.toString())) {
|
|
if (value.get(Constantes.LIBELLE_TAILLE_PARTIE_DECIMALE) != null) {
|
column.setTaillePartieDecimale(Integer.parseInt(value.get(Constantes.LIBELLE_TAILLE_PARTIE_DECIMALE)));
|
}
|
|
} else if (column.getTypeDonnee().equalsIgnoreCase(TypeDonnee.DATE.toString())) {
|
String separateurDate = value.get(Constantes.LIBELLE_SEPARATEUR_DATE);
|
String formatDate = value.get(Constantes.LIBELLE_FORMAT_DATE);
|
|
if (formatDate != null && !formatDate.isEmpty()) {
|
|
if (separateurDate != null && !separateurDate.isEmpty()) {
|
|
if (separateurDate.equals("-") || separateurDate.equals("/")) {
|
formatDate = addSeparateurToDateFormat(formatDate, separateurDate, column.getName());
|
|
} else {
|
throw new ValidatorException("Le séparateur de date du champ " + column.getName() + " ne peut être " + separateurDate);
|
}
|
}
|
column.setFormatDate(formatDate);
|
column.setSeparateurDate(separateurDate);
|
} else {
|
throw new ValidatorException("Le format date du champ " + column.getName() + " est absent");
|
}
|
}
|
|
columns.add(column);
|
}
|
|
return columns;
|
}
|
|
/**
|
* Méthode qui ajoute le séparateur renseigné dans le validateur au format
|
*
|
* @param formatDate
|
* @param separateurDate
|
* @param columnName
|
* @return
|
*/
|
public static String addSeparateurToDateFormat(String formatDate, String separateurDate, String columnName) {
|
StringBuilder dateValue = new StringBuilder();
|
|
switch (formatDate) {
|
case "ddMMyyyy":
|
dateValue.append("dd").append(separateurDate).append("MM").append(separateurDate).append("yyyy");
|
break;
|
case "ddyyyyMM":
|
dateValue.append("dd").append(separateurDate).append("yyyy").append(separateurDate).append("MM");
|
break;
|
case "MMddyyyy":
|
dateValue.append("MM").append(separateurDate).append("dd").append(separateurDate).append("yyyy");
|
break;
|
case "MMyyyydd":
|
dateValue.append("MM").append(separateurDate).append("yyyy").append(separateurDate).append("dd");
|
break;
|
case "yyyyddMM":
|
dateValue.append("yyyy").append(separateurDate).append("dd").append(separateurDate).append("MM");
|
break;
|
case "yyyyMMdd":
|
dateValue.append("yyyy").append(separateurDate).append("MM").append(separateurDate).append("dd");
|
break;
|
case "yyyy":
|
dateValue.append("yyyy");
|
break;
|
case "yyyyMM":
|
dateValue.append("yyyy").append(separateurDate).append("MM");
|
case "MMyyyy":
|
dateValue.append("MM").append(separateurDate).append("yyyy");
|
break;
|
default:
|
throw new ValidatorException("Le format date " + formatDate + " du champ" + columnName + " n'est pas acceptable ");
|
}
|
|
return dateValue.toString();
|
}
|
|
private static String constructFieldName(String fieldName, String codeTypeFichier) {
|
|
fieldName = fieldName.startsWith(codeTypeFichier)
|
? fieldName.substring(6)
|
: fieldName;
|
fieldName = fieldName.equalsIgnoreCase("int") ? "_" + fieldName : fieldName;
|
return removeAccents(fieldName.replaceAll(" ", "_"));
|
}
|
|
private static String removeAccents(String input) {
|
// Normalize to decomposed form (NFD): é → e + ´, è → e + `
|
String normalized = Normalizer.normalize(input, Normalizer.Form.NFD);
|
// Remove all diacritical marks (accents)
|
return normalized.replaceAll("\\p{M}", "");
|
}
|
}
|
