From 23a46b4be35277e06ec89f48730eeb694e686be8 Mon Sep 17 00:00:00 2001
From: Kenmegne <stephanie.kenmegne@gmail.com>
Date: Thu, 18 Jun 2026 15:40:06 +0000
Subject: [PATCH] add fdx-commons and fdx-consultation
---
fdx-consultation/fdxconsultation-core-impl/src/main/java/com/megatim/fdxconsultation/core/impl/db/ReferentielDataSaverImpl.java | 586 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 586 insertions(+), 0 deletions(-)
diff --git a/fdx-consultation/fdxconsultation-core-impl/src/main/java/com/megatim/fdxconsultation/core/impl/db/ReferentielDataSaverImpl.java b/fdx-consultation/fdxconsultation-core-impl/src/main/java/com/megatim/fdxconsultation/core/impl/db/ReferentielDataSaverImpl.java
new file mode 100644
index 0000000..737c630
--- /dev/null
+++ b/fdx-consultation/fdxconsultation-core-impl/src/main/java/com/megatim/fdxconsultation/core/impl/db/ReferentielDataSaverImpl.java
@@ -0,0 +1,586 @@
+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);
+ }
+ }
+ }
+ }
+}
--
Gitblit v1.10.0