package com.megatim.fdxconvert.controller;
|
|
import com.megatim.typefichier.validator.Validator;
|
import com.megatim.typefichier.validator.model.ConfigJsonValidator;
|
import com.megatim.typefichier.validator.model.ConfigStreamValidator;
|
import com.megatimfx.common.abstracts.AbstractEditDialogController;
|
import com.megatimfx.common.enums.TypeOperation;
|
import com.megatimfx.common.utils.ViewLoaderUtil;
|
import com.megatimfx.components.customdialogs.AlertMessageUtil;
|
import com.megatimfx.components.customdialogs.LoadinIndicatorDialogUtil;
|
import com.megatimfx.components.dialogs.NotificationDialog;
|
import com.megatimfx.components.dialogs.NotificationType;
|
import com.megatim.fdxconvert.dao.TypeFichierJsonDAO;
|
import com.megatim.fdxconvert.dao.ValidateurDAO;
|
import com.megatim.fdxconvert.enums.DataType;
|
import com.megatim.fdxconvert.exceptions.ConfigException;
|
import com.megatim.fdxconvert.exceptions.ValidatorException;
|
import com.megatim.fdxconvert.forms.MetaAlphaNumeriqueFieldEditFormController;
|
import com.megatim.fdxconvert.forms.FileToValidateEditFormController;
|
import com.megatim.fdxconvert.model.AlphaNumeriqueField;
|
import com.megatim.fdxconvert.model.Configuration;
|
import com.megatim.fdxconvert.model.TypeFichierJson;
|
import com.megatim.fdxconvert.pojo.FileToValidate;
|
import com.megatim.fdxconvert.model.Validateur;
|
import com.megatim.fdxconvert.service.ConfigurationService;
|
import com.megatim.fdxconvert.util.ImportData;
|
import com.megatim.fdxconvert.pojo.FileToValidateDescription;
|
import com.megatim.fdxconvert.util.TypeFichierJsonConverter;
|
import com.megatim.fdxconvert.util.Utilities;
|
import java.io.File;
|
import java.io.FileNotFoundException;
|
import java.io.IOException;
|
import java.net.URL;
|
import java.nio.file.Paths;
|
import java.time.LocalDateTime;
|
import java.time.format.DateTimeFormatter;
|
import java.util.HashSet;
|
import java.util.Optional;
|
import java.util.Random;
|
import java.util.ResourceBundle;
|
import java.util.Set;
|
import javafx.concurrent.Task;
|
import javafx.event.ActionEvent;
|
import javafx.scene.Node;
|
import javafx.scene.layout.Pane;
|
import javafx.stage.Stage;
|
import org.apache.commons.io.IOUtils;
|
|
/**
|
*
|
* @author STEPHANIE
|
*/
|
public class FileToValidateEditDialogController extends AbstractEditDialogController<FileToValidate> {
|
|
org.apache.log4j.Logger logger = org.apache.log4j.Logger.getLogger(FileToValidateEditDialogController.class);
|
|
private FileToValidateEditFormController fileToValidateEditFormController;
|
private MetaAlphaNumeriqueFieldEditDialogController metaAlphaNumeriqueFieldEditDialogController;
|
|
@Override
|
public String getTitle() {
|
|
getEditButton().setText("Valider");
|
return "Conversion manuelle des fichiers";
|
|
}
|
|
@Override
|
public Pane getContentFormPane() throws IOException {
|
return ViewLoaderUtil.getPaneFromFxmlFile(fileToValidateEditFormController.getClass().getResource("FileToValidateEditForm.fxml"), fileToValidateEditFormController);
|
}
|
|
@Override
|
public Object getContentFormController() {
|
return fileToValidateEditFormController;
|
}
|
|
@Override
|
public void initialize(URL url, ResourceBundle rb) {
|
fileToValidateEditFormController = new FileToValidateEditFormController();
|
metaAlphaNumeriqueFieldEditDialogController = new MetaAlphaNumeriqueFieldEditDialogController();
|
|
metaAlphaNumeriqueFieldEditDialogController.setAlphaNumeriqueFieldEditFormController(new MetaAlphaNumeriqueFieldEditFormController());
|
|
super.initialize(url, rb);
|
|
}
|
|
@Override
|
protected void afterBindCurrentObjectWithFormField(FileToValidate bindObject, Object formController, TypeOperation typeOperation) {
|
FileToValidateEditFormController controller = (FileToValidateEditFormController) formController;
|
controller.getMetaAlphaNumeriqueFieldAbstractTable().setController(metaAlphaNumeriqueFieldEditDialogController);
|
}
|
|
@Override
|
protected void afterBindFormFieldWithCurrentObject(FileToValidate bindObject, Object formController, TypeOperation typeOperation) {
|
|
if (formController instanceof FileToValidateEditFormController) {
|
FileToValidateEditFormController controller = (FileToValidateEditFormController) formController;
|
controller.getMetaAlphaNumeriqueFieldAbstractTable().setController(metaAlphaNumeriqueFieldEditDialogController);
|
|
switch (typeOperation) {
|
|
case ADD:
|
controller.getTypeFichierAbstractSelectItem().selectedElementProperty().addListener((observable, oldValue, newValue) -> {
|
|
if (newValue != null) {
|
metaAlphaNumeriqueFieldEditDialogController.getAlphaNumeriqueFieldEditFormController().setTypeFichier(newValue);
|
|
if (controller.getDataTypeComboBox().getSelectionModel().getSelectedItem() != null && controller.getDataTypeComboBox().getSelectionModel().getSelectedItem().equals(DataType.JSON)) {
|
controller.getSaisieAlphaNumeriqueFieldChecBox().setDisable(true);
|
}
|
controller.getSaisieAlphaNumeriqueFieldChecBox().setDisable(false);
|
}
|
});
|
fileToValidateEditFormController.getSaisieAlphaNumeriqueFieldChecBox().selectedProperty().addListener(listener -> {
|
|
if (fileToValidateEditFormController.getSaisieAlphaNumeriqueFieldChecBox().isSelected()) {
|
fileToValidateEditFormController.getMetaAlphaNumeriqueFieldAbstractTable().setDisable(false);
|
}
|
});
|
fileToValidateEditFormController.getStrictValidationCheckbox().selectedProperty().addListener(l -> {
|
if (fileToValidateEditFormController.getStrictValidationCheckbox().isSelected()) {
|
fileToValidateEditFormController.getMetaAlphaNumeriqueFieldAbstractTable().setDisable(true);
|
}
|
});
|
break;
|
default:
|
controller.getSaisieAlphaNumeriqueFieldChecBox().setSelected(true);
|
controller.getSaisieAlphaNumeriqueFieldChecBox().setDisable(true);
|
break;
|
}
|
}
|
}
|
|
@Override
|
public void afterSave(ActionEvent event) {
|
Configuration config = ConfigurationService.getInstance().getCurrentConfig();
|
|
if (getCurrentObject().getDataType().equals(DataType.JSON)) {
|
validateJsonFile(config, event);
|
} else {
|
Optional<Validateur> validateur = ValidateurDAO.findByCodeTypeFichier(getCurrentObject().getTypeFichier().getCode());
|
|
if (!validateur.isPresent()) {
|
Node source = (Node) event.getSource();
|
Stage parentStage = (Stage) source.getScene().getWindow();
|
NotificationDialog notificationDialog = new NotificationDialog("Validation impossible. Le type fichier " + getCurrentObject().getTypeFichier().getCode() + " n'a pas de validateur enregistré!",
|
NotificationType.ERROR,
|
parentStage);
|
notificationDialog.showNotification();
|
}
|
validateTexteFile(config, validateur.get(), event);
|
}
|
|
}
|
|
private void validateTexteFile(Configuration config, Validateur validateur, ActionEvent event) {
|
Task<Void> task = new Task<Void>() {
|
|
@Override
|
protected Void call() throws Exception {
|
|
if (validateur.isConvertDataBeforeValidation()) {
|
|
//On converti le fichier à valider en fichier
|
generateAndParseTxtFile(getCurrentObject(), config, validateur);
|
}
|
return null;
|
}
|
};
|
|
task.setOnRunning(e -> LoadinIndicatorDialogUtil.getLoadingIndicatorDialog().show());
|
task.setOnFailed(e -> {
|
LoadinIndicatorDialogUtil.getLoadingIndicatorDialog().hide();
|
Throwable th = task.getException();
|
|
if ((th instanceof ConfigException) || (th instanceof ValidatorException)) {
|
|
Node source = (Node) event.getSource();
|
Stage parentStage = (Stage) source.getScene().getWindow();
|
NotificationDialog notificationDialog = new NotificationDialog(th.getMessage(), NotificationType.WARNING, parentStage);
|
logger.warn(th.getMessage());
|
notificationDialog.showNotification();
|
|
} else {
|
logger.error(task.getException());
|
AlertMessageUtil.showAlertException(task.getException(), "Une exception s'est produite pendant l'importation des données", "Erreur");
|
}
|
});
|
task.setOnSucceeded(e -> {
|
LoadinIndicatorDialogUtil.getLoadingIndicatorDialog().hide();
|
validateGeneratedFile(config, validateur, event);
|
});
|
new Thread(task).start();
|
}
|
|
private void validateGeneratedFile(Configuration config, Validateur validateur, ActionEvent event) {
|
Task<Boolean> task = new Task<Boolean>() {
|
|
@Override
|
protected Boolean call() throws Exception {
|
return validate(config, validateur);
|
}
|
};
|
task.setOnRunning(e -> LoadinIndicatorDialogUtil.getLoadingIndicatorDialog().show());
|
task.setOnSucceeded(e -> {
|
LoadinIndicatorDialogUtil.getLoadingIndicatorDialog().hide();
|
Node source = (Node) event.getSource();
|
Stage parentStage = (Stage) source.getScene().getWindow();
|
|
boolean valid = task.getValue();
|
String message;
|
NotificationDialog notificationDialog;
|
String errorFileName = getCurrentObject().getTxtFilePath() != null
|
? new File(getCurrentObject().getTxtFilePath()).getName()
|
: new File(getCurrentObject().getFilePath()).getName();
|
|
if (!valid) {
|
message = "Echec de la validation. Le fichier contient des erreurs, veuillez consulter le répertoire " + config.getErrorDir() + ", puis et ouvrir le fichier d'erreur "
|
+ errorFileName + ".err pour en savoir plus";
|
notificationDialog = new NotificationDialog(message, NotificationType.ERROR, parentStage);
|
|
} else {
|
message = "Validation réussie. Fichier correcte";
|
notificationDialog = new NotificationDialog(message, NotificationType.SUCCESS, parentStage);
|
}
|
logger.error(message);
|
notificationDialog.showNotification();
|
|
});
|
|
task.setOnFailed(e -> {
|
LoadinIndicatorDialogUtil.getLoadingIndicatorDialog().hide();
|
Throwable th = task.getException();
|
|
if (th instanceof ConfigException || th instanceof ValidatorException) {
|
Node source = (Node) event.getSource();
|
Stage parentStage = (Stage) source.getScene().getWindow();
|
NotificationDialog notificationDialog = new NotificationDialog(th.getMessage(), NotificationType.WARNING, parentStage);
|
logger.warn(th.getMessage());
|
notificationDialog.showNotification();
|
|
} else {
|
logger.error(th);
|
AlertMessageUtil.showAlertException(th, "Une exception s'est produite pendant la validation du fichier", "Erreur");
|
}
|
});
|
|
new Thread(task).start();
|
|
}
|
|
/**
|
* Méthode qui appelle la méthode de validation
|
*
|
* @param val :
|
* @param config
|
* @return
|
* @throws Exception
|
*/
|
private boolean validate(Configuration config, Validateur validateur) throws Exception {
|
|
if (config == null) {
|
throw new ConfigException("Validation impossible, les répertoires ne sont pas configurés. Bien vouloir les configurer avant avant d'effectuer cette action");
|
}
|
File originalFile = new File(getCurrentObject().getFilePath());
|
File file = validateur.isConvertDataBeforeValidation() ? new File(getCurrentObject().getTxtFilePath()) : originalFile; //Fichier à valider
|
|
if (!file.exists()) {
|
throw new FileNotFoundException("Le fichier " + file.getAbsolutePath() + " est introuvable");
|
}
|
byte[] targetArray = IOUtils.toByteArray(FileToValidateEditDialogController.class.getClassLoader().getResourceAsStream("predicatelogic-engine.xml"));
|
ConfigStreamValidator configValidator = new ConfigStreamValidator(targetArray, validateur.getContent(), config.getErrorDir(), config.getOutputDir(), file, originalFile);
|
Validator validator = new Validator();
|
return validator.validate(configValidator, Boolean.TRUE, Boolean.TRUE, Utilities.getNbThreads());
|
}
|
|
/**
|
* Méthode qui génère et parse fichier txt à partir d'un fichier de données
|
* csv, txt, ou excel
|
*
|
* @param val : objet contenant
|
* @param config : objet contenant l'ensemeble des repertoires nécessaire à
|
* l'extraction des données
|
* @return : renvoie le chemin vers le fichier crée
|
* @throws Exception
|
*/
|
private void generateAndParseTxtFile(FileToValidate fileToValidate, Configuration config, Validateur validateur) throws Exception {
|
if (config == null) {
|
throw new ConfigException("Validation impossible, veuillez configurer les repertoires avant d'effectuer cette action");
|
}
|
String fileName = fileToValidate.getTypeFichier().getCode() + LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss")) + generateTierce() + ".txt";
|
File outputFile = new File(config.getDatasDir(), fileName);
|
|
if (!outputFile.exists()) {
|
|
//Creation du fichier
|
outputFile.createNewFile();
|
}
|
getCurrentObject().setTxtFilePath(outputFile.getAbsolutePath());
|
Set<AlphaNumeriqueField> alphaNumeriqueToBeTruncated = new HashSet<>();
|
|
fileToValidate.getMetaAlphaNumeriqueFields().forEach(m -> {
|
alphaNumeriqueToBeTruncated.add(m.getAlphaNumeriqueField());
|
});
|
|
switch (fileToValidate.getDataType()) {
|
case TXT:
|
FileToValidateDescription raw = new FileToValidateDescription(new File(fileToValidate.getFilePath()), fileToValidate.getDelimiteurLigne().getCode(), fileToValidate.getDelimiteurColonne().getCode());
|
|
if (fileToValidate.isStrictValidation()) {
|
ImportData.parseFileByFieldLength(raw, validateur, outputFile, fileToValidate.isHeaderPresent());
|
|
} else {
|
ImportData.parseFileCharacterByCharacter(raw, validateur, outputFile, fileToValidate.isHeaderPresent(), alphaNumeriqueToBeTruncated);
|
}
|
break;
|
case CSV:
|
raw = new FileToValidateDescription(new File(fileToValidate.getFilePath()), fileToValidate.getDelimiteurLigne().getCode(), fileToValidate.getDelimiteurColonne().getCode());
|
ImportData.parseCsvFile(raw, validateur, outputFile, fileToValidate.isHeaderPresent(), alphaNumeriqueToBeTruncated);
|
break;
|
|
case XLS:
|
ImportData.parseXlsFile(fileToValidate.getFilePath(), fileToValidate.isHeaderPresent(), outputFile, validateur, alphaNumeriqueToBeTruncated);
|
break;
|
case XLSX:
|
ImportData.parseXlsxFile(fileToValidate.getFilePath(), fileToValidate.isHeaderPresent(), outputFile, validateur, alphaNumeriqueToBeTruncated);
|
break;
|
default:
|
break;
|
}
|
}
|
|
private String generateTierce() {
|
|
// Instance of random class
|
Random rand = new Random();
|
int upperbound = 60;
|
int random = rand.nextInt(upperbound);
|
|
return String.format("%02d", random);
|
|
}
|
|
private boolean validateJson(FileToValidate fileToValidate, Configuration config) throws IOException {
|
|
if (config == null) {
|
throw new ConfigException("Validation impossible, les répertoires ne sont pas configurés. Bien vouloir les configurer avant avant d'effectuer cette action");
|
}
|
TypeFichierJson typefichierJson = TypeFichierJsonDAO.getByTypeFichier(fileToValidate.getTypeFichier().getCode());
|
|
if (typefichierJson == null) {
|
throw new ValidatorException("Validation impossible. Le type fichier " + fileToValidate.getTypeFichier().getCode() + " n'a pas de structure JSON enregistré");
|
}
|
Validator validator = new Validator();
|
ConfigJsonValidator configJson = new ConfigJsonValidator(
|
fileToValidate.getErrorFilePath(),
|
config.getOutputDir(),
|
new File(fileToValidate.getFilePath()),
|
new TypeFichierJsonConverter(typefichierJson).convert()
|
);
|
|
return validator.validate(configJson, System.getProperty("user.dir") + "\\src\\main\\java", true, true, Utilities.getNbThreads());
|
}
|
|
private void validateJsonFile(Configuration config, ActionEvent event) {
|
getCurrentObject().setErrorFilePath(Paths.get(config.getErrorDir(),
|
getCurrentObject().getTypeFichier().getCode() + LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss"))
|
+ generateTierce() + "_JSON.txt").toString());
|
|
Task<Boolean> task = new Task<Boolean>() {
|
|
@Override
|
protected Boolean call() throws Exception {
|
|
return validateJson(getCurrentObject(), config);
|
|
}
|
|
};
|
|
task.setOnRunning(e -> LoadinIndicatorDialogUtil.getLoadingIndicatorDialog().show());
|
|
task.setOnSucceeded(e -> {
|
|
LoadinIndicatorDialogUtil.getLoadingIndicatorDialog().hide();
|
Node source = (Node) event.getSource();
|
Stage parentStage = (Stage) source.getScene().getWindow();
|
|
boolean valid = task.getValue();
|
|
String message;
|
NotificationDialog notificationDialog;
|
|
if (!valid) {
|
|
message = "Echec de la validation. Le fichier contient des erreurs, veuillez consulter le répertoire " + config.getErrorDir() + ", puis ouvrir le fichier d'erreur "
|
+ new File(getCurrentObject().getErrorFilePath()).getName() + ".err pour en savoir plus";
|
|
notificationDialog = new NotificationDialog(message, NotificationType.ERROR, parentStage);
|
|
} else {
|
|
message = "Validation réussie. Fichier correcte";
|
|
notificationDialog = new NotificationDialog(message, NotificationType.SUCCESS, parentStage);
|
}
|
|
logger.error(message);
|
|
notificationDialog.showNotification();
|
|
});
|
|
task.setOnFailed(e -> {
|
|
LoadinIndicatorDialogUtil.getLoadingIndicatorDialog().hide();
|
|
Throwable th = task.getException();
|
|
if (th instanceof ConfigException || th instanceof ValidatorException) {
|
|
Node source = (Node) event.getSource();
|
|
Stage parentStage = (Stage) source.getScene().getWindow();
|
|
NotificationDialog notificationDialog = new NotificationDialog(th.getMessage(), NotificationType.WARNING, parentStage);
|
|
logger.warn(th.getMessage());
|
|
notificationDialog.showNotification();
|
|
} else {
|
|
logger.error(th);
|
|
AlertMessageUtil.showAlertException(th, "Une exception s'est produite pendant la validation du fichier", "Erreur");
|
|
}
|
|
});
|
|
new Thread(task).start();
|
|
}
|
}
|
