move to local repo

Kenmegne

2025-12-10 e34275be46c7c50daa5f5229a4c19c4e0ffa83ff

move to local repo

 generatetxt/pom.xml

New file
@@ -0,0 +1,92 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.megatim</groupId>
    <artifactId>generatetxt</artifactId>
    <version>1.0</version>
    <packaging>jar</packaging>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <exec.mainClass>com.megatim.generatetxt.App</exec.mainClass>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.apache.tika</groupId>
            <artifactId>tika-parser-text-module</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.validation</groupId>
            <artifactId>validation-api</artifactId>
            <version>2.0.0.Final</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate.validator</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>6.0.13.Final</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.3.0.Final</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>com.megatimfx.common</groupId>
            <artifactId>megatimfx-common</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>org.dhatim</groupId>
            <artifactId>fastexcel-reader</artifactId>
            <version>0.15.7</version>
        </dependency>
        <dependency>
            <groupId>com.megatim.typefichier.validator</groupId>
            <artifactId>typefichier-validator</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.11.0</version>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>   
            
            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass>com.megatim.generatetxt.App</mainClass>
                        </manifest>
                    </archive>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id> <!-- this is used for inheritance merges -->
                        <phase>package</phase> <!-- bind to the packaging phase -->
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
                     
        </plugins>
    </build>
</project>

 generatetxt/src/main/java/com/megatim/generatetxt/App.java

New file
@@ -0,0 +1,26 @@
/*
 * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
 * Click nbfs://nbhost/SystemFileSystem/Templates/Project/Maven2/JavaApp/src/main/java/${packagePath}/${mainClassName}.java to edit this template
 */
package com.megatim.generatetxt;

import com.megatim.generatetxt.generate.ParseData;
import java.io.File;
import com.megatim.generatetxt.pojo.FileToValidateDescription;
import java.util.HashSet;

/**
 *
 * @author ASUS
 */
public class App {

    public static void main(String[] args) throws Exception {
        File dataFile = new File("C:\\Users\\ASUS\\Documents\\minfopra\\E20.M102025.csv");
        String validatorPath = "C:\\Users\\ASUS\\Downloads\\REF000027-20251112-171437\\validateurs\\000026\\FPR\\Fdx-ValidatorFPRE20-20251104-094833.xml";
        String outputDir = "C:\\Users\\ASUS\\Documents\\ERROR";
        FileToValidateDescription fileDesc = new FileToValidateDescription(dataFile, "\n", ";", "FPRE20", validatorPath, outputDir);
        File file = new ParseData().validateCsvFile(fileDesc, true, new HashSet<>(), 2);
        System.out.println("--------- file = " + file.getAbsolutePath());
    }
}

 generatetxt/src/main/java/com/megatim/generatetxt/constraints/FileToValidateDelimiterConstraint.java

New file
@@ -0,0 +1,30 @@
/*
 * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
 * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Interface.java to edit this template
 */
package com.megatim.generatetxt.constraints;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import javax.validation.Constraint;
import javax.validation.Payload;

/**
 *
 * @author ASUS
 */
@Documented
@Constraint(validatedBy = FileToValidateDelimiterValidator.class)
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface FileToValidateDelimiterConstraint {
    
     String message() default "Les délimiteurs de ligne et de colonne sont obligatoires";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};
}

 generatetxt/src/main/java/com/megatim/generatetxt/constraints/FileToValidateDelimiterValidator.java

New file
@@ -0,0 +1,30 @@
/*
 * 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.constraints;

import com.megatim.generatetxt.enums.DataType;
import com.megatim.generatetxt.pojo.FileToValidate;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;

/**
 *
 * @author ASUS
 */
public class FileToValidateDelimiterValidator  implements ConstraintValidator<FileToValidateDelimiterConstraint, FileToValidate> {
    
    @Override
    public boolean isValid(FileToValidate t, ConstraintValidatorContext cvc) {

        if (t.getDataType() != null
                && (t.getDataType().equals(DataType.CSV) || t.getDataType().equals(DataType.TXT))) {

            return t.getDelimiteurColonne()!= null && t.getDelimiteurLigne()!= null ;

        }

        return true;
    }
}

 generatetxt/src/main/java/com/megatim/generatetxt/enums/DataType.java

New file
@@ -0,0 +1,38 @@
/*
 * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
 * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Enum.java to edit this template
 */
package com.megatim.generatetxt.enums;

import java.util.stream.Stream;

/**
 *
 * @author STEPHANIE
 */
public enum DataType {
    
    CSV("CSV"), XLSX("Excel-XLSX"), XLS("Excel-XLS"), TXT("Texte(TXT)"),JSON("JSON");

    private final String  dataType;

    private DataType(String dataType) {
        this.dataType = dataType;
    }

     public static DataType of(String dataType) {
        return Stream.of(DataType.values())
          .filter(p -> p.getDataType().equals(dataType))
          .findFirst()
          .orElseThrow(IllegalArgumentException::new);
    }
     
    public String getDataType() {
        return dataType;
    }
            
    @Override
    public String toString() {
        return dataType;
    }
}

 generatetxt/src/main/java/com/megatim/generatetxt/generate/ParseData.java

New file
@@ -0,0 +1,572 @@
/*
 * 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.generate;

import com.megatim.generatetxt.model.AlphaNumeriqueField;
import com.megatim.generatetxt.model.TruncatedElement;
import com.megatim.generatetxt.pojo.Constantes;
import com.megatim.generatetxt.pojo.FileToValidateDescription;
import com.megatim.generatetxt.pojo.ResultFileParsing;
import com.megatim.generatetxt.utilities.ParserUtils;
import static com.megatim.generatetxt.utilities.Utilities.getCharset;
import com.megatim.typefichier.validator.Validator;
import com.megatim.typefichier.validator.model.ConfigStreamValidator;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
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.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Random;
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.CSVRecord;
import org.apache.commons.io.IOUtils;

/**
 *
 * @author ASUS
 */
public class ParseData {

    public File validateCsvFile(FileToValidateDescription fileDescription, boolean headerPresent, Set<AlphaNumeriqueField> alphaNumeriqueToBeTruncated, int nbreThreads) throws Exception {
        File fileToValidate = parseCsvFile(fileDescription, headerPresent, alphaNumeriqueToBeTruncated);

        byte[] targetArray = IOUtils.toByteArray(ParseData.class.getClassLoader().getResourceAsStream("predicatelogic-engine.xml"));
        ConfigStreamValidator configValidator = new ConfigStreamValidator(
                targetArray,
                IOUtils.toByteArray(new FileInputStream(fileDescription.getValidatorPath())),
                fileDescription.getOutputDir(),
                fileToValidate
        );

        if (new Validator().validate(configValidator, Boolean.FALSE, Boolean.FALSE, nbreThreads)) {
            return fileToValidate;
        }
        throw new Exception("Echec Validation\nFichier en entrée : " + fileDescription.getFile().getAbsolutePath() + "\nFichier en TXT sortie : " + fileToValidate.getAbsolutePath()
                + "\nFichier des erreurs : " + fileToValidate.getName() + Validator.ERROR_EXTENSION);
    }

    /**
     *
     * @param fileDescription objet contenant les informations d'extraction de
     * données
     * @param headerPresent : renseigne si le fichier a une ligne d'entête
     * @param alphaNumeriqueToBeTruncated : liste des champs à tronquer
     * @throws Exception
     */
    private File parseCsvFile(FileToValidateDescription fileDescription, boolean headerPresent, Set<AlphaNumeriqueField> alphaNumeriqueToBeTruncated) throws Exception {
        AtomicInteger numeroLigne = new AtomicInteger(0);
        AtomicBoolean columnTruncated = new AtomicBoolean();

        if (fileDescription != null) {
            String fileName = fileDescription.getCodeTypeFichier() + LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss")) + generateTierce() + ".txt";
            File outputFile = new File(fileDescription.getOutputDir(), fileName);
            Map<Integer, Map> mapParams = ParserUtils.getValidateurElements(fileDescription.getValidatorPath());
            Charset charset = getCharset(fileDescription.getFile());

            CSVFormat csvFormat = CSVFormat.DEFAULT.builder()
                    .setSkipHeaderRecord(headerPresent)
                    .setIgnoreSurroundingSpaces(true)
                    .setTrim(true)
                    .setDelimiter(fileDescription.getColumnDelimiter())
                    .build();

            AtomicBoolean withHeader = new AtomicBoolean(headerPresent);
            Path pathOfTruncatedElts = createTruncatedEltsPath(fileDescription.getCodeTypeFichier(), fileDescription.getOutputDir(), fileDescription.getFile());

            try ( FileInputStream fis = new FileInputStream(fileDescription.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)) {

                    Iterable<CSVRecord> records = csvFormat.parse(reader);

                    for (CSVRecord record : records) {

                        String[] columnsTableLine = new String[record.size()];

                        AtomicInteger i = new AtomicInteger();

                        if (!withHeader.get()) {

                            record.forEach(column -> {

                                columnsTableLine[i.get()] = column != null ? column.replaceAll(" {2,}", " ").replaceAll("\r", "").replaceAll("\n", "").replaceAll("\t", "") : "";

                                i.set(i.get() + 1);

                            });

                            //Nettoyage d'une colonne de chaque ligne
                            ResultFileParsing resultFileParsing = buildFinalColumnsTableLine(outputFile, columnsTableLine, mapParams, alphaNumeriqueToBeTruncated, numeroLigne.incrementAndGet(), truncateWriter, fileDescription.getCodeTypeFichier());
                            String[] finalColumnsTableLine = resultFileParsing.getFinalColumnsTableLine();
                            columnTruncated.set(resultFileParsing.isColumnTruncated());

                            String[] encodedStrings = ParserUtils.encodeStrings(finalColumnsTableLine, charset);
                            ParserUtils.writeToFile(encodedStrings, bufferWriter);

                        } else {

                            withHeader.set(false);

                        }

                    }

                } catch (Exception e) {
                    Logger.getLogger(ParseData.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(fileDescription.getCodeTypeFichier(), fileDescription.getOutputDir(), fileDescription.getFile());

                    //Copie du fichier dont les colonnes ont été tronqués vers le répertoire archivage 
                    if (fileDescription.getFile().exists()) {
                        Files.copy(fileDescription.getFile().toPath(), originalFilePathInArchiveFolder);
                    }

                } else {//Sinon supprimer le fichier des éléments tronqués, car il est vide
                    Files.deleteIfExists(pathOfTruncatedElts);
                }
            }
            return outputFile;
        }
        return null;
    }

    /**
     * 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(String codeTypeFichier, String arhivageDirectory, File originalFile) throws IOException {
        final String today = LocalDate.now().toString();

        Path originalFilesDir = Paths.get(arhivageDirectory, today, codeTypeFichier, "fichiers");

        if (!Files.exists(originalFilesDir, LinkOption.NOFOLLOW_LINKS)) {
            Files.createDirectories(originalFilesDir);
        }

        Path originalFilePath = Paths.get(arhivageDirectory, today, codeTypeFichier, "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, codeTypeFichier, "fichiers",
                        fileNameWithoutExtension + "(" + nbFiles + ")" + getFileExtension(originalFile));
            }
        }

        return originalFilePath;
    }

    /**
     * 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, String codeTypeFichier) 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 {
                columnsTableLine[j] = initialColumnsTableLine[j];
            }
        }

        //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)) {

                    if (columnTableLine.length() >= taille) {
                        finalColumnsTableLine[index] = columnTableLine;
                    } else {

                        finalColumnsTableLine[index] = nomarlizeDecimal(columnTableLine, map);
                    }

                    //Traitement d'une donnée de type DATE
                } else if (typeDonnee.equalsIgnoreCase(Constantes.LIBELLE_DATE)) {

                    if (columnTableLine.length() >= taille) {
                        finalColumnsTableLine[index] = columnTableLine;
                    } else {

                        finalColumnsTableLine[index] = columnTableLine + generateUnknown(taille - columnTableLine.length(), " ");
                    }

                    //Traitement d'une donnée de type NUMERIQUE
                } else if (typeDonnee.equalsIgnoreCase(Constantes.LIBELLE_NUMERIQUE)) {
                    finalColumnsTableLine[index] = nomarlizeNumber(columnTableLine, taille);

                } else if (typeDonnee.equalsIgnoreCase(Constantes.LIBELLE_ALPHANUMERIQUE)) {//Traitement d'une donnée de type ALPHANUMERIQUE

                    if (columnTableLine.length() < taille) {

                        finalColumnsTableLine[index] = columnTableLine + generateUnknown(taille - columnTableLine.length(), " ");

                    } 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(codeTypeFichier,
                                        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 nomarlizeNumber(String value, int taille) {
        String newValue = value
                .trim()
                .replaceAll("\\s+", "")
                .replaceAll("\\u00A0", "")
                .replaceAll("\t", "")
                .replaceAll("\r", "")
                .replaceAll("\n", "");

        if (newValue.matches("[-+]?\\d+(\\.\\d+)?[eE][-+]?\\d+") || newValue.matches("^\\d{1,3},\\d+E[+-]?\\d+$")) {
            newValue = new BigDecimal(newValue.replace(',', '.')).toPlainString();//Remplacer la virgule par le point

        } else if (!newValue.matches("\\d+")) {
            return generateUnknown(taille - newValue.length(), " ") + newValue;
        }
        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 nomarlizeDecimal(String value, Map<String, String> map) {
        String newValue = value.trim();

        //taille de la partie décimale
        int taillePartieDecimale = Integer.parseInt(map.get(Constantes.LIBELLE_TAILLE_PARTIE_DECIMALE));

        //Taille totale du nombre décimal
        int taille = Integer.parseInt(map.get(Constantes.LIBELLE_TAILLE));

        //taille de la partie entière. On enlève un, car c'est la taille du séparateur
        int taillePartieEntiere = taille - taillePartieDecimale - 1;

        String separator = map.get(Constantes.LIBELLE_SEPARATEUR_DECIMAL);
        String[] parts;
        String escapedSeparator;

        if (separator.equals(".")) {
            escapedSeparator = "\\.";
        } else {
            escapedSeparator = separator;
        }

        String result = "";

        if (value.isEmpty()) {
            result = generateUnknown(taillePartieEntiere, "?") + separator + generateUnknown(taillePartieDecimale, "?");
        } else {
            parts = newValue.split(escapedSeparator);

            //Si le nombre a une partie décimale
            if (newValue.contains(separator)) {

                //si le nombre a une partie entière et une partie décimale
                switch (parts.length) {
                    case 2:
                        //Si la partie entière n'est pas vide
                        if (!parts[0].isEmpty()) {

                            result = generateUnknown(taillePartieEntiere - parts[0].length(), "0") + parts[0];
                        } else {

                            //Si partie entière vide, remplacer le vide par les séparateurs
                            result = generateUnknown(taillePartieEntiere, "?");
                        }
                        result += separator;

                        //Si la partie décimale n'est pas vide
                        if (!parts[1].isEmpty()) {

                            result += parts[1] + generateUnknown(taillePartieDecimale - parts[1].length(), "0");
                        } else {

                            //Si partie décimale vide, remplacer le vide par le point d'interrogation
                            result += generateUnknown(taillePartieDecimale, "?");
                        }
                        break;
                    case 1:
                        //Si c'est la partie entière qui est manquante
                        if (newValue.matches(escapedSeparator + ".+")) {

                            result += generateUnknown(taillePartieEntiere, "?") + separator + parts[0]
                                    + generateUnknown(taillePartieDecimale - parts[0].length(), "0");

                            //Si c'est la partie décimale qui est manquante
                        } else if (newValue.matches(".+" + escapedSeparator)) {

                            result += generateUnknown(taillePartieEntiere - parts[0].length(), "0") + parts[0] + separator
                                    + generateUnknown(taillePartieDecimale, "?");
                        }
                        break;
                    default:
                        result += generateUnknown(taillePartieEntiere, "?") + separator
                                + generateUnknown(taillePartieDecimale, "?");
                        break;
                }
            } else {

                //Si le nombre n'est pas décimale, ajouter une partie décimale en complétant avec des zéros
                result = generateUnknown(taillePartieEntiere - newValue.length(), "0") + newValue + separator
                        + generateUnknown(taillePartieDecimale, "0");
            }
        }
        return result;

    }

    /**
     * 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 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 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);
        }
    }

    /**
     * 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(String codeTypeFichier, String arhivageDirectory, File outputFile) throws IOException {
        final String today = LocalDate.now().toString();

        Path logDir = Paths.get(arhivageDirectory, today, codeTypeFichier, "logs");

        if (!Files.exists(logDir, LinkOption.NOFOLLOW_LINKS)) {
            Files.createDirectories(logDir);
        }

        Path pathOfTruncatedElts = Paths.get(arhivageDirectory, today, codeTypeFichier, "logs", fileNameWithoutExtension(outputFile) + "_truncated_elements.txt");

        return pathOfTruncatedElts;

    }

    /**
     * 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();
        }
    }

    private String generateTierce() {

        // Instance of random class
        Random rand = new Random();
        int upperbound = 60;
        int random = rand.nextInt(upperbound);

        return String.format("%02d", random);

    }
}

 generatetxt/src/main/java/com/megatim/generatetxt/jaxb/Assertion.java

New file
@@ -0,0 +1,63 @@
/*
 * 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.jaxb;

import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;

/**
 *
 * @author ASUS
 */
//@XmlRootElement(name = "assertion")
public class Assertion {

    private String assertName;

    private String errorCode;

    private boolean activate;

    private List<ParamValue> paramValues = new ArrayList<>();

    @XmlAttribute(name = "assert-name")
    public String getAssertName() {
        return assertName;
    }

    public void setAssertName(String assertName) {
        this.assertName = assertName;
    }

    @XmlAttribute(name = "error-code")
    public String getErrorCode() {
        return errorCode;
    }

    public void setErrorCode(String errorCode) {
        this.errorCode = errorCode;
    }

    @XmlAttribute
    public boolean isActivate() {
        return activate;
    }

    public void setActivate(boolean activate) {
        this.activate = activate;
    }

    @XmlElement(name = "param-value")
    public List<ParamValue> getParamValues() {
        return paramValues;
    }

    public void setParamValues(List<ParamValue> paramValues) {
        this.paramValues = paramValues;
    }

}

 generatetxt/src/main/java/com/megatim/generatetxt/jaxb/Entity.java

New file
@@ -0,0 +1,62 @@
/*
 * 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.jaxb;

import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;

/**
 *
 * @author ASUS
 */
public class Entity {

    private String name;

    private String errorReportField;

    private boolean activate;

    private List<Validation> validations = new ArrayList<>();

    @XmlAttribute
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @XmlAttribute(name = "error-report-field")
    public String getErrorReportField() {
        return errorReportField;
    }

    public void setErrorReportField(String errorReportField) {
        this.errorReportField = errorReportField;
    }

    @XmlAttribute
    public boolean isActivate() {
        return activate;
    }

    public void setActivate(boolean activate) {
        this.activate = activate;
    }

    @XmlElement(name = "validation")
    public List<Validation> getValidations() {
        return validations;
    }

    public void setValidations(List<Validation> validations) {
        this.validations = validations;
    }

}

 generatetxt/src/main/java/com/megatim/generatetxt/jaxb/EntityList.java

New file
@@ -0,0 +1,29 @@
/*
 * 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.jaxb;

import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlElement;

/**
 *
 * @author ASUS
 */
//@XmlRootElement(name = "entities")
public class EntityList {

    @XmlElement(name = "entity")
    private List<Entity> entityList = new ArrayList<>();

    public List<Entity> getEntities() {
        return entityList;
    }

    public void setEntities(List<Entity> entities) {
        this.entityList = entities;
    }

}

 generatetxt/src/main/java/com/megatim/generatetxt/jaxb/ParamValue.java

New file
@@ -0,0 +1,49 @@
/*
 * 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.jaxb;

import javax.xml.bind.annotation.XmlAttribute;

/**
 *
 * @author ASUS
 */
//@XmlRootElement(name = "param-value")
public class ParamValue {

    private String name;

    private String value;

    private String field;

    @XmlAttribute
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @XmlAttribute
    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @XmlAttribute
    public String getField() {
        return field;
    }

    public void setField(String field) {
        this.field = field;
    }

}

