move to new repo

Kenmegne

6 days ago 8cbaa370347e6fc997381cf35d6c295685b90f98

move to new repo

 dynamicjsonparser/pom.xml

New file
@@ -0,0 +1,61 @@
<?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>dynamicjsonparser</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.dynamicjsonparser.Example</exec.mainClass>
    </properties>
    
    <dependencies>
        <dependency>
            <groupId>org.burningwave</groupId>
            <artifactId>core</artifactId>
            <version>12.64.2</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-xml</artifactId>
            <version>2.15.2</version>
        </dependency>
        <dependency>
            <groupId>commons-validator</groupId>
            <artifactId>commons-validator</artifactId>
            <version>1.6</version>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>            
            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>3.0.0</version>
                <configuration>
                    <archive>
                        <manifest>
                            <addClasspath>true</addClasspath>
                            <mainClass>com.megatim.dynamicjsonparser.Example</mainClass>
                        </manifest>
                    </archive>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
                <executions>
                    <execution>
                        <id>make-my-jar-with-dependencies</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>            
        </plugins>
    </build>
</project>

 dynamicjsonparser/src/main/java/com/megatim/dynamicjsonparser/App.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/Project/Maven2/JavaApp/src/main/java/${packagePath}/${mainClassName}.java to edit this template
 */
package com.megatim.dynamicjsonparser;

import java.io.IOException;

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

    static String packageName = "com.megatim.dynamicjsonparser.generated";

    public static void main(String[] args) throws IOException {

    }

}

 dynamicjsonparser/src/main/java/com/megatim/dynamicjsonparser/enums/TypeDonnee.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/Enum.java to edit this template
 */
package com.megatim.dynamicjsonparser.enums;

/**
 *
 * @author STEPHANIE
 */
public enum TypeDonnee {
    ALPHANUMERIQUE("ALPHANUMERIQUE"),
    NUMERIQUE("NUMERIQUE"),
    DECIMAL("DECIMAL"),
    DATE("DATE"),
    OBJET("OBJET");

    private final String value;

    private TypeDonnee(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    public static TypeDonnee fromValeur(String value) {
        if (value.equalsIgnoreCase("ALPHANUMERIQUE")) {
            return TypeDonnee.ALPHANUMERIQUE;
        } else if (value.equalsIgnoreCase("DATE")) {
            return TypeDonnee.DATE;
        } else if (value.equalsIgnoreCase("NUMERIQUE")) {
            return TypeDonnee.NUMERIQUE;
        } else if (value.equalsIgnoreCase("DECIMAL")) {
            return TypeDonnee.DECIMAL;
        } else {
            return null;
        }
    }

    @Override
    public String toString() {
        return value;
    }
}

 dynamicjsonparser/src/main/java/com/megatim/dynamicjsonparser/extender/DataRetrieverAction.java

New file
@@ -0,0 +1,79 @@
/*
 * 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.dynamicjsonparser.extender;

import com.megatim.dynamicjsonparser.pojo.CustomError;
import com.megatim.dynamicjsonparser.pojo.JsonField;
import com.megatim.dynamicjsonparser.pojo.JsonParsedData;
import com.megatim.dynamicjsonparser.pojo.Node;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Deque;
import java.util.List;
import java.util.concurrent.ConcurrentLinkedDeque;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;
import org.burningwave.core.Virtual;

/**
 *
 * @author ASUS
 */
public class DataRetrieverAction extends RecursiveTask<JsonParsedData> {

    //Liste des données extraites du fichier json
    private final List<Virtual> finalVirtuals = Collections.synchronizedList(new ArrayList<>());

    //Liste des erreurs recontrées dans le fichier json
    private final Deque<CustomError> deque = new ConcurrentLinkedDeque<>();

    private final List<Node> nodes;
    private final Class classOfEntity;
    private final List<JsonField> jsonFields;
    private final String rootClass;
    private final int nbThreads;

    public DataRetrieverAction(List<Node> nodes, Class classOfEntity, List<JsonField> jsonFields, String rootClass, int nbThreads) {
        this.nodes = nodes;
        this.classOfEntity = classOfEntity;
        this.jsonFields = jsonFields;
        this.rootClass = rootClass;
        this.nbThreads = nbThreads;
    }

    @Override
    protected JsonParsedData compute() {
        if (nbThreads > 1) {
            ForkJoinTask
                    .invokeAll(createSubtasks())
                    .stream()
                    .map(DataRetrieverAction::join)
                    .forEach(p -> {
                        deque.addAll(p.getErrors());
                        finalVirtuals.addAll(p.getVirtuals());
                    });
            return new JsonParsedData(finalVirtuals, new ArrayList<>(deque));
        } else {
            return new JsonDataProcessor(nodes, classOfEntity, jsonFields, rootClass).iterateThroughNodes();
        }
    }

    private List<DataRetrieverAction> createSubtasks() {
        List<DataRetrieverAction> subtasks = new ArrayList<>();
        int nbEltsPerTask = nodes.size() / nbThreads;
        int remainder = nodes.size() % nbThreads;

        for (int i = 0; i < nbThreads; i++) {
            if (remainder > 0 && i == nbThreads - 1) {
                subtasks.add(new DataRetrieverAction(nodes.subList(nbEltsPerTask * i, nbEltsPerTask * i + nbEltsPerTask + remainder), classOfEntity, jsonFields, rootClass, 1));
            } else {
                subtasks.add(new DataRetrieverAction(nodes.subList(nbEltsPerTask * i, nbEltsPerTask * i + nbEltsPerTask), classOfEntity, jsonFields, rootClass, 1));
            }
        }

        return subtasks;
    }

}

 dynamicjsonparser/src/main/java/com/megatim/dynamicjsonparser/extender/JsonDataProcessor.java

New file
@@ -0,0 +1,432 @@
/*
 * 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.dynamicjsonparser.extender;

import com.fasterxml.jackson.databind.JsonNode;
import com.megatim.dynamicjsonparser.pojo.CustomError;
import com.megatim.dynamicjsonparser.pojo.JsonField;
import com.megatim.dynamicjsonparser.pojo.JsonParsedData;
import com.megatim.dynamicjsonparser.pojo.Node;
import com.megatim.dynamicjsonparser.pojo.Indexe;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import org.apache.commons.validator.GenericValidator;
import org.burningwave.core.Virtual;
import org.burningwave.core.classes.Constructors;

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

    private final List<Node> nodes;
    private final Class classOfEntity;
    private final List<JsonField> jsonFields;
    private final String rootClass;

    private final JsonParsedData parsedData = new JsonParsedData();

    public JsonDataProcessor(List<Node> nodes, Class classOfEntity, List<JsonField> jsonFields, String rootClass) {
        this.nodes = nodes;
        this.classOfEntity = classOfEntity;
        this.jsonFields = jsonFields;
        this.rootClass = rootClass;
    }

    public JsonParsedData iterateThroughNodes() {
        for (Node node : nodes) {

            Virtual virtualObject = traverseNode(node.getNode(), classOfEntity, jsonFields, Arrays.asList(new Indexe(node.getIndex())),
                    rootClass);

            //Ajout de l'objet extrait dans la liste
            parsedData.getVirtuals().add(virtualObject);
        }
        return parsedData;
    }

    private JsonField retrieveField(List<JsonField> jsonFields, String fieldName) {
        Optional<JsonField> optJsonField = jsonFields.stream().filter(j -> j.getName().equalsIgnoreCase(fieldName)).findFirst();
        if (optJsonField.isPresent()) {
            return optJsonField.get();
        } else {
            return null;
        }
    }

    /**
     * Méthode permettant de parcourir recursivement les noeuds du fichier json
     *
     * @param node : noeud à parcourir
     * @param classOfEntity : classe Java du noeud à parcourir
     * @param map : map contenant tous champs de la classe Java à utiliser lors
     * de l'extraction
     * @param indexes : tableau contenant la hiérarchie des index, cad les index
     * permettant de déterminer la posotion précise du noeud dans le fichier
     * @return
     */
    private Virtual traverseNode(final JsonNode node, final Class classOfEntity, final List<JsonField> jsonFields, List<Indexe> indexes, String fullQualifiedNameOfField) {
        if (node != null && classOfEntity != null && jsonFields != null && !jsonFields.isEmpty()) {
            Iterator<Map.Entry<String, JsonNode>> nodeFields = node.fields();
            Virtual virtualObject = new Constructors().newInstanceOf(classOfEntity);
            Set<String> foundFields = new HashSet<>();//contient les champs rencontrés dans chaque noeud json

            Integer index = indexes.get(0).getPosition();

            while (nodeFields.hasNext()) {

                Map.Entry<String, JsonNode> entry = nodeFields.next();
                final JsonField dynamicField = retrieveField(jsonFields, entry.getKey());

                //Si c'est un attribut de l'objet en cours de traitement
                if (dynamicField != null) {
                    foundFields.add(entry.getKey());

                    if (entry.getValue().toString().equals("null")) {//si la valeur du noeud est à null
                        if (dynamicField.isRequired()) {
                            parsedData.getErrors().add(requiredErrorMessage(entry.getKey(), fullQualifiedNameOfField, indexes));
                        }
                    } else {
                        //Si la donnée que contient le noeud est un tableau
                        if (entry.getValue().isArray() && entry.getValue().size() > 0) {

                            JsonNode firstElement = entry.getValue().get(0);

                            //Si c'est un tableau d'objets
                            if (firstElement.isObject()) { //si c'est un tableau d'objets
                                traverseArrayOfObjectNodes(virtualObject, entry, dynamicField, indexes, fullQualifiedNameOfField);
                            } else {
                                traverseArrayOfTextualNodes(virtualObject, entry, dynamicField, indexes, fullQualifiedNameOfField);
                            }
                        } else if (entry.getValue().isObject()) {
                            traverseSingleObjectNode(virtualObject, entry, dynamicField, indexes, fullQualifiedNameOfField);
                        } else {
                            traverseSingleTextualNode(virtualObject, entry, dynamicField, indexes, fullQualifiedNameOfField);
                        }
                    }
                } else {
                    CustomError customError = constructErrorMessage(indexes);
                    customError.getMessage().append("Attribut ").append("\"").append(fullQualifiedNameOfField).append(".").append(entry.getKey()).append("\"")
                            .append(" inexistant dans la définition de l'entité ").append("\"")
                            .append(jsonFields.get(0).getClassName())
                            .append("\"");
                    parsedData.getErrors().add(customError);
                }

            }
            //Vérifier si des champs obligatoirs sont absents
            checkIfRequiredFieldIsAbsent(foundFields, jsonFields, indexes, fullQualifiedNameOfField);
            index++;

            return virtualObject;
        } else {
            return null;
        }
    }

    private void checkIfRequiredFieldIsAbsent(Set<String> foundFields, final List<JsonField> jsonFields, List<Indexe> indexes, String fullQualifiedNameOfField) {
        jsonFields.forEach(j -> {
            if (j.isRequired() && !foundFields.stream().filter(f->f.equalsIgnoreCase(j.getName())).findFirst().isPresent()) {
                parsedData.getErrors().add(requiredErrorMessage(j.getName(), fullQualifiedNameOfField, indexes));
            }
        });
    }

    private CustomError requiredErrorMessage(String key, String fullQualifiedNameOfField, List<Indexe> indexes) {
        CustomError customError = constructErrorMessage(indexes);
        customError.getMessage().append("La valeur de l'attribut ").append("\"").append(fullQualifiedNameOfField).append(".").append(key).append("\"")
                .append(" ne peut être nulle ");

        return customError;
    }

    private void traverseArrayOfTextualNodes(Virtual virtualObject, Map.Entry<String, JsonNode> entry, JsonField dynamicField, List<Indexe> indexes, String fullQualifiedNameOfField) {

        if (entry.getValue().toString().equals("null") || entry.getValue().size() == 0) {
            if (dynamicField.isRequired()) {
                parsedData.getErrors().add(requiredErrorMessage(entry.getKey(), fullQualifiedNameOfField, indexes));
            }
            return;
        }
        Class classOfField = dynamicField.getClazz();
        CustomError customError = constructErrorMessage(indexes);
        customError.getMessage().append("\"").append(fullQualifiedNameOfField).append(".").append(entry.getKey()).append("\"").append(" {");

        boolean isTextFormatted = true;
        List<Object> values = new ArrayList<>();

        //On valide chaque élément du tableau
        for (int i = 0; i < entry.getValue().size(); i++) {
            Object finalObject = validateValue(entry.getValue().get(i).asText(), dynamicField);

            //Si l'objet retourné après validation est nul, alors la validation a échoué
            if (finalObject == null) {
                customError.getMessage().append(" Elément N°").append(i + 1).append(" est mal formaté").append(", ");//On renseigne la position de l'élément qui a échoué
                isTextFormatted = false;

            } else if (finalObject.toString().length() > dynamicField.getLengthh()) {
                customError.getMessage().append(" Elément N°").append(i + 1).append(" La taille de la donnée est supérieure à la taille attendue").append(", ");//On renseigne la position de l'élément qui a échoué
                isTextFormatted = false;
            }
            values.add(finalObject);// ajouter l'élément au tableau final
        }

        if (!isTextFormatted) {
            customError.getMessage().replace(customError.getMessage().length() - 2, customError.getMessage().length(), " }");
            parsedData.getErrors().add(customError);
        }

        List finalValues = convertToRealType(values, classOfField);
        virtualObject.invoke(setterofField(dynamicField.getName()), finalValues);
    }

    private void traverseArrayOfObjectNodes(Virtual virtualObject, Map.Entry<String, JsonNode> entry, JsonField dynamicField, List<Indexe> indexes, String fullQualifiedNameOfField) {
        if (entry.getValue().toString().equals("null") || entry.getValue().size() == 0) {
            if (dynamicField.isRequired()) {
                parsedData.getErrors().add(requiredErrorMessage(entry.getKey(), fullQualifiedNameOfField, indexes));
            }
            return;
        }
        List<Virtual> virtuals = new ArrayList<>();
        List<Indexe> subIndexes = new ArrayList<>();
        subIndexes.addAll(indexes);

        subIndexes.add(new Indexe(1, fullQualifiedNameOfField + "." + entry.getKey()));

        for (int i = 0; i < entry.getValue().size(); i++) {

            //Valider de façon récursive les objets du tableau
            virtuals.add(traverseNode(entry.getValue().get(i), dynamicField.getClazz(), dynamicField.getDynamicFields(), subIndexes, fullQualifiedNameOfField + "." + entry.getKey()));

            int subPosition = subIndexes.get(subIndexes.size() - 1).getPosition();
            subIndexes.get(subIndexes.size() - 1).setPosition(subPosition + 1);
        }

        virtualObject.invoke(setterofField(dynamicField.getName()), virtuals);
    }

    private void traverseSingleTextualNode(Virtual virtualObject, Map.Entry<String, JsonNode> entry, JsonField dynamicField, List<Indexe> indexes, String fullQualifiedNameOfField) {
        if (entry.getValue().toString().equals("null") || entry.getValue().asText().isEmpty()) {
            if (dynamicField.isRequired()) {
                parsedData.getErrors().add(requiredErrorMessage(entry.getKey(), fullQualifiedNameOfField, indexes));
            }
            return;
        }
        Object finalValue = validateValue(entry.getValue().asText(), dynamicField);

        if (finalValue == null) {
            CustomError customError = constructErrorMessage(indexes);
            customError.getMessage().append("\"").append(fullQualifiedNameOfField).append(".").append(entry.getKey()).append("\"").append(" est mal formaté");
            parsedData.getErrors().add(customError);

        } else if (finalValue.toString().length() > dynamicField.getLengthh()) {
            CustomError customError = constructErrorMessage(indexes);
            customError.getMessage().append("\"").append(fullQualifiedNameOfField).append(".").append(entry.getKey()).append("\"").append(" La taille de la donnée est supérieure à la taille attendue");
            parsedData.getErrors().add(customError);
        } else {
            virtualObject.invoke(setterofField(dynamicField.getName()), finalValue);
        }
    }

    private void traverseSingleObjectNode(Virtual virtualObject, Map.Entry<String, JsonNode> entry, JsonField dynamicField, List<Indexe> indexes, String fullQualifiedNameOfField) {
        List<Indexe> subIndexes = new ArrayList<>();
        subIndexes.addAll(indexes);
        subIndexes.add(new Indexe(entry.getKey()));

        if (entry.getValue().toString().equals("null")) {
            if (dynamicField.isRequired()) {
                parsedData.getErrors().add(requiredErrorMessage(entry.getKey(), fullQualifiedNameOfField, indexes));
            }
            return;
        }
        Virtual virtual = traverseNode(entry.getValue(), dynamicField.getClazz(), dynamicField.getDynamicFields(), subIndexes, fullQualifiedNameOfField + "." + entry.getKey());

        virtualObject.invoke(setterofField(dynamicField.getName()), virtual);
    }

    private boolean validateDate(String value, String formatDate, String separateurDate) {
        boolean result = false;

        StringBuilder dateToValidate = new StringBuilder(0);

        if (separateurDate != null && !separateurDate.isEmpty()) {

            String[] dateArray = value.split(separateurDate);

            for (String d : dateArray) {
                dateToValidate.append(d);
            }
        } else {
            dateToValidate = new StringBuilder(value);
        }

        if (formatDate != null && !formatDate.isEmpty()) {
            result = GenericValidator.isDate(dateToValidate.toString(), formatDate, false);
        }
        return result;
    }

    /**
     * Méthode qui validate une donnée
     *
     * @param value
     * @param classOfField
     * @return
     */
    private Object validateValue(String value, JsonField dynamicField) {
        Object finalValue = null;
        Class classOfField = dynamicField.getClazz();

        try {
            if (classOfField.isAssignableFrom(LocalDate.class)) {

                boolean isFormatted = validateDate(value, dynamicField.getFormatDate(), dynamicField.getSeparateurDate());

                if (isFormatted) {
                    finalValue = value;
                }

            } else if (classOfField.isAssignableFrom(Long.class)) {

                finalValue = Long.valueOf(value);
            } else if (classOfField.isAssignableFrom(BigDecimal.class)) {
                finalValue = new BigDecimal(value);

            } else {
                finalValue = value;
            }
        } catch (Exception ex) {
        }
        return finalValue;
    }

    private List<LocalDate> convertListOfDate(List<Object> genericValues) {
        List<LocalDate> listeLocalDate = new ArrayList<>();

        genericValues.forEach(g -> {

            LocalDate localDate = null;

            if (g != null) {
                localDate = (LocalDate) g;
            }

            listeLocalDate.add(localDate);
        });
        return listeLocalDate;
    }

    private List<Long> convertListOfLong(List<Object> genericValues) {
        List<Long> listeLong = new ArrayList<>();

        genericValues.forEach(g -> {

            Long longValue = null;

            if (g != null) {
                longValue = (Long) g;
            }
            listeLong.add(longValue);
        });

        return listeLong;
    }

    private List<BigDecimal> convertListOfBigDecimal(List<Object> genericValues) {
        List<BigDecimal> listeBigDecimal = new ArrayList<>();

        genericValues.forEach(g -> {

            BigDecimal bigDecimalValue = null;

            if (g != null) {
                bigDecimalValue = (BigDecimal) g;
            }

            listeBigDecimal.add(bigDecimalValue);
        });

        return listeBigDecimal;
    }

    private List<String> convertListOfString(List<Object> genericValues) {
        List<String> listeString = new ArrayList<>();

        genericValues.forEach(g -> {

            String str = null;

            if (g != null) {
                str = (String) g;
            }

            listeString.add(str);
        });
        return listeString;
    }

    /**
     * Méthode qui converti une liste d'objets en une liste d'un type précis
     *
     * @param genericValues
     * @param classOfField
     * @return
     */
    private List convertToRealType(List<Object> genericValues, Class classOfField) {

        if (classOfField.isAssignableFrom(LocalDate.class)) {
            return convertListOfDate(genericValues);

        } else if (classOfField.isAssignableFrom(Long.class)) {
            return convertListOfLong(genericValues);

        } else if (classOfField.isAssignableFrom(BigDecimal.class)) {
            return convertListOfBigDecimal(genericValues);

        } else {
            return convertListOfString(genericValues);
        }
    }

    private CustomError constructErrorMessage(List<Indexe> indexes) {
        StringBuilder error = new StringBuilder();
        CustomError customError = new CustomError();
        customError.setEltNumber(indexes.get(0).getPosition());

        indexes.forEach(indexe -> {

            if (indexe.getFullQualifiedNameOfField() != null && !indexe.getFullQualifiedNameOfField().isEmpty() && indexe.getPosition() != 0) {
                error.append("\"").append(indexe.getFullQualifiedNameOfField()).append("\"").append(" : ").append("Elément N° ").append(indexe.getPosition()).append(" : ");

            } else if (indexe.getFullQualifiedNameOfField() != null && !indexe.getFullQualifiedNameOfField().isEmpty()) {
                error.append("\"").append(indexe.getFullQualifiedNameOfField()).append("\"").append(" : ");

            } else if (indexe.getPosition() != 0) {
                error.append("Elément N° ").append(indexe.getPosition()).append(" : ");
            }
        });

        customError.setMessage(error);
        return customError;
    }

    private static String setterofField(String fieldName) {

        String name = String.valueOf(fieldName.charAt(0)).toUpperCase() + fieldName.substring(1);

        return "set" + name;
    }
}

 dynamicjsonparser/src/main/java/com/megatim/dynamicjsonparser/extender/JsonDataValidator.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.dynamicjsonparser.extender;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.megatim.dynamicjsonparser.pojo.CustomError;
import com.megatim.dynamicjsonparser.pojo.JsonField;
import com.megatim.dynamicjsonparser.pojo.JsonParsedData;
import com.megatim.dynamicjsonparser.pojo.Node;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.burningwave.core.assembler.ComponentContainer;
import org.burningwave.core.assembler.ComponentSupplier;
import org.burningwave.core.classes.ClassFactory;
import org.burningwave.core.classes.UnitSourceGenerator;
import java.util.Collections;
import java.util.concurrent.ForkJoinPool;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * Classe permettant d'extraire les données d'un fichier json, de les valider
 *
 * @author ASUS
 */
public class JsonDataValidator {

    private JsonParsedData parsedData;

    public JsonParsedData getParsedData() {
        return parsedData;
    }

    /**
     * Méthode permettant d'extraire les données d'in fichier json
     *
     * @param dynamicFields
     * @param storePath
     * @param packageName : nom du package de la classe
     * @param dataFile : fichier Json d'où proviennent les données à valider
     * @param nbThreads
     * @return : retourne vrai si la validation a été un succès, faux sinon
     * @throws IOException
     */
    public boolean validateDatas(List<JsonField> dynamicFields, String storePath, String packageName, final File dataFile, int nbThreads) throws IOException {

        // objet qui contient ls informations sur la classe dont on veut parser les instances
        UnitSourceGenerator unitSG = RuntimeClassBuilder.createRuntimeClass(packageName, dynamicFields, storePath);

        if (unitSG != null && packageName != null && !packageName.isEmpty() && dynamicFields != null && !dynamicFields.isEmpty() && dataFile != null) {
            unitSG.make();

            ComponentSupplier componentSupplier = ComponentContainer.getInstance();
            ClassFactory classFactory = componentSupplier.getClassFactory();

            try ( ClassFactory.ClassRetriever classRetriever = classFactory.loadOrBuildAndDefine(unitSG)) {
                Class classOfEntity = classRetriever.get(packageName + "." + dynamicFields.get(0).getClassName());

                ObjectMapper mapper = new ObjectMapper();
                JsonNode parentNode = mapper.readTree(dataFile);

                parsedData = process(parentNode, classOfEntity, dynamicFields, dynamicFields.get(0).getClassName(), nbThreads);
            }
        }
        parsedData.getErrors().removeIf(c -> c == null || c.getEltNumber() == null);
        Collections.sort(parsedData.getErrors(), (CustomError c1, CustomError c2) -> c1.getEltNumber().compareTo(c2.getEltNumber()));

        return parsedData.getErrors().isEmpty();
    }

    /**
     *
     * @param parentNode
     * @param classOfEntity
     * @param rootClass
     */
    private JsonParsedData process(JsonNode parentNode, Class classOfEntity, List<JsonField> dynamicFields, String rootClass, int nbThreads) {
        Map<String, JsonField> dynamicFieldsToMap = dynamicFields.stream().collect(Collectors.toMap(JsonField::getName, Function.identity()));
        List<Node> nodes = constructList(parentNode);
        
        ForkJoinPool pool = new ForkJoinPool();
        return pool.invoke(new DataRetrieverAction(nodes, classOfEntity, dynamicFields, rootClass, nbThreads));
    }

    private List<Node> constructList(JsonNode parent) {
        List<Node> nodes = new ArrayList<>();

        if (parent.isArray()) {//Si les données sont dans un tableau {
            for (int j = 0; j < parent.size(); j++) {
                nodes.add(new Node(parent.get(j), j + 1));
            }
        } else if (!parent.isEmpty()) {
            nodes.add(new Node(parent, 1));
        }
        return nodes;
    }
}

 dynamicjsonparser/src/main/java/com/megatim/dynamicjsonparser/extender/RuntimeClassBuilder.java

New file
@@ -0,0 +1,153 @@
/*
 * 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.dynamicjsonparser.extender;

import com.megatim.dynamicjsonparser.pojo.JsonField;
import java.io.Serializable;
import java.lang.reflect.Modifier;
import java.time.LocalDate;
import java.util.List;
import org.burningwave.core.Virtual;
import org.burningwave.core.assembler.ComponentContainer;
import org.burningwave.core.assembler.ComponentSupplier;
import org.burningwave.core.classes.AnnotationSourceGenerator;
import org.burningwave.core.classes.ClassFactory;
import org.burningwave.core.classes.ClassSourceGenerator;
import org.burningwave.core.classes.FunctionSourceGenerator;
import org.burningwave.core.classes.GenericSourceGenerator;
import org.burningwave.core.classes.TypeDeclarationSourceGenerator;
import org.burningwave.core.classes.UnitSourceGenerator;
import org.burningwave.core.classes.VariableSourceGenerator;

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

    /**
     * Méthode qui crée dynamiquement une classe Java
     * @param packagename : nom du package de la classe
     * @param fields : liste des chmaps de la classe
     * @param classPathFolder : chemin où sera stocké la classe sur le disque
     * @return 
     */
    public static UnitSourceGenerator createRuntimeClass(final String packagename, List<JsonField> fields,String classPathFolder) {
        final String className = fields.get(0).getClassName();

        //Ajout modificateur d'accès de la classe
        ClassSourceGenerator clazz = ClassSourceGenerator
                .create(TypeDeclarationSourceGenerator.create(className))
                .addModifier(Modifier.PUBLIC);

        //Ajout des interfaces à implémenter
        clazz.addConcretizedType(Serializable.class)
                .addConcretizedType(Virtual.class);

        //Déclaration des champs de la classe
        fields.forEach(f -> {

            //Si le type du champ est encore à construire
            if (f.getDynamicFields() != null && !f.getDynamicFields().isEmpty()) {

                //Appel récursif afin de construire le sous-type
                UnitSourceGenerator subUnitSG = createRuntimeClass(packagename, f.getDynamicFields(),classPathFolder);

                ComponentSupplier componentSupplier = ComponentContainer.getInstance();
                ClassFactory classFactory = componentSupplier.getClassFactory();

                try ( ClassFactory.ClassRetriever classRetriever = classFactory.loadOrBuildAndDefine(subUnitSG)) {
                    
                    Class classOfField = classRetriever.get(packagename + "." + f.getDynamicFields().get(0).getClassName());
                    f.setClazz(classOfField);
                }

            }

            //Si le type du champ est connu
            if (f.getClazz() != null) {

                if (f.isCollection()) {
                    clazz.addField(VariableSourceGenerator.create(TypeDeclarationSourceGenerator.create(List.class).addGeneric(GenericSourceGenerator.create(f.getClazz())), f.getName())
                            .addModifier(Modifier.PRIVATE));
                } else {
                    Class realClass = f.getClazz().equals(LocalDate.class) ? String.class : f.getClazz();
                    clazz.addField(
                            VariableSourceGenerator.create(realClass, f.getName())
                                    .addModifier(Modifier.PRIVATE)
                    );
                }

            }
        });

        //Déclaration du constructeur sans argument
        clazz.addConstructor(FunctionSourceGenerator.create().addModifier(Modifier.PUBLIC).addBodyCodeLine());

        fields.forEach(f -> {
            String fieldName = String.valueOf(f.getName().charAt(0)).toUpperCase() + f.getName().substring(1);

            if (f.getClazz() != null) {

                //Déclaration du getter de chaque attribut
                FunctionSourceGenerator getter = FunctionSourceGenerator.create("get" + fieldName)
                        .addModifier(Modifier.PUBLIC)
                        .addBodyCodeLine("return this." + f.getName() + ";");

                Class realClass = f.getClazz().equals(LocalDate.class) ? String.class : f.getClazz();
                
                if(f.isCollection()) {
                    getter.setReturnType(TypeDeclarationSourceGenerator.create(List.class).addGeneric(GenericSourceGenerator.create(realClass)));
                    
                } else {
                    getter.setReturnType(realClass);
                }
                clazz.addMethod(getter);
                
                //Déclaration du setter de chaque attribut
                FunctionSourceGenerator setter = FunctionSourceGenerator.create("set" + fieldName)
                        .addModifier(Modifier.PUBLIC)
                        .setReturnType(void.class)
                        .addBodyCodeLine("this." + f.getName() + " = " + f.getName() + ";");
                
                 if(f.isCollection()) {
                    setter.addParameter(VariableSourceGenerator.create(TypeDeclarationSourceGenerator.create(List.class).addGeneric(GenericSourceGenerator.create(realClass)), f.getName()));
                } else {
                    setter.addParameter(VariableSourceGenerator.create(realClass, f.getName()));
                }
                clazz.addMethod(setter);
            }
        });

        //Définition de la valeur de retour de la méthode toString()
        StringBuilder toString = new StringBuilder();
        for (JsonField f : fields) {
            toString.append("this.").append(f.getName()).append("+").append("\",\"").append("+");
        }

        //Retirer les caractères +","+
        toString.replace(toString.length() - 5, toString.length(), "");

        //Déclaration de la méthode toString
        clazz.addMethod(
                FunctionSourceGenerator.create("toString")
                        .addAnnotation(AnnotationSourceGenerator.create(Override.class))
                        .addModifier(Modifier.PUBLIC)
                        .setReturnType(String.class)
                        .addBodyCodeLine("return " + toString + ";")
        );

        UnitSourceGenerator unitSG = UnitSourceGenerator.create(packagename).addClass(clazz);
        unitSG.make();

        //Enregistre la classe sur le disque 
        if(classPathFolder != null && !classPathFolder.isEmpty()) {
            unitSG.storeToClassPath(classPathFolder);
        }

        return unitSG;
    }

}

 dynamicjsonparser/src/main/java/com/megatim/dynamicjsonparser/extender/SourceCompiler.java

New file
@@ -0,0 +1,35 @@
/*
 * 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.dynamicjsonparser.extender;

import org.burningwave.core.assembler.ComponentContainer;
import static org.burningwave.core.assembler.StaticComponentContainer.ClassLoaders;
import org.burningwave.core.classes.JavaMemoryCompiler;
import org.burningwave.core.classes.JavaMemoryCompiler.Compilation;
import org.burningwave.core.classes.UnitSourceGenerator;
import org.burningwave.core.concurrent.QueuedTaskExecutor.ProducerTask;

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

    public static Class<?> compileAndLoad(UnitSourceGenerator unitSG, String binaryFilePath, String fullQualifiedName) throws ClassNotFoundException {
        ComponentContainer componentContainer = ComponentContainer.getInstance();
        JavaMemoryCompiler javaMemoryCompiler = componentContainer.getJavaMemoryCompiler();

        ProducerTask<Compilation.Result> compilationTask = javaMemoryCompiler.compile(
                Compilation.Config.forUnitSourceGenerator(unitSG).storeCompiledClassesTo(binaryFilePath));
        Compilation.Result compilationResult = compilationTask.join();

        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        ClassLoaders.addClassPaths(classLoader, compilationResult.getDependencies());
        ClassLoaders.addClassPath(classLoader, compilationResult.getClassPath().getAbsolutePath());

        return classLoader.loadClass(fullQualifiedName);
    }

}

 dynamicjsonparser/src/main/java/com/megatim/dynamicjsonparser/generated/CompteBancaire.java

New file
@@ -0,0 +1,54 @@
package com.megatim.dynamicjsonparser.generated;

import java.io.Serializable;
import java.lang.Override;
import java.lang.String;
import java.math.BigDecimal;
import org.burningwave.core.Virtual;

public class CompteBancaire implements Serializable, Virtual { 

    private String dateCreation;
    private String rib;
    private BigDecimal solde; 

    public CompteBancaire() {
		
    } 

    public String getDateCreation() {
        return this.dateCreation; 
    }
	
    public void setDateCreation(
        String dateCreation
    ) {
        this.dateCreation = dateCreation; 
    }
	
    public String getRib() {
        return this.rib; 
    }
	
    public void setRib(
        String rib
    ) {
        this.rib = rib; 
    }
	
    public BigDecimal getSolde() {
        return this.solde; 
    }
	
    public void setSolde(
        BigDecimal solde
    ) {
        this.solde = solde; 
    }
	
    @Override
    public String toString() {
        return this.dateCreation+","+this.rib+","+this.solde; 
    } 

}

 dynamicjsonparser/src/main/java/com/megatim/dynamicjsonparser/generated/Personne.java

New file
@@ -0,0 +1,79 @@
package com.megatim.dynamicjsonparser.generated;

import com.megatim.dynamicjsonparser.generated.CompteBancaire;
import java.io.Serializable;
import java.lang.Long;
import java.lang.Override;
import java.lang.String;
import java.math.BigDecimal;
import java.util.List;
import org.burningwave.core.Virtual;

public class Personne implements Serializable, Virtual { 

    private List<Long> numeros;
    private Long nbreEnfants;
    private String dateNaissance;
    private BigDecimal salaire;
    private List<CompteBancaire> cptBanque; 

    public Personne() {
		
    } 

    public List<Long> getNumeros() {
        return this.numeros; 
    }
	
    public void setNumeros(
        List<Long> numeros
    ) {
        this.numeros = numeros; 
    }
	
    public Long getNbreEnfants() {
        return this.nbreEnfants; 
    }
	
    public void setNbreEnfants(
        Long nbreEnfants
    ) {
        this.nbreEnfants = nbreEnfants; 
    }
	
    public String getDateNaissance() {
        return this.dateNaissance; 
    }
	
    public void setDateNaissance(
        String dateNaissance
    ) {
        this.dateNaissance = dateNaissance; 
    }
	
    public BigDecimal getSalaire() {
        return this.salaire; 
    }
	
    public void setSalaire(
        BigDecimal salaire
    ) {
        this.salaire = salaire; 
    }
	
    public List<CompteBancaire> getCptBanque() {
        return this.cptBanque; 
    }
	
    public void setCptBanque(
        List<CompteBancaire> cptBanque
    ) {
        this.cptBanque = cptBanque; 
    }
	
    @Override
    public String toString() {
        return this.numeros+","+this.nbreEnfants+","+this.dateNaissance+","+this.salaire+","+this.cptBanque; 
    } 

}

 dynamicjsonparser/src/main/java/com/megatim/dynamicjsonparser/pojo/CustomError.java

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

/**
 *
 * @author ASUS
 */
public class CustomError {
    private StringBuilder message;
    
    private Integer eltNumber;

    public StringBuilder getMessage() {
        return message;
    }

    public void setMessage(StringBuilder message) {
        this.message = message;
    }

    public Integer getEltNumber() {
        return eltNumber;
    }

    public void setEltNumber(Integer eltNumber) {
        this.eltNumber = eltNumber;
    }
    
    
}

 dynamicjsonparser/src/main/java/com/megatim/dynamicjsonparser/pojo/Indexe.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.dynamicjsonparser.pojo;

/**
 *
 * @author ASUS
 */
public class Indexe {
    private int position;
    
    private String fullQualifiedNameOfField;

    public Indexe(int position) {
        this.position = position;
    }
    
    public Indexe(int position, String fullQualifiedNameOfField) {
        this.position = position;
        this.fullQualifiedNameOfField = fullQualifiedNameOfField;
    }
    
     public Indexe(String fullQualifiedNameOfField) {
        this.fullQualifiedNameOfField = fullQualifiedNameOfField;
    }

    public int getPosition() {
        return position;
    }

    public void setPosition(int position) {
        this.position = position;
    }

    public String getFullQualifiedNameOfField() {
        return fullQualifiedNameOfField;
    }

    public void setFullQualifiedNameOfField(String fullQualifiedNameOfField) {
        this.fullQualifiedNameOfField = fullQualifiedNameOfField;
    }

    
}

 dynamicjsonparser/src/main/java/com/megatim/dynamicjsonparser/pojo/JsonDataType.java

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

import com.megatim.dynamicjsonparser.enums.TypeDonnee;
import java.util.ArrayList;
import java.util.List;

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

    //nom du champ
    private String fieldName;

    //Type du champ si ce type est un primitif
    private TypeDonnee typeDonnee;

    // Liste des attributs de l'objet, si le type du champ est un objet Java à définir
    private List<JsonDataType> jsonDataTypes = new ArrayList<>();

    //Renseigne si ce champ est une collection(liste)
    private boolean collection;

    //Nom de la classe à laquelle appartient ce champ
    private String className;

    private String formatDate;

    private String separateurDate;

    private boolean required;

    public JsonDataType(String fieldName, TypeDonnee typeDonnee, String className, boolean collection) {
        this.fieldName = fieldName;
        this.typeDonnee = typeDonnee;
        this.className = className;
        this.collection = collection;
    }

    public JsonDataType(String fieldName, List<JsonDataType> jsonDataTypes, String className, boolean collection) {
        this.fieldName = fieldName;
        this.jsonDataTypes = jsonDataTypes;
        this.className = className;
        this.collection = collection;
        this.typeDonnee = TypeDonnee.OBJET;
    }

    public JsonDataType(String fieldName, TypeDonnee typeDonnee, String className, boolean required, boolean collection) {
        this.fieldName = fieldName;
        this.typeDonnee = typeDonnee;
        this.className = className;
        this.required = required;
        this.collection = collection;
    }

    public JsonDataType(String fieldName, List<JsonDataType> jsonDataTypes, String className, boolean required, boolean collection) {
        this.fieldName = fieldName;
        this.jsonDataTypes = jsonDataTypes;
        this.className = className;
        this.required = required;
        this.collection = collection;
        this.typeDonnee = TypeDonnee.OBJET;
    }

    @Override
    public String toString() {
        return "JsonDataType{" + "fieldName=" + fieldName + ", typeDonnee=" + typeDonnee + ", jsonDataTypes=" + jsonDataTypes + ", collection=" + collection + ", className=" + className + ", formatDate=" + formatDate + ", separateurDate=" + separateurDate + ", required=" + required + '}';
    }

    public String getFieldName() {
        return fieldName;
    }

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

    public TypeDonnee getTypeDonnee() {
        return typeDonnee;
    }

    public void setTypeDonnee(TypeDonnee typeDonnee) {
        this.typeDonnee = typeDonnee;
    }

    public List<JsonDataType> getJsonDataTypes() {
        return jsonDataTypes;
    }

    public void setJsonDataTypes(List<JsonDataType> jsonDataTypes) {
        this.jsonDataTypes = jsonDataTypes;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public boolean isCollection() {
        return collection;
    }

    public void setCollection(boolean collection) {
        this.collection = collection;
    }

    public String getFormatDate() {
        return formatDate;
    }

    public void setFormatDate(String formatDate) {
        this.formatDate = formatDate;
    }

    public String getSeparateurDate() {
        return separateurDate;
    }

    public void setSeparateurDate(String separateurDate) {
        this.separateurDate = separateurDate;
    }

    public boolean isRequired() {
        return required;
    }

    public void setRequired(boolean required) {
        this.required = required;
    }
}

 dynamicjsonparser/src/main/java/com/megatim/dynamicjsonparser/pojo/JsonField.java

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

import java.util.ArrayList;
import java.util.List;

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

    private Class clazz;

    private final String name;

    private final String className;

    private int lengthh;

    private List<JsonField> dynamicFields = new ArrayList<>();

    private final boolean collection;

    private boolean required;

    private String formatDate;

    private String separateurDate;

    public JsonField(Class clazz, String name, String className, boolean collection) {
        this.clazz = clazz;
        this.name = name;
        this.className = className;
        this.collection = collection;
    }

    public JsonField(String name, List<JsonField> dynamicFields, String className, boolean collection) {
        this.name = name;
        this.dynamicFields = dynamicFields;
        this.className = className;
        this.collection = collection;
    }

    public JsonField(Class clazz, String name, String className, int lengthh, boolean required, boolean collection) {
        this.clazz = clazz;
        this.name = name;
        this.className = className;
        this.lengthh = lengthh;
        this.required = required;
        this.collection = collection;
    }

    public JsonField(String name, List<JsonField> dynamicFields, String className, int lengthh, boolean required, boolean collection) {
        this.name = name;
        this.dynamicFields = dynamicFields;
        this.className = className;
        this.lengthh = lengthh;
        this.required = required;
        this.collection = collection;
    }

    @Override
    public String toString() {
        return "DynamicField{" + "clazz=" + clazz + ", name=" + name + ", className=" + className + ", dynamicFields=" + dynamicFields + ", collection=" + collection + ", required=" + required + ", formatDate=" + formatDate + ", separateurDate=" + separateurDate + '}';
    }

    public Class getClazz() {
        return clazz;
    }

    public void setClazz(Class clazz) {
        this.clazz = clazz;
    }

    public String getName() {
        return name;
    }

    public String getClassName() {
        return className;
    }

    public List<JsonField> getDynamicFields() {
        return dynamicFields;
    }

    public void setDynamicFields(List<JsonField> dynamicFields) {
        this.dynamicFields = dynamicFields;
    }

    public boolean isCollection() {
        return collection;
    }

    public String getFormatDate() {
        return formatDate;
    }

    public void setFormatDate(String formatDate) {
        this.formatDate = formatDate;
    }

    public String getSeparateurDate() {
        return separateurDate;
    }

    public void setSeparateurDate(String separateurDate) {
        this.separateurDate = separateurDate;
    }

    public boolean isRequired() {
        return required;
    }

    public void setRequired(boolean required) {
        this.required = required;
    }

    public int getLengthh() {
        return lengthh;
    }

    public void setLengthh(int lengthh) {
        this.lengthh = lengthh;
    }
}

 dynamicjsonparser/src/main/java/com/megatim/dynamicjsonparser/pojo/JsonParsedData.java

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

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.burningwave.core.Virtual;

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

    //Liste des données
    private List<Virtual> virtuals = Collections.synchronizedList(new ArrayList<>());

    //Liste des erreurs
    private List<CustomError> errors = new ArrayList<>();

    public JsonParsedData() {
    }

    public JsonParsedData(List<Virtual> virtuals, List<CustomError> errors) {
        this.errors = errors;
        this.virtuals = virtuals;
    }

    public List<Virtual> getVirtuals() {
        return virtuals;
    }

    public List<CustomError> getErrors() {
        return errors;
    }

}

 dynamicjsonparser/src/main/java/com/megatim/dynamicjsonparser/pojo/Node.java

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

import com.fasterxml.jackson.databind.JsonNode;

/**
 *
 * @author ASUS
 */
public class Node {
    private JsonNode node;
    
    private int index;

    public Node(JsonNode node, int index) {
        this.node = node;
        this.index = index;
    }

    public JsonNode getNode() {
        return node;
    }

    public void setNode(JsonNode node) {
        this.node = node;
    }

    public int getIndex() {
        return index;
    }

    public void setIndex(int index) {
        this.index = index;
    }
    
    
}

 dynamicjsonparser/src/main/java/com/megatim/dynamicjsonparser/utils/Utility.java

New file
@@ -0,0 +1,37 @@
/*
 * 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.dynamicjsonparser.utils;

import com.megatim.dynamicjsonparser.pojo.CustomError;
import java.io.BufferedWriter;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.List;

/**
 *
 * @author ASUS
 */
public class Utility {
     /**
     * Méthode qui écrit une liste de String dans un fichier
     *
     * @param errors
     * @param errorPath : Chemin du fichier
     */
    public static void writeToFile(List<CustomError> errors, Path errorPath) {

        try ( BufferedWriter bufferWriter = Files.newBufferedWriter(errorPath, StandardCharsets.UTF_8, StandardOpenOption.CREATE, StandardOpenOption.CREATE, StandardOpenOption.SYNC)) {

            for (CustomError c : errors) {
                bufferWriter.write(c.getMessage() + System.lineSeparator());
            }
        } catch (Exception ex) {

        }
    }
}

 dynamicjsonparser/target/classes/.netbeans_automatic_build

 dynamicjsonparser/target/maven-archiver/pom.properties

New file
@@ -0,0 +1,5 @@
#Generated by Maven
#Fri Jun 19 12:10:24 WAT 2026
version=1.0
groupId=com.megatim
artifactId=dynamicjsonparser

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

New file
@@ -0,0 +1,16 @@
com\megatim\dynamicjsonparser\generated\Personne.class
com\megatim\dynamicjsonparser\pojo\CustomError.class
com\megatim\dynamicjsonparser\extender\JsonDataProcessor.class
com\megatim\dynamicjsonparser\extender\JsonDataValidator.class
com\megatim\dynamicjsonparser\pojo\JsonParsedData.class
com\megatim\dynamicjsonparser\App.class
com\megatim\dynamicjsonparser\extender\DataRetrieverAction.class
com\megatim\dynamicjsonparser\pojo\JsonDataType.class
com\megatim\dynamicjsonparser\enums\TypeDonnee.class
com\megatim\dynamicjsonparser\generated\CompteBancaire.class
com\megatim\dynamicjsonparser\extender\RuntimeClassBuilder.class
com\megatim\dynamicjsonparser\pojo\JsonField.class
com\megatim\dynamicjsonparser\extender\SourceCompiler.class
com\megatim\dynamicjsonparser\utils\Utility.class
com\megatim\dynamicjsonparser\pojo\Indexe.class
com\megatim\dynamicjsonparser\pojo\Node.class

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

New file
@@ -0,0 +1,16 @@
C:\Users\ASUS\Documents\NetBeansProjects\share_sources\dynamicjsonparser\src\main\java\com\megatim\dynamicjsonparser\utils\Utility.java
C:\Users\ASUS\Documents\NetBeansProjects\share_sources\dynamicjsonparser\src\main\java\com\megatim\dynamicjsonparser\enums\TypeDonnee.java
C:\Users\ASUS\Documents\NetBeansProjects\share_sources\dynamicjsonparser\src\main\java\com\megatim\dynamicjsonparser\extender\DataRetrieverAction.java
C:\Users\ASUS\Documents\NetBeansProjects\share_sources\dynamicjsonparser\src\main\java\com\megatim\dynamicjsonparser\generated\Personne.java
C:\Users\ASUS\Documents\NetBeansProjects\share_sources\dynamicjsonparser\src\main\java\com\megatim\dynamicjsonparser\pojo\Indexe.java
C:\Users\ASUS\Documents\NetBeansProjects\share_sources\dynamicjsonparser\src\main\java\com\megatim\dynamicjsonparser\pojo\Node.java
C:\Users\ASUS\Documents\NetBeansProjects\share_sources\dynamicjsonparser\src\main\java\com\megatim\dynamicjsonparser\extender\JsonDataValidator.java
C:\Users\ASUS\Documents\NetBeansProjects\share_sources\dynamicjsonparser\src\main\java\com\megatim\dynamicjsonparser\extender\RuntimeClassBuilder.java
C:\Users\ASUS\Documents\NetBeansProjects\share_sources\dynamicjsonparser\src\main\java\com\megatim\dynamicjsonparser\App.java
C:\Users\ASUS\Documents\NetBeansProjects\share_sources\dynamicjsonparser\src\main\java\com\megatim\dynamicjsonparser\extender\SourceCompiler.java
C:\Users\ASUS\Documents\NetBeansProjects\share_sources\dynamicjsonparser\src\main\java\com\megatim\dynamicjsonparser\pojo\JsonField.java
C:\Users\ASUS\Documents\NetBeansProjects\share_sources\dynamicjsonparser\src\main\java\com\megatim\dynamicjsonparser\pojo\JsonDataType.java
C:\Users\ASUS\Documents\NetBeansProjects\share_sources\dynamicjsonparser\src\main\java\com\megatim\dynamicjsonparser\pojo\JsonParsedData.java
C:\Users\ASUS\Documents\NetBeansProjects\share_sources\dynamicjsonparser\src\main\java\com\megatim\dynamicjsonparser\extender\JsonDataProcessor.java
C:\Users\ASUS\Documents\NetBeansProjects\share_sources\dynamicjsonparser\src\main\java\com\megatim\dynamicjsonparser\pojo\CustomError.java
C:\Users\ASUS\Documents\NetBeansProjects\share_sources\dynamicjsonparser\src\main\java\com\megatim\dynamicjsonparser\generated\CompteBancaire.java

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

 dynamicjsonparser/target/test-classes/.netbeans_automatic_build