package com.megatim.apifdxweb.core.impl.db;
|
|
import com.megatim.apifdxweb.core.ifaces.referentiel.RoutageManager;
|
import com.megatim.fdxcommons.core.ifaces.db.ReferentielDataSaver;
|
import com.megatim.apifdxweb.core.ifaces.integration.ColumnDefinitionManager;
|
import com.megatim.apifdxweb.core.ifaces.referentiel.ApplicationSourceManager;
|
import com.megatim.apifdxweb.core.ifaces.referentiel.ExtensionFichierManager;
|
import com.megatim.apifdxweb.core.ifaces.referentiel.GroupeNoeudManager;
|
import com.megatim.apifdxweb.core.ifaces.referentiel.GroupeParticipantManager;
|
import com.megatim.apifdxweb.core.ifaces.referentiel.NoeudManager;
|
import com.megatim.apifdxweb.core.ifaces.referentiel.ParticipantManager;
|
import com.megatim.apifdxweb.core.ifaces.referentiel.PaysManager;
|
import com.megatim.apifdxweb.core.ifaces.referentiel.ReferentielManager;
|
import com.megatim.apifdxweb.core.ifaces.referentiel.StructureLigneManager;
|
import com.megatim.apifdxweb.core.ifaces.referentiel.TypeFichierManager;
|
import com.megatim.apifdxweb.core.ifaces.referentiel.ValidateurFichierConfigurationManager;
|
import com.megatim.apifdxweb.core.ifaces.referentiel.ValidateurFichierManager;
|
import com.megatim.apifdxweb.core.ifaces.referentiel.natureproduction.NatureProductionFichierManager;
|
import com.megatim.apifdxweb.model.camel.historique.ConsumedFilesHistory;
|
import com.megatim.apifdxweb.model.camel.historique.ConsumedFileType;
|
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.pojo.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.FileTypeNotExistException;
|
import com.megatim.fdxcommons.tools.exceptions.CommonRessourceNotFoundException;
|
import java.time.LocalDateTime;
|
import java.util.ArrayList;
|
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;
|
import com.megatim.apifdxweb.core.ifaces.camel.historique.ConsumedFilesHistoryManager;
|
|
/**
|
*
|
* @author ASUS
|
*/
|
@Dependent
|
public class ReferentielDataSaverImpl implements ReferentielDataSaver {
|
|
@Inject
|
ReferentielManager refManager;
|
|
@Inject
|
ApplicationSourceManager appSourceManager;
|
|
@Inject
|
ExtensionFichierManager extFichierManager;
|
|
@Inject
|
GroupeNoeudManager groupeNoeudManager;
|
|
@Inject
|
GroupeParticipantManager groupePartManager;
|
|
@Inject
|
NoeudManager noeudManager;
|
|
@Inject
|
ParticipantManager participantManager;
|
|
@Inject
|
PaysManager paysManager;
|
|
@Inject
|
RoutageManager routageManager;
|
|
@Inject
|
TypeFichierManager typeFichierManager;
|
|
@Inject
|
StructureLigneManager structLigneManager;
|
|
@Inject
|
ValidateurFichierManager valFichManager;
|
|
@Inject
|
ValidateurFichierConfigurationManager valFichConfManager;
|
|
@Inject
|
ColumnDefinitionManager columnDefinitionManager;
|
|
@Inject
|
NatureProductionFichierManager natureProdFichManager;
|
|
@Inject
|
ConsumedFilesHistoryManager refHistManager;
|
|
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());
|
|
persistColumnsDefinition(referentielToImportData.getTableDefinitions());
|
|
persistNatureProductionFichiers(referentielToImportData.getNatureProductionFichiers());
|
|
persistReferentielHistorique(referentielToImportData.getFileName());
|
}
|
|
private void persistReferentielHistorique(String fileName) {
|
ConsumedFilesHistory consumedFilesHistory = new ConsumedFilesHistory();
|
consumedFilesHistory.setFileName(fileName);
|
consumedFilesHistory.setDateCreation(LocalDateTime.now());
|
consumedFilesHistory.setConsumedFileType(ConsumedFileType.REFERENTIEL);
|
|
refHistManager.save(consumedFilesHistory);
|
}
|
|
private void persistReferentiels(List<Referentiel> referentiels) {
|
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) {
|
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) {
|
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);
|
paysManager.save(p);
|
}
|
|
}
|
}
|
}
|
|
private void persistExtensionFichiers(List<ExtensionFichier> extFichiers) {
|
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) {
|
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);
|
|
participantManager.save(p);
|
}
|
|
}
|
}
|
}
|
|
private void persistTypeFichiers(List<TypeFichier> typeFichiers) {
|
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);
|
|
typeFichierManager.save(typeFich);
|
}
|
}
|
}
|
}
|
}
|
|
private void persistValidateurFichiers(List<ValidateurFichier> validateurFichiers) throws FileTypeNotExistException {
|
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 FileTypeNotExistException(codeTypeFichier);
|
}
|
ValidateurFichier valFichFound = validateurFichiersMap.get(val.getId());
|
|
if (valFichFound == null) {
|
val.setTypeFichier(typeFichierFound);
|
valFichManager.save(val);
|
}
|
}
|
}
|
}
|
|
private void persistValidateurFichierConfigurations(List<ValidateurFichierConfiguration> valFichConfs) throws FileTypeNotExistException {
|
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 FileTypeNotExistException(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) {
|
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) {
|
noeudsMap = noeudManager.getAll(null).stream().collect(Collectors.toMap(Noeud::getCode, Function.identity()));
|
List<Noeud> savedNoeuds = new ArrayList<>();
|
|
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);
|
|
savedNoeuds.add(noeudManager.save(n));
|
}
|
|
}
|
}
|
// return savedNoeuds;
|
}
|
|
private void persistGroupeNoeuds(List<GroupeNoeud> groupeNoeuds) {
|
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) {
|
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);
|
groupePartManager.save(gp);
|
|
}
|
|
}
|
}
|
}
|
|
private void persistRoutages(List<Routage> routages) throws FileTypeNotExistException {
|
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 FileTypeNotExistException(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 persistColumnsDefinition(List<TableDefinition> tablesDefinition) {
|
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 FileTypeNotExistException {
|
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 FileTypeNotExistException(codeTypeFichier);
|
}
|
NatureProductionFichier natureProdFichFound = natureProdFichsMap.get(n.getReferentiel().getVersion() + "-" + n.getTypeFichier().getCode());
|
|
if (natureProdFichFound == null) {
|
n.setReferentiel(referentielFound);
|
n.setTypeFichier(typeFichierFound);
|
|
natureProdFichManager.save(n);
|
}
|
}
|
}
|
}
|
|
}
|
