/*
|
* 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.typefichier.validator.utilities.Constantes;
|
import com.megatim.fdxconvert.pojo.DataToImport;
|
import com.megatim.fdxconvert.pojo.FileToValidateDescription;
|
import com.megatim.fdxconvert.exceptions.AttributeFormatException;
|
import static com.megatim.typefichier.validator.utilities.Utilities.getCharset;
|
import com.megatim.fdxconvert.model.AlphaNumeriqueField;
|
import com.megatim.fdxconvert.model.TruncatedElement;
|
import com.megatim.fdxconvert.model.Validateur;
|
import com.megatim.fdxconvert.pojo.ResultFileParsing;
|
import com.megatim.fdxconvert.service.ConfigurationService;
|
import java.beans.IntrospectionException;
|
import java.beans.PropertyDescriptor;
|
import java.io.BufferedReader;
|
import java.io.BufferedWriter;
|
import java.io.File;
|
import java.io.FileInputStream;
|
import java.io.FileNotFoundException;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.io.InputStreamReader;
|
import java.lang.reflect.Field;
|
import java.lang.reflect.InvocationTargetException;
|
import java.lang.reflect.Method;
|
import java.math.BigDecimal;
|
import java.nio.charset.Charset;
|
import java.nio.charset.StandardCharsets;
|
import java.nio.file.Files;
|
import java.nio.file.LinkOption;
|
import java.nio.file.Path;
|
import java.nio.file.Paths;
|
import java.nio.file.StandardOpenOption;
|
import java.text.Normalizer;
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.time.format.DateTimeFormatter;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Collections;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
import java.util.concurrent.atomic.AtomicBoolean;
|
import java.util.concurrent.atomic.AtomicInteger;
|
import java.util.logging.Level;
|
import java.util.logging.Logger;
|
import java.util.stream.Collectors;
|
import org.apache.commons.csv.CSVFormat;
|
import org.apache.commons.csv.CSVParser;
|
import org.apache.commons.csv.CSVRecord;
|
import org.apache.commons.text.StringEscapeUtils;
|
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
|
import org.apache.poi.ss.usermodel.Sheet;
|
import org.apache.poi.ss.usermodel.Workbook;
|
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
|
|
/**
|
*
|
* @author mela
|
*/
|
public class ImportData {
|
|
/**
|
* Méthode qui parse le fichier csv et en extrait les données
|
*
|
* @param <T>
|
* @param datIm
|
* @return
|
* @throws java.lang.Exception
|
*/
|
public static <T> List<T> importDataFromCsvFile(DataToImport<T> datIm) throws Exception {
|
|
// FileReader reader = null;
|
List<String[]> datas = new ArrayList<>();
|
|
List<T> listeToReturn = new ArrayList<>();
|
|
if (datIm != null) {
|
|
try ( FileInputStream fis = new FileInputStream(datIm.getFile()); InputStreamReader isr = new InputStreamReader(fis, StandardCharsets.UTF_8); BufferedReader reader = new BufferedReader(isr)) {
|
|
String line = "";
|
|
while ((line = reader.readLine()) != null) {
|
|
String[] row = line.split(datIm.getRowDelimiter());
|
|
for (String r : row) {
|
|
String[] values = new String[datIm.getFields().size()];
|
|
String[] columns = r.split(datIm.getColumnDelimiter());
|
|
int ss = 0;
|
|
while (ss < datIm.getFields().size() && ss < columns.length) {
|
|
values[ss] = columns[ss];
|
|
ss++;
|
}
|
|
datas.add(values);
|
|
}
|
|
}
|
|
} catch (FileNotFoundException ex) {
|
|
Logger.getLogger(ImportData.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
|
|
} catch (IOException ex) {
|
|
Logger.getLogger(ImportData.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
|
|
}
|
|
if (!datas.isEmpty()) {
|
|
//tous les champs du type paramétré
|
Field[] fields = datIm.getType().getDeclaredFields();
|
|
// mettre les champs du type paramétré dans une map afin de faciliter leur accès
|
Map<String, Field> fieldsToMap = fieldsToMap(fields);
|
|
datas.forEach(d -> {
|
|
try {
|
|
T obj = datIm.getType().newInstance();
|
|
Map<String, String> map = tabToMap(datIm.getFields(), d);
|
|
for (Field field : fields) {
|
|
String fieldName = field.getName();
|
|
if (map.containsKey(fieldName) && fieldsToMap.containsKey(fieldName)) {
|
|
try {
|
|
Object converted = convertToPrimitive(field, map.get(fieldName));
|
Method method = new PropertyDescriptor(fieldName, datIm.getType()).getWriteMethod();
|
method.invoke(obj, converted);
|
|
} catch (IntrospectionException | IllegalAccessException | InvocationTargetException ex) {
|
|
Logger.getLogger(ImportData.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
|
|
} catch (IllegalArgumentException | ClassCastException ex) {
|
|
throw new AttributeFormatException("Erreur de type sur le champ " + fieldName);
|
|
}
|
|
}
|
|
}
|
|
listeToReturn.add(obj);
|
|
} catch (InstantiationException | IllegalAccessException ex) {
|
|
Logger.getLogger(ImportData.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
return listeToReturn;
|
|
}
|
|
/**
|
* Méthode qui extrait les données d'un fichier csv et les normalise
|
*
|
* @param rawCsvData : objet contenant les informations de validationdonnées
|
* @param validateur : Validateur du type fichier auquel appartient le
|
* fichier à valider
|
* @param outputFile : fichier texte généré en sortie
|
* @param headerPresent : renseigne si le fichier a une ligne d'entête
|
* @param alphaNumeriqueToBeTruncated : liste des champs à tronquer
|
* @throws Exception
|
*/
|
public static void parseCsvFile(FileToValidateDescription rawCsvData, Validateur validateur, File outputFile, boolean headerPresent, Set<AlphaNumeriqueField> alphaNumeriqueToBeTruncated) throws Exception {
|
|
Map<Integer, Map> mapParams = ParserUtils.getValidateurElements(validateur);
|
AtomicInteger numeroLigne = new AtomicInteger(0);
|
AtomicBoolean columnTruncated = new AtomicBoolean();
|
int lineNumber = 1;
|
|
if (rawCsvData != null) {
|
Charset charset = getCharset(rawCsvData.getFile());
|
|
AtomicBoolean withHeader = new AtomicBoolean(headerPresent);
|
Path pathOfTruncatedElts = createTruncatedEltsPath(validateur, rawCsvData.getFile());
|
|
try ( FileInputStream fis = new FileInputStream(rawCsvData.getFile()); InputStreamReader isr = new InputStreamReader(fis, charset); BufferedReader reader = new BufferedReader(isr)) {
|
try ( BufferedWriter bufferWriter = Files.newBufferedWriter(outputFile.toPath(), charset, StandardOpenOption.APPEND, StandardOpenOption.CREATE, StandardOpenOption.SYNC); BufferedWriter truncateWriter = Files.newBufferedWriter(pathOfTruncatedElts, StandardCharsets.UTF_8, StandardOpenOption.APPEND, StandardOpenOption.CREATE, StandardOpenOption.SYNC)) {
|
|
CSVParser parser = new CSVParser(reader, CSVFormat.DEFAULT.builder()
|
.setSkipHeaderRecord(headerPresent)
|
.setIgnoreSurroundingSpaces(true)
|
.setTrim(true)
|
.setDelimiter(StringEscapeUtils.unescapeJava(rawCsvData.getColumnDelimiter()))
|
.setRecordSeparator(StringEscapeUtils.unescapeJava(rawCsvData.getRowDelimiter()))
|
.build());
|
|
for (CSVRecord record : parser) {
|
|
String[] columnsTableLine = new String[record.size()];
|
AtomicInteger i = new AtomicInteger(0);
|
|
if (!withHeader.get()) {
|
|
record.forEach(column -> {
|
columnsTableLine[i.get()] = column != null ? column.replaceAll(" {2,}", " ").replaceAll("\r", "").replaceAll("\n", "").replaceAll("\t", "").trim() : "";
|
i.set(i.get() + 1);
|
});
|
|
//Nettoyage d'une colonne de chaque ligne
|
ResultFileParsing resultFileParsing = buildFinalColumnsTableLine(outputFile, columnsTableLine, mapParams, alphaNumeriqueToBeTruncated, numeroLigne.incrementAndGet(), truncateWriter);
|
String[] finalColumnsTableLine = resultFileParsing.getFinalColumnsTableLine();
|
columnTruncated.set(resultFileParsing.isColumnTruncated());
|
|
String[] encodedStrings = ParserUtils.encodeStrings(finalColumnsTableLine, charset);
|
ParserUtils.writeToFile(encodedStrings, bufferWriter);
|
|
lineNumber++;
|
} else {
|
withHeader.set(false);
|
}
|
|
}
|
|
} catch (Exception e) {
|
Logger.getLogger(ImportData.class.getName()).log(Level.SEVERE, e.getMessage(), e);
|
}
|
|
//Si au moins une colonne a été tronqué, alors copier le fichier dont les lignes ont été tronqué dans le répertoire d'archivage
|
if (columnTruncated.get()) {
|
Path originalFilePathInArchiveFolder = createOriginalFileInArchive(validateur, rawCsvData.getFile());
|
|
//Copie du fichier dont les colonnes ont été tronqués vers le répertoire archivage
|
if (rawCsvData.getFile().exists()) {
|
Files.copy(rawCsvData.getFile().toPath(), originalFilePathInArchiveFolder);
|
}
|
|
} else {//Sinon supprimer le fichier des éléments tronqués, car il est vide
|
Files.deleteIfExists(pathOfTruncatedElts);
|
}
|
}
|
}
|
}
|
|
/**
|
* Méthode qui extrait les données dans un fichier txt en respectant
|
* scrupuleusement la taille de chaque colonne
|
*
|
* @param rawCsvData : objet contenant les informations de validationdonnées
|
* @param validateur : Validateur du type fichier auquel appartient le
|
* fichier à valider
|
* @param outputFile : fichier texte généré en sortie
|
* @param headerPresent : renseigne si le fichier a une ligne d'entête
|
* @throws Exception
|
*/
|
public static void parseFileByFieldLength(FileToValidateDescription rawCsvData, Validateur validateur, File outputFile, boolean headerPresent) throws Exception {
|
System.out.println("----------------------In parseFileByFieldLength------------------");
|
Map<Integer, Map> mapParams = ParserUtils.getValidateurElements(validateur);
|
//boolean result = true;
|
int nbLine = 0;
|
|
if (rawCsvData != null) {
|
|
Charset charset = getCharset(rawCsvData.getFile());
|
|
//Lecture des lignes du fichier et chargment dans une liste
|
try ( FileInputStream fis = new FileInputStream(rawCsvData.getFile()); InputStreamReader isr = new InputStreamReader(fis, charset); BufferedReader reader = new BufferedReader(isr)) {
|
|
try ( //Initialisation du write pour traiter chaque ligne du fichier
|
BufferedWriter bufferWriter = Files.newBufferedWriter(outputFile.toPath(), charset, StandardOpenOption.APPEND, StandardOpenOption.CREATE, StandardOpenOption.SYNC);) {
|
|
boolean withHeader = headerPresent;
|
|
StringBuilder line = new StringBuilder();
|
|
int c = 0;
|
|
boolean carriageReaded = false; //Indique si on a lu un retour chariot
|
|
char lastCharacter = '\u0000';
|
|
while ((c = reader.read()) != -1) {
|
|
char characterRead = (char) c;
|
|
if (characterRead == '\r') {
|
|
if (carriageReaded) { //On a lu le retour chariot deux fois consécutives donc on a pas de séparateur de ligne au sens windows
|
|
//On ajoute les deux caractère à la chaîne que nous construisons
|
line.append('\r').append(characterRead);
|
|
carriageReaded = false; //On marque que la lecture d'une nouvelle ligne redémarre
|
|
} else { // Première lecture du retour chariot
|
|
carriageReaded = true; // On marque que nous avons lu un retour chariot
|
|
}
|
|
} else {
|
|
if (carriageReaded) { // Le caractère précédemment lu c'est le retour chariot
|
|
if (characterRead == '\n') { // Si le nouveau caractère lu est un saut de ligne c'est que nous venons de lire une nouvelle ligne
|
|
//On effectue les traitements propres à la ligne
|
String newLine = line.toString();
|
nbLine++;
|
|
if (!withHeader) {
|
|
parseLineUsingFieldLength(newLine, mapParams, rawCsvData.getColumnDelimiter(), bufferWriter, charset);
|
|
} else {
|
|
withHeader = false;
|
|
}
|
|
line = new StringBuilder(); //On réinitialise notre constructeur de ligne
|
|
carriageReaded = false; //On marque que la lecture d'une nouvelle ligne redémarre
|
|
} else {
|
|
line.append(' '); //On change le saut de ligne par un espace
|
|
}
|
|
} else {
|
|
if (characterRead == '\n') {
|
|
if (lastCharacter != '\n') {
|
|
line.append(' ');
|
|
}
|
|
} else {
|
|
line.append(characterRead);
|
|
}
|
|
}
|
|
}
|
|
lastCharacter = characterRead;
|
}
|
|
} //Fermeture du writer
|
|
}
|
|
}
|
|
}
|
|
/**
|
* Méthode qui parcours un fichier txt caractère par caractère afin d'en
|
* extraire les données et de les normaliser
|
*
|
* @param rawCsvData : objet contenant les informations de validationdonnées
|
* @param validateur : Validateur du type fichier auquel appartient le
|
* fichier à valider
|
* @param outputFile : fichier texte généré en sortie
|
* @param headerPresent : renseigne si le fichier a une ligne d'entête
|
* @param alphaNumeriqueToBeTruncated : liste des champs à tronquer
|
* @throws Exception
|
*/
|
public static void parseFileCharacterByCharacter(FileToValidateDescription rawCsvData, Validateur validateur, File outputFile, boolean headerPresent, Set<AlphaNumeriqueField> alphaNumeriqueToBeTruncated) throws Exception {
|
|
Map<Integer, Map> mapParams = ParserUtils.getValidateurElements(validateur);
|
AtomicInteger numeroLigne = new AtomicInteger(0);
|
AtomicBoolean columnTruncated = new AtomicBoolean();
|
|
if (rawCsvData != null) {
|
|
Charset charset = getCharset(rawCsvData.getFile());
|
Path pathOfTruncatedElts = createTruncatedEltsPath(validateur, rawCsvData.getFile());
|
|
//Lecture des lignes du fichier et chargement dans une liste
|
try ( FileInputStream fis = new FileInputStream(rawCsvData.getFile()); InputStreamReader isr = new InputStreamReader(fis, charset); BufferedReader reader = new BufferedReader(isr)) {
|
|
try ( //Initialisation du write pour traiter chaque ligne du fichier
|
BufferedWriter bufferWriter = Files.newBufferedWriter(outputFile.toPath(), charset, StandardOpenOption.APPEND, StandardOpenOption.CREATE, StandardOpenOption.SYNC); BufferedWriter truncateWriter = Files.newBufferedWriter(pathOfTruncatedElts, StandardCharsets.UTF_8, StandardOpenOption.APPEND, StandardOpenOption.CREATE, StandardOpenOption.SYNC)) {
|
|
boolean withHeader = headerPresent;
|
|
StringBuilder line = new StringBuilder();
|
|
int c = 0;
|
|
boolean carriageReaded = false; //Indique si on a lu un retour chariot
|
|
char lastCharacter = '\u0000';
|
|
while ((c = reader.read()) != -1) {
|
|
char characterRead = (char) c;
|
|
if (characterRead == '\r') {
|
|
if (carriageReaded) { //On a lu le retour chariot deux fois consécutives donc on a pas de séparateur de ligne au sens windows
|
|
//On ajoute les deux caractère à la chaîne que nous construisons
|
line.append('\r').append(characterRead);
|
|
carriageReaded = false; //On marque que la lecture d'une nouvelle ligne redémarre
|
|
} else { // Première lecture du retour chariot
|
|
carriageReaded = true; // On marque que nous avons lu un retour chariot
|
|
}
|
|
} else {
|
|
if (carriageReaded) { // Le caractère précédemment lu c'est le retour chariot
|
|
if (characterRead == '\n') { // Si le nouveau caractère lu est un saut de ligne c'est que nous venons de lire une nouvelle ligne
|
|
//On effectue les traitements propres à la ligne
|
String newLine = line.toString();
|
|
if (ParserUtils.characterOfDelimiteur(rawCsvData.getColumnDelimiter()) != '\0') {
|
newLine = newLine.replaceAll(" {2,}", " ");
|
}
|
|
if (!withHeader) {
|
|
//Représente les colonnes extraites de chaque ligne du fichier
|
//String[] columnsTableLine = newLine.split(rawCsvData.getColumnDelimiter());
|
String[] columnsTableLine;
|
|
if (rawCsvData.getColumnDelimiter().equals("\\t")) {
|
|
columnsTableLine = ParserUtils.splitIntoColumns(newLine, '\t');
|
ResultFileParsing resultFileParsing = buildFinalColumnsTableLine(outputFile, columnsTableLine, mapParams, alphaNumeriqueToBeTruncated, numeroLigne.incrementAndGet(), truncateWriter);
|
String[] finalColumnsTableLine = resultFileParsing.getFinalColumnsTableLine();
|
columnTruncated.set(resultFileParsing.isColumnTruncated());
|
|
String[] encodedStrings = ParserUtils.encodeStrings(finalColumnsTableLine, charset);
|
ParserUtils.writeToFile(encodedStrings, bufferWriter);
|
|
} else if (rawCsvData.getColumnDelimiter().isEmpty()) {
|
parseLineUsingFieldLength(newLine, mapParams, rawCsvData.getColumnDelimiter(), bufferWriter, charset);
|
} else {
|
|
columnsTableLine = (newLine).split(rawCsvData.getColumnDelimiter());
|
ResultFileParsing resultFileParsing = buildFinalColumnsTableLine(outputFile, columnsTableLine, mapParams, alphaNumeriqueToBeTruncated, numeroLigne.incrementAndGet(), truncateWriter);
|
String[] finalColumnsTableLine = resultFileParsing.getFinalColumnsTableLine();
|
|
if (!columnTruncated.get()) {
|
columnTruncated.set(resultFileParsing.isColumnTruncated());
|
}
|
|
String[] encodedStrings = ParserUtils.encodeStrings(finalColumnsTableLine, charset);
|
ParserUtils.writeToFile(encodedStrings, bufferWriter);
|
|
}
|
|
//Nettoyage d'une colonne de chaque ligne
|
} else {
|
|
withHeader = false;
|
|
}
|
|
line = new StringBuilder(); //On réinitialise notre constructeur de ligne
|
|
carriageReaded = false; //On marque que la lecture d'une nouvelle ligne redémarre
|
|
} else {
|
|
line.append(' '); //On change le saut de ligne par un espace
|
|
}
|
|
} else {
|
|
if (characterRead == '\n') {
|
|
if (lastCharacter != '\n') {
|
|
line.append(' ');
|
|
}
|
|
} else {
|
|
line.append(characterRead);
|
|
}
|
|
}
|
|
}
|
|
lastCharacter = characterRead;
|
}
|
|
} //Fermeture du writer
|
|
}
|
|
//Si au moins une colonne a été tronqué, alors copier le fichier dont les lignes ont été tronqué dans le répertoire d'archivage
|
if (columnTruncated.get()) {
|
Path originalFilePathInArchiveFolder = createOriginalFileInArchive(validateur, rawCsvData.getFile());
|
|
//Copie du fichier dont les colonnes ont été tronqués vers le répertoire archivage
|
if (rawCsvData.getFile().exists()) {
|
Files.copy(rawCsvData.getFile().toPath(), originalFilePathInArchiveFolder);
|
}
|
|
} else {//Sinon supprimer le fichier des éléments tronqués, car il est vide
|
Files.deleteIfExists(pathOfTruncatedElts);
|
}
|
}
|
|
}
|
|
/**
|
* Méthode qui extrait les données d'un fichier xlsx et les normalise
|
*
|
* @param validateur : Validateur du type fichier auquel appartient le
|
* fichier à valider
|
* @param outputFile : fichier texte généré en sortie
|
* @param headerPresent : renseigne si le fichier a une ligne d'entête
|
* @param alphaNumeriqueToBeTruncated : liste des champs à tronquer
|
* @param filePath : Fichier qui contient les données à extraire
|
* @throws IOException
|
* @throws Exception
|
*/
|
public static void parseXlsxFile(String filePath, boolean headerPresent, File outputFile, Validateur validateur, Set<AlphaNumeriqueField> alphaNumeriqueToBeTruncated) throws Exception {
|
AtomicBoolean columnTruncated = new AtomicBoolean();
|
Path pathOfTruncatedElts = createTruncatedEltsPath(validateur, new File(filePath));
|
|
try ( InputStream is = new FileInputStream(filePath); Workbook wb = new XSSFWorkbook(is)) {
|
parseExcelFile(filePath, wb, headerPresent, outputFile, validateur, alphaNumeriqueToBeTruncated, pathOfTruncatedElts);
|
}
|
treatTruncatedElements(filePath, pathOfTruncatedElts, validateur, columnTruncated);
|
|
}
|
|
public static void parseXlsFile(String filePath, boolean headerPresent, File outputFile, Validateur validateur, Set<AlphaNumeriqueField> alphaNumeriqueToBeTruncated) throws Exception {
|
AtomicBoolean columnTruncated = new AtomicBoolean();
|
Path pathOfTruncatedElts = createTruncatedEltsPath(validateur, new File(filePath));
|
|
try ( InputStream is = new FileInputStream(filePath); Workbook wb = new HSSFWorkbook(is)) {
|
parseExcelFile(filePath, wb, headerPresent, outputFile, validateur, alphaNumeriqueToBeTruncated, pathOfTruncatedElts);
|
}
|
treatTruncatedElements(filePath, pathOfTruncatedElts, validateur, columnTruncated);
|
|
}
|
|
private static void parseExcelFile(String filePath, Workbook wb, boolean headerPresent, File outputFile, Validateur validateur, Set<AlphaNumeriqueField> alphaNumeriqueToBeTruncated, Path pathOfTruncatedElts) throws IOException, Exception {
|
Map<Integer, Map> mapParams = ParserUtils.getValidateurElements(validateur);
|
final int maxPosition = Collections.max(mapParams.keySet());
|
AtomicInteger numeroLigne = new AtomicInteger(0);
|
AtomicBoolean columnTruncated = new AtomicBoolean();
|
Charset charset = getCharset(new File(filePath));
|
|
try ( BufferedWriter bufferWriter = Files.newBufferedWriter(outputFile.toPath(), charset, StandardOpenOption.APPEND, StandardOpenOption.CREATE, StandardOpenOption.SYNC); BufferedWriter truncateWriter = Files.newBufferedWriter(pathOfTruncatedElts, Charset.defaultCharset(), StandardOpenOption.APPEND, StandardOpenOption.CREATE, StandardOpenOption.SYNC)) {
|
|
for (int i = 0; i < wb.getNumberOfSheets(); i++) {
|
Sheet sheet = wb.getSheetAt(i);
|
AtomicInteger numberOfColumns = new AtomicInteger(0);
|
AtomicBoolean withHeader = new AtomicBoolean(headerPresent);
|
AtomicInteger lineNumber = new AtomicInteger(1);
|
|
for (org.apache.poi.ss.usermodel.Row r : sheet) {
|
|
if (!withHeader.get()) {
|
for (int cn = 0; cn < r.getLastCellNum(); cn++) {
|
numberOfColumns.incrementAndGet();
|
}
|
//Représente les colonnes extraites de chaque ligne du fichier
|
String[] columnsTableLine = new String[numberOfColumns.get()];
|
AtomicInteger index = new AtomicInteger(0);
|
|
for (int cn = 0; cn < r.getLastCellNum(); cn++) {
|
if (cn < maxPosition) {
|
Map<String, String> map = mapParams.get(index.get() + 1);
|
|
//Prendre aussi les cellules vides en considération
|
org.apache.poi.ss.usermodel.Cell c = r.getCell(cn, org.apache.poi.ss.usermodel.Row.MissingCellPolicy.CREATE_NULL_AS_BLANK);
|
String value = com.megatim.typefichier.validator.utilities.ParserUtils.getXlxsCellValue(c,
|
wb,
|
map.get(Constantes.LIBELLE_TYPE_DONNEE),
|
map.get(Constantes.LIBELLE_FORMAT_DATE),
|
map.get(Constantes.LIBELLE_SEPARATEUR_DATE),
|
map.get(Constantes.ERROR_CODE));
|
columnsTableLine[index.get()] = value;
|
index.incrementAndGet();
|
} else {
|
break;
|
}
|
}
|
|
try {
|
//Nettoyage d'une colonne de chaque ligne
|
ResultFileParsing resultFileParsing = buildFinalColumnsTableLine(outputFile, columnsTableLine, mapParams, alphaNumeriqueToBeTruncated, numeroLigne.incrementAndGet(), truncateWriter);
|
String[] finalColumnsTableLine = resultFileParsing.getFinalColumnsTableLine();
|
columnTruncated.set(resultFileParsing.isColumnTruncated());
|
|
ParserUtils.writeToFile(finalColumnsTableLine, bufferWriter);
|
|
} catch (Exception ex) {
|
Logger.getLogger(ImportData.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
|
}
|
} else {
|
withHeader.set(false);
|
}
|
lineNumber.incrementAndGet();
|
}
|
}
|
|
}
|
}
|
|
private static void treatTruncatedElements(String filePath, Path pathOfTruncatedElts, Validateur validateur, AtomicBoolean columnTruncated) throws IOException {
|
//Si au moins une colonne a été tronqué, alors copier le fichier dont les lignes ont été tronqué dans le répertoire d'archivage
|
if (columnTruncated.get()) {
|
Path pathoriginalFilePath = Paths.get(filePath);
|
Path originalFilePathInArchiveFolder = createOriginalFileInArchive(validateur, new File(filePath));
|
|
//Copie du fichier dont les colonnes ont été tronqués vers le répertoire archivage
|
if (Files.exists(pathoriginalFilePath, LinkOption.NOFOLLOW_LINKS)) {
|
Files.copy(pathoriginalFilePath, originalFilePathInArchiveFolder);
|
}
|
|
} else {//Sinon supprimer le fichier des éléments tronqués, car il est vide
|
Files.deleteIfExists(pathOfTruncatedElts);
|
}
|
}
|
|
/**
|
* Méthode qui met les libellés des colonnes et leurs valeurs
|
* correspondantes dans une map
|
*
|
* @param titles : ensemble des noms de colonnes
|
* @param values : ensemble des données
|
* @return : rentourne une map (clé,valeur) = (nom_de_la_colonne,
|
* valeur_colonne)
|
*/
|
private static Map<String, String> tabToMap(List<String> titles, String[] values) {
|
Map<String, String> map = new HashMap<>();
|
for (int i = 0; i < titles.size(); i++) {
|
map.put(titles.get(i), values[i]);
|
}
|
|
return map;
|
}
|
|
/**
|
* Méthode qui met un tableau de Field dans une
|
* map<nom_du_champ,objet représentant_le_champ>
|
* afin de faciliter leur accès
|
*
|
* @param fields
|
* @return
|
*/
|
private static Map<String, Field> fieldsToMap(Field[] fields) {
|
Map<String, Field> map = new HashMap<>();
|
for (Field f : fields) {
|
map.put(f.getName(), f);
|
}
|
|
return map;
|
}
|
|
/**
|
* Méthode qui fait la conversion de la donnée extraite vers un type
|
* primitif
|
*
|
* @param field : objet contenant les informations sur le type auquel
|
* appartient le champ de la donnée extraite
|
* @param value : donnée à convertir
|
* @return : retourne un String si le type du champ ne figure pas dans la
|
* liste ci-dessus
|
*/
|
private static Object convertToPrimitive(Field field, String value) {
|
Object obj = value;
|
|
if (field.getType().isAssignableFrom(Integer.class)
|
|| field.getType().isAssignableFrom(int.class)) {
|
obj = Integer.valueOf(value);
|
} else if (field.getType().isAssignableFrom(Double.class)
|
|| field.getType().isAssignableFrom(double.class)) {
|
obj = Double.valueOf(value);
|
} else if (field.getType().isAssignableFrom(java.math.BigDecimal.class)) {
|
obj = new java.math.BigDecimal(value);
|
} else if (field.getType().isAssignableFrom(Float.class)
|
|| field.getType().isAssignableFrom(float.class)) {
|
obj = Float.valueOf(value);
|
} else if (field.getType().isAssignableFrom(Long.class)
|
|| field.getType().isAssignableFrom(long.class)) {
|
obj = Long.valueOf(value);
|
} else if (field.getType().isAssignableFrom(Boolean.class)
|
|| field.getType().isAssignableFrom(boolean.class)) {
|
Boolean.valueOf(value);
|
}
|
|
return obj;
|
}
|
|
/**
|
* Méthode permettant de construire la donnée finale à écrire dans le
|
* fichier texte
|
*
|
* @param outputFile
|
* @param initialColumnsTableLine
|
* @param mapParams
|
* @param fieldsToBeTruncated
|
* @param numeroLigne
|
* @param truncateWriter
|
* @return
|
* @throws Exception
|
*/
|
private static ResultFileParsing buildFinalColumnsTableLine(File outputFile, String[] initialColumnsTableLine, Map<Integer, Map> mapParams, Set<AlphaNumeriqueField> fieldsToBeTruncated, int numeroLigne, BufferedWriter truncateWriter) throws Exception {
|
|
String[] finalColumnsTableLine = new String[mapParams.size() - 1];
|
String[] columnsTableLine = new String[mapParams.size() - 1];
|
|
//On copie les éléments à normaliser dans un nouveau tableau
|
for (int j = 0; j < finalColumnsTableLine.length; j++) {
|
|
//Arreter la copie si on atteint la fin du tableau initial
|
if (j == initialColumnsTableLine.length) {
|
j = finalColumnsTableLine.length;
|
} else {
|
final String result = initialColumnsTableLine[j] != null && !initialColumnsTableLine[j].isEmpty()
|
? Normalizer
|
.normalize(initialColumnsTableLine[j], Normalizer.Form.NFD) //Retrait des caractères accentués
|
.replaceAll("\\p{M}+", "")
|
: "";
|
columnsTableLine[j] = result;
|
}
|
}
|
|
//Type de données utilisé pour retourner le résultat de la construction des lignes de données
|
ResultFileParsing resultFileParsing = new ResultFileParsing();
|
|
int index = 0;
|
|
for (String str : columnsTableLine) {
|
|
String columnTableLine = str != null ? str.trim() : "";
|
|
if (index < mapParams.size() - 1) {
|
|
Map<String, String> map = mapParams.get(index + 1);
|
|
final int taille = Integer.parseInt(map.get(Constantes.LIBELLE_TAILLE));
|
String typeDonnee = map.get(Constantes.LIBELLE_TYPE_DONNEE);
|
|
//Traitement d'une donnée de type décimal
|
if (typeDonnee.equalsIgnoreCase(Constantes.LIBELLE_DECIMAL)) {
|
finalColumnsTableLine[index] = normalizeDecimal(columnTableLine, map);
|
|
//Traitement d'une donnée de type DATE
|
} else if (typeDonnee.equalsIgnoreCase(Constantes.LIBELLE_DATE)) {
|
|
if (columnTableLine.length() < taille) {
|
finalColumnsTableLine[index] = generateUnknown(taille - columnTableLine.length(), " ") + columnTableLine;
|
|
} else if (columnTableLine.length() == taille) {
|
finalColumnsTableLine[index] = columnTableLine;
|
|
} else {
|
finalColumnsTableLine[index] = columnTableLine.substring(0, taille);
|
}
|
|
//Traitement d'une donnée de type NUMERIQUE
|
} else if (typeDonnee.equalsIgnoreCase(Constantes.LIBELLE_NUMERIQUE)) {
|
finalColumnsTableLine[index] = normalizeNumber(columnTableLine, taille);
|
//
|
} else if (typeDonnee.equalsIgnoreCase(Constantes.LIBELLE_ALPHANUMERIQUE)) { //Traitement d'une donnée de type ALPHANUMERIQUE
|
|
if (columnTableLine.length() < taille) {
|
|
finalColumnsTableLine[index] = generateUnknown(taille - columnTableLine.length(), " ") + columnTableLine;
|
|
} else if (columnTableLine.length() == taille) {
|
|
finalColumnsTableLine[index] = columnTableLine;
|
|
} else {
|
|
if (!fieldsToBeTruncated.isEmpty()) {
|
|
//Récupérer l'index de début du champ en cours de traitement
|
int indexDebutChamp = Integer.parseInt(map.get(Constantes.LIBELLE_INDEX));
|
|
//Mettre les champs à tronquer dans une liste afin d'y rechercher le champ en cours de traitement
|
List<AlphaNumeriqueField> liste = Arrays.asList(fieldsToBeTruncated.toArray(new AlphaNumeriqueField[0]))
|
.stream().filter(a -> {
|
|
// ici on vérifie si l'index de début du champ en cours de traitement correspond à l'index d'un des champs à tronquer
|
//Car si 2 champs ont le même index, alors il s'agit d'un seul champ
|
return a.getIndex() == indexDebutChamp;
|
}).collect(Collectors.toList());
|
|
// Si on a trouvé un champ à tronquer qui a le même index que le champ courant alors, tronquer le champ
|
boolean found = (liste.size() == 1);
|
|
if (found) {
|
|
AlphaNumeriqueField alphaField = liste.get(0);
|
|
String finalData = columnTableLine.substring(0, taille);
|
|
TruncatedElement truncatedElement = new TruncatedElement(alphaField.getValidateur().getCodeTypeFichier(),
|
alphaField.getCodeColonne(), columnTableLine, finalData,
|
outputFile.getName(), LocalDateTime.now(), numeroLigne, taille, columnTableLine.length());
|
|
// Journalisation du champs tronqués
|
writeTruncatedElementsToFile(truncatedElement, truncateWriter);
|
|
resultFileParsing.setColumnTruncated(true);
|
|
finalColumnsTableLine[index] = finalData;
|
} else {
|
finalColumnsTableLine[index] = columnTableLine;
|
}
|
|
} else {
|
finalColumnsTableLine[index] = columnTableLine;
|
}
|
}
|
} else {
|
finalColumnsTableLine[index] = columnTableLine;
|
}
|
}
|
|
index++;
|
|
}
|
|
resultFileParsing.setFinalColumnsTableLine(finalColumnsTableLine);
|
return resultFileParsing;
|
}
|
|
/**
|
* Méthode qui normalise un nombre en ajoutant des zéros à gauche
|
*
|
* @param value
|
* @param taille
|
* @return
|
*/
|
private static String normalizeNumber(String value, int taille) {
|
String newValue = value
|
.trim()
|
.replaceAll("\\s+", "")
|
.replaceAll("\\u00A0", "")//nbsp
|
.replaceAll(" ", "")//nbsp
|
.replaceAll("\\p{Z}", "")
|
.replaceAll("\t", "")
|
.replaceAll("\r", "")
|
.replaceAll("\n", "");
|
|
try {
|
if (!newValue.matches("\\d+")) {
|
newValue = new BigDecimal(newValue.replace(',', '.')).longValue() + "";//Remplacer la virgule par le point
|
}
|
} catch (Exception ex) {
|
}
|
return generateUnknown(taille - newValue.length(), " ") + newValue;
|
}
|
|
/**
|
* Méthode qui normalise les nombres décimaux conformat aux tailles, en
|
* ajoutant éventuellement des zéros à gauche de la partie entière et à
|
* droite de la partie décimale renseignés dans le validateur
|
*
|
* @param value : chaîne à normaliser
|
* @param map : map contenant les infos sur les parties entire et décimale
|
* @return
|
*/
|
private static String normalizeDecimal(String value, Map<String, String> map) {
|
|
//Taille totale du nombre décimal
|
int taille = Integer.parseInt(map.get(Constantes.LIBELLE_TAILLE));
|
int taillePartieDecimale = Integer.parseInt(map.get(Constantes.LIBELLE_TAILLE_PARTIE_DECIMALE));
|
String separateurDecimal = map.get(Constantes.LIBELLE_SEPARATEUR_DECIMAL);
|
int tailleReelle = taille + taillePartieDecimale + separateurDecimal.trim().length();
|
|
String newValue = value.trim()
|
.replaceAll("\\s+", "")
|
.replaceAll("\\u00A0", "")//nbsp
|
.replaceAll(" ", "")//nbsp
|
.replaceAll("\\p{Z}", "")
|
.replaceAll("\t", "")
|
.replaceAll("\r", "")
|
.replaceAll("\n", "");
|
|
if (newValue.length() >= tailleReelle) {
|
return newValue;
|
}
|
if (newValue.matches("^\\d+[,.]?\\d+$")
|
|| newValue.matches("[-+]?\\d+(\\.\\d+)?[eE][-+]?\\d+")
|
|| newValue.matches("^\\d{1,3},\\d+E[+-]?\\d+$")) {//Notation scientifique
|
try {
|
newValue = new BigDecimal(newValue.replace(',', '.')).toPlainString();//Remplacer la virgule par le point
|
} catch (Exception ex) {
|
}
|
}
|
return generateUnknown(tailleReelle - newValue.length(), " ") + newValue;
|
}
|
|
/**
|
* Méthode qui génère un nombre précis d'un quelconque caractère
|
*
|
* @param nbOfCharacter : nombre de fois à générer le caractère
|
* @param character : caractère à générer
|
* @return
|
*/
|
private static String generateUnknown(int nbOfCharacter, String character) {
|
String str = "";
|
|
for (int i = 0; i < nbOfCharacter; i++) {
|
str += character;
|
}
|
return str;
|
}
|
|
/**
|
* Méthode qui extrait les données en se basant sur la taille des champs
|
* définis dans le validateur
|
*/
|
private static void parseLineUsingFieldLength(String line, Map<Integer, Map> mapParams, String delimiteurColonne, BufferedWriter bufferWriter, Charset charset) throws IOException {
|
|
String[] columnsTableLine = new String[mapParams.size() - 1];
|
|
try {
|
int index = 0;
|
int i = 1;
|
|
while (i < mapParams.size()) {
|
Map<String, String> map = mapParams.get(i);
|
|
int taille = Integer.parseInt(map.get(Constantes.LIBELLE_TAILLE));
|
|
if (i == mapParams.size() - 1) {
|
columnsTableLine[i - 1] = line.substring(index);
|
} else {
|
columnsTableLine[i - 1] = line.substring(index, index + taille);
|
}
|
|
index = index + taille;
|
|
//recupérer le charactère correspondant au delimiteur
|
char character = ParserUtils.characterOfDelimiteur(delimiteurColonne);
|
|
//Si le démimiteur n'est pas la chaîne vide
|
if (character != '\0') {
|
|
//Si on ne trouve pas le délimiteur après avoir lu le champ précédent, on arrete le traitement de cette ligne car fichier mal formaté
|
if ((i < mapParams.size() - 1) && (line.charAt(index) != character)) {
|
|
//Interrompre l'extraction des données en remplissant la condition de sortie de laboucle
|
i = mapParams.size();
|
} else {
|
|
//Incrementer l'index un afin de traverser le séparateur
|
index = index + 1;
|
}
|
|
}
|
i++;
|
}
|
|
String[] encodedStrings = ParserUtils.encodeStrings(columnsTableLine, charset);
|
ParserUtils.writeToFile(encodedStrings, bufferWriter);
|
|
} catch (Exception ex) {
|
Logger.getLogger(ImportData.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
|
}
|
|
}
|
|
/**
|
* Méthode qui écrit les informations sur les éléments tronqués dans un
|
* fichier
|
*
|
* @param t
|
* @param bufferWriter
|
* @throws IOException
|
*/
|
private static void writeTruncatedElementsToFile(TruncatedElement t, final BufferedWriter bufferWriter) throws IOException {
|
|
//Ecriture dans le fichier output
|
StringBuilder safeLineBuilder = new StringBuilder(0);
|
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
|
LocalDateTime date = t.getDateAction();
|
|
safeLineBuilder.append("Fichier:").append(t.getFileName()).append("|");
|
safeLineBuilder.append("Date:").append(date.format(formatter)).append("|");
|
safeLineBuilder.append("Ligne:").append(t.getLineNumber()).append("|");
|
safeLineBuilder.append("Colonne:").append(t.getCodeColonne()).append("|");
|
safeLineBuilder.append("Taille attendue:").append(t.getTailleAttendue()).append("|");
|
safeLineBuilder.append("Donnée finale:").append(t.getFinalData()).append("|");
|
safeLineBuilder.append("Taille trouvée:").append(t.getTailleTrouvee()).append("|");
|
safeLineBuilder.append("Donnée initiale:").append(t.getInitialData());
|
|
String safeLine = safeLineBuilder.toString();
|
|
if (safeLine.length() > 0) {
|
|
bufferWriter.write(safeLine + System.lineSeparator());
|
|
}
|
}
|
|
/**
|
* Méthode qui retourne le nom fichier sans extension
|
*
|
* @param file
|
* @return
|
*/
|
private static String fileNameWithoutExtension(File file) {
|
int index = file.getName().lastIndexOf(".");
|
|
if (index > 0) {
|
|
return file.getName().substring(0, index);
|
} else {
|
return file.getName();
|
}
|
}
|
|
/**
|
* Méthode qui construit le chemin du fichier qui va contenit les logs des
|
* éléments tronqués
|
*
|
* @param validateur
|
* @param outputFile
|
* @return
|
* @throws IOException
|
*/
|
private static Path createTruncatedEltsPath(Validateur validateur, File outputFile) throws IOException {
|
final String arhivageDirectory = ConfigurationService.getInstance().getCurrentConfig().getArchivesDir();
|
final String today = LocalDate.now().toString();
|
|
Path logDir = Paths.get(arhivageDirectory, today, validateur.getCodeTypeFichier(), "logs");
|
|
if (!Files.exists(logDir, LinkOption.NOFOLLOW_LINKS)) {
|
Files.createDirectories(logDir);
|
}
|
|
Path pathOfTruncatedElts = Paths.get(arhivageDirectory, today, validateur.getCodeTypeFichier(), "logs", fileNameWithoutExtension(outputFile) + "_truncated_elements.txt");
|
|
return pathOfTruncatedElts;
|
|
}
|
|
/**
|
* méthode permettant de construire le chemin du fichier d'origine dans le
|
* répertoire d'archivages
|
*
|
* @param validateur
|
* @param originalFile
|
* @return
|
* @throws IOException
|
*/
|
private static Path createOriginalFileInArchive(Validateur validateur, File originalFile) throws IOException {
|
final String arhivageDirectory = ConfigurationService.getInstance().getCurrentConfig().getArchivesDir();
|
final String today = LocalDate.now().toString();
|
|
Path originalFilesDir = Paths.get(arhivageDirectory, today, validateur.getCodeTypeFichier(), "fichiers");
|
|
if (!Files.exists(originalFilesDir, LinkOption.NOFOLLOW_LINKS)) {
|
Files.createDirectories(originalFilesDir);
|
}
|
|
Path originalFilePath = Paths.get(arhivageDirectory, today, validateur.getCodeTypeFichier(), "fichiers", originalFile.getName());
|
final String fileNameWithoutExtension = fileNameWithoutExtension(originalFile);
|
|
//Si le fichier existe dans le répertoire d'archivages, alors ajouter un numero d'ordre dans son nom
|
if (Files.exists(originalFilePath, LinkOption.NOFOLLOW_LINKS)) {
|
List<Path> existingFiles = Files.list(originalFilesDir).filter(p
|
-> p.toString().contains(fileNameWithoutExtension)).collect(Collectors.toList());
|
|
int nbFiles = existingFiles.size();
|
|
if (nbFiles > 0) {
|
originalFilePath = Paths.get(arhivageDirectory, today, validateur.getCodeTypeFichier(), "fichiers",
|
fileNameWithoutExtension + "(" + nbFiles + ")" + getFileExtension(originalFile));
|
}
|
}
|
|
return originalFilePath;
|
}
|
|
/**
|
* Méthode qui retourne l'extension d'un fichier
|
*
|
* @param file
|
* @return
|
*/
|
private static String getFileExtension(File file) {
|
int index = file.getName().lastIndexOf(".");
|
|
if (index <= 0) {
|
return "";
|
|
} else {
|
return file.getName().substring(index);
|
}
|
}
|
|
}
|