 generatetxt/src/main/java/com/megatim/generatetxt/jaxb/PredicateConfig.java

New file
@@ -0,0 +1,62 @@
/*
 * 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.jaxb;

import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;

/**
 *
 * @author ASUS
 */
@XmlRootElement(name = "predicate-config")
public class PredicateConfig {

    private String xmlnsXsi;

    private String xsiSchemaLocation;

    private String xmlns;

    private EntityList entityList;

    @XmlAttribute(name = "xmlns:xsi")
    public String getXmlnsXsi() {
        return xmlnsXsi;
    }

    public void setXmlnsXsi(String xmlnsXsi) {
        this.xmlnsXsi = xmlnsXsi;
    }

    @XmlAttribute(name = "xsi:schemaLocation")
    public String getXsiSchemaLocation() {
        return xsiSchemaLocation;
    }

    public void setXsiSchemaLocation(String xsiSchemaLocation) {
        this.xsiSchemaLocation = xsiSchemaLocation;
    }

    @XmlAttribute(name = "xmlns")
    public String getXmlns() {
        return xmlns;
    }

    public void setXmlns(String xmlns) {
        this.xmlns = xmlns;
    }

    @XmlElement(name = "entities")
    public EntityList getEntityList() {
        return entityList;
    }

    public void setEntityList(EntityList entityList) {
        this.entityList = entityList;
    }

}

 generatetxt/src/main/java/com/megatim/generatetxt/jaxb/Validation.java

New file
@@ -0,0 +1,50 @@
/*
 * 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.jaxb;

import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;

/**
 *
 * @author ASUS
 */
//@XmlRootElement(name = "validation")
public class Validation {

    private String fieldName;

    private boolean activate;

    private Assertion assertion;

    @XmlAttribute(name = "field-name")
    public String getFieldName() {
        return fieldName;
    }

    public void setFieldName(String fieldName) {
        this.fieldName = fieldName;
    }

    @XmlAttribute
    public boolean isActivate() {
        return activate;
    }

    public void setActivate(boolean activate) {
        this.activate = activate;
    }

    @XmlElement
    public Assertion getAssertion() {
        return assertion;
    }

    public void setAssertion(Assertion assertion) {
        this.assertion = assertion;
    }

}

 generatetxt/src/main/java/com/megatim/generatetxt/model/AlphaNumeriqueField.java

New file
@@ -0,0 +1,103 @@
/*
 * 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.model;

import java.io.Serializable;
import java.time.LocalDateTime;
import java.util.Objects;
import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.persistence.UniqueConstraint;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import org.hibernate.annotations.CreationTimestamp;
import org.hibernate.annotations.UpdateTimestamp;

/**
 *
 * @author ASUS
 */
@Entity
@Getter
@Setter
@NoArgsConstructor
@Table(uniqueConstraints = {
    @UniqueConstraint(name = "UniquecodeColonneAndCodeTypeFichier", columnNames = {"codeColonne", "codeTypeFichier"})})
public class AlphaNumeriqueField implements Serializable {

    @GeneratedValue
    @Id
    private Long id;

//    @ManyToOne(fetch = FetchType.LAZY)
//    @JoinColumn(name = "codeTypeFichier")
//    private Validateur validateur;

    private String codeColonne;
    
    private String codeTypeFichier;

    private int taille;

    private int index;

    private String typeDonnee;

    @CreationTimestamp
    private LocalDateTime dateCreation;

    @UpdateTimestamp
    private LocalDateTime dateMiseAJour;

    @OneToMany(mappedBy = "alphaNumeriqueField")
    private Set<MetaAlphaNumeriqueField> metaAlphaNumeriqueFields;

    public AlphaNumeriqueField(String type, String codeColonne, int taille, int index) {
//        this.validateur = validateur;
        this.codeColonne = codeColonne;
        this.taille = taille;
        this.index = index;
        this.typeDonnee = type;
    }

    @Override
    public int hashCode() {
        int hash = 7;
//        hash = 31 * hash + Objects.hashCode(this.validateur.getCodeTypeFichier());
        hash = 31 * hash + Objects.hashCode(this.codeColonne);
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final AlphaNumeriqueField other = (AlphaNumeriqueField) obj;
        if (!Objects.equals(this.codeTypeFichier, other.codeTypeFichier)) {
            return false;
        }
        return Objects.equals(this.codeColonne, other.codeColonne);
    }

    @Override
    public String toString() {
        return codeTypeFichier + " - " + codeColonne;
    }
}

 generatetxt/src/main/java/com/megatim/generatetxt/model/MetaAlphaNumeriqueField.java

New file
@@ -0,0 +1,67 @@
/*
 * 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.model;

import com.megatim.generatetxt.pojo.FileToValidate;
import com.megatimfx.common.schedules.Tache;
import java.io.Serializable;
import java.time.LocalDateTime;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Transient;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import org.hibernate.annotations.CreationTimestamp;
import org.hibernate.annotations.UpdateTimestamp;

/**
 *
 * @author ASUS
 */
@Entity
@Getter
@Setter
@NoArgsConstructor
public class MetaAlphaNumeriqueField implements Serializable {

    @Id
    @GeneratedValue
    private Long id;

    @ManyToOne
    @JoinColumn(name = "alphaNumeriqueField_id")
    private AlphaNumeriqueField alphaNumeriqueField;

    @Transient
    @ManyToOne
    private FileToValidate fileToValidate;

    @ManyToOne
    @JoinColumn(name = "tache_id")
    private Tache tache;

//    @ManyToOne
//    @JoinColumn(name = "configuration_conversion_id")
//    private ConversionModel configurationConversion;
    
    @CreationTimestamp
    private LocalDateTime dateCreation;
    
    @UpdateTimestamp
    private LocalDateTime dateMiseAJour;

    public MetaAlphaNumeriqueField(AlphaNumeriqueField field) {
        this.alphaNumeriqueField = field;
    }
    
    @Override
    public String toString() {
        return alphaNumeriqueField.getCodeColonne();
    }
}

 generatetxt/src/main/java/com/megatim/generatetxt/model/TruncatedElement.java

New file
@@ -0,0 +1,84 @@
/*
 * 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.model;

import java.io.Serializable;
import java.time.LocalDate;
import java.time.LocalDateTime;
import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Transient;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import org.hibernate.annotations.CreationTimestamp;
import org.hibernate.annotations.UpdateTimestamp;

/**
 *
 * @author ASUS
 */
@Getter
@Setter
@NoArgsConstructor
public class TruncatedElement implements Serializable {

    @Id
    @GeneratedValue
    private Long id;

    private String codeTypeFichier;

    private String codeColonne;

    @Column(length = 1000)
    private String initialData;

    @Column(length = 1000)
    private String finalData;
    
    private int tailleAttendue;
    
    private int tailleTrouvee;
    
    private String fileName;

    private int lineNumber;

    private LocalDateTime dateAction;

    private LocalDate localDateAction;

    @Transient
    private String displayDate;

    @CreationTimestamp
    private LocalDateTime dateCreation;

    @UpdateTimestamp
    private LocalDateTime dateMiseAJour;

    public TruncatedElement(String codeTypeFichier, String codeColonne, String initialData, String finalData, String fileName,
            LocalDateTime dateAction,int ligne,int tailleA,int tailleT) {

        this.codeTypeFichier = codeTypeFichier;
        this.codeColonne = codeColonne;
        this.initialData = initialData;
        this.finalData = finalData;
        this.fileName = fileName;
        this.dateAction = dateAction;
        this.lineNumber = ligne;
        this.tailleAttendue = tailleA;
        this.tailleTrouvee = tailleT;

    }

    @Override
    public String toString() {
        return "TruncatedElement{" + "codeTypeFichier=" + codeTypeFichier + ", codeColonne=" + codeColonne + ", initialData=" + initialData + ", finalData=" + finalData + ", fileName=" + fileName + '}';
    }

}

 generatetxt/src/main/java/com/megatim/generatetxt/model/TypeFichier.java

New file
@@ -0,0 +1,90 @@
/*
 * 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.model;

import com.megatimfx.common.validationgroups.ViewFormValidationGroup;
import java.io.Serializable;
import java.time.LocalDateTime;
import java.util.Objects;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.validation.constraints.NotEmpty;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
import lombok.Getter;
import lombok.Setter;
import org.hibernate.annotations.CreationTimestamp;
import org.hibernate.annotations.UpdateTimestamp;

/**
 *
 * @author STEPHANIE
 */
@Entity
@Getter
@Setter
@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class TypeFichier implements Serializable {

    @Id
    @NotEmpty(message = "Le code du type de fichier est obligatoire", groups = {ViewFormValidationGroup.class})
    private String code;

    @NotEmpty(message = "Le libellé du type de fichier est obligatoire", groups = {ViewFormValidationGroup.class})
    @XmlTransient
    private String libelle;

    @NotEmpty(message = "Le code du participant est obligatoire", groups = {ViewFormValidationGroup.class})
    @XmlTransient
    private String codeParticipant;

    @CreationTimestamp
    @XmlTransient
    private LocalDateTime dateCreation;

    @UpdateTimestamp
    @XmlTransient
    private LocalDateTime dateMiseAJour;

    @Override
    public String toString() {
        return this.getCode();
    }

    @Override
    public boolean equals(Object obj) {

        if (this == obj) {
            return true;
        }

        if (obj == null) {
            return false;
        }
        if (!(obj instanceof TypeFichier)) {
            return false;
        }
        final TypeFichier other = (TypeFichier) obj;

        if (this.getCode() != null && !this.getCode().equals(other.getCode())) {
            return false;
        }
        return true;
    }

    @Override
    public int hashCode() {
        int hash = 5;
        hash = 73 * hash + Objects.hashCode(this.code);
        hash = 73 * hash + Objects.hashCode(this.libelle);
        return hash;
    }

}

 generatetxt/src/main/java/com/megatim/generatetxt/pojo/Constantes.java

New file
@@ -0,0 +1,29 @@
/*
 * 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.pojo;

/**
 *
 * @author ASUS
 */
public class Constantes {

    public final static String LIBELLE_TAILLE = "taille";
    public final static String LIBELLE_SEPARATEUR_DATE = "separateurDate";
    public final static String LIBELLE_INDEX = "index";
    public final static String LIBELLE_TYPE_DONNEE = "typeDonnee";
    public final static String LIBELLE_TAILLE_PARTIE_DECIMALE = "taillePartieDecimale";
    public final static String LIBELLE_SEPARATEUR_DECIMAL = "separateurDecimal";
    public final static String LIBELLE_LIGNE = "ligne";
    public final static String LIBELLE_FORMAT_DATE = "formatDate";
    public final static String LIBELLE_DECIMAL = "DECIMAL";
    public final static String LIBELLE_DATE = "DATE";
    public final static String LIBELLE_NUMERIQUE = "NUMERIQUE";
    public final static String LIBELLE_ALPHANUMERIQUE = "ALPHANUMERIQUE";

    public static final String FIELD_NAME = "field-name";
    public static final String EQUAL_PARAM = "equalParam";
    public static final String ERROR_CODE = "error-code";
}

 generatetxt/src/main/java/com/megatim/generatetxt/pojo/Delimiteur.java

New file
@@ -0,0 +1,28 @@
/*
 * 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.pojo;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.Setter;

/**
 *
 * @author STEPHANIE
 */
@Getter
@Setter
@AllArgsConstructor
public class Delimiteur {

    private String code;

    private String libelle;

    @Override
    public String toString() {
        return this.getLibelle();
    }
}

 generatetxt/src/main/java/com/megatim/generatetxt/pojo/FileToValidate.java

New file
@@ -0,0 +1,49 @@
package com.megatim.generatetxt.pojo;

import com.megatim.generatetxt.constraints.FileToValidateDelimiterConstraint;
import com.megatim.generatetxt.enums.DataType;
import com.megatim.generatetxt.model.TypeFichier;
import com.megatimfx.common.validationgroups.ViewFormValidationGroup;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
import lombok.Getter;
import lombok.Setter;

/**
 *
 * @author STEPHANIE
 */
@Getter
@Setter
@FileToValidateDelimiterConstraint(groups = {ViewFormValidationGroup.class})
public class FileToValidate {

    @NotEmpty(message = "Le fichier à valider est obligatoire", groups = {ViewFormValidationGroup.class})
    //@Pattern(regexp="(.+\\.csv)|(.+\\.xlsx)|(.+\\.xls|.+\\.txt)", flags = Flag.CASE_INSENSITIVE, message="Bien vouloir sélectionner un fichier csv, xlsx, xls ou txt" , groups = {ViewFormValidationGroup.class})
    private String filePath;

    @NotNull(message = "Le typefichier est obligatoire", groups = {ViewFormValidationGroup.class})
    private TypeFichier typeFichier;

    private Delimiteur delimiteurLigne;

    private Delimiteur delimiteurColonne;

    private String txtFilePath;
    
    private String errorFilePath;

    @NotNull(message = "Le format du fichier de données est obligatoire", groups = {ViewFormValidationGroup.class})
    private DataType dataType;

    private boolean headerPresent;
    
    private boolean strictValidation;
    
    
    @Override
    public String toString() {
        return filePath+":"+typeFichier.getCode()+":"+dataType.getDataType();
    }

}

 generatetxt/src/main/java/com/megatim/generatetxt/pojo/FileToValidateDescription.java

New file
@@ -0,0 +1,39 @@
/*
 * 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.pojo;

import java.io.File;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

/**
 * Classe qui sert à importer les données des fichiers à transférer
 *
 * @author STEPHANIE
 */
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
public class FileToValidateDescription {

    //Fichier duquel seront extraits les données
    private File file;

    //délimiteur de ligne
    private String rowDelimiter;

    //délimiteur de colonne
    private String columnDelimiter;

    private String codeTypeFichier;

    private String validatorPath;

    private String outputDir;

}

 generatetxt/src/main/java/com/megatim/generatetxt/pojo/ParseResult.java

New file
@@ -0,0 +1,22 @@
/*
 * 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.pojo;

import java.io.File;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.Setter;

/**
 *
 * @author ASUS
 */
@Getter
@Setter
@AllArgsConstructor
public class ParseResult {
    private boolean result;
    private File txtFile;
}

 generatetxt/src/main/java/com/megatim/generatetxt/pojo/ResultFileParsing.java

New file
@@ -0,0 +1,21 @@
/*
 * 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.pojo;

import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

/**
 *
 * @author ASUS
 */
@Getter
@Setter
@NoArgsConstructor
public class ResultFileParsing {
    private String[] finalColumnsTableLine;
    private boolean columnTruncated;
}

 generatetxt/src/main/java/com/megatim/generatetxt/utilities/ParserUtils.java

New file
@@ -0,0 +1,358 @@
/*
 * 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());

        }
    }
}

 generatetxt/src/main/java/com/megatim/generatetxt/utilities/Utilities.java

New file
@@ -0,0 +1,46 @@
/*
 * 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.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.Charset;
import java.nio.charset.UnsupportedCharsetException;
import org.apache.tika.parser.txt.CharsetDetector;
import org.apache.tika.parser.txt.CharsetMatch;

/**
 *
 * @author ASUS
 */
public class Utilities {
     /**
     * Méthode qui récupère l'encodage d'un fichier
     *
     * @param file : Fichier dont on veut connaître l'encodage
     * @return : retourne l'encodage le plus probable
     * @throws FileNotFoundException
     * @throws IOException
     */
    public static Charset getCharset(File file) throws FileNotFoundException, IOException {
        try ( InputStream stream = new FileInputStream(file);  InputStream input = new BufferedInputStream(stream);) {
            CharsetDetector charsetDetector = new CharsetDetector();

            charsetDetector.setText(input);

            CharsetMatch charsetMatch = charsetDetector.detect();
            String charsetName = charsetMatch != null ? charsetMatch.getName() : "";

            return Charset.forName(charsetName);

        } catch (UnsupportedCharsetException ex) {
            return Charset.forName("Cp850");
        }
    }
}

 generatetxt/src/main/resources/predicatelogic-engine.xml

New file
@@ -0,0 +1,1665 @@
<?xml version="1.0" encoding="UTF-8"?>
<predicate-engine xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                  xsi:schemaLocation="http://www.leadware.net/predicatelogic-engine ../xsd/predicatelogic-engine.xsd"
                  xmlns="http://www.leadware.net/predicatelogic-engine">

    <!-- Définition des connecteurs -->
    <connectors>

        <connector name="not">
            <invoke method="not"
                                class-name="com.megatim.typefichier.validator.predicat.ConnectorImpl" />
            <param name="notParam" type="Boolean" />
        </connector>

        <connector name="or">
            <invoke method="or"
                                class-name="com.megatim.typefichier.validator.predicat.ConnectorImpl" />
            <param name="orParam1" type="Boolean" />
            <param name="orParam2" type="Boolean" />
        </connector>

        <connector name="and">
            <invoke method="and"
                                class-name="com.megatim.typefichier.validator.predicat.ConnectorImpl" />
            <param name="andParam1" type="Boolean" />
            <param name="andParam2" type="Boolean" />
        </connector>

        <connector name="implies">
            <invoke method="implies"
                                class-name="com.megatim.typefichier.validator.predicat.ConnectorImpl" />
            <param name="impliesAssumption" type="Boolean" />
            <param name="impliesConclusion" type="Boolean" />
        </connector>

    </connectors>

    <!-- Définition des prédicats -->
    <predicates>
        <predicate name="inValues">
            <invoke  method="inValues" class-name="com.megatim.typefichier.validator.predicat.PredicateImpl"/>
            <param name="values" type="String"/>
            <param name="fieldToCheck" type="String" />
        </predicate>
             
        <predicate name="ifTypeFichier">
            <invoke  method="ifTypeFichier" class-name="com.megatim.typefichier.validator.predicat.PredicateImpl"/>
            <param name="index" type="int"/>
            <param name="taille" type="int"/>
            <param name="typeDonnee" type="String"/>
            <param name="ligne" type="String"/>
            <param name="formatDate" type="String"/>
            <param name="separateurDate" type="String"/>
            <param name="taillePartieDecimale" type="String"/>
            <param name="separateurDecimal" type="String"/>
        </predicate>
        
        <predicate name="ifTypeFichierFileName">
            <invoke  method="ifTypeFichierFileName" class-name="com.megatim.typefichier.validator.predicat.PredicateImpl"/>
            <param name="prefixe" type="String"/>
            <param name="type_suffixe" type="String"/>
            <param name="formatDate" type="String"/>
            <param name="fileName" type="String"/>
        </predicate>
        
        <predicate name="ifVersion">
            <invoke  method="ifVersion" class-name="com.megatim.typefichier.validator.predicat.PredicateImpl"/>
            <param name="version" type="String"/>
            <param name="nbPosition" type="int"/>
            <param name="typeCharactere" type="String"/>
        </predicate>
        
        <predicate name="ifCodeRemise">
            <invoke  method="ifCodeRemise" class-name="com.megatim.typefichier.validator.predicat.PredicateImpl"/>
            <param name="codeRemise" type="String"/>
            <param name="nbPosition" type="int"/>
            <param name="typeCharactere" type="String"/>
        </predicate>
        
        <predicate name="ifNumber">
            <invoke  method="ifNumber" class-name="com.megatim.typefichier.validator.predicat.PredicateImpl"/>
            <param name="nbFiles" type="String"/>
        </predicate>
        
        <predicate name="ifDate">
            <invoke  method="ifDate" class-name="com.megatim.typefichier.validator.predicat.PredicateImpl"/>
            <param name="date" type="String"/>
            <param name="format" type="String"/>
            <param-value name="index" type="int" />
            <param-value name="fileName" type="String" />
        </predicate>
        
        <predicate name="ifCodeAgentOrCodeParticipant">
            <invoke  method="ifCodeAgentOrCodeParticipant" class-name="com.megatim.typefichier.validator.predicat.PredicateImpl"/>
            <param name="code" type="String"/>
            <param name="fileName" type="String"/>
            <param-value name="index" type="int" />
            <param-value name="taille" type="int" />
        </predicate>
        
        <predicate name="ifTierce">
            <invoke  method="ifTierce" class-name="com.megatim.typefichier.validator.predicat.PredicateImpl"/>
            <param name="fileName" type="String"/>
            <param-value name="index" type="int" />
            <param-value name="minValue" type="int" />
            <param-value name="maxValue" type="int" />
        </predicate>
        
        <predicate name="ifDecimal">
            <invoke  method="ifDecimal" class-name="com.megatim.typefichier.validator.predicat.PredicateImpl"/>
            <param-value name="index" type="int" />
            <param-value name="taille" type="int" />
            <param-value name="typeDonnee" type="String" />
            <param name="ligne" type="String"/>
            <param-value name="decimalPartMaxLength" type="int" />
            <param-value name="separator" type="char"/>
        </predicate>
        
        <predicate name="equal">
            <invoke method="equal" class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="equalParam" type="Object" />
            <param name="equalValue" type="Object" />
        </predicate>
         
        <predicate name="empty">
            <invoke method="empty"
                    class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="emptyParam" type="Object" />
            
        </predicate>
        <predicate name="equal">
            <invoke method="equal"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="equalParam" type="Object" />
            <param name="equalValue" type="Object" />
        </predicate>

        <predicate name="empty">
            <invoke method="empty"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="emptyParam" type="Object" />
        </predicate>

        <predicate name="notEmptyValues">
            <invoke method="notEmptyValues"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="notEmptyValuesParam" type="Collection" />
        </predicate>

        <predicate name="emptyValues">
            <invoke method="emptyValues"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="emptyValuesParam" type="Collection" />
        </predicate>

        <predicate name="propertyReferenceEntry">
            <invoke method="propertyReferenceEntry"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="entityName" type="String" />
            <param name="propertyName" type="String" />
            <param name="propertyValue" type="Object" />
        </predicate>

        <predicate name="propertiesReferenceEntry">
            <invoke method="propertiesReferenceEntry"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="entityName" type="String" />
            <param name="properties" type="Map" />
        </predicate>

        <predicate name="dateFormat">
            <invoke method="dateFormat"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="dateValue" type="String" />
            <param name="dateFormat" type="String" />
        </predicate>

        <predicate name="csvEntry">
            <invoke method="csvEntry"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="entryValue" type="String" />
            <param name="csvValues" type="String" />
        </predicate>

        <predicate name="singleton">
            <invoke method="singleton"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="collectionEntries" type="java.util.Collection" />
            <param name="entryTypeName" type="String" />
            <param name="entryPropertyName" type="String" />
        </predicate>

        <predicate name="singletonValue">
            <invoke method="singletonValue"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="collectionEntries" type="java.util.Collection" />
            <param name="entryTypeName" type="String" />
            <param name="entryPropertyName" type="String" />
            <param name="singletonValue" type="Object" />
        </predicate>

        <predicate name="singleOccurenceValue">
            <invoke method="singleOccurenceValue"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="collectionEntries" type="java.util.Collection" />
            <param name="entryTypeName" type="String" />
            <param name="entryPropertyName" type="String" />
            <param name="occurenceValue" type="Object" />
        </predicate>

        <predicate name="singleOccurenceValueByGroup">
            <invoke method="singleOccurenceValueByGroup"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="collectionEntries" type="java.util.Collection" />
            <param name="entryTypeName" type="String" />
            <param name="entryPropertyName" type="String" />
            <param name="csvGroupPropertiesNames" type="String" />
            <param name="occurenceEntity" type="Object" />
            <param name="occurenceValue" type="Object" />
        </predicate>

        <predicate name="sum">
            <invoke method="sum"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="collectionEntries" type="java.util.Collection" />
            <param name="entryTypeName" type="String" />
            <param name="entryPropertyName" type="String" />
            <param name="sumValue" type="java.math.BigDecimal" />
        </predicate>

        <predicate name="size">
            <invoke method="size"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="collectionEntries" type="java.util.Collection" />
            <param name="entryTypeName" type="String" />
            <param name="sizeValue" type="java.math.BigDecimal" />
        </predicate>

        <predicate name="greater">
            <invoke method="greater"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="greaterValue" type="Object" />
            <param name="greaterLimit" type="Object" />
        </predicate>

        <predicate name="lower">
            <invoke method="lower"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="lowerValue" type="Object" />
            <param name="lowerLimit" type="Object" />
        </predicate>

        <predicate name="ribChecker">
            <invoke method="ribChecker"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="ribValue" type="String" />
        </predicate>

        <predicate name="systacCountryExist">
            <invoke  method="systacCountryExist" 
                                 class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="countryCode" type="String"/>
        </predicate>

        <predicate name="posteComptableExist">
            <invoke  method="posteComptableExist" 
                                 class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="codePosteComptable" type="String"/>
        </predicate>
                
        <predicate name="systacBankExist">
            <invoke  method="systacBankExist" 
                                 class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="bankCode" type="String"/>
        </predicate>

        <predicate name="systacAgencyExist">
            <invoke  method="systacAgencyExist" 
                                 class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="agencyCode" type="String"/>
        </predicate>
                
        <predicate name="systacAgencyBankExist">
            <invoke  method="systacAgencyBankExist" 
                                 class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="bankCode" type="String"/>
            <param name="agencyCode" type="String"/>
        </predicate>		
		
        <predicate name="sygmaParticipantCodeBicExist">
            <invoke  method="sygmaParticipantCodeBicExist" 
                                 class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="codeBicParticipant" type="String"/>
        </predicate>

        <predicate name="sygmaParticipantCodeBicWithPropertiesExist">
            <invoke  method="sygmaParticipantCodeBicWithPropertiesExist" 
                                 class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="codeBicParticipant" type="String"/>
            <param name="properties" type="Map"/>
        </predicate>

        <predicate name="sygmaParticipantNumeroCompteExist">
            <invoke  method="sygmaParticipantNumeroCompteExist" class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="numeroCompteParticipant" type="String"/>
        </predicate>

        <predicate name="sygmaParticipantNumeroCompteWithPropertiesExist">
            <invoke  method="sygmaParticipantNumeroCompteWithPropertiesExist" class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="numeroCompteParticipant" type="String"/>
            <param name="properties" type="Map"/>
        </predicate>

        <predicate name="ifReplayQueueInDataExist">
            <invoke  method="ifReplayQueueInDataExist" class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="numeroReference" type="String"/>
            <param name="numeroBordereauVirement" type="String"/>
            <param name="codeEnregistrement"   type="String"/>
            <param name="codeValeur"  type="String"/>
        </predicate>
				 
        <predicate name="ifMt103001Message">
            <invoke  method="ifMt103001Message" class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="codeTypeMessage" type="String"/>
            <param name="codeTypeTransaction" type="String"/>
        </predicate>
                 
        <predicate name="ifAdmin">
            <invoke  method="ifAdmin" class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="loginValue" type="String"/>
            <param name="passwordValue" type="String"/>
        </predicate>
                 
        <predicate name="ifReplayQueueInDataExistSystac">
            <invoke  method="ifReplayQueueInDataExistSystac" class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="numeroOperation" type="String"/>
            <param name="datePresentation" type="String"/>
            <param name="codeValeur"  type="String"/>
            <param name="codeEnregistrement"   type="String"/>                       
        </predicate>
                 
        <predicate name="ifReplayQueueInDataExistSygma">
            <invoke  method="ifReplayQueueInDataExistSygma" class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="codeReference" type="String"/>
            <param name="datePresentation" type="String"/>                                              
        </predicate>    
                 
        <predicate name="ifBankIsNotInBlackList">
            <invoke  method="ifBankIsNotInBlackList" class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="codeBanqueDestinataire" type="String"/>
        </predicate>
                 
        <predicate name="ifParticipantIsNotInBlackList">
            <invoke  method="ifParticipantIsNotInBlackList" class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="codeBicDestinataireSygma" type="String"/>
        </predicate>      
                 
        <predicate name="checkReconciliationItemExistence">
            <invoke  method="checkReconciliationItemExistence" class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="numeroReference" type="String"/>
            <param name="montant" type="String"/>
            <param name="datePresentation"   type="String"/>                        
        </predicate>  
                
        <predicate name="queueInAnnulationCalendarValidation">
            <invoke method="queueInAnnulationCalendarValidation"
                            class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="entityName" type="String" />
            <param name="properties" type="Map" />
        </predicate>
        <predicate name="uniqueCodeSystem">
            <invoke  method="uniqueCodeSystem" class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="codeSystem" type="String"/>
        </predicate>
        <predicate name="justOneOperation">
            <invoke  method="justOneOperation" class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="numeroBonVirement" type="String"/>
        </predicate>
    </predicates>

    <!-- Définition des assertions : ce sont des compositions de connecteurs, 
    predicats et d'autres assertions -->
    <asserts>
        <assert name="inValues">
            <param name="values" type="String"/>
            <param-value name="fieldToCheck" type="String" />
            <formula predicate-ref="inValues">
                <param name="values" assert-param-ref="values" />
                <param name="fieldToCheck" assert-param-ref="fieldToCheck" />
            </formula>
        </assert>
            
        <assert name="ifTypeFichier">
            <param name="index" type="int"/>
            <param name="taille" type="int"/>
            <param name="typeDonnee" type="String"/>
            <param name="ligne" type="String"/>
            <param name="formatDate" type="String"/>
            <param name="separateurDate" type="String"/>
            <param-value name="taillePartieDecimale" type="int" />
            <param-value name="separateurDecimal" type="char"/>
            <formula predicate-ref="ifTypeFichier">
                <param name="index" assert-param-ref="index" />
                <param name="taille" assert-param-ref="taille" />
                <param name="typeDonnee" assert-param-ref="typeDonnee" />
                <param name="ligne" assert-param-ref="ligne" />
                <param name="formatDate" assert-param-ref="formatDate" />
                <param name="separateurDate" assert-param-ref="separateurDate" />
                <param name="taillePartieDecimale" assert-param-ref="taillePartieDecimale" />
                <param name="separateurDecimal" assert-param-ref="separateurDecimal" />
                    
            </formula>
        </assert>
            
        <assert name="ifTypeFichierFileName">
            <param name="prefixe" type="String"/>
            <param name="type_suffixe" type="String"/>
            <param name="formatDate" type="String"/>
            <param name="fileName" type="String"/>
            <formula predicate-ref="ifTypeFichierFileName">
                <param name="prefixe" assert-param-ref="prefixe" />
                <param name="type_suffixe" assert-param-ref="type_suffixe" />
                <param name="formatDate" assert-param-ref="formatDate" />
                <param name="fileName" assert-param-ref="fileName" />
            </formula>
        </assert>
            
        <assert name="ifVersion">
            <param name="version" type="String"/>
            <param name="nbPosition" type="int"/>
            <param name="typeCharactere" type="String"/>
            <formula predicate-ref="ifVersion">
                <param name="version" assert-param-ref="version" />
                <param name="nbPosition" assert-param-ref="nbPosition" />
                <param name="typeCharactere" assert-param-ref="typeCharactere" />
            </formula>
        </assert>
                
        <assert name="ifCodeRemise">
            <param name="codeRemise" type="String"/>
            <param name="nbPosition" type="int"/>
            <param name="typeCharactere" type="String"/>
            <formula predicate-ref="ifCodeRemise">
                <param name="codeRemise" assert-param-ref="codeRemise" />
                <param name="nbPosition" assert-param-ref="nbPosition" />
                <param name="typeCharactere" assert-param-ref="typeCharactere" />
            </formula>
        </assert>
                
        <assert name="ifNumber">
            <param name="nbFiles" type="String"/>
            <formula predicate-ref="ifNumber">
                <param name="nbFiles" assert-param-ref="nbFiles" />
            </formula>
        </assert>
                
                
        <assert name="ifDate">
            <param name="date" type="String"/>
            <param name="format" type="String"/>
            <param name="fileName" type="String"/>
            <param-value name="index" type="int" />
            <formula predicate-ref="ifDate">
                <param name="date" assert-param-ref="date" />
                <param name="format" assert-param-ref="format" />
                <param name="index" assert-param-ref="index" />
                <param name="fileName" assert-param-ref="fileName" />
            </formula>
        </assert>
                
        <assert name="ifCodeAgentOrCodeParticipant">
            <param name="code" type="String"/>
            <param name="fileName" type="String"/>
            <param-value name="index" type="int" />
            <param-value name="taille" type="int" />
            <formula predicate-ref="ifCodeAgentOrCodeParticipant">
                <param name="code" assert-param-ref="code" />
                <param name="fileName" assert-param-ref="fileName" />
                <param name="taille" assert-param-ref="taille" />
                <param name="index" assert-param-ref="index" />
            </formula>
        </assert>

         
        <assert name="ifTierce">
            <param name="fileName" type="String"/>
            <param-value name="index" type="int" />
            <param-value name="minValue" type="int" />
            <param-value name="maxValue" type="int" />
            <formula predicate-ref="ifTierce">
                <param name="fileName" assert-param-ref="fileName" />
                <param name="minValue" assert-param-ref="minValue" />
                <param name="maxValue" assert-param-ref="maxValue" />
                <param name="index" assert-param-ref="index" />
            </formula>
        </assert>
              
        <assert name="ifDecimal">
            <param-value name="index" type="int" />
            <param-value name="taille" type="int" />
            <param-value name="typeDonnee" value="String" />
            <param name="ligne" type="String"/>
            <param-value name="decimalPartMaxLength" type="int" />
            <param-value name="separator" type="char" />
            <formula predicate-ref="ifDecimal">
                <param name="index" assert-param-ref="index" />
                <param name="taille" assert-param-ref="taille" />
                <param name="typeDonnee" assert-param-ref="typeDonnee" />
                <param name="ligne" assert-param-ref="ligne"/>
                <param name="decimalPartMaxLength" assert-param-ref="decimalPartMaxLength" />
                <param name="separator" assert-param-ref="separator" />
            </formula>
        </assert>
              
        <assert name="equal">
            <param name="equalValue" type="Object" />
            <param name="equalParam" type="Object" />
            <formula predicate-ref="equal">
                <param name="equalValue" assert-param-ref="equalValue" />
                <param name="equalParam" assert-param-ref="equalParam" />
            </formula>
        </assert>

        <assert name="empty">
            <param name="emptyParam" type="Object" />
            <formula predicate-ref="empty">
                <param name="emptyParam" assert-param-ref="emptyParam" />
            </formula>
        </assert>

        <!-- Est vrai si toutes les valeurs sont non vides -->
        <assert name="notEmptyValues">
            <param name="notEmptyValuesParam" type="Object" />
            <formula predicate-ref="notEmptyValues">
                <param name="notEmptyValuesParam" assert-param-ref="notEmptyValuesParam" />
            </formula>
        </assert>

        <!-- Est vrai si toutes les valeurs sont vides -->
        <assert name="emptyValues">
            <param name="emptyValuesParam" type="Object" />
            <formula predicate-ref="emptyValues">
                <param name="emptyValuesParam" assert-param-ref="emptyValuesParam" />
            </formula>
        </assert>

        <assert name="propertyReferenceEntry">
            <param name="entityName" type="String" />
            <param name="propertyName" type="String" />
            <param name="propertyValue" type="Object" />
            <formula predicate-ref="propertyReferenceEntry">
                <param name="entityName" assert-param-ref="entityName" />
                <param name="propertyName" assert-param-ref="propertyName" />
                <param name="propertyValue" assert-param-ref="propertyValue" />
            </formula>
        </assert>

        <assert name="propertiesReferenceEntry">
            <param name="entityName" type="String" />
            <param name="properties" type="Map" />
            <formula predicate-ref="propertiesReferenceEntry">
                <param name="entityName" assert-param-ref="entityName" />
                <param name="properties" assert-param-ref="properties" />
            </formula>
        </assert>

        <assert name="dateFormat">
            <param name="dateValue" type="String" />
            <param name="dateFormat" type="String" />
            <formula predicate-ref="dateFormat">
                <param name="dateValue" assert-param-ref="dateValue" />
                <param name="dateFormat" assert-param-ref="dateFormat" />
            </formula>
        </assert>

        <assert name="csvEntry">
            <param name="entryValue" type="String" />
            <param name="csvValues" type="String" />
            <formula predicate-ref="csvEntry">
                <param name="entryValue" assert-param-ref="entryValue" />
                <param name="csvValues" assert-param-ref="csvValues" />
            </formula>
        </assert>

        <assert name="singleton">
            <param name="collectionEntries" type="java.util.Collection" />
            <param name="entryTypeName" type="String" />
            <param name="entryPropertyName" type="String" />
            <formula predicate-ref="singleton">
                <param name="collectionEntries" assert-param-ref="collectionEntries" />
                <param name="entryTypeName" assert-param-ref="entryTypeName" />
                <param name="entryPropertyName" assert-param-ref="entryPropertyName" />
            </formula>
        </assert>

        <assert name="singletonValue">
            <param name="collectionEntries" type="java.util.Collection" />
            <param name="entryTypeName" type="String" />
            <param name="entryPropertyName" type="String" />
            <param name="singletonValue" type="Object" />
            <formula predicate-ref="singletonValue">
                <param name="collectionEntries" assert-param-ref="collectionEntries" />
                <param name="entryTypeName" assert-param-ref="entryTypeName" />
                <param name="entryPropertyName" assert-param-ref="entryPropertyName" />
                <param name="singletonValue" assert-param-ref="singletonValue" />
            </formula>
        </assert>

        <assert name="singleOccurenceValue">
            <param name="collectionEntries" type="java.util.Collection" />
            <param name="entryTypeName" type="String" />
            <param name="entryPropertyName" type="String" />
            <param name="occurenceValue" type="Object" />
            <formula predicate-ref="singleOccurenceValue">
                <param name="collectionEntries" assert-param-ref="collectionEntries" />
                <param name="entryTypeName" assert-param-ref="entryTypeName" />
                <param name="entryPropertyName" assert-param-ref="entryPropertyName" />
                <param name="occurenceValue" assert-param-ref="occurenceValue" />
            </formula>
        </assert>

        <assert name="singleOccurenceValueByGroup">
            <param name="collectionEntries" type="java.util.Collection" />
            <param name="entryTypeName" type="String" />
            <param name="entryPropertyName" type="String" />
            <param name="csvGroupPropertiesNames" type="String" />
            <param name="occurenceEntity" type="Object" />
            <param name="occurenceValue" type="Object" />
            <formula predicate-ref="singleOccurenceValueByGroup">
                <param name="collectionEntries" assert-param-ref="collectionEntries" />
                <param name="entryTypeName" assert-param-ref="entryTypeName" />
                <param name="entryPropertyName" assert-param-ref="entryPropertyName" />
                <param name="csvGroupPropertiesNames" assert-param-ref="csvGroupPropertiesNames" />
                <param name="occurenceEntity" assert-param-ref="occurenceEntity" />
                <param name="occurenceValue" assert-param-ref="occurenceValue" />
            </formula>
        </assert>

        <assert name="sum">
            <param name="collectionEntries" type="java.util.Collection" />
            <param name="entryTypeName" type="String" />
            <param name="entryPropertyName" type="String" />
            <param name="sumValue" type="java.math.BigDecimal" />
            <formula predicate-ref="sum">
                <param name="collectionEntries" assert-param-ref="collectionEntries" />
                <param name="entryTypeName" assert-param-ref="entryTypeName" />
                <param name="entryPropertyName" assert-param-ref="entryPropertyName" />
                <param name="sumValue" assert-param-ref="sumValue" />
            </formula>
        </assert>

        <assert name="size">
            <param name="collectionEntries" type="java.util.Collection" />
            <param name="entryTypeName" type="String" />
            <param name="sizeValue" type="java.math.BigDecimal" />
            <formula predicate-ref="size">
                <param name="collectionEntries" assert-param-ref="collectionEntries" />
                <param name="entryTypeName" assert-param-ref="entryTypeName" />
                <param name="sizeValue" assert-param-ref="sizeValue" />
            </formula>
        </assert>

        <assert name="greater">
            <param name="greaterValue" type="Object" />
            <param name="greaterLimit" type="Object" />
            <formula predicate-ref="greater">
                <param name="greaterValue" assert-param-ref="greaterValue" />
                <param name="greaterLimit" assert-param-ref="greaterLimit" />
            </formula>
        </assert>

        <assert name="lower">
            <param name="lowerValue" type="Object" />
            <param name="lowerLimit" type="Object" />
            <formula predicate-ref="lower">
                <param name="lowerValue" assert-param-ref="lowerValue" />
                <param name="lowerLimit" assert-param-ref="lowerLimit" />
            </formula>
        </assert>

        <assert name="ribChecker">
            <param name="ribValue" type="String" />
            <formula predicate-ref="ribChecker">
                <param name="ribValue" assert-param-ref="ribValue" />
            </formula>
        </assert>

        <assert name="systacCountryExist">
            <param name="countryCode" type="String" />
            <formula predicate-ref="systacCountryExist">
                <param name="countryCode" assert-param-ref="countryCode" />
            </formula>
        </assert>
                
        <assert name="uniqueCodeSystem">
            <param name="codeSystem" type="String" />
            <formula predicate-ref="uniqueCodeSystem">
                <param name="codeSystem" assert-param-ref="codeSystem" />
            </formula>
        </assert>
                
        <assert name="justOneOperation">
            <param name="numeroBonVirement" type="String" />
            <formula predicate-ref="justOneOperation">
                <param name="numeroBonVirement" assert-param-ref="numeroBonVirement" />
            </formula>
        </assert>

        <assert name="posteComptableExist">
            <param name="codePosteComptable" type="String" />
            <formula predicate-ref="posteComptableExist">
                <param name="codePosteComptable" assert-param-ref="codePosteComptable" />
            </formula>
        </assert>
                
        <assert name="systacBankExist">
            <param name="bankCode" type="String" />
            <formula predicate-ref="systacBankExist">
                <param name="bankCode" assert-param-ref="bankCode" />
            </formula>
        </assert>

        <assert name="systacAgencyExist">
            <param name="agencyCode" type="String" />
            <formula predicate-ref="systacAgencyExist">
                <param name="agencyCode" assert-param-ref="agencyCode" />
            </formula>
        </assert>
		
        <assert name="systacAgencyBankExist">
            <param name="bankCode" type="String" />
            <param name="agencyCode" type="String" />
            <formula predicate-ref="systacAgencyBankExist">
                <param name="bankCode" assert-param-ref="bankCode" />
                <param name="agencyCode" assert-param-ref="agencyCode" />
            </formula>
        </assert>	

        <assert name="sygmaParticipantCodeBicExist">
            <param name="codeBicParticipant" type="String" />
            <formula predicate-ref="sygmaParticipantCodeBicExist">
                <param name="codeBicParticipant" assert-param-ref="codeBicParticipant" />
            </formula>
        </assert>

        <assert name="sygmaParticipantCodeBicWithPropertiesExist">
            <param name="codeBicParticipant" type="String" />
            <param name="properties" type="Map" />
            <formula predicate-ref="sygmaParticipantCodeBicWithPropertiesExist">
                <param name="codeBicParticipant" assert-param-ref="codeBicParticipant" />
                <param name="properties" assert-param-ref="properties" />
            </formula>
        </assert>

        <assert name="sygmaParticipantNumeroCompteExist">
            <param name="numeroCompteParticipant" type="String" />
            <formula predicate-ref="sygmaParticipantNumeroCompteExist">
                <param name="numeroCompteParticipant" assert-param-ref="numeroCompteParticipant" />
            </formula>
        </assert>

        <assert name="sygmaParticipantNumeroCompteWithPropertiesExist">
            <param name="numeroCompteParticipant" type="String" />
            <param name="properties" type="Map" />
            <formula predicate-ref="sygmaParticipantNumeroCompteWithPropertiesExist">
                <param name="numeroCompteParticipant" assert-param-ref="numeroCompteParticipant" />
                <param name="properties" assert-param-ref="properties" />
            </formula>
        </assert> 
        
        <assert name="ifMt103001Message">
            <param name="codeTypeMessage" type="String" />
            <param name="codeTypeTransaction" type="String" />
            <formula predicate-ref="ifMt103001Message">
                <param name="codeTypeMessage" assert-param-ref="codeTypeMessage" />
                <param name="codeTypeTransaction" assert-param-ref="codeTypeTransaction" />
            </formula>
        </assert>
                
        <assert name="ifAdmin">
            <param name="loginValue" type="String" />
            <param name="passwordValue" type="String" />
            <formula predicate-ref="ifAdmin">
                <param name="loginValue" assert-param-ref="loginValue" />
                <param name="passwordValue" assert-param-ref="passwordValue" />
            </formula>
        </assert>
		
        <assert name="ifReplayQueueInDataExist">
            <param name="numeroReference" type="String" />
            <param name="numeroBordereauVirement" type="String" />
            <param name="codeEnregistrement"  type="String" />
            <param name="codeValeur"  type="String" />
            <formula predicate-ref="ifReplayQueueInDataExist">
                <param name="numeroReference" assert-param-ref="numeroReference" />
                <param name="numeroBordereauVirement" assert-param-ref="numeroBordereauVirement" />
                <param name="codeEnregistrement"    assert-param-ref="codeEnregistrement" />
                <param name="codeValeur"  assert-param-ref="codeValeur" />
            </formula>
        </assert>
                
        <assert name="ifReplayQueueInDataExistSystac">
            <param name="numeroOperation" type="String" />
            <param name="datePresentation" type="String" />     
            <param name="codeValeur"  type="String" />  
            <param name="codeEnregistrement"  type="String" />                                 
            <formula predicate-ref="ifReplayQueueInDataExistSystac">
                <param name="numeroOperation" assert-param-ref="numeroOperation" />
                <param name="datePresentation" assert-param-ref="datePresentation" />
                <param name="codeValeur"  assert-param-ref="codeValeur" />
                <param name="codeEnregistrement"    assert-param-ref="codeEnregistrement" />                            
            </formula>
        </assert>
                
        <assert name="ifReplayQueueInDataExistSygma">
            <param name="codeReference" type="String" />
            <param name="datePresentation" type="String" />                                      
            <formula predicate-ref="ifReplayQueueInDataExistSygma">
                <param name="codeReference" assert-param-ref="codeReference" />
                <param name="datePresentation" assert-param-ref="datePresentation" />                            
            </formula>
        </assert>
                
        <assert name="ifBankIsNotInBlackList">
            <param name="codeBanqueDestinataire" type="String" />                  
            <formula predicate-ref="ifBankIsNotInBlackList">
                <param name="codeBanqueDestinataire" assert-param-ref="codeBanqueDestinataire" />                           
            </formula>
        </assert>
                
        <assert name="ifParticipantIsNotInBlackList">
            <param name="codeBicDestinataireSygma" type="String" />                  
            <formula predicate-ref="ifParticipantIsNotInBlackList">
                <param name="codeBicDestinataireSygma" assert-param-ref="codeBicDestinataireSygma" />                           
            </formula>
        </assert>        
                
        <assert name="checkReconciliationItemExistence">
            <param name="numeroReference" type="String" />
            <param name="montant" type="String" />
            <param name="datePresentation"  type="String" />
            <formula predicate-ref="checkReconciliationItemExistence">
                <param name="numeroReference" assert-param-ref="numeroReference" />
                <param name="montant" assert-param-ref="montant" />
                <param name="datePresentation"    assert-param-ref="datePresentation" />
            </formula>
        </assert>    
                
        <assert name="queueInAnnulationCalendarValidation">
            <param name="entityName" type="String" />
            <param name="properties" type="Map" />
            <formula predicate-ref="queueInAnnulationCalendarValidation">
                <param name="entityName" assert-param-ref="entityName" />
                <param name="properties" assert-param-ref="properties" />
            </formula>
        </assert>

        <assert name="notEqual">
            <param name="notEqualParam" type="Object" />
            <param name="notEqualValue" type="Object" />
            <formula connector-ref="not">
                <param name="notParam" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="notEqualParam" />
                    <param name="equalValue" assert-param-ref="notEqualValue" />
                </param>
            </formula>
        </assert>

        <assert name="notPropertyReferenceEntry">
            <param name="entityName" type="String" />
            <param name="propertyName" type="String" />
            <param name="propertyValue" type="Object" />
            <formula connector-ref="not">
                <param name="notParam" predicate-ref="propertyReferenceEntry">
                    <param name="entityName" assert-param-ref="entityName" />
                    <param name="propertyName" assert-param-ref="propertyName" />
                    <param name="propertyValue" assert-param-ref="propertyValue" />
                </param>
            </formula>
        </assert>

        <assert name="notPropertiesReferenceEntry">
            <param name="entityName" type="String" />
            <param name="properties" type="Map" />
            <formula connector-ref="not">
                <param name="notParam" predicate-ref="propertiesReferenceEntry">
                    <param name="entityName" assert-param-ref="entityName" />
                    <param name="properties" assert-param-ref="properties" />
                </param>
            </formula>
        </assert>

        <assert name="notEmpty">
            <param name="notEmptyParam" type="Object" />
            <formula connector-ref="not">
                <param name="notParam" predicate-ref="empty">
                    <param name="emptyParam" assert-param-ref="notEmptyParam" />
                </param>
            </formula>
        </assert>

        <!-- Est vrai si aumoins l'une des valeurs de la collection est non vide -->
        <assert name="lazyNotEmptyValues">
            <param name="lazyNotEmptyValuesParam" type="Collection" />
            <formula connector-ref="not">
                <param name="notParam" predicate-ref="emptyValues">
                    <param name="emptyValuesParam" assert-param-ref="lazyNotEmptyValuesParam" />
                </param>
            </formula>
        </assert>

        <!-- Est vrai si aumoins l'une des valeurs de la liste est vide -->
        <assert name="lazyEmptyValues">
            <param name="lazyEmptyValues" type="Collection" />
            <formula connector-ref="not">
                <param name="notParam" predicate-ref="notEmptyValues">
                    <param name="notEmptyValuesParam" assert-param-ref="lazyEmptyValues" />
                </param>
            </formula>
        </assert>

        <assert name="greaterOrEqual">
            <param name="greaterEqualValue" type="Object" />
            <param name="greaterEqualLimit" type="Object" />
            <formula connector-ref="or">
                <param name="orParam1" predicate-ref="greater">
                    <param name="greaterValue" assert-param-ref="greaterEqualValue" />
                    <param name="greaterLimit" assert-param-ref="greaterEqualLimit" />
                </param>
                <param name="orParam2" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="greaterEqualValue" />
                    <param name="equalValue" assert-param-ref="greaterEqualLimit" />
                </param>
            </formula>
        </assert>

        <assert name="lowerOrEqual">
            <param name="lowerEqualValue" type="Object" />
            <param name="lowerEqualLimit" type="Object" />
            <formula connector-ref="or">
                <param name="orParam1" predicate-ref="lower">
                    <param name="lowerValue" assert-param-ref="lowerEqualValue" />
                    <param name="lowerLimit" assert-param-ref="lowerEqualLimit" />
                </param>
                <param name="orParam2" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="lowerEqualValue" />
                    <param name="equalValue" assert-param-ref="lowerEqualLimit" />
                </param>
            </formula>
        </assert>

        <assert name="notCsvEntry">
            <param name="notEntryValue" type="String" />
            <param name="notCsvValues" type="String" />
            <formula connector-ref="not">
                <param name="notParam" predicate-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="notEntryValue" />
                    <param name="csvValues" assert-param-ref="notCsvValues" />
                </param>
            </formula>
        </assert>

        <assert name="equalAndNotEmpty">
            <param name="equalParam" type="Object" />
            <param name="equalValue" type="Object" />
            <param name="notEmptyParam" type="Object" />
            <formula connector-ref="and">
                <param name="andParam1" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="equalParam" />
                    <param name="equalValue" assert-param-ref="equalValue" />
                </param>
                <param name="andParam2" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParam" />
                </param>
            </formula>
        </assert>

        <assert name="equalAndEqual">
            <param name="equalParam1" type="Object" />
            <param name="equalValue1" type="Object" />
            <param name="equalParam2" type="Object" />
            <param name="equalValue2" type="Object" />
            <formula connector-ref="and">
                <param name="andParam1" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="equalParam1" />
                    <param name="equalValue" assert-param-ref="equalValue1" />
                </param>
                <param name="andParam2" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="equalParam2" />
                    <param name="equalValue" assert-param-ref="equalValue2" />
                </param>
            </formula>
        </assert>

        <assert name="csvEntryAndCsvEntry">
            <param name="entryValue1" type="Object" />
            <param name="csvValues1" type="Object" />
            <param name="entryValue2" type="Object" />
            <param name="csvValues2" type="Object" />
            <formula connector-ref="and">
                <param name="andParam1" predicate-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="entryValue1" />
                    <param name="csvValues" assert-param-ref="csvValues1" />
                </param>
                <param name="andParam2" predicate-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="entryValue2" />
                    <param name="csvValues" assert-param-ref="csvValues2" />
                </param>
            </formula>
        </assert>

        <assert name="csvEntryAndNotCsvEntry">
            <param name="entryValue" type="Object" />
            <param name="csvValues" type="Object" />
            <param name="notEntryValue" type="Object" />
            <param name="notCsvValues" type="Object" />
            <formula connector-ref="and">
                <param name="andParam1" predicate-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="entryValue" />
                    <param name="csvValues" assert-param-ref="csvValues" />
                </param>
                <param name="andParam2" assert-ref="notCsvEntry">
                    <param name="notEntryValue" assert-param-ref="notEntryValue" />
                    <param name="notCsvValues" assert-param-ref="notCsvValues" />
                </param>
            </formula>
        </assert>

        <assert name="ifEqualThenGreater">
            <param name="equalParamAssumption" type="String" />
            <param name="equalValueAssumption" type="String" />
            <param name="greaterValueConclusion" type="String" />
            <param name="greaterLimitConclusion" type="String" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="equalParamAssumption" />
                    <param name="equalValue" assert-param-ref="equalValueAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="greater">
                    <param name="greaterValue" assert-param-ref="greaterValueConclusion" />
                    <param name="greaterLimit" assert-param-ref="greaterLimitConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifEqualThenLower">
            <param name="equalParamAssumption" type="String" />
            <param name="equalValueAssumption" type="String" />
            <param name="lowerValueConclusion" type="String" />
            <param name="lowerLimitConclusion" type="String" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="equalParamAssumption" />
                    <param name="equalValue" assert-param-ref="equalValueAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="lower">
                    <param name="lowerValue" assert-param-ref="lowerValueConclusion" />
                    <param name="lowerLimit" assert-param-ref="lowerLimitConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifEqualThenEqual">
            <param name="equalParam1Assumption" type="String" />
            <param name="equalValue1Assumption" type="String" />
            <param name="equalParam2Conclusion" type="String" />
            <param name="equalValue2Conclusion" type="String" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="equalParam1Assumption" />
                    <param name="equalValue" assert-param-ref="equalValue1Assumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="equalParam2Conclusion" />
                    <param name="equalValue" assert-param-ref="equalValue2Conclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifEqualThenNotEqual">
            <param name="equalParamAssumption" type="String" />
            <param name="equalValueAssumption" type="String" />
            <param name="notEqualParamConclusion" type="String" />
            <param name="notEqualValueConclusion" type="String" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="equalParamAssumption" />
                    <param name="equalValue" assert-param-ref="equalValueAssumption" />
                </param>
                <param name="impliesConclusion" assert-ref="notEqual">
                    <param name="notEqualParam" assert-param-ref="notEqualParamConclusion" />
                    <param name="notEqualValue" assert-param-ref="notEqualValueConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifEqualThenNotCsvEntry">
            <param name="equalParamAssumption" type="String" />
            <param name="equalValueAssumption" type="String" />
            <param name="notEntryValueConclusion" type="String" />
            <param name="notCsvValuesConclusion" type="String" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="equalParamAssumption" />
                    <param name="equalValue" assert-param-ref="equalValueAssumption" />
                </param>
                <param name="impliesConclusion" assert-ref="notCsvEntry">
                    <param name="notEntryValue" assert-param-ref="notEntryValueConclusion" />
                    <param name="notCsvValues" assert-param-ref="notCsvValuesConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifEqualThenCsvEntry">
            <param name="equalParamAssumption" type="String" />
            <param name="equalValueAssumption" type="String" />
            <param name="entryValueConclusion" type="String" />
            <param name="csvValuesConclusion" type="String" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="equalParamAssumption" />
                    <param name="equalValue" assert-param-ref="equalValueAssumption" />
                </param>
                <param name="impliesConclusion" assert-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="entryValueConclusion" />
                    <param name="csvValues" assert-param-ref="csvValuesConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifCsvEntryThenCsvEntry">
            <param name="entryValueAssumption" type="String" />
            <param name="csvValuesAssumption" type="String" />
            <param name="entryValueConclusion" type="String" />
            <param name="csvValuesConclusion" type="String" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="entryValueAssumption" />
                    <param name="csvValues" assert-param-ref="csvValuesAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="entryValueConclusion" />
                    <param name="csvValues" assert-param-ref="csvValuesConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifCsvEntryThenSingleton">
            <param name="entryValueAssumption" type="String" />
            <param name="csvValuesAssumption" type="String" />
            <param name="collectionEntriesConclusion" type="java.util.Collection" />
            <param name="entryTypeNameConclusion" type="String" />
            <param name="entryPropertyNameConclusion" type="String" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="entryValueAssumption" />
                    <param name="csvValues" assert-param-ref="csvValuesAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="singleton">
                    <param name="collectionEntries" assert-param-ref="collectionEntriesConclusion" />
                    <param name="entryTypeName" assert-param-ref="entryTypeNameConclusion" />
                    <param name="entryPropertyName" assert-param-ref="entryPropertyNameConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifCsvEntryThenSingleOccurenceValueByGroup">
            <param name="entryValueAssumption" type="String" />
            <param name="csvValuesAssumption" type="String" />
            <param name="collectionEntriesConclusion" type="java.util.Collection" />
            <param name="entryTypeNameConclusion" type="String" />
            <param name="entryPropertyNameConclusion" type="String" />
            <param name="csvGroupPropertiesNamesConclusion" type="String" />
            <param name="occurenceEntityConclusion" type="Object" />
            <param name="occurenceValueConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="entryValueAssumption" />
                    <param name="csvValues" assert-param-ref="csvValuesAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="singleOccurenceValueByGroup">
                    <param name="collectionEntries" assert-param-ref="collectionEntriesConclusion" />
                    <param name="entryTypeName" assert-param-ref="entryTypeNameConclusion" />
                    <param name="entryPropertyName" assert-param-ref="entryPropertyNameConclusion" />
                    <param name="csvGroupPropertiesNames" assert-param-ref="csvGroupPropertiesNamesConclusion" />
                    <param name="occurenceEntity" assert-param-ref="occurenceEntityConclusion" />
                    <param name="occurenceValue" assert-param-ref="occurenceValueConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifCsvEntryThenEqual">
            <param name="entryValueAssumption" type="String" />
            <param name="csvValuesAssumption" type="String" />
            <param name="equalParamConclusion" type="String" />
            <param name="equalValueConclusion" type="String" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="entryValueAssumption" />
                    <param name="csvValues" assert-param-ref="csvValuesAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="equalParamConclusion" />
                    <param name="equalValue" assert-param-ref="equalValueConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifCsvEntryThenNotEqual">
            <param name="entryValueAssumption" type="String" />
            <param name="csvValuesAssumption" type="String" />
            <param name="notEqualParamConclusion" type="String" />
            <param name="notEqualValueConclusion" type="String" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="entryValueAssumption" />
                    <param name="csvValues" assert-param-ref="csvValuesAssumption" />
                </param>
                <param name="impliesConclusion" assert-ref="notEqual">
                    <param name="notEqualParam" assert-param-ref="notEqualParamConclusion" />
                    <param name="notEqualValue" assert-param-ref="notEqualValueConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifCsvEntryThenNotCsvEntry">
            <param name="entryValueAssumption" type="String" />
            <param name="csvValuesAssumption" type="String" />
            <param name="notEntryValueConclusion" type="String" />
            <param name="notCsvValuesConclusion" type="String" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="entryValueAssumption" />
                    <param name="csvValues" assert-param-ref="csvValuesAssumption" />
                </param>
                <param name="impliesConclusion" assert-ref="notCsvEntry">
                    <param name="notEntryValue" assert-param-ref="notEntryValueConclusion" />
                    <param name="notCsvValues" assert-param-ref="notCsvValuesConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifEqualThenPropertyReferenceEntry">
            <param name="equalParamAssumption" type="String" />
            <param name="equalValueAssumption" type="String" />
            <param name="entityNameConclusion" type="String" />
            <param name="propertyNameConclusion" type="String" />
            <param name="propertyValueConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="equalParamAssumption" />
                    <param name="equalValue" assert-param-ref="equalValueAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="propertyReferenceEntry">
                    <param name="entityName" assert-param-ref="entityNameConclusion" />
                    <param name="propertyName" assert-param-ref="propertyNameConclusion" />
                    <param name="propertyValue" assert-param-ref="propertyValueConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifEqualAndNotEmptyThenRibChecker">
            <param name="equalParamAssumption" type="Object" />
            <param name="equalValueAssumption" type="Object" />
            <param name="notEmptyParamAssumption" type="Object" />
            <param name="ribValueConclusion" type="String" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="equalAndNotEmpty">
                    <param name="equalParam" assert-param-ref="equalParamAssumption" />
                    <param name="equalValue" assert-param-ref="equalValueAssumption" />
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="ribChecker">
                    <param name="ribValue" assert-param-ref="ribValueConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifCsvEntryAndCsvEntryThenNotEmpty">
            <param name="entryValue1Assumption" type="Object" />
            <param name="csvValues1Assumption" type="Object" />
            <param name="entryValue2Assumption" type="Object" />
            <param name="csvValues2Assumption" type="Object" />
            <param name="notEmptyParamConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="csvEntryAndCsvEntry">
                    <param name="entryValue1" assert-param-ref="entryValue1Assumption" />
                    <param name="csvValues1" assert-param-ref="csvValues1Assumption" />
                    <param name="entryValue2" assert-param-ref="entryValue2Assumption" />
                    <param name="csvValues2" assert-param-ref="csvValues2Assumption" />
                </param>
                <param name="impliesConclusion" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifCsvEntryThenNotEmpty">
            <param name="entryValueAssumption" type="Object" />
            <param name="csvValuesAssumption" type="Object" />
            <param name="notEmptyParamConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="entryValueAssumption" />
                    <param name="csvValues" assert-param-ref="csvValuesAssumption" />
                </param>
                <param name="impliesConclusion" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamConclusion" />
                </param>
            </formula>
        </assert>


        <assert name="ifCsvEntryAndCsvEntryThenEqual">
            <param name="entryValue1Assumption" type="Object" />
            <param name="csvValues1Assumption" type="Object" />
            <param name="entryValue2Assumption" type="Object" />
            <param name="csvValues2Assumption" type="Object" />
            <param name="equalParamConclusion" type="Object" />
            <param name="equalValueConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="csvEntryAndCsvEntry">
                    <param name="entryValue1" assert-param-ref="entryValue1Assumption" />
                    <param name="csvValues1" assert-param-ref="csvValues1Assumption" />
                    <param name="entryValue2" assert-param-ref="entryValue2Assumption" />
                    <param name="csvValues2" assert-param-ref="csvValues2Assumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="equalParamConclusion" />
                    <param name="equalValue" assert-param-ref="equalValueConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifCsvEntryAndCsvEntryThenPropertyReferenceEntry">
            <param name="entryValue1Assumption" type="Object" />
            <param name="csvValues1Assumption" type="Object" />
            <param name="entryValue2Assumption" type="Object" />
            <param name="csvValues2Assumption" type="Object" />
            <param name="entityNameConclusion" type="Object" />
            <param name="propertyNameConclusion" type="Object" />
            <param name="propertyValueConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="csvEntryAndCsvEntry">
                    <param name="entryValue1" assert-param-ref="entryValue1Assumption" />
                    <param name="csvValues1" assert-param-ref="csvValues1Assumption" />
                    <param name="entryValue2" assert-param-ref="entryValue2Assumption" />
                    <param name="csvValues2" assert-param-ref="csvValues2Assumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="propertyReferenceEntry">
                    <param name="entityName" assert-param-ref="entityNameConclusion" />
                    <param name="propertyName" assert-param-ref="propertyNameConclusion" />
                    <param name="propertyValue" assert-param-ref="propertyValueConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifCsvEntryAndCsvEntryThenSygmaParticipantCodeBicExist">
            <param name="entryValue1Assumption" type="Object" />
            <param name="csvValues1Assumption" type="Object" />
            <param name="entryValue2Assumption" type="Object" />
            <param name="csvValues2Assumption" type="Object" />
            <param name="codeBicParticipantConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="csvEntryAndCsvEntry">
                    <param name="entryValue1" assert-param-ref="entryValue1Assumption" />
                    <param name="csvValues1" assert-param-ref="csvValues1Assumption" />
                    <param name="entryValue2" assert-param-ref="entryValue2Assumption" />
                    <param name="csvValues2" assert-param-ref="csvValues2Assumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="sygmaParticipantCodeBicExist">
                    <param name="codeBicParticipant" assert-param-ref="codeBicParticipantConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifCsvEntryAndCsvEntryThenSygmaParticipantNumeroCompteExist">
            <param name="entryValue1Assumption" type="Object" />
            <param name="csvValues1Assumption" type="Object" />
            <param name="entryValue2Assumption" type="Object" />
            <param name="csvValues2Assumption" type="Object" />
            <param name="numeroCompteParticipantConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="csvEntryAndCsvEntry">
                    <param name="entryValue1" assert-param-ref="entryValue1Assumption" />
                    <param name="csvValues1" assert-param-ref="csvValues1Assumption" />
                    <param name="entryValue2" assert-param-ref="entryValue2Assumption" />
                    <param name="csvValues2" assert-param-ref="csvValues2Assumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="sygmaParticipantNumeroCompteExist">
                    <param name="numeroCompteParticipant" assert-param-ref="numeroCompteParticipantConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifNotEmptyThenCsvEntry">
            <param name="notEmptyParamAssumption" type="Object" />
            <param name="entryValueConclusion" type="Object" />
            <param name="csvValuesConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="entryValueConclusion" />
                    <param name="csvValues" assert-param-ref="csvValuesConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifNotEmptyThenEqual">
            <param name="notEmptyParamAssumption" type="Object" />
            <param name="equalValueConclusion" type="Object" />
            <param name="equalParamConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="equal">
                    <param name="equalValue" assert-param-ref="equalValueConclusion" />
                    <param name="equalParam" assert-param-ref="equalParamConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifEqualThenNotEmpty">
            <param name="equalValueAssumption" type="Object" />
            <param name="equalParamAssumption" type="Object" />
            <param name="notEmptyParamConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="equal">
                    <param name="equalValue" assert-param-ref="equalValueAssumption" />
                    <param name="equalParam" assert-param-ref="equalParamAssumption" />
                </param>				
                <param name="impliesConclusion" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifNotEmptyThenNotEmpty">
            <param name="notEmptyParamAssumption" type="Object" />
            <param name="notEmptyParamConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamAssumption" />
                </param>
                <param name="impliesConclusion" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifNotCsvEntryThenNotEmpty">
            <param name="notEntryValueAssumption" type="Object" />
            <param name="notCsvValuesAssumption" type="Object" />
            <param name="notEmptyParamConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="notCsvEntry">
                    <param name="notEntryValue" assert-param-ref="notEntryValueAssumption" />
                    <param name="notCsvValues" assert-param-ref="notCsvValuesAssumption" />
                </param>
                <param name="impliesConclusion" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamConclusion" />
                </param>
            </formula>
        </assert>


        <assert name="ifNotEmptyThenPropertyReferenceEntry">
            <param name="notEmptyParamAssumption" type="Object" />
            <param name="entityNameConclusion" type="Object" />
            <param name="propertyNameConclusion" type="Object" />
            <param name="propertyValueConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="propertyReferenceEntry">
                    <param name="entityName" assert-param-ref="entityNameConclusion" />
                    <param name="propertyName" assert-param-ref="propertyNameConclusion" />
                    <param name="propertyValue" assert-param-ref="propertyValueConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifNotEmptyThenSygmaParticipantCodeBicExist">
            <param name="notEmptyParamAssumption" type="Object" />
            <param name="codeBicParticipantConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="sygmaParticipantCodeBicExist">
                    <param name="codeBicParticipant" assert-param-ref="codeBicParticipantConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifNotEmptyThenSygmaParticipantNumeroCompteExist">
            <param name="notEmptyParamAssumption" type="Object" />
            <param name="numeroCompteParticipantConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="sygmaParticipantNumeroCompteExist">
                    <param name="numeroCompteParticipant" assert-param-ref="numeroCompteParticipantConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifNotEmptyThenSygmaParticipantCodeBicWithPropertiesExist">
            <param name="notEmptyParamAssumption" type="Object" />
            <param name="codeBicParticipantConclusion" type="Object" />
            <param name="propertiesConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="sygmaParticipantCodeBicWithPropertiesExist">
                    <param name="codeBicParticipant" assert-param-ref="codeBicParticipantConclusion" />
                    <param name="properties" assert-param-ref="propertiesConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifNotEmptyThenSygmaParticipantNumeroCompteWithPropertiesExist">
            <param name="notEmptyParamAssumption" type="Object" />
            <param name="numeroCompteParticipantConclusion" type="Object" />
            <param name="propertiesConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="sygmaParticipantNumeroCompteWithPropertiesExist">
                    <param name="numeroCompteParticipant" assert-param-ref="numeroCompteParticipantConclusion" />
                    <param name="properties" assert-param-ref="propertiesConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifNotEmptyThenPropertiesReferenceEntry">
            <param name="notEmptyParamAssumption" type="Object" />
            <param name="entityNameConclusion" type="Object" />
            <param name="propertiesConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="propertiesReferenceEntry">
                    <param name="entityName" assert-param-ref="entityNameConclusion" />
                    <param name="properties" assert-param-ref="propertiesConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifCsvEntryThenLazyNotEmptyValues">
            <param name="entryValueAssumption" type="Object" />
            <param name="csvValuesAssumption" type="Object" />
            <param name="lazyNotEmptyValuesParamConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="entryValueAssumption" />
                    <param name="csvValues" assert-param-ref="csvValuesAssumption" />
                </param>
                <param name="impliesConclusion" assert-ref="lazyNotEmptyValues">
                    <param name="lazyNotEmptyValuesParam" assert-param-ref="lazyNotEmptyValuesParamConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifNotEmptyValuesThenPropertyReferenceEntry">
            <param name="notEmptyValuesParamAssumption" type="String" />
            <param name="entityNameConclusion" type="String" />
            <param name="propertyNameConclusion" type="String" />
            <param name="propertyValueConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="notEmptyValues">
                    <param name="notEmptyValuesParam" assert-param-ref="notEmptyValuesParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="propertyReferenceEntry">
                    <param name="entityName" assert-param-ref="entityNameConclusion" />
                    <param name="propertyName" assert-param-ref="propertyNameConclusion" />
                    <param name="propertyValue" assert-param-ref="propertyValueConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifNotEmptyValuesThenSygmaParticipantCodeBicExist">
            <param name="notEmptyValuesParamAssumption" type="String" />
            <param name="codeBicParticipantConclusion" type="String" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="notEmptyValues">
                    <param name="notEmptyValuesParam" assert-param-ref="notEmptyValuesParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="sygmaParticipantCodeBicExist">
                    <param name="codeBicParticipant" assert-param-ref="codeBicParticipantConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifNotEmptyValuesThenSygmaParticipantNumeroCompteExist">
            <param name="notEmptyValuesParamAssumption" type="String" />
            <param name="numeroCompteParticipantConclusion" type="String" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="notEmptyValues">
                    <param name="notEmptyValuesParam" assert-param-ref="notEmptyValuesParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="sygmaParticipantNumeroCompteExist">
                    <param name="numeroCompteParticipant" assert-param-ref="numeroCompteParticipantConclusion" />
                </param>
            </formula>
        </assert>


        <assert name="ifNotEmptyValuesThenPropertiesReferenceEntry">
            <param name="notEmptyValuesParamAssumption" type="Object" />
            <param name="entityNameConclusion" type="Object" />
            <param name="propertiesConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="notEmptyValues">
                    <param name="notEmptyValuesParam" assert-param-ref="notEmptyValuesParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="propertiesReferenceEntry">
                    <param name="entityName" assert-param-ref="entityNameConclusion" />
                    <param name="properties" assert-param-ref="propertiesConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifNotEmptyValuesThenSygmaParticipantCodeBicWithPropertiesExist">
            <param name="notEmptyValuesParamAssumption" type="Object" />
            <param name="codeBicParticipantConclusion" type="Object" />
            <param name="propertiesConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="notEmptyValues">
                    <param name="notEmptyValuesParam" assert-param-ref="notEmptyValuesParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="sygmaParticipantCodeBicWithPropertiesExist">
                    <param name="codeBicParticipant" assert-param-ref="codeBicParticipantConclusion" />
                    <param name="properties" assert-param-ref="propertiesConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifNotEmptyValuesThenSygmaParticipantNumeroCompteWithPropertiesExist">
            <param name="notEmptyValuesParamAssumption" type="Object" />
            <param name="numeroCompteParticipantConclusion" type="Object" />
            <param name="propertiesConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="notEmptyValues">
                    <param name="notEmptyValuesParam" assert-param-ref="notEmptyValuesParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="sygmaParticipantNumeroCompteWithPropertiesExist">
                    <param name="numeroCompteParticipant" assert-param-ref="numeroCompteParticipantConclusion" />
                    <param name="properties" assert-param-ref="propertiesConclusion" />
                </param>
            </formula>
        </assert>
               

    </asserts>

</predicate-engine>

 generatetxt/target/classes/com/megatim/generatetxt/App.class

Binary files differ

 generatetxt/target/classes/com/megatim/generatetxt/constraints/FileToValidateDelimiterConstraint.class

Binary files differ

 generatetxt/target/classes/com/megatim/generatetxt/constraints/FileToValidateDelimiterValidator.class

Binary files differ

 generatetxt/target/classes/com/megatim/generatetxt/enums/DataType.class

Binary files differ

 generatetxt/target/classes/com/megatim/generatetxt/generate/ParseData.class

Binary files differ

 generatetxt/target/classes/com/megatim/generatetxt/jaxb/Assertion.class

Binary files differ

 generatetxt/target/classes/com/megatim/generatetxt/jaxb/Entity.class

Binary files differ

 generatetxt/target/classes/com/megatim/generatetxt/jaxb/EntityList.class

Binary files differ

 generatetxt/target/classes/com/megatim/generatetxt/jaxb/ParamValue.class

Binary files differ

 generatetxt/target/classes/com/megatim/generatetxt/jaxb/PredicateConfig.class

Binary files differ

 generatetxt/target/classes/com/megatim/generatetxt/jaxb/Validation.class

Binary files differ

 generatetxt/target/classes/com/megatim/generatetxt/model/AlphaNumeriqueField.class

Binary files differ

 generatetxt/target/classes/com/megatim/generatetxt/model/MetaAlphaNumeriqueField.class

Binary files differ

 generatetxt/target/classes/com/megatim/generatetxt/model/TruncatedElement.class

Binary files differ

 generatetxt/target/classes/com/megatim/generatetxt/model/TypeFichier.class

Binary files differ

 generatetxt/target/classes/com/megatim/generatetxt/pojo/Constantes.class

Binary files differ

 generatetxt/target/classes/com/megatim/generatetxt/pojo/Delimiteur.class

Binary files differ

 generatetxt/target/classes/com/megatim/generatetxt/pojo/FileToValidate.class

Binary files differ

 generatetxt/target/classes/com/megatim/generatetxt/pojo/FileToValidateDescription.class

Binary files differ

 generatetxt/target/classes/com/megatim/generatetxt/pojo/ParseResult.class

Binary files differ

 generatetxt/target/classes/com/megatim/generatetxt/pojo/ResultFileParsing.class

Binary files differ

 generatetxt/target/classes/com/megatim/generatetxt/utilities/ParserUtils$1.class

Binary files differ

 generatetxt/target/classes/com/megatim/generatetxt/utilities/ParserUtils.class

Binary files differ

 generatetxt/target/classes/com/megatim/generatetxt/utilities/Utilities.class

Binary files differ

 generatetxt/target/classes/predicatelogic-engine.xml

New file
@@ -0,0 +1,1665 @@
<?xml version="1.0" encoding="UTF-8"?>
<predicate-engine xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                  xsi:schemaLocation="http://www.leadware.net/predicatelogic-engine ../xsd/predicatelogic-engine.xsd"
                  xmlns="http://www.leadware.net/predicatelogic-engine">

    <!-- Définition des connecteurs -->
    <connectors>

        <connector name="not">
            <invoke method="not"
                                class-name="com.megatim.typefichier.validator.predicat.ConnectorImpl" />
            <param name="notParam" type="Boolean" />
        </connector>

        <connector name="or">
            <invoke method="or"
                                class-name="com.megatim.typefichier.validator.predicat.ConnectorImpl" />
            <param name="orParam1" type="Boolean" />
            <param name="orParam2" type="Boolean" />
        </connector>

        <connector name="and">
            <invoke method="and"
                                class-name="com.megatim.typefichier.validator.predicat.ConnectorImpl" />
            <param name="andParam1" type="Boolean" />
            <param name="andParam2" type="Boolean" />
        </connector>

        <connector name="implies">
            <invoke method="implies"
                                class-name="com.megatim.typefichier.validator.predicat.ConnectorImpl" />
            <param name="impliesAssumption" type="Boolean" />
            <param name="impliesConclusion" type="Boolean" />
        </connector>

    </connectors>

    <!-- Définition des prédicats -->
    <predicates>
        <predicate name="inValues">
            <invoke  method="inValues" class-name="com.megatim.typefichier.validator.predicat.PredicateImpl"/>
            <param name="values" type="String"/>
            <param name="fieldToCheck" type="String" />
        </predicate>
             
        <predicate name="ifTypeFichier">
            <invoke  method="ifTypeFichier" class-name="com.megatim.typefichier.validator.predicat.PredicateImpl"/>
            <param name="index" type="int"/>
            <param name="taille" type="int"/>
            <param name="typeDonnee" type="String"/>
            <param name="ligne" type="String"/>
            <param name="formatDate" type="String"/>
            <param name="separateurDate" type="String"/>
            <param name="taillePartieDecimale" type="String"/>
            <param name="separateurDecimal" type="String"/>
        </predicate>
        
        <predicate name="ifTypeFichierFileName">
            <invoke  method="ifTypeFichierFileName" class-name="com.megatim.typefichier.validator.predicat.PredicateImpl"/>
            <param name="prefixe" type="String"/>
            <param name="type_suffixe" type="String"/>
            <param name="formatDate" type="String"/>
            <param name="fileName" type="String"/>
        </predicate>
        
        <predicate name="ifVersion">
            <invoke  method="ifVersion" class-name="com.megatim.typefichier.validator.predicat.PredicateImpl"/>
            <param name="version" type="String"/>
            <param name="nbPosition" type="int"/>
            <param name="typeCharactere" type="String"/>
        </predicate>
        
        <predicate name="ifCodeRemise">
            <invoke  method="ifCodeRemise" class-name="com.megatim.typefichier.validator.predicat.PredicateImpl"/>
            <param name="codeRemise" type="String"/>
            <param name="nbPosition" type="int"/>
            <param name="typeCharactere" type="String"/>
        </predicate>
        
        <predicate name="ifNumber">
            <invoke  method="ifNumber" class-name="com.megatim.typefichier.validator.predicat.PredicateImpl"/>
            <param name="nbFiles" type="String"/>
        </predicate>
        
        <predicate name="ifDate">
            <invoke  method="ifDate" class-name="com.megatim.typefichier.validator.predicat.PredicateImpl"/>
            <param name="date" type="String"/>
            <param name="format" type="String"/>
            <param-value name="index" type="int" />
            <param-value name="fileName" type="String" />
        </predicate>
        
        <predicate name="ifCodeAgentOrCodeParticipant">
            <invoke  method="ifCodeAgentOrCodeParticipant" class-name="com.megatim.typefichier.validator.predicat.PredicateImpl"/>
            <param name="code" type="String"/>
            <param name="fileName" type="String"/>
            <param-value name="index" type="int" />
            <param-value name="taille" type="int" />
        </predicate>
        
        <predicate name="ifTierce">
            <invoke  method="ifTierce" class-name="com.megatim.typefichier.validator.predicat.PredicateImpl"/>
            <param name="fileName" type="String"/>
            <param-value name="index" type="int" />
            <param-value name="minValue" type="int" />
            <param-value name="maxValue" type="int" />
        </predicate>
        
        <predicate name="ifDecimal">
            <invoke  method="ifDecimal" class-name="com.megatim.typefichier.validator.predicat.PredicateImpl"/>
            <param-value name="index" type="int" />
            <param-value name="taille" type="int" />
            <param-value name="typeDonnee" type="String" />
            <param name="ligne" type="String"/>
            <param-value name="decimalPartMaxLength" type="int" />
            <param-value name="separator" type="char"/>
        </predicate>
        
        <predicate name="equal">
            <invoke method="equal" class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="equalParam" type="Object" />
            <param name="equalValue" type="Object" />
        </predicate>
         
        <predicate name="empty">
            <invoke method="empty"
                    class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="emptyParam" type="Object" />
            
        </predicate>
        <predicate name="equal">
            <invoke method="equal"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="equalParam" type="Object" />
            <param name="equalValue" type="Object" />
        </predicate>

        <predicate name="empty">
            <invoke method="empty"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="emptyParam" type="Object" />
        </predicate>

        <predicate name="notEmptyValues">
            <invoke method="notEmptyValues"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="notEmptyValuesParam" type="Collection" />
        </predicate>

        <predicate name="emptyValues">
            <invoke method="emptyValues"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="emptyValuesParam" type="Collection" />
        </predicate>

        <predicate name="propertyReferenceEntry">
            <invoke method="propertyReferenceEntry"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="entityName" type="String" />
            <param name="propertyName" type="String" />
            <param name="propertyValue" type="Object" />
        </predicate>

        <predicate name="propertiesReferenceEntry">
            <invoke method="propertiesReferenceEntry"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="entityName" type="String" />
            <param name="properties" type="Map" />
        </predicate>

        <predicate name="dateFormat">
            <invoke method="dateFormat"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="dateValue" type="String" />
            <param name="dateFormat" type="String" />
        </predicate>

        <predicate name="csvEntry">
            <invoke method="csvEntry"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="entryValue" type="String" />
            <param name="csvValues" type="String" />
        </predicate>

        <predicate name="singleton">
            <invoke method="singleton"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="collectionEntries" type="java.util.Collection" />
            <param name="entryTypeName" type="String" />
            <param name="entryPropertyName" type="String" />
        </predicate>

        <predicate name="singletonValue">
            <invoke method="singletonValue"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="collectionEntries" type="java.util.Collection" />
            <param name="entryTypeName" type="String" />
            <param name="entryPropertyName" type="String" />
            <param name="singletonValue" type="Object" />
        </predicate>

        <predicate name="singleOccurenceValue">
            <invoke method="singleOccurenceValue"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="collectionEntries" type="java.util.Collection" />
            <param name="entryTypeName" type="String" />
            <param name="entryPropertyName" type="String" />
            <param name="occurenceValue" type="Object" />
        </predicate>

        <predicate name="singleOccurenceValueByGroup">
            <invoke method="singleOccurenceValueByGroup"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="collectionEntries" type="java.util.Collection" />
            <param name="entryTypeName" type="String" />
            <param name="entryPropertyName" type="String" />
            <param name="csvGroupPropertiesNames" type="String" />
            <param name="occurenceEntity" type="Object" />
            <param name="occurenceValue" type="Object" />
        </predicate>

        <predicate name="sum">
            <invoke method="sum"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="collectionEntries" type="java.util.Collection" />
            <param name="entryTypeName" type="String" />
            <param name="entryPropertyName" type="String" />
            <param name="sumValue" type="java.math.BigDecimal" />
        </predicate>

        <predicate name="size">
            <invoke method="size"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="collectionEntries" type="java.util.Collection" />
            <param name="entryTypeName" type="String" />
            <param name="sizeValue" type="java.math.BigDecimal" />
        </predicate>

        <predicate name="greater">
            <invoke method="greater"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="greaterValue" type="Object" />
            <param name="greaterLimit" type="Object" />
        </predicate>

        <predicate name="lower">
            <invoke method="lower"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="lowerValue" type="Object" />
            <param name="lowerLimit" type="Object" />
        </predicate>

        <predicate name="ribChecker">
            <invoke method="ribChecker"
                                class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="ribValue" type="String" />
        </predicate>

        <predicate name="systacCountryExist">
            <invoke  method="systacCountryExist" 
                                 class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="countryCode" type="String"/>
        </predicate>

        <predicate name="posteComptableExist">
            <invoke  method="posteComptableExist" 
                                 class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="codePosteComptable" type="String"/>
        </predicate>
                
        <predicate name="systacBankExist">
            <invoke  method="systacBankExist" 
                                 class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="bankCode" type="String"/>
        </predicate>

        <predicate name="systacAgencyExist">
            <invoke  method="systacAgencyExist" 
                                 class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="agencyCode" type="String"/>
        </predicate>
                
        <predicate name="systacAgencyBankExist">
            <invoke  method="systacAgencyBankExist" 
                                 class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="bankCode" type="String"/>
            <param name="agencyCode" type="String"/>
        </predicate>		
		
        <predicate name="sygmaParticipantCodeBicExist">
            <invoke  method="sygmaParticipantCodeBicExist" 
                                 class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="codeBicParticipant" type="String"/>
        </predicate>

        <predicate name="sygmaParticipantCodeBicWithPropertiesExist">
            <invoke  method="sygmaParticipantCodeBicWithPropertiesExist" 
                                 class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="codeBicParticipant" type="String"/>
            <param name="properties" type="Map"/>
        </predicate>

        <predicate name="sygmaParticipantNumeroCompteExist">
            <invoke  method="sygmaParticipantNumeroCompteExist" class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="numeroCompteParticipant" type="String"/>
        </predicate>

        <predicate name="sygmaParticipantNumeroCompteWithPropertiesExist">
            <invoke  method="sygmaParticipantNumeroCompteWithPropertiesExist" class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="numeroCompteParticipant" type="String"/>
            <param name="properties" type="Map"/>
        </predicate>

        <predicate name="ifReplayQueueInDataExist">
            <invoke  method="ifReplayQueueInDataExist" class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="numeroReference" type="String"/>
            <param name="numeroBordereauVirement" type="String"/>
            <param name="codeEnregistrement"   type="String"/>
            <param name="codeValeur"  type="String"/>
        </predicate>
				 
        <predicate name="ifMt103001Message">
            <invoke  method="ifMt103001Message" class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="codeTypeMessage" type="String"/>
            <param name="codeTypeTransaction" type="String"/>
        </predicate>
                 
        <predicate name="ifAdmin">
            <invoke  method="ifAdmin" class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="loginValue" type="String"/>
            <param name="passwordValue" type="String"/>
        </predicate>
                 
        <predicate name="ifReplayQueueInDataExistSystac">
            <invoke  method="ifReplayQueueInDataExistSystac" class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="numeroOperation" type="String"/>
            <param name="datePresentation" type="String"/>
            <param name="codeValeur"  type="String"/>
            <param name="codeEnregistrement"   type="String"/>                       
        </predicate>
                 
        <predicate name="ifReplayQueueInDataExistSygma">
            <invoke  method="ifReplayQueueInDataExistSygma" class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="codeReference" type="String"/>
            <param name="datePresentation" type="String"/>                                              
        </predicate>    
                 
        <predicate name="ifBankIsNotInBlackList">
            <invoke  method="ifBankIsNotInBlackList" class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="codeBanqueDestinataire" type="String"/>
        </predicate>
                 
        <predicate name="ifParticipantIsNotInBlackList">
            <invoke  method="ifParticipantIsNotInBlackList" class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="codeBicDestinataireSygma" type="String"/>
        </predicate>      
                 
        <predicate name="checkReconciliationItemExistence">
            <invoke  method="checkReconciliationItemExistence" class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="numeroReference" type="String"/>
            <param name="montant" type="String"/>
            <param name="datePresentation"   type="String"/>                        
        </predicate>  
                
        <predicate name="queueInAnnulationCalendarValidation">
            <invoke method="queueInAnnulationCalendarValidation"
                            class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl" />
            <param name="entityName" type="String" />
            <param name="properties" type="Map" />
        </predicate>
        <predicate name="uniqueCodeSystem">
            <invoke  method="uniqueCodeSystem" class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="codeSystem" type="String"/>
        </predicate>
        <predicate name="justOneOperation">
            <invoke  method="justOneOperation" class-name="com.mgt.moteur.predicat.validation.impl.PredicateImpl"/>
            <param name="numeroBonVirement" type="String"/>
        </predicate>
    </predicates>

    <!-- Définition des assertions : ce sont des compositions de connecteurs, 
    predicats et d'autres assertions -->
    <asserts>
        <assert name="inValues">
            <param name="values" type="String"/>
            <param-value name="fieldToCheck" type="String" />
            <formula predicate-ref="inValues">
                <param name="values" assert-param-ref="values" />
                <param name="fieldToCheck" assert-param-ref="fieldToCheck" />
            </formula>
        </assert>
            
        <assert name="ifTypeFichier">
            <param name="index" type="int"/>
            <param name="taille" type="int"/>
            <param name="typeDonnee" type="String"/>
            <param name="ligne" type="String"/>
            <param name="formatDate" type="String"/>
            <param name="separateurDate" type="String"/>
            <param-value name="taillePartieDecimale" type="int" />
            <param-value name="separateurDecimal" type="char"/>
            <formula predicate-ref="ifTypeFichier">
                <param name="index" assert-param-ref="index" />
                <param name="taille" assert-param-ref="taille" />
                <param name="typeDonnee" assert-param-ref="typeDonnee" />
                <param name="ligne" assert-param-ref="ligne" />
                <param name="formatDate" assert-param-ref="formatDate" />
                <param name="separateurDate" assert-param-ref="separateurDate" />
                <param name="taillePartieDecimale" assert-param-ref="taillePartieDecimale" />
                <param name="separateurDecimal" assert-param-ref="separateurDecimal" />
                    
            </formula>
        </assert>
            
        <assert name="ifTypeFichierFileName">
            <param name="prefixe" type="String"/>
            <param name="type_suffixe" type="String"/>
            <param name="formatDate" type="String"/>
            <param name="fileName" type="String"/>
            <formula predicate-ref="ifTypeFichierFileName">
                <param name="prefixe" assert-param-ref="prefixe" />
                <param name="type_suffixe" assert-param-ref="type_suffixe" />
                <param name="formatDate" assert-param-ref="formatDate" />
                <param name="fileName" assert-param-ref="fileName" />
            </formula>
        </assert>
            
        <assert name="ifVersion">
            <param name="version" type="String"/>
            <param name="nbPosition" type="int"/>
            <param name="typeCharactere" type="String"/>
            <formula predicate-ref="ifVersion">
                <param name="version" assert-param-ref="version" />
                <param name="nbPosition" assert-param-ref="nbPosition" />
                <param name="typeCharactere" assert-param-ref="typeCharactere" />
            </formula>
        </assert>
                
        <assert name="ifCodeRemise">
            <param name="codeRemise" type="String"/>
            <param name="nbPosition" type="int"/>
            <param name="typeCharactere" type="String"/>
            <formula predicate-ref="ifCodeRemise">
                <param name="codeRemise" assert-param-ref="codeRemise" />
                <param name="nbPosition" assert-param-ref="nbPosition" />
                <param name="typeCharactere" assert-param-ref="typeCharactere" />
            </formula>
        </assert>
                
        <assert name="ifNumber">
            <param name="nbFiles" type="String"/>
            <formula predicate-ref="ifNumber">
                <param name="nbFiles" assert-param-ref="nbFiles" />
            </formula>
        </assert>
                
                
        <assert name="ifDate">
            <param name="date" type="String"/>
            <param name="format" type="String"/>
            <param name="fileName" type="String"/>
            <param-value name="index" type="int" />
            <formula predicate-ref="ifDate">
                <param name="date" assert-param-ref="date" />
                <param name="format" assert-param-ref="format" />
                <param name="index" assert-param-ref="index" />
                <param name="fileName" assert-param-ref="fileName" />
            </formula>
        </assert>
                
        <assert name="ifCodeAgentOrCodeParticipant">
            <param name="code" type="String"/>
            <param name="fileName" type="String"/>
            <param-value name="index" type="int" />
            <param-value name="taille" type="int" />
            <formula predicate-ref="ifCodeAgentOrCodeParticipant">
                <param name="code" assert-param-ref="code" />
                <param name="fileName" assert-param-ref="fileName" />
                <param name="taille" assert-param-ref="taille" />
                <param name="index" assert-param-ref="index" />
            </formula>
        </assert>

         
        <assert name="ifTierce">
            <param name="fileName" type="String"/>
            <param-value name="index" type="int" />
            <param-value name="minValue" type="int" />
            <param-value name="maxValue" type="int" />
            <formula predicate-ref="ifTierce">
                <param name="fileName" assert-param-ref="fileName" />
                <param name="minValue" assert-param-ref="minValue" />
                <param name="maxValue" assert-param-ref="maxValue" />
                <param name="index" assert-param-ref="index" />
            </formula>
        </assert>
              
        <assert name="ifDecimal">
            <param-value name="index" type="int" />
            <param-value name="taille" type="int" />
            <param-value name="typeDonnee" value="String" />
            <param name="ligne" type="String"/>
            <param-value name="decimalPartMaxLength" type="int" />
            <param-value name="separator" type="char" />
            <formula predicate-ref="ifDecimal">
                <param name="index" assert-param-ref="index" />
                <param name="taille" assert-param-ref="taille" />
                <param name="typeDonnee" assert-param-ref="typeDonnee" />
                <param name="ligne" assert-param-ref="ligne"/>
                <param name="decimalPartMaxLength" assert-param-ref="decimalPartMaxLength" />
                <param name="separator" assert-param-ref="separator" />
            </formula>
        </assert>
              
        <assert name="equal">
            <param name="equalValue" type="Object" />
            <param name="equalParam" type="Object" />
            <formula predicate-ref="equal">
                <param name="equalValue" assert-param-ref="equalValue" />
                <param name="equalParam" assert-param-ref="equalParam" />
            </formula>
        </assert>

        <assert name="empty">
            <param name="emptyParam" type="Object" />
            <formula predicate-ref="empty">
                <param name="emptyParam" assert-param-ref="emptyParam" />
            </formula>
        </assert>

        <!-- Est vrai si toutes les valeurs sont non vides -->
        <assert name="notEmptyValues">
            <param name="notEmptyValuesParam" type="Object" />
            <formula predicate-ref="notEmptyValues">
                <param name="notEmptyValuesParam" assert-param-ref="notEmptyValuesParam" />
            </formula>
        </assert>

        <!-- Est vrai si toutes les valeurs sont vides -->
        <assert name="emptyValues">
            <param name="emptyValuesParam" type="Object" />
            <formula predicate-ref="emptyValues">
                <param name="emptyValuesParam" assert-param-ref="emptyValuesParam" />
            </formula>
        </assert>

        <assert name="propertyReferenceEntry">
            <param name="entityName" type="String" />
            <param name="propertyName" type="String" />
            <param name="propertyValue" type="Object" />
            <formula predicate-ref="propertyReferenceEntry">
                <param name="entityName" assert-param-ref="entityName" />
                <param name="propertyName" assert-param-ref="propertyName" />
                <param name="propertyValue" assert-param-ref="propertyValue" />
            </formula>
        </assert>

        <assert name="propertiesReferenceEntry">
            <param name="entityName" type="String" />
            <param name="properties" type="Map" />
            <formula predicate-ref="propertiesReferenceEntry">
                <param name="entityName" assert-param-ref="entityName" />
                <param name="properties" assert-param-ref="properties" />
            </formula>
        </assert>

        <assert name="dateFormat">
            <param name="dateValue" type="String" />
            <param name="dateFormat" type="String" />
            <formula predicate-ref="dateFormat">
                <param name="dateValue" assert-param-ref="dateValue" />
                <param name="dateFormat" assert-param-ref="dateFormat" />
            </formula>
        </assert>

        <assert name="csvEntry">
            <param name="entryValue" type="String" />
            <param name="csvValues" type="String" />
            <formula predicate-ref="csvEntry">
                <param name="entryValue" assert-param-ref="entryValue" />
                <param name="csvValues" assert-param-ref="csvValues" />
            </formula>
        </assert>

        <assert name="singleton">
            <param name="collectionEntries" type="java.util.Collection" />
            <param name="entryTypeName" type="String" />
            <param name="entryPropertyName" type="String" />
            <formula predicate-ref="singleton">
                <param name="collectionEntries" assert-param-ref="collectionEntries" />
                <param name="entryTypeName" assert-param-ref="entryTypeName" />
                <param name="entryPropertyName" assert-param-ref="entryPropertyName" />
            </formula>
        </assert>

        <assert name="singletonValue">
            <param name="collectionEntries" type="java.util.Collection" />
            <param name="entryTypeName" type="String" />
            <param name="entryPropertyName" type="String" />
            <param name="singletonValue" type="Object" />
            <formula predicate-ref="singletonValue">
                <param name="collectionEntries" assert-param-ref="collectionEntries" />
                <param name="entryTypeName" assert-param-ref="entryTypeName" />
                <param name="entryPropertyName" assert-param-ref="entryPropertyName" />
                <param name="singletonValue" assert-param-ref="singletonValue" />
            </formula>
        </assert>

        <assert name="singleOccurenceValue">
            <param name="collectionEntries" type="java.util.Collection" />
            <param name="entryTypeName" type="String" />
            <param name="entryPropertyName" type="String" />
            <param name="occurenceValue" type="Object" />
            <formula predicate-ref="singleOccurenceValue">
                <param name="collectionEntries" assert-param-ref="collectionEntries" />
                <param name="entryTypeName" assert-param-ref="entryTypeName" />
                <param name="entryPropertyName" assert-param-ref="entryPropertyName" />
                <param name="occurenceValue" assert-param-ref="occurenceValue" />
            </formula>
        </assert>

        <assert name="singleOccurenceValueByGroup">
            <param name="collectionEntries" type="java.util.Collection" />
            <param name="entryTypeName" type="String" />
            <param name="entryPropertyName" type="String" />
            <param name="csvGroupPropertiesNames" type="String" />
            <param name="occurenceEntity" type="Object" />
            <param name="occurenceValue" type="Object" />
            <formula predicate-ref="singleOccurenceValueByGroup">
                <param name="collectionEntries" assert-param-ref="collectionEntries" />
                <param name="entryTypeName" assert-param-ref="entryTypeName" />
                <param name="entryPropertyName" assert-param-ref="entryPropertyName" />
                <param name="csvGroupPropertiesNames" assert-param-ref="csvGroupPropertiesNames" />
                <param name="occurenceEntity" assert-param-ref="occurenceEntity" />
                <param name="occurenceValue" assert-param-ref="occurenceValue" />
            </formula>
        </assert>

        <assert name="sum">
            <param name="collectionEntries" type="java.util.Collection" />
            <param name="entryTypeName" type="String" />
            <param name="entryPropertyName" type="String" />
            <param name="sumValue" type="java.math.BigDecimal" />
            <formula predicate-ref="sum">
                <param name="collectionEntries" assert-param-ref="collectionEntries" />
                <param name="entryTypeName" assert-param-ref="entryTypeName" />
                <param name="entryPropertyName" assert-param-ref="entryPropertyName" />
                <param name="sumValue" assert-param-ref="sumValue" />
            </formula>
        </assert>

        <assert name="size">
            <param name="collectionEntries" type="java.util.Collection" />
            <param name="entryTypeName" type="String" />
            <param name="sizeValue" type="java.math.BigDecimal" />
            <formula predicate-ref="size">
                <param name="collectionEntries" assert-param-ref="collectionEntries" />
                <param name="entryTypeName" assert-param-ref="entryTypeName" />
                <param name="sizeValue" assert-param-ref="sizeValue" />
            </formula>
        </assert>

        <assert name="greater">
            <param name="greaterValue" type="Object" />
            <param name="greaterLimit" type="Object" />
            <formula predicate-ref="greater">
                <param name="greaterValue" assert-param-ref="greaterValue" />
                <param name="greaterLimit" assert-param-ref="greaterLimit" />
            </formula>
        </assert>

        <assert name="lower">
            <param name="lowerValue" type="Object" />
            <param name="lowerLimit" type="Object" />
            <formula predicate-ref="lower">
                <param name="lowerValue" assert-param-ref="lowerValue" />
                <param name="lowerLimit" assert-param-ref="lowerLimit" />
            </formula>
        </assert>

        <assert name="ribChecker">
            <param name="ribValue" type="String" />
            <formula predicate-ref="ribChecker">
                <param name="ribValue" assert-param-ref="ribValue" />
            </formula>
        </assert>

        <assert name="systacCountryExist">
            <param name="countryCode" type="String" />
            <formula predicate-ref="systacCountryExist">
                <param name="countryCode" assert-param-ref="countryCode" />
            </formula>
        </assert>
                
        <assert name="uniqueCodeSystem">
            <param name="codeSystem" type="String" />
            <formula predicate-ref="uniqueCodeSystem">
                <param name="codeSystem" assert-param-ref="codeSystem" />
            </formula>
        </assert>
                
        <assert name="justOneOperation">
            <param name="numeroBonVirement" type="String" />
            <formula predicate-ref="justOneOperation">
                <param name="numeroBonVirement" assert-param-ref="numeroBonVirement" />
            </formula>
        </assert>

        <assert name="posteComptableExist">
            <param name="codePosteComptable" type="String" />
            <formula predicate-ref="posteComptableExist">
                <param name="codePosteComptable" assert-param-ref="codePosteComptable" />
            </formula>
        </assert>
                
        <assert name="systacBankExist">
            <param name="bankCode" type="String" />
            <formula predicate-ref="systacBankExist">
                <param name="bankCode" assert-param-ref="bankCode" />
            </formula>
        </assert>

        <assert name="systacAgencyExist">
            <param name="agencyCode" type="String" />
            <formula predicate-ref="systacAgencyExist">
                <param name="agencyCode" assert-param-ref="agencyCode" />
            </formula>
        </assert>
		
        <assert name="systacAgencyBankExist">
            <param name="bankCode" type="String" />
            <param name="agencyCode" type="String" />
            <formula predicate-ref="systacAgencyBankExist">
                <param name="bankCode" assert-param-ref="bankCode" />
                <param name="agencyCode" assert-param-ref="agencyCode" />
            </formula>
        </assert>	

        <assert name="sygmaParticipantCodeBicExist">
            <param name="codeBicParticipant" type="String" />
            <formula predicate-ref="sygmaParticipantCodeBicExist">
                <param name="codeBicParticipant" assert-param-ref="codeBicParticipant" />
            </formula>
        </assert>

        <assert name="sygmaParticipantCodeBicWithPropertiesExist">
            <param name="codeBicParticipant" type="String" />
            <param name="properties" type="Map" />
            <formula predicate-ref="sygmaParticipantCodeBicWithPropertiesExist">
                <param name="codeBicParticipant" assert-param-ref="codeBicParticipant" />
                <param name="properties" assert-param-ref="properties" />
            </formula>
        </assert>

        <assert name="sygmaParticipantNumeroCompteExist">
            <param name="numeroCompteParticipant" type="String" />
            <formula predicate-ref="sygmaParticipantNumeroCompteExist">
                <param name="numeroCompteParticipant" assert-param-ref="numeroCompteParticipant" />
            </formula>
        </assert>

        <assert name="sygmaParticipantNumeroCompteWithPropertiesExist">
            <param name="numeroCompteParticipant" type="String" />
            <param name="properties" type="Map" />
            <formula predicate-ref="sygmaParticipantNumeroCompteWithPropertiesExist">
                <param name="numeroCompteParticipant" assert-param-ref="numeroCompteParticipant" />
                <param name="properties" assert-param-ref="properties" />
            </formula>
        </assert> 
        
        <assert name="ifMt103001Message">
            <param name="codeTypeMessage" type="String" />
            <param name="codeTypeTransaction" type="String" />
            <formula predicate-ref="ifMt103001Message">
                <param name="codeTypeMessage" assert-param-ref="codeTypeMessage" />
                <param name="codeTypeTransaction" assert-param-ref="codeTypeTransaction" />
            </formula>
        </assert>
                
        <assert name="ifAdmin">
            <param name="loginValue" type="String" />
            <param name="passwordValue" type="String" />
            <formula predicate-ref="ifAdmin">
                <param name="loginValue" assert-param-ref="loginValue" />
                <param name="passwordValue" assert-param-ref="passwordValue" />
            </formula>
        </assert>
		
        <assert name="ifReplayQueueInDataExist">
            <param name="numeroReference" type="String" />
            <param name="numeroBordereauVirement" type="String" />
            <param name="codeEnregistrement"  type="String" />
            <param name="codeValeur"  type="String" />
            <formula predicate-ref="ifReplayQueueInDataExist">
                <param name="numeroReference" assert-param-ref="numeroReference" />
                <param name="numeroBordereauVirement" assert-param-ref="numeroBordereauVirement" />
                <param name="codeEnregistrement"    assert-param-ref="codeEnregistrement" />
                <param name="codeValeur"  assert-param-ref="codeValeur" />
            </formula>
        </assert>
                
        <assert name="ifReplayQueueInDataExistSystac">
            <param name="numeroOperation" type="String" />
            <param name="datePresentation" type="String" />     
            <param name="codeValeur"  type="String" />  
            <param name="codeEnregistrement"  type="String" />                                 
            <formula predicate-ref="ifReplayQueueInDataExistSystac">
                <param name="numeroOperation" assert-param-ref="numeroOperation" />
                <param name="datePresentation" assert-param-ref="datePresentation" />
                <param name="codeValeur"  assert-param-ref="codeValeur" />
                <param name="codeEnregistrement"    assert-param-ref="codeEnregistrement" />                            
            </formula>
        </assert>
                
        <assert name="ifReplayQueueInDataExistSygma">
            <param name="codeReference" type="String" />
            <param name="datePresentation" type="String" />                                      
            <formula predicate-ref="ifReplayQueueInDataExistSygma">
                <param name="codeReference" assert-param-ref="codeReference" />
                <param name="datePresentation" assert-param-ref="datePresentation" />                            
            </formula>
        </assert>
                
        <assert name="ifBankIsNotInBlackList">
            <param name="codeBanqueDestinataire" type="String" />                  
            <formula predicate-ref="ifBankIsNotInBlackList">
                <param name="codeBanqueDestinataire" assert-param-ref="codeBanqueDestinataire" />                           
            </formula>
        </assert>
                
        <assert name="ifParticipantIsNotInBlackList">
            <param name="codeBicDestinataireSygma" type="String" />                  
            <formula predicate-ref="ifParticipantIsNotInBlackList">
                <param name="codeBicDestinataireSygma" assert-param-ref="codeBicDestinataireSygma" />                           
            </formula>
        </assert>        
                
        <assert name="checkReconciliationItemExistence">
            <param name="numeroReference" type="String" />
            <param name="montant" type="String" />
            <param name="datePresentation"  type="String" />
            <formula predicate-ref="checkReconciliationItemExistence">
                <param name="numeroReference" assert-param-ref="numeroReference" />
                <param name="montant" assert-param-ref="montant" />
                <param name="datePresentation"    assert-param-ref="datePresentation" />
            </formula>
        </assert>    
                
        <assert name="queueInAnnulationCalendarValidation">
            <param name="entityName" type="String" />
            <param name="properties" type="Map" />
            <formula predicate-ref="queueInAnnulationCalendarValidation">
                <param name="entityName" assert-param-ref="entityName" />
                <param name="properties" assert-param-ref="properties" />
            </formula>
        </assert>

        <assert name="notEqual">
            <param name="notEqualParam" type="Object" />
            <param name="notEqualValue" type="Object" />
            <formula connector-ref="not">
                <param name="notParam" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="notEqualParam" />
                    <param name="equalValue" assert-param-ref="notEqualValue" />
                </param>
            </formula>
        </assert>

        <assert name="notPropertyReferenceEntry">
            <param name="entityName" type="String" />
            <param name="propertyName" type="String" />
            <param name="propertyValue" type="Object" />
            <formula connector-ref="not">
                <param name="notParam" predicate-ref="propertyReferenceEntry">
                    <param name="entityName" assert-param-ref="entityName" />
                    <param name="propertyName" assert-param-ref="propertyName" />
                    <param name="propertyValue" assert-param-ref="propertyValue" />
                </param>
            </formula>
        </assert>

        <assert name="notPropertiesReferenceEntry">
            <param name="entityName" type="String" />
            <param name="properties" type="Map" />
            <formula connector-ref="not">
                <param name="notParam" predicate-ref="propertiesReferenceEntry">
                    <param name="entityName" assert-param-ref="entityName" />
                    <param name="properties" assert-param-ref="properties" />
                </param>
            </formula>
        </assert>

        <assert name="notEmpty">
            <param name="notEmptyParam" type="Object" />
            <formula connector-ref="not">
                <param name="notParam" predicate-ref="empty">
                    <param name="emptyParam" assert-param-ref="notEmptyParam" />
                </param>
            </formula>
        </assert>

        <!-- Est vrai si aumoins l'une des valeurs de la collection est non vide -->
        <assert name="lazyNotEmptyValues">
            <param name="lazyNotEmptyValuesParam" type="Collection" />
            <formula connector-ref="not">
                <param name="notParam" predicate-ref="emptyValues">
                    <param name="emptyValuesParam" assert-param-ref="lazyNotEmptyValuesParam" />
                </param>
            </formula>
        </assert>

        <!-- Est vrai si aumoins l'une des valeurs de la liste est vide -->
        <assert name="lazyEmptyValues">
            <param name="lazyEmptyValues" type="Collection" />
            <formula connector-ref="not">
                <param name="notParam" predicate-ref="notEmptyValues">
                    <param name="notEmptyValuesParam" assert-param-ref="lazyEmptyValues" />
                </param>
            </formula>
        </assert>

        <assert name="greaterOrEqual">
            <param name="greaterEqualValue" type="Object" />
            <param name="greaterEqualLimit" type="Object" />
            <formula connector-ref="or">
                <param name="orParam1" predicate-ref="greater">
                    <param name="greaterValue" assert-param-ref="greaterEqualValue" />
                    <param name="greaterLimit" assert-param-ref="greaterEqualLimit" />
                </param>
                <param name="orParam2" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="greaterEqualValue" />
                    <param name="equalValue" assert-param-ref="greaterEqualLimit" />
                </param>
            </formula>
        </assert>

        <assert name="lowerOrEqual">
            <param name="lowerEqualValue" type="Object" />
            <param name="lowerEqualLimit" type="Object" />
            <formula connector-ref="or">
                <param name="orParam1" predicate-ref="lower">
                    <param name="lowerValue" assert-param-ref="lowerEqualValue" />
                    <param name="lowerLimit" assert-param-ref="lowerEqualLimit" />
                </param>
                <param name="orParam2" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="lowerEqualValue" />
                    <param name="equalValue" assert-param-ref="lowerEqualLimit" />
                </param>
            </formula>
        </assert>

        <assert name="notCsvEntry">
            <param name="notEntryValue" type="String" />
            <param name="notCsvValues" type="String" />
            <formula connector-ref="not">
                <param name="notParam" predicate-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="notEntryValue" />
                    <param name="csvValues" assert-param-ref="notCsvValues" />
                </param>
            </formula>
        </assert>

        <assert name="equalAndNotEmpty">
            <param name="equalParam" type="Object" />
            <param name="equalValue" type="Object" />
            <param name="notEmptyParam" type="Object" />
            <formula connector-ref="and">
                <param name="andParam1" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="equalParam" />
                    <param name="equalValue" assert-param-ref="equalValue" />
                </param>
                <param name="andParam2" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParam" />
                </param>
            </formula>
        </assert>

        <assert name="equalAndEqual">
            <param name="equalParam1" type="Object" />
            <param name="equalValue1" type="Object" />
            <param name="equalParam2" type="Object" />
            <param name="equalValue2" type="Object" />
            <formula connector-ref="and">
                <param name="andParam1" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="equalParam1" />
                    <param name="equalValue" assert-param-ref="equalValue1" />
                </param>
                <param name="andParam2" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="equalParam2" />
                    <param name="equalValue" assert-param-ref="equalValue2" />
                </param>
            </formula>
        </assert>

        <assert name="csvEntryAndCsvEntry">
            <param name="entryValue1" type="Object" />
            <param name="csvValues1" type="Object" />
            <param name="entryValue2" type="Object" />
            <param name="csvValues2" type="Object" />
            <formula connector-ref="and">
                <param name="andParam1" predicate-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="entryValue1" />
                    <param name="csvValues" assert-param-ref="csvValues1" />
                </param>
                <param name="andParam2" predicate-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="entryValue2" />
                    <param name="csvValues" assert-param-ref="csvValues2" />
                </param>
            </formula>
        </assert>

        <assert name="csvEntryAndNotCsvEntry">
            <param name="entryValue" type="Object" />
            <param name="csvValues" type="Object" />
            <param name="notEntryValue" type="Object" />
            <param name="notCsvValues" type="Object" />
            <formula connector-ref="and">
                <param name="andParam1" predicate-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="entryValue" />
                    <param name="csvValues" assert-param-ref="csvValues" />
                </param>
                <param name="andParam2" assert-ref="notCsvEntry">
                    <param name="notEntryValue" assert-param-ref="notEntryValue" />
                    <param name="notCsvValues" assert-param-ref="notCsvValues" />
                </param>
            </formula>
        </assert>

        <assert name="ifEqualThenGreater">
            <param name="equalParamAssumption" type="String" />
            <param name="equalValueAssumption" type="String" />
            <param name="greaterValueConclusion" type="String" />
            <param name="greaterLimitConclusion" type="String" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="equalParamAssumption" />
                    <param name="equalValue" assert-param-ref="equalValueAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="greater">
                    <param name="greaterValue" assert-param-ref="greaterValueConclusion" />
                    <param name="greaterLimit" assert-param-ref="greaterLimitConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifEqualThenLower">
            <param name="equalParamAssumption" type="String" />
            <param name="equalValueAssumption" type="String" />
            <param name="lowerValueConclusion" type="String" />
            <param name="lowerLimitConclusion" type="String" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="equalParamAssumption" />
                    <param name="equalValue" assert-param-ref="equalValueAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="lower">
                    <param name="lowerValue" assert-param-ref="lowerValueConclusion" />
                    <param name="lowerLimit" assert-param-ref="lowerLimitConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifEqualThenEqual">
            <param name="equalParam1Assumption" type="String" />
            <param name="equalValue1Assumption" type="String" />
            <param name="equalParam2Conclusion" type="String" />
            <param name="equalValue2Conclusion" type="String" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="equalParam1Assumption" />
                    <param name="equalValue" assert-param-ref="equalValue1Assumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="equalParam2Conclusion" />
                    <param name="equalValue" assert-param-ref="equalValue2Conclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifEqualThenNotEqual">
            <param name="equalParamAssumption" type="String" />
            <param name="equalValueAssumption" type="String" />
            <param name="notEqualParamConclusion" type="String" />
            <param name="notEqualValueConclusion" type="String" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="equalParamAssumption" />
                    <param name="equalValue" assert-param-ref="equalValueAssumption" />
                </param>
                <param name="impliesConclusion" assert-ref="notEqual">
                    <param name="notEqualParam" assert-param-ref="notEqualParamConclusion" />
                    <param name="notEqualValue" assert-param-ref="notEqualValueConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifEqualThenNotCsvEntry">
            <param name="equalParamAssumption" type="String" />
            <param name="equalValueAssumption" type="String" />
            <param name="notEntryValueConclusion" type="String" />
            <param name="notCsvValuesConclusion" type="String" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="equalParamAssumption" />
                    <param name="equalValue" assert-param-ref="equalValueAssumption" />
                </param>
                <param name="impliesConclusion" assert-ref="notCsvEntry">
                    <param name="notEntryValue" assert-param-ref="notEntryValueConclusion" />
                    <param name="notCsvValues" assert-param-ref="notCsvValuesConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifEqualThenCsvEntry">
            <param name="equalParamAssumption" type="String" />
            <param name="equalValueAssumption" type="String" />
            <param name="entryValueConclusion" type="String" />
            <param name="csvValuesConclusion" type="String" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="equalParamAssumption" />
                    <param name="equalValue" assert-param-ref="equalValueAssumption" />
                </param>
                <param name="impliesConclusion" assert-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="entryValueConclusion" />
                    <param name="csvValues" assert-param-ref="csvValuesConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifCsvEntryThenCsvEntry">
            <param name="entryValueAssumption" type="String" />
            <param name="csvValuesAssumption" type="String" />
            <param name="entryValueConclusion" type="String" />
            <param name="csvValuesConclusion" type="String" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="entryValueAssumption" />
                    <param name="csvValues" assert-param-ref="csvValuesAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="entryValueConclusion" />
                    <param name="csvValues" assert-param-ref="csvValuesConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifCsvEntryThenSingleton">
            <param name="entryValueAssumption" type="String" />
            <param name="csvValuesAssumption" type="String" />
            <param name="collectionEntriesConclusion" type="java.util.Collection" />
            <param name="entryTypeNameConclusion" type="String" />
            <param name="entryPropertyNameConclusion" type="String" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="entryValueAssumption" />
                    <param name="csvValues" assert-param-ref="csvValuesAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="singleton">
                    <param name="collectionEntries" assert-param-ref="collectionEntriesConclusion" />
                    <param name="entryTypeName" assert-param-ref="entryTypeNameConclusion" />
                    <param name="entryPropertyName" assert-param-ref="entryPropertyNameConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifCsvEntryThenSingleOccurenceValueByGroup">
            <param name="entryValueAssumption" type="String" />
            <param name="csvValuesAssumption" type="String" />
            <param name="collectionEntriesConclusion" type="java.util.Collection" />
            <param name="entryTypeNameConclusion" type="String" />
            <param name="entryPropertyNameConclusion" type="String" />
            <param name="csvGroupPropertiesNamesConclusion" type="String" />
            <param name="occurenceEntityConclusion" type="Object" />
            <param name="occurenceValueConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="entryValueAssumption" />
                    <param name="csvValues" assert-param-ref="csvValuesAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="singleOccurenceValueByGroup">
                    <param name="collectionEntries" assert-param-ref="collectionEntriesConclusion" />
                    <param name="entryTypeName" assert-param-ref="entryTypeNameConclusion" />
                    <param name="entryPropertyName" assert-param-ref="entryPropertyNameConclusion" />
                    <param name="csvGroupPropertiesNames" assert-param-ref="csvGroupPropertiesNamesConclusion" />
                    <param name="occurenceEntity" assert-param-ref="occurenceEntityConclusion" />
                    <param name="occurenceValue" assert-param-ref="occurenceValueConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifCsvEntryThenEqual">
            <param name="entryValueAssumption" type="String" />
            <param name="csvValuesAssumption" type="String" />
            <param name="equalParamConclusion" type="String" />
            <param name="equalValueConclusion" type="String" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="entryValueAssumption" />
                    <param name="csvValues" assert-param-ref="csvValuesAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="equalParamConclusion" />
                    <param name="equalValue" assert-param-ref="equalValueConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifCsvEntryThenNotEqual">
            <param name="entryValueAssumption" type="String" />
            <param name="csvValuesAssumption" type="String" />
            <param name="notEqualParamConclusion" type="String" />
            <param name="notEqualValueConclusion" type="String" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="entryValueAssumption" />
                    <param name="csvValues" assert-param-ref="csvValuesAssumption" />
                </param>
                <param name="impliesConclusion" assert-ref="notEqual">
                    <param name="notEqualParam" assert-param-ref="notEqualParamConclusion" />
                    <param name="notEqualValue" assert-param-ref="notEqualValueConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifCsvEntryThenNotCsvEntry">
            <param name="entryValueAssumption" type="String" />
            <param name="csvValuesAssumption" type="String" />
            <param name="notEntryValueConclusion" type="String" />
            <param name="notCsvValuesConclusion" type="String" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="entryValueAssumption" />
                    <param name="csvValues" assert-param-ref="csvValuesAssumption" />
                </param>
                <param name="impliesConclusion" assert-ref="notCsvEntry">
                    <param name="notEntryValue" assert-param-ref="notEntryValueConclusion" />
                    <param name="notCsvValues" assert-param-ref="notCsvValuesConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifEqualThenPropertyReferenceEntry">
            <param name="equalParamAssumption" type="String" />
            <param name="equalValueAssumption" type="String" />
            <param name="entityNameConclusion" type="String" />
            <param name="propertyNameConclusion" type="String" />
            <param name="propertyValueConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="equalParamAssumption" />
                    <param name="equalValue" assert-param-ref="equalValueAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="propertyReferenceEntry">
                    <param name="entityName" assert-param-ref="entityNameConclusion" />
                    <param name="propertyName" assert-param-ref="propertyNameConclusion" />
                    <param name="propertyValue" assert-param-ref="propertyValueConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifEqualAndNotEmptyThenRibChecker">
            <param name="equalParamAssumption" type="Object" />
            <param name="equalValueAssumption" type="Object" />
            <param name="notEmptyParamAssumption" type="Object" />
            <param name="ribValueConclusion" type="String" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="equalAndNotEmpty">
                    <param name="equalParam" assert-param-ref="equalParamAssumption" />
                    <param name="equalValue" assert-param-ref="equalValueAssumption" />
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="ribChecker">
                    <param name="ribValue" assert-param-ref="ribValueConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifCsvEntryAndCsvEntryThenNotEmpty">
            <param name="entryValue1Assumption" type="Object" />
            <param name="csvValues1Assumption" type="Object" />
            <param name="entryValue2Assumption" type="Object" />
            <param name="csvValues2Assumption" type="Object" />
            <param name="notEmptyParamConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="csvEntryAndCsvEntry">
                    <param name="entryValue1" assert-param-ref="entryValue1Assumption" />
                    <param name="csvValues1" assert-param-ref="csvValues1Assumption" />
                    <param name="entryValue2" assert-param-ref="entryValue2Assumption" />
                    <param name="csvValues2" assert-param-ref="csvValues2Assumption" />
                </param>
                <param name="impliesConclusion" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifCsvEntryThenNotEmpty">
            <param name="entryValueAssumption" type="Object" />
            <param name="csvValuesAssumption" type="Object" />
            <param name="notEmptyParamConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="entryValueAssumption" />
                    <param name="csvValues" assert-param-ref="csvValuesAssumption" />
                </param>
                <param name="impliesConclusion" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamConclusion" />
                </param>
            </formula>
        </assert>


        <assert name="ifCsvEntryAndCsvEntryThenEqual">
            <param name="entryValue1Assumption" type="Object" />
            <param name="csvValues1Assumption" type="Object" />
            <param name="entryValue2Assumption" type="Object" />
            <param name="csvValues2Assumption" type="Object" />
            <param name="equalParamConclusion" type="Object" />
            <param name="equalValueConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="csvEntryAndCsvEntry">
                    <param name="entryValue1" assert-param-ref="entryValue1Assumption" />
                    <param name="csvValues1" assert-param-ref="csvValues1Assumption" />
                    <param name="entryValue2" assert-param-ref="entryValue2Assumption" />
                    <param name="csvValues2" assert-param-ref="csvValues2Assumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="equal">
                    <param name="equalParam" assert-param-ref="equalParamConclusion" />
                    <param name="equalValue" assert-param-ref="equalValueConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifCsvEntryAndCsvEntryThenPropertyReferenceEntry">
            <param name="entryValue1Assumption" type="Object" />
            <param name="csvValues1Assumption" type="Object" />
            <param name="entryValue2Assumption" type="Object" />
            <param name="csvValues2Assumption" type="Object" />
            <param name="entityNameConclusion" type="Object" />
            <param name="propertyNameConclusion" type="Object" />
            <param name="propertyValueConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="csvEntryAndCsvEntry">
                    <param name="entryValue1" assert-param-ref="entryValue1Assumption" />
                    <param name="csvValues1" assert-param-ref="csvValues1Assumption" />
                    <param name="entryValue2" assert-param-ref="entryValue2Assumption" />
                    <param name="csvValues2" assert-param-ref="csvValues2Assumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="propertyReferenceEntry">
                    <param name="entityName" assert-param-ref="entityNameConclusion" />
                    <param name="propertyName" assert-param-ref="propertyNameConclusion" />
                    <param name="propertyValue" assert-param-ref="propertyValueConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifCsvEntryAndCsvEntryThenSygmaParticipantCodeBicExist">
            <param name="entryValue1Assumption" type="Object" />
            <param name="csvValues1Assumption" type="Object" />
            <param name="entryValue2Assumption" type="Object" />
            <param name="csvValues2Assumption" type="Object" />
            <param name="codeBicParticipantConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="csvEntryAndCsvEntry">
                    <param name="entryValue1" assert-param-ref="entryValue1Assumption" />
                    <param name="csvValues1" assert-param-ref="csvValues1Assumption" />
                    <param name="entryValue2" assert-param-ref="entryValue2Assumption" />
                    <param name="csvValues2" assert-param-ref="csvValues2Assumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="sygmaParticipantCodeBicExist">
                    <param name="codeBicParticipant" assert-param-ref="codeBicParticipantConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifCsvEntryAndCsvEntryThenSygmaParticipantNumeroCompteExist">
            <param name="entryValue1Assumption" type="Object" />
            <param name="csvValues1Assumption" type="Object" />
            <param name="entryValue2Assumption" type="Object" />
            <param name="csvValues2Assumption" type="Object" />
            <param name="numeroCompteParticipantConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="csvEntryAndCsvEntry">
                    <param name="entryValue1" assert-param-ref="entryValue1Assumption" />
                    <param name="csvValues1" assert-param-ref="csvValues1Assumption" />
                    <param name="entryValue2" assert-param-ref="entryValue2Assumption" />
                    <param name="csvValues2" assert-param-ref="csvValues2Assumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="sygmaParticipantNumeroCompteExist">
                    <param name="numeroCompteParticipant" assert-param-ref="numeroCompteParticipantConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifNotEmptyThenCsvEntry">
            <param name="notEmptyParamAssumption" type="Object" />
            <param name="entryValueConclusion" type="Object" />
            <param name="csvValuesConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="entryValueConclusion" />
                    <param name="csvValues" assert-param-ref="csvValuesConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifNotEmptyThenEqual">
            <param name="notEmptyParamAssumption" type="Object" />
            <param name="equalValueConclusion" type="Object" />
            <param name="equalParamConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="equal">
                    <param name="equalValue" assert-param-ref="equalValueConclusion" />
                    <param name="equalParam" assert-param-ref="equalParamConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifEqualThenNotEmpty">
            <param name="equalValueAssumption" type="Object" />
            <param name="equalParamAssumption" type="Object" />
            <param name="notEmptyParamConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="equal">
                    <param name="equalValue" assert-param-ref="equalValueAssumption" />
                    <param name="equalParam" assert-param-ref="equalParamAssumption" />
                </param>				
                <param name="impliesConclusion" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifNotEmptyThenNotEmpty">
            <param name="notEmptyParamAssumption" type="Object" />
            <param name="notEmptyParamConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamAssumption" />
                </param>
                <param name="impliesConclusion" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifNotCsvEntryThenNotEmpty">
            <param name="notEntryValueAssumption" type="Object" />
            <param name="notCsvValuesAssumption" type="Object" />
            <param name="notEmptyParamConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="notCsvEntry">
                    <param name="notEntryValue" assert-param-ref="notEntryValueAssumption" />
                    <param name="notCsvValues" assert-param-ref="notCsvValuesAssumption" />
                </param>
                <param name="impliesConclusion" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamConclusion" />
                </param>
            </formula>
        </assert>


        <assert name="ifNotEmptyThenPropertyReferenceEntry">
            <param name="notEmptyParamAssumption" type="Object" />
            <param name="entityNameConclusion" type="Object" />
            <param name="propertyNameConclusion" type="Object" />
            <param name="propertyValueConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="propertyReferenceEntry">
                    <param name="entityName" assert-param-ref="entityNameConclusion" />
                    <param name="propertyName" assert-param-ref="propertyNameConclusion" />
                    <param name="propertyValue" assert-param-ref="propertyValueConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifNotEmptyThenSygmaParticipantCodeBicExist">
            <param name="notEmptyParamAssumption" type="Object" />
            <param name="codeBicParticipantConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="sygmaParticipantCodeBicExist">
                    <param name="codeBicParticipant" assert-param-ref="codeBicParticipantConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifNotEmptyThenSygmaParticipantNumeroCompteExist">
            <param name="notEmptyParamAssumption" type="Object" />
            <param name="numeroCompteParticipantConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="sygmaParticipantNumeroCompteExist">
                    <param name="numeroCompteParticipant" assert-param-ref="numeroCompteParticipantConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifNotEmptyThenSygmaParticipantCodeBicWithPropertiesExist">
            <param name="notEmptyParamAssumption" type="Object" />
            <param name="codeBicParticipantConclusion" type="Object" />
            <param name="propertiesConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="sygmaParticipantCodeBicWithPropertiesExist">
                    <param name="codeBicParticipant" assert-param-ref="codeBicParticipantConclusion" />
                    <param name="properties" assert-param-ref="propertiesConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifNotEmptyThenSygmaParticipantNumeroCompteWithPropertiesExist">
            <param name="notEmptyParamAssumption" type="Object" />
            <param name="numeroCompteParticipantConclusion" type="Object" />
            <param name="propertiesConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="sygmaParticipantNumeroCompteWithPropertiesExist">
                    <param name="numeroCompteParticipant" assert-param-ref="numeroCompteParticipantConclusion" />
                    <param name="properties" assert-param-ref="propertiesConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifNotEmptyThenPropertiesReferenceEntry">
            <param name="notEmptyParamAssumption" type="Object" />
            <param name="entityNameConclusion" type="Object" />
            <param name="propertiesConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" assert-ref="notEmpty">
                    <param name="notEmptyParam" assert-param-ref="notEmptyParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="propertiesReferenceEntry">
                    <param name="entityName" assert-param-ref="entityNameConclusion" />
                    <param name="properties" assert-param-ref="propertiesConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifCsvEntryThenLazyNotEmptyValues">
            <param name="entryValueAssumption" type="Object" />
            <param name="csvValuesAssumption" type="Object" />
            <param name="lazyNotEmptyValuesParamConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="csvEntry">
                    <param name="entryValue" assert-param-ref="entryValueAssumption" />
                    <param name="csvValues" assert-param-ref="csvValuesAssumption" />
                </param>
                <param name="impliesConclusion" assert-ref="lazyNotEmptyValues">
                    <param name="lazyNotEmptyValuesParam" assert-param-ref="lazyNotEmptyValuesParamConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifNotEmptyValuesThenPropertyReferenceEntry">
            <param name="notEmptyValuesParamAssumption" type="String" />
            <param name="entityNameConclusion" type="String" />
            <param name="propertyNameConclusion" type="String" />
            <param name="propertyValueConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="notEmptyValues">
                    <param name="notEmptyValuesParam" assert-param-ref="notEmptyValuesParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="propertyReferenceEntry">
                    <param name="entityName" assert-param-ref="entityNameConclusion" />
                    <param name="propertyName" assert-param-ref="propertyNameConclusion" />
                    <param name="propertyValue" assert-param-ref="propertyValueConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifNotEmptyValuesThenSygmaParticipantCodeBicExist">
            <param name="notEmptyValuesParamAssumption" type="String" />
            <param name="codeBicParticipantConclusion" type="String" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="notEmptyValues">
                    <param name="notEmptyValuesParam" assert-param-ref="notEmptyValuesParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="sygmaParticipantCodeBicExist">
                    <param name="codeBicParticipant" assert-param-ref="codeBicParticipantConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifNotEmptyValuesThenSygmaParticipantNumeroCompteExist">
            <param name="notEmptyValuesParamAssumption" type="String" />
            <param name="numeroCompteParticipantConclusion" type="String" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="notEmptyValues">
                    <param name="notEmptyValuesParam" assert-param-ref="notEmptyValuesParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="sygmaParticipantNumeroCompteExist">
                    <param name="numeroCompteParticipant" assert-param-ref="numeroCompteParticipantConclusion" />
                </param>
            </formula>
        </assert>


        <assert name="ifNotEmptyValuesThenPropertiesReferenceEntry">
            <param name="notEmptyValuesParamAssumption" type="Object" />
            <param name="entityNameConclusion" type="Object" />
            <param name="propertiesConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="notEmptyValues">
                    <param name="notEmptyValuesParam" assert-param-ref="notEmptyValuesParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="propertiesReferenceEntry">
                    <param name="entityName" assert-param-ref="entityNameConclusion" />
                    <param name="properties" assert-param-ref="propertiesConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifNotEmptyValuesThenSygmaParticipantCodeBicWithPropertiesExist">
            <param name="notEmptyValuesParamAssumption" type="Object" />
            <param name="codeBicParticipantConclusion" type="Object" />
            <param name="propertiesConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="notEmptyValues">
                    <param name="notEmptyValuesParam" assert-param-ref="notEmptyValuesParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="sygmaParticipantCodeBicWithPropertiesExist">
                    <param name="codeBicParticipant" assert-param-ref="codeBicParticipantConclusion" />
                    <param name="properties" assert-param-ref="propertiesConclusion" />
                </param>
            </formula>
        </assert>

        <assert name="ifNotEmptyValuesThenSygmaParticipantNumeroCompteWithPropertiesExist">
            <param name="notEmptyValuesParamAssumption" type="Object" />
            <param name="numeroCompteParticipantConclusion" type="Object" />
            <param name="propertiesConclusion" type="Object" />
            <formula connector-ref="implies">
                <param name="impliesAssumption" predicate-ref="notEmptyValues">
                    <param name="notEmptyValuesParam" assert-param-ref="notEmptyValuesParamAssumption" />
                </param>
                <param name="impliesConclusion" predicate-ref="sygmaParticipantNumeroCompteWithPropertiesExist">
                    <param name="numeroCompteParticipant" assert-param-ref="numeroCompteParticipantConclusion" />
                    <param name="properties" assert-param-ref="propertiesConclusion" />
                </param>
            </formula>
        </assert>
               

    </asserts>

</predicate-engine>

 generatetxt/target/generatetxt-1.0-jar-with-dependencies.jar

Binary files differ

 generatetxt/target/generatetxt-1.0.jar

Binary files differ

 generatetxt/target/maven-archiver/pom.properties

New file
@@ -0,0 +1,5 @@
#Generated by Maven
#Wed Nov 19 13:05:27 WAT 2025
version=1.0
groupId=com.megatim
artifactId=generatetxt

 generatetxt/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst

New file
@@ -0,0 +1,24 @@
com\megatim\generatetxt\pojo\FileToValidateDescription.class
com\megatim\generatetxt\jaxb\Validation.class
com\megatim\generatetxt\utilities\Utilities.class
com\megatim\generatetxt\jaxb\ParamValue.class
com\megatim\generatetxt\jaxb\EntityList.class
com\megatim\generatetxt\pojo\ParseResult.class
com\megatim\generatetxt\constraints\FileToValidateDelimiterValidator.class
com\megatim\generatetxt\jaxb\PredicateConfig.class
com\megatim\generatetxt\utilities\ParserUtils.class
com\megatim\generatetxt\generate\ParseData.class
com\megatim\generatetxt\pojo\Delimiteur.class
com\megatim\generatetxt\utilities\ParserUtils$1.class
com\megatim\generatetxt\enums\DataType.class
com\megatim\generatetxt\model\TypeFichier.class
com\megatim\generatetxt\jaxb\Assertion.class
com\megatim\generatetxt\model\TruncatedElement.class
com\megatim\generatetxt\App.class
com\megatim\generatetxt\constraints\FileToValidateDelimiterConstraint.class
com\megatim\generatetxt\model\AlphaNumeriqueField.class
com\megatim\generatetxt\jaxb\Entity.class
com\megatim\generatetxt\pojo\Constantes.class
com\megatim\generatetxt\pojo\FileToValidate.class
com\megatim\generatetxt\pojo\ResultFileParsing.class
com\megatim\generatetxt\model\MetaAlphaNumeriqueField.class

 generatetxt/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst

New file
@@ -0,0 +1,23 @@
C:\Users\ASUS\Documents\NetBeansProjects\csv_to_txt\generatetxt\src\main\java\com\megatim\generatetxt\jaxb\ParamValue.java
C:\Users\ASUS\Documents\NetBeansProjects\csv_to_txt\generatetxt\src\main\java\com\megatim\generatetxt\model\TypeFichier.java
C:\Users\ASUS\Documents\NetBeansProjects\csv_to_txt\generatetxt\src\main\java\com\megatim\generatetxt\pojo\FileToValidateDescription.java
C:\Users\ASUS\Documents\NetBeansProjects\csv_to_txt\generatetxt\src\main\java\com\megatim\generatetxt\pojo\Constantes.java
C:\Users\ASUS\Documents\NetBeansProjects\csv_to_txt\generatetxt\src\main\java\com\megatim\generatetxt\constraints\FileToValidateDelimiterConstraint.java
C:\Users\ASUS\Documents\NetBeansProjects\csv_to_txt\generatetxt\src\main\java\com\megatim\generatetxt\jaxb\EntityList.java
C:\Users\ASUS\Documents\NetBeansProjects\csv_to_txt\generatetxt\src\main\java\com\megatim\generatetxt\jaxb\Validation.java
C:\Users\ASUS\Documents\NetBeansProjects\csv_to_txt\generatetxt\src\main\java\com\megatim\generatetxt\jaxb\Entity.java
C:\Users\ASUS\Documents\NetBeansProjects\csv_to_txt\generatetxt\src\main\java\com\megatim\generatetxt\utilities\ParserUtils.java
C:\Users\ASUS\Documents\NetBeansProjects\csv_to_txt\generatetxt\src\main\java\com\megatim\generatetxt\App.java
C:\Users\ASUS\Documents\NetBeansProjects\csv_to_txt\generatetxt\src\main\java\com\megatim\generatetxt\jaxb\Assertion.java
C:\Users\ASUS\Documents\NetBeansProjects\csv_to_txt\generatetxt\src\main\java\com\megatim\generatetxt\model\MetaAlphaNumeriqueField.java
C:\Users\ASUS\Documents\NetBeansProjects\csv_to_txt\generatetxt\src\main\java\com\megatim\generatetxt\pojo\Delimiteur.java
C:\Users\ASUS\Documents\NetBeansProjects\csv_to_txt\generatetxt\src\main\java\com\megatim\generatetxt\pojo\FileToValidate.java
C:\Users\ASUS\Documents\NetBeansProjects\csv_to_txt\generatetxt\src\main\java\com\megatim\generatetxt\enums\DataType.java
C:\Users\ASUS\Documents\NetBeansProjects\csv_to_txt\generatetxt\src\main\java\com\megatim\generatetxt\generate\ParseData.java
C:\Users\ASUS\Documents\NetBeansProjects\csv_to_txt\generatetxt\src\main\java\com\megatim\generatetxt\model\AlphaNumeriqueField.java
C:\Users\ASUS\Documents\NetBeansProjects\csv_to_txt\generatetxt\src\main\java\com\megatim\generatetxt\pojo\ResultFileParsing.java
C:\Users\ASUS\Documents\NetBeansProjects\csv_to_txt\generatetxt\src\main\java\com\megatim\generatetxt\utilities\Utilities.java
C:\Users\ASUS\Documents\NetBeansProjects\csv_to_txt\generatetxt\src\main\java\com\megatim\generatetxt\constraints\FileToValidateDelimiterValidator.java
C:\Users\ASUS\Documents\NetBeansProjects\csv_to_txt\generatetxt\src\main\java\com\megatim\generatetxt\pojo\ParseResult.java
C:\Users\ASUS\Documents\NetBeansProjects\csv_to_txt\generatetxt\src\main\java\com\megatim\generatetxt\model\TruncatedElement.java
C:\Users\ASUS\Documents\NetBeansProjects\csv_to_txt\generatetxt\src\main\java\com\megatim\generatetxt\jaxb\PredicateConfig.java

 generatetxt/target/maven-status/maven-compiler-plugin/testCompile/default-testCompile/inputFiles.lst