~fstephanie/sources_fdx_api.git

package com.megatim.fdxconsultation.core.impl.db;
 
import com.megatim.fdxcommons.core.ifaces.db.ReferentielDataSaver;
import com.megatim.fdxcommons.model.enumeration.CategorieFichier;
import com.megatim.fdxcommons.model.integration.ColumnDefinition;
import com.megatim.fdxcommons.model.pojo.ReferentielToImportData;
import com.megatim.fdxcommons.model.integration.TableDefinition;
import com.megatim.fdxcommons.model.referentiel.ApplicationSource;
import com.megatim.fdxcommons.model.referentiel.ExtensionFichier;
import com.megatim.fdxcommons.model.referentiel.GroupeNoeud;
import com.megatim.fdxcommons.model.referentiel.GroupeParticipant;
import com.megatim.fdxcommons.model.referentiel.Noeud;
import com.megatim.fdxcommons.model.referentiel.Participant;
import com.megatim.fdxcommons.model.referentiel.Pays;
import com.megatim.fdxcommons.model.referentiel.Referentiel;
import com.megatim.fdxcommons.model.referentiel.Routage;
import com.megatim.fdxcommons.model.referentiel.StructureLigne;
import com.megatim.fdxcommons.model.referentiel.TypeFichier;
import com.megatim.fdxcommons.model.referentiel.ValidateurFichier;
import com.megatim.fdxcommons.model.referentiel.ValidateurFichierConfiguration;
import com.megatim.fdxcommons.model.referentiel.natureproduction.NatureProductionFichier;
import com.megatim.fdxcommons.tools.exceptions.TypeFichierExistNotException;
import com.megatim.fdxcommons.tools.exceptions.CommonRessourceNotFoundException;
import com.megatim.fdxconsultation.core.ifaces.integration.ColumnDefinitionManager;
import com.megatim.fdxconsultation.core.ifaces.integration.TableDefinitionManager;
import com.megatim.fdxconsultation.core.ifaces.referentiel.ApplicationSourceManager;
import com.megatim.fdxconsultation.core.ifaces.referentiel.ExtensionFichierManager;
import com.megatim.fdxconsultation.core.ifaces.referentiel.GroupeNoeudManager;
import com.megatim.fdxconsultation.core.ifaces.referentiel.GroupeParticipantManager;
import com.megatim.fdxconsultation.core.ifaces.referentiel.NoeudManager;
import com.megatim.fdxconsultation.core.ifaces.referentiel.ParticipantManager;
import com.megatim.fdxconsultation.core.ifaces.referentiel.PaysManager;
import com.megatim.fdxconsultation.core.ifaces.referentiel.ReferentielManager;
import com.megatim.fdxconsultation.core.ifaces.referentiel.RoutageManager;
import com.megatim.fdxconsultation.core.ifaces.referentiel.StructureLigneManager;
import com.megatim.fdxconsultation.core.ifaces.referentiel.TypeFichierManager;
import com.megatim.fdxconsultation.core.ifaces.referentiel.ValidateurFichierConfigurationManager;
import com.megatim.fdxconsultation.core.ifaces.referentiel.ValidateurFichierManager;
import com.megatim.fdxconsultation.core.ifaces.referentiel.natureproduction.NatureProductionFichierManager;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
import javax.enterprise.context.Dependent;
import javax.inject.Inject;
 
/**
 *
 * @author ASUS
 */
@Dependent
public class ReferentielDataSaverImpl implements ReferentielDataSaver {
 
    @Inject
    private ReferentielManager refManager;
 
    @Inject
    private ApplicationSourceManager appSourceManager;
 
    @Inject
    private ExtensionFichierManager extFichierManager;
 
    @Inject
    private GroupeNoeudManager groupeNoeudManager;
 
    @Inject
    private GroupeParticipantManager groupePartManager;
 
    @Inject
    private NoeudManager noeudManager;
 
    @Inject
    private ParticipantManager participantManager;
 
    @Inject
    private PaysManager paysManager;
 
    @Inject
    private RoutageManager routageManager;
 
    @Inject
    private TypeFichierManager typeFichierManager;
 
