/*
|
* 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.generatetxt.utilities;
|
|
import java.io.BufferedWriter;
|
import java.io.ByteArrayInputStream;
|
import java.io.File;
|
import java.io.IOException;
|
import java.nio.charset.Charset;
|
import java.nio.file.Files;
|
import java.util.HashMap;
|
import java.util.Map;
|
import javax.xml.parsers.DocumentBuilder;
|
import javax.xml.parsers.DocumentBuilderFactory;
|
import org.dhatim.fastexcel.reader.Cell;
|
import org.dhatim.fastexcel.reader.CellType;
|
import static org.dhatim.fastexcel.reader.CellType.BOOLEAN;
|
import static org.dhatim.fastexcel.reader.CellType.EMPTY;
|
import static org.dhatim.fastexcel.reader.CellType.NUMBER;
|
import static org.dhatim.fastexcel.reader.CellType.STRING;
|
import org.w3c.dom.Document;
|
import org.w3c.dom.NamedNodeMap;
|
import org.w3c.dom.Node;
|
import org.w3c.dom.NodeList;
|
|
/**
|
*
|
* @author ASUS
|
*/
|
public class ParserUtils {
|
//Nombre be balise <entity> dans le validateur XML
|
|
private static final int ENTITY_LIST_SIZE = 2;
|
|
private ParserUtils() {
|
|
}
|
|
public static Map<Integer, Map> getValidateurElements(String validatorPath) throws Exception {
|
byte[] bytes = Files.readAllBytes(new File(validatorPath).toPath());
|
Document doc = intialize(bytes);
|
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> mapParams = new HashMap<>();
|
|
int position = 0;
|
|
if (entityList.getLength() == ENTITY_LIST_SIZE) {
|
|
//Liste des noeud de type <validation> du deuximème Noeud <entity>
|
NodeList entityFileLineChildren = entityList.item(1).getChildNodes();
|
|
//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) {
|
|
position++;
|
|
//Liste des assertions de la balise <validation>
|
NodeList assertions = validation.getChildNodes();
|
|
for (int r = 0; r < assertions.getLength(); r++) {
|
|
Node assertion = assertions.item(r);
|
|
Map<String, String> mapAttributes = new HashMap<>();
|
|
if (assertion != null && assertion.getAttributes() != null) {
|
|
//Les attributs de la balise <assertion>
|
NamedNodeMap attributesAssertion = assertion.getAttributes();
|
|
for (int k = 0; k < attributesAssertion.getLength(); k++) {
|
|
String nodeValue = attributesAssertion.item(k).getNodeValue();
|
String nodeName = attributesAssertion.item(k).getNodeName();
|
|
if (nodeName.equals("error-code")) {
|
mapAttributes.put(nodeName, nodeValue);
|
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();
|
|
for (int k = 0; k < attributesParamValue.getLength(); k++) {
|
|
String nodeValue = attributesParamValue.item(k).getNodeValue();
|
String nextNodeValue = attributesParamValue.item(++k).getNodeValue();
|
mapAttributes.put(nodeValue, nextNodeValue);
|
|
}
|
|
mapParams.put(position, mapAttributes);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return mapParams;
|
|
}
|
|
/**
|
* Méthode permettant de convertir la données contenu dans une cellule excel
|
* en chaîne de caractères
|
*
|
* @param cell
|
* @return
|
*/
|
public static String getCellValueAsString(Cell cell) {
|
|
String val = "";
|
|
if (cell != null) {
|
|
CellType cellType = cell.getType();
|
|
switch (cellType) {
|
|
case EMPTY:
|
break;
|
|
case STRING:
|
|
if (!cell.getText().equals("null")) {
|
|
val = cell.getText().replaceAll("\\p{Cntrl}", "");
|
|
}
|
|
break;
|
|
case NUMBER:
|
|
val = cell.asNumber().toPlainString();
|
|
if (val.equals("null")) {
|
|
}
|
|
break;
|
|
case BOOLEAN:
|
|
val = String.valueOf(cell.asBoolean());
|
|
if (val.equals("null")) {
|
|
}
|
|
break;
|
|
default:
|
break;
|
|
}
|
|
}
|
|
return val;
|
|
}
|
|
/**
|
* Méthode qui retire le caractère retour charriot dans une chaîne
|
*
|
* @param str
|
* @return
|
*/
|
public static String removeReturnCharriot(String str) {
|
|
String[] tab = str.split("\n");
|
|
String result = "";
|
|
for (String s : tab) {
|
|
result += s;
|
}
|
|
return result;
|
|
}
|
|
/**
|
* Méthode utilitaire pour extraire les données dans un fichier xml
|
*
|
* @param array
|
* @return
|
* @throws Exception
|
*/
|
private static Document intialize(byte[] array) throws Exception {
|
|
/**
|
* Défini un factory qui aide à obtenir un parseur qui produit un arbre
|
* d'objets DOM à partir d'un docuent 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(new ByteArrayInputStream(array));
|
|
doc.getDocumentElement().normalize();
|
|
return doc;
|
}
|
|
/**
|
* Méthode pour obtenir l'objet de typr char correspondant à chaque
|
* délimiteur
|
*
|
* @param delimiteur
|
* @return
|
*/
|
public static char characterOfDelimiteur(String delimiteur) {
|
char character;
|
|
switch (delimiteur) {
|
case "\\t":
|
character = '\t';
|
break;
|
case "\\n":
|
character = '\n';
|
break;
|
case "":
|
character = '\0';
|
break;
|
default:
|
character = delimiteur.charAt(0);
|
}
|
|
return character;
|
}
|
|
/**
|
* Méthode permettant d'encoder une chaîne de caractères
|
*
|
* @param datas : tableau de String à encoder
|
* @param charset : encodage à utiliser
|
* @return
|
*/
|
public static String[] encodeStrings(String[] datas, Charset charset) {
|
String[] encodedStrings = new String[datas.length];
|
|
for (int i = 0; i < encodedStrings.length; i++) {
|
byte[] bytesOfString = datas[i].getBytes();
|
encodedStrings[i] = new String(bytesOfString, charset);
|
|
}
|
return encodedStrings;
|
}
|
|
/**
|
* Méthode qui extrait une sous-chaîne dans une chaîne de caractères en
|
* utilisant un délimiteur
|
*
|
* @param line : chaîne mère à séparer
|
* @param character : délimiteur de chaîne
|
* @return : retourne un tableau contenant les châines extraites
|
*/
|
public static String[] splitIntoColumns(String line, char character) {
|
|
int count = 0;
|
|
for (int i = 0; i < line.length(); i++) {
|
|
if (line.charAt(i) == character) {
|
count++;
|
}
|
|
}
|
|
String[] columns = new String[count + 1];
|
|
StringBuilder builder = new StringBuilder(0);
|
|
count = 0;
|
|
for (int i = 0; i < line.length(); i++) {
|
|
if (line.charAt(i) == character) {
|
|
columns[count] = builder.toString();
|
|
builder = new StringBuilder(0);
|
|
count++;
|
|
} else {
|
|
builder.append(line.charAt(i));
|
}
|
|
}
|
|
columns[count] = builder.toString();
|
|
return columns;
|
}
|
|
/**
|
* Méthode qui écrit dans un fichier
|
*
|
* @param finalColumnsTableLine : liste des châines à écrire dans le fichier
|
* @param bufferWriter : ressource permettant d'écrire dans le fichier
|
*/
|
public static void writeToFile(String[] finalColumnsTableLine, final BufferedWriter bufferWriter) throws IOException {
|
|
//Ecriture dans le fichier output
|
StringBuilder safeLineBuilder = new StringBuilder(0);
|
|
for (String s : finalColumnsTableLine) {
|
safeLineBuilder.append(s);
|
}
|
|
String safeLine = safeLineBuilder.toString();
|
|
if (safeLine.length() > 0) {
|
|
bufferWriter.write(safeLine + System.lineSeparator());
|
|
}
|
}
|
}
|