    @Inject
    private StructureLigneManager structLigneManager;
 
    @Inject
    private ValidateurFichierManager valFichManager;
 
    @Inject
    private ValidateurFichierConfigurationManager valFichConfManager;
 
    @Inject
    private ColumnDefinitionManager columnDefinitionManager;
 
    @Inject
    private TableDefinitionManager tableDefinitionManager;
 
    @Inject
    NatureProductionFichierManager natureProdFichManager;
 
    private Map<String, Referentiel> referentielsMap;
    private Map<String, TypeFichier> typeFichiersMap;
    private Map<String, Pays> paysMap;
    private Map<String, Participant> participantsMap;
    private Map<String, ApplicationSource> appSourcesMap;
    private Map<String, ExtensionFichier> extensionFichiersMap;
    private Map<String, ValidateurFichier> validateurFichiersMap;
    private Map<String, ValidateurFichierConfiguration> validateurFichierConfsMap;
    private Map<String, StructureLigne> structLignesMap;
    private Map<String, Noeud> noeudsMap;
    private Map<String, GroupeNoeud> groupeNoeudsMap;
    private Map<String, GroupeParticipant> groupeParticipantsMap;
    private Map<String, Routage> routagesMap;
    private Map<String, ColumnDefinition> columnDefinitionsMap;
    private Map<String, NatureProductionFichier> natureProdFichsMap;
 
    @Override
    public void persist(ReferentielToImportData referentielToImportData) throws Exception {
 
        refManager.archiverReferentielEncours();
 
        persistReferentiels(referentielToImportData.getReferentiels());
 
        persistApplicationSources(referentielToImportData.getApplicationSources());
 
        persistPayss(referentielToImportData.getPays());
 
        persistExtensionFichiers(referentielToImportData.getExtensionFichiers());
 
        persistParticipants(referentielToImportData.getParticipants());
 
        persistTypeFichiers(referentielToImportData.getTypeFichiers());
 
//        persistValidateurFichiers(referentielToImportData.getValidateurFichiers());
//
//        persistValidateurFichierConfigurations(referentielToImportData.getValidateurFichierConfigurations());
//
//        persitStructuresLignes(referentielToImportData.getStructureLignes());
        persistNoeuds(referentielToImportData.getNoeuds());
 
        persistGroupeNoeuds(referentielToImportData.getGroupeNoeuds());
 
        persistGroupeParticipants(referentielToImportData.getGroupeParticipants());
 
        persistRoutages(referentielToImportData.getRoutages());
 
        persistTableDefinitions(referentielToImportData.getTableDefinitions());
 
        persistColumnsDefinition(referentielToImportData.getTableDefinitions());
 
        persistNatureProductionFichiers(referentielToImportData.getNatureProductionFichiers());
    }
 
    private void persistReferentiels(List<Referentiel> referentiels) throws Exception {
        referentielsMap = refManager.getAll(null).stream().collect(Collectors.toMap(Referentiel::getVersion, Function.identity()));
 
        if (referentiels != null) {
 
            for (Referentiel ref : referentiels) {
                Referentiel referentielFound = referentielsMap.get(ref.getVersion());
 
                if (referentielFound == null) {
                    refManager.save(ref);
                }
            }
        }
    }
 
    private void persistApplicationSources(List<ApplicationSource> appSources) throws Exception {
        referentielsMap = refManager.getAll(null).stream().collect(Collectors.toMap(Referentiel::getVersion, Function.identity()));
        appSourcesMap = appSourceManager.getAll(null).stream().collect(Collectors.toMap(ApplicationSource::getLibelle, Function.identity()));
 
        if (appSources != null) {
 
            for (ApplicationSource appSource : appSources) {
                String referentielVersion = appSource.getReferentiel().getVersion();
                Referentiel referentielFound = referentielsMap.get(referentielVersion);
 
                if (referentielFound == null) {
                    throw new CommonRessourceNotFoundException("Le referentiel suivant est introuvable : " + referentielVersion);
                }
 
                ApplicationSource appSourceFound = appSourcesMap.get(appSource.getLibelle());
                if (appSourceFound == null) {
                    appSource.setReferentiel(referentielFound);
                    appSourceManager.save(appSource);
                }
 
            }
        }
 
    }
 
    private void persistPayss(List<Pays> payss) throws Exception {
        paysMap = paysManager.getAll(null).stream().collect(Collectors.toMap(Pays::getCode, Function.identity()));
 
        if (payss != null) {
 
            for (Pays p : payss) {
                String referentielVersion = p.getReferentiel().getVersion();
                Referentiel referentielFound = referentielsMap.get(referentielVersion);
 
                if (referentielFound == null) {
                    throw new CommonRessourceNotFoundException("La ressource Referentiel suivante est introuvable : " + referentielVersion);
                }
                Pays paysFound = paysMap.get(p.getCode());
 
                if (paysFound == null) {
                    p.setReferentiel(referentielFound);
                    p.setParticipants(new HashSet<>());
                    paysManager.save(p);
                }
 
            }
        }
    }
 
    private void persistExtensionFichiers(List<ExtensionFichier> extFichiers) throws Exception {
        referentielsMap = refManager.getAll(null).stream().collect(Collectors.toMap(Referentiel::getVersion, Function.identity()));
        extensionFichiersMap = extFichierManager.getAll(null).stream().collect(Collectors.toMap(ExtensionFichier::getExtension, Function.identity()));
 
        if (extFichiers != null) {
 
            for (ExtensionFichier e : extFichiers) {
                String referentielVersion = e.getReferentiel().getVersion();
                Referentiel referentielFound = referentielsMap.get(referentielVersion);
 
                if (referentielFound == null) {
                    throw new CommonRessourceNotFoundException("Le referentiel suivant est introuvable : " + referentielVersion);
                }
 
                ExtensionFichier extFichierFound = extensionFichiersMap.get(e.getExtension());
                if (extFichierFound == null) {
                    e.setReferentiel(referentielFound);
                    extFichierManager.save(e);
                }
            }
        }
    }
 
    private void persistParticipants(List<Participant> participants) throws Exception {
        paysMap = paysManager.getAll(null).stream().collect(Collectors.toMap(Pays::getCode, Function.identity()));
        participantsMap = participantManager.getAll(null).stream().collect(Collectors.toMap(Participant::getCode, Function.identity()));
 
        if (participants != null) {
 
            for (Participant p : participants) {
                String referentielVersion = p.getReferentiel().getVersion();
                String codePays = p.getPays().getCode();
                Referentiel referentielFound = referentielsMap.get(referentielVersion);
 
                if (referentielFound == null) {
                    throw new CommonRessourceNotFoundException("La ressource Referentiel suivante est introuvable : " + referentielVersion);
                }
                Pays paysFound = paysMap.get(codePays);
 
                if (paysFound == null) {
                    throw new CommonRessourceNotFoundException("La ressource Pays suivante est introuvable : " + codePays);
                }
                Participant participantFound = participantsMap.get(p.getCode());
 
                if (participantFound == null) {
                    p.setPays(paysFound);
                    p.setReferentiel(referentielFound);
                    p.setNoeuds(new HashSet<>());
                    p.setRoutageEnvois(new HashSet<>());
                    p.setRoutageReceptions(new HashSet<>());
                    p.setGroupeParticipants(new HashSet<>());
 
                    participantManager.save(p);
                }
 
            }
        }
    }
 
    private void persistTypeFichiers(List<TypeFichier> typeFichiers) throws Exception {
        participantsMap = participantManager.getAll(null).stream().collect(Collectors.toMap(Participant::getCode, Function.identity()));
        typeFichiersMap = typeFichierManager.getAll(null).stream().collect(Collectors.toMap(TypeFichier::getCode, Function.identity()));
 
        if (typeFichiers != null) {
 
            for (TypeFichier typeFich : typeFichiers) {
 
                if (typeFich.getCategorieFichier().equals(CategorieFichier.STRUCTURE)) {
 
                    String referentielVersion = typeFich.getReferentiel().getVersion();
                    String codeParticipant = typeFich.getParticipant().getCode();
 
                    Referentiel referentielFound = referentielsMap.get(referentielVersion);
                    if (referentielFound == null) {
                        throw new CommonRessourceNotFoundException("La ressource Referentiel suivante est introuvable : " + referentielVersion);
                    }
 
                    Participant participantFound = participantsMap.get(codeParticipant);
                    if (participantFound == null) {
                        throw new CommonRessourceNotFoundException("La ressource Participant suivante est introuvable : " + codeParticipant);
                    }
                    TypeFichier typeFichierFound = typeFichiersMap.get(typeFich.getCode());
 
                    if (typeFichierFound == null) {
                        typeFich.setReferentiel(referentielFound);
                        typeFich.setParticipant(participantFound);
                        typeFich.setRoutages(new HashSet<>());
                        typeFich.setValidateurFichierConfigurations(new HashSet<>());
                        typeFich.setValidateurFichiers(new HashSet<>());
 
                        typeFichierManager.save(typeFich);
                    }
                }
            }
        }
    }
 
    private void persistValidateurFichiers(List<ValidateurFichier> validateurFichiers) throws Exception {
        validateurFichiersMap = valFichManager.getAll(null).stream().collect(Collectors.toMap(ValidateurFichier::getId, Function.identity()));
        typeFichiersMap = typeFichierManager.getAll(null).stream().collect(Collectors.toMap(TypeFichier::getCode, Function.identity()));
 
        if (validateurFichiers != null) {
 
            for (ValidateurFichier val : validateurFichiers) {
                String codeTypeFichier = val.getTypeFichier().getCode();
                TypeFichier typeFichierFound = typeFichiersMap.get(codeTypeFichier);
 
                if (typeFichierFound == null) {
                    throw new TypeFichierExistNotException(codeTypeFichier);
                }
                ValidateurFichier valFichFound = validateurFichiersMap.get(val.getId());
 
                if (valFichFound == null) {
                    val.setTypeFichier(typeFichierFound);
                    valFichManager.save(val);
                }
            }
        }
    }
 
    private void persistValidateurFichierConfigurations(List<ValidateurFichierConfiguration> valFichConfs) throws TypeFichierExistNotException, Exception {
        validateurFichierConfsMap = valFichConfManager.getAll(null)
                .stream()
                .collect(Collectors.toMap(x -> x.getReferentiel().getVersion() + "-" + x.getTypeFichier().getCode(),
                        Function.identity()));
 
        if (valFichConfs != null) {
 
            for (ValidateurFichierConfiguration valFichConf : valFichConfs) {
                String codeTypeFichier = valFichConf.getTypeFichier().getCode();
                String referentielVersion = valFichConf.getReferentiel().getVersion();
 
                Referentiel referentielFound = referentielsMap.get(referentielVersion);
                if (referentielFound == null) {
                    throw new CommonRessourceNotFoundException("Le referentiel suivant est introuvable : " + referentielVersion);
                }
 
                TypeFichier typeFichierFound = typeFichiersMap.get(codeTypeFichier);
                if (typeFichierFound == null) {
                    throw new TypeFichierExistNotException(codeTypeFichier);
                }
 
                ValidateurFichierConfiguration ValFichConfFound = validateurFichierConfsMap.get(valFichConf.getReferentiel().getVersion() + "-" + valFichConf.getTypeFichier().getCode());
 
                if (ValFichConfFound == null) {
                    valFichConf.setTypeFichier(typeFichierFound);
                    valFichConf.setReferentiel(referentielFound);
 
                    valFichConfManager.save(valFichConf);
                }
 
            }
        }
    }
 
    private void persitStructuresLignes(List<StructureLigne> structLignes) throws Exception {
        validateurFichiersMap = valFichManager.getAll(null).stream().collect(Collectors.toMap(ValidateurFichier::getId, Function.identity()));
        appSourcesMap = appSourceManager.getAll(null).stream().collect(Collectors.toMap(ApplicationSource::getLibelle, Function.identity()));
        structLignesMap = structLigneManager.getAll(null).stream().collect(Collectors.toMap(StructureLigne::getId, Function.identity()));
 
        if (structLignes != null) {
 
            for (StructureLigne s : structLignes) {
                String valFichierId = s.getValidateurFichier().getId();
                String libelleAppSource = s.getApplicationSource().getLibelle();
 
                ApplicationSource appSourceFound = appSourcesMap.get(libelleAppSource);
                if (appSourceFound == null) {
                    throw new CommonRessourceNotFoundException("La ressource ApplicationSource suivante est introuvable : " + libelleAppSource);
                }
 
                ValidateurFichier valFichFound = validateurFichiersMap.get(valFichierId);
                if (valFichFound == null) {
                    throw new CommonRessourceNotFoundException("La ressource ValidateurFichier suivante est introuvable : " + valFichierId);
                }
                StructureLigne structureLigneFound = structLignesMap.get(s.getId());
 
                if (structureLigneFound == null) {
                    s.setValidateurFichier(valFichFound);
                    s.setApplicationSource(appSourceFound);
 
                    structLigneManager.save(s);
                }
 
            }
        }
    }
 
    private void persistNoeuds(List<Noeud> noeuds) throws Exception {
        noeudsMap = noeudManager.getAll(null).stream().collect(Collectors.toMap(Noeud::getCode, Function.identity()));
 
        if (noeuds != null) {
 
            for (Noeud n : noeuds) {
                String referentielVersion = n.getReferentiel().getVersion();
                String codeParticipant = n.getParticipant().getCode();
 
                Referentiel referentielFound = referentielsMap.get(referentielVersion);
                if (referentielFound == null) {
                    throw new CommonRessourceNotFoundException("La ressource Referentiel suivante est introuvable : " + referentielVersion);
                }
 
                Participant participantFound = participantsMap.get(codeParticipant);
                if (participantFound == null) {
                    throw new CommonRessourceNotFoundException("La ressource Participant suivante est introuvable : " + codeParticipant);
                }
                Noeud noeudFound = noeudsMap.get(n.getCode());
 
                if (noeudFound == null) {
                    n.setReferentiel(referentielFound);
                    n.setParticipant(participantFound);
                    n.setGroupeNoeuds(new HashSet<>());
                    n.setRoutageEnvois(new HashSet<>());
                    n.setRoutageReceptions(new HashSet<>());
 
                    noeudManager.save(n);
                }
 
            }
        }
    }
 
    private void persistGroupeNoeuds(List<GroupeNoeud> groupeNoeuds) throws Exception {
        groupeNoeudsMap = groupeNoeudManager.getAll(null).stream().collect(Collectors.toMap(GroupeNoeud::getCode, Function.identity()));
 
        if (groupeNoeuds != null) {
 
            for (GroupeNoeud gn : groupeNoeuds) {
                String referentielVersion = gn.getReferentiel().getVersion();
                Referentiel referentielFound = referentielsMap.get(referentielVersion);
 
                if (referentielFound == null) {
                    throw new CommonRessourceNotFoundException("La ressource Referentiel suivante est introuvable : " + referentielVersion);
                }
                GroupeNoeud grpNoeudFound = groupeNoeudsMap.get(gn.getCode());
 
                if (grpNoeudFound == null) {
                    gn.setReferentiel(referentielFound);
                    groupeNoeudManager.save(gn);
                }
            }
        }
    }
 
    private void persistGroupeParticipants(List<GroupeParticipant> groupeParticipants) throws Exception {
        groupeParticipantsMap = groupePartManager.getAll(null).stream().collect(Collectors.toMap(GroupeParticipant::getCode, Function.identity()));
 
        if (groupeParticipants != null) {
 
            for (GroupeParticipant gp : groupeParticipants) {
                String referentielVersion = gp.getReferentiel().getVersion();
                Referentiel referentielFound = referentielsMap.get(referentielVersion);
 
                if (referentielFound == null) {
                    throw new CommonRessourceNotFoundException("La ressource Referentiel suivante est introuvable : " + referentielVersion);
                }
                GroupeParticipant grpParticipantFound = groupeParticipantsMap.get(gp.getCode());
 
                if (grpParticipantFound == null) {
                    gp.setReferentiel(referentielFound);
                    gp.setRoutageEnvois(new HashSet<>());
                    gp.setRoutageReceptions(new HashSet<>());
 
                    groupePartManager.save(gp);
                }
 
            }
        }
    }
 
    private void persistRoutages(List<Routage> routages) throws Exception {
        typeFichiersMap = typeFichierManager.getAll(null).stream().collect(Collectors.toMap(TypeFichier::getCode, Function.identity()));
        routagesMap = routageManager.getAll(null)
                .stream()
                .collect(Collectors.toMap(x -> x.getReferentiel().getVersion() + "-" + x.getTypeFichier().getCode(),
                        Function.identity()));
 
        if (routages != null) {
 
            for (Routage r : routages) {
                String referentielVersion = r.getReferentiel().getVersion();
                String codeTypeFichier = r.getTypeFichier().getCode();
 
                Referentiel referentielFound = referentielsMap.get(referentielVersion);
                if (referentielFound == null) {
                    throw new CommonRessourceNotFoundException("Le referentiel suivant est introuvable : " + referentielVersion);
                }
 
                TypeFichier typeFichierFound = typeFichiersMap.get(codeTypeFichier);
                if (typeFichierFound == null) {
                    throw new TypeFichierExistNotException(codeTypeFichier);
                }
                Routage routageFound = routagesMap.get(r.getReferentiel().getVersion() + "-" + r.getTypeFichier().getCode());
 
                if (routageFound == null) {
                    r.setReferentiel(referentielFound);
                    r.setTypeFichier(typeFichierFound);
 
                    routageManager.save(r);
                }
            }
        }
    }
 
    private void persistTableDefinitions(List<TableDefinition> tablesDefinition) {
        for (TableDefinition t : tablesDefinition) {
            if (t.getHeaderPresent() != null && t.getColumnDelimiter() != null && t.getLineDelimiter() != null) {
                tableDefinitionManager.save(t);
            }
        }
    }
 
    private void persistColumnsDefinition(List<TableDefinition> tablesDefinition) throws Exception {
        columnDefinitionsMap = columnDefinitionManager.getAll(null)
                .stream()
                .collect(Collectors.toMap(x -> x.getName() + "-" + x.getReferentielVersion() + "-" + x.getCodeTypeFichier(),
                        Function.identity()
                ));
 
        if (tablesDefinition != null) {
 
            for (TableDefinition t : tablesDefinition) {
 
                for (ColumnDefinition c : t.getColumnDefinitions()) {
                    ColumnDefinition colDefFound = columnDefinitionsMap.get(c.getName() + "-" + c.getReferentielVersion() + "-" + c.getCodeTypeFichier());
 
                    if (colDefFound == null) {
                        columnDefinitionManager.save(c);
                    }
                }
            }
        }
    }
 
    private void persistNatureProductionFichiers(List<NatureProductionFichier> natureProductionFichs) throws TypeFichierExistNotException {
        natureProdFichsMap = natureProdFichManager.getAll(null)
                .stream()
                .collect(Collectors.toMap(x -> x.getReferentiel().getVersion() + "-" + x.getTypeFichier().getCode(),
                        Function.identity()));
 
        if (natureProductionFichs != null) {
 
            for (NatureProductionFichier n : natureProductionFichs) {
                String referentielVersion = n.getReferentiel().getVersion();
                String codeTypeFichier = n.getTypeFichier().getCode();
 
                Referentiel referentielFound = referentielsMap.get(referentielVersion);
                if (referentielFound == null) {
                    throw new CommonRessourceNotFoundException("Le referentiel suivant est introuvable : " + referentielVersion);
                }
 
                TypeFichier typeFichierFound = typeFichiersMap.get(codeTypeFichier);
                if (typeFichierFound == null) {
                    throw new TypeFichierExistNotException(codeTypeFichier);
                }
                NatureProductionFichier natureProdFichFound = natureProdFichsMap.get(n.getReferentiel().getVersion() + "-" + n.getTypeFichier().getCode());
 
                if (natureProdFichFound == null) {
                    n.setReferentiel(referentielFound);
                    n.setTypeFichier(typeFichierFound);
 
                    natureProdFichManager.save(n);
                }
            }
        }
    }
}