ImporterUtils.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */


  22. package org.openspcoop2.web.ctrlstat.servlet.archivi;

  24. import java.io.File;
  25. import java.io.FileInputStream;
  26. import java.io.FileOutputStream;
  27. import java.util.ArrayList;
  28. import java.util.HashMap;
  29. import java.util.List;
  30. import java.util.Map;

  32. import org.apache.commons.lang.StringUtils;
  33. import org.apache.struts.action.ActionForm;
  34. import org.apache.struts.upload.FormFile;
  35. import org.openspcoop2.core.config.Credenziali;
  36. import org.openspcoop2.core.config.InvocazioneServizio;
  37. import org.openspcoop2.core.constants.Costanti;
  38. import org.openspcoop2.core.id.IDAccordo;
  39. import org.openspcoop2.core.id.IDAccordoCooperazione;
  40. import org.openspcoop2.core.id.IDSoggetto;
  41. import org.openspcoop2.core.registry.Connettore;
  42. import org.openspcoop2.core.registry.PortType;
  43. import org.openspcoop2.core.registry.Soggetto;
  44. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  45. import org.openspcoop2.core.registry.driver.FiltroRicercaAccordi;
  46. import org.openspcoop2.core.registry.driver.FiltroRicercaSoggetti;
  47. import org.openspcoop2.core.registry.driver.IDAccordoCooperazioneFactory;
  48. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  49. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  50. import org.openspcoop2.protocol.engine.archive.ImportInformationMissing;
  51. import org.openspcoop2.protocol.engine.archive.ImportInformationMissingCollection;
  52. import org.openspcoop2.protocol.information_missing.Wizard;
  53. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  54. import org.openspcoop2.protocol.sdk.ProtocolException;
  55. import org.openspcoop2.protocol.sdk.archive.ArchiveMode;
  56. import org.openspcoop2.protocol.sdk.archive.ArchiveModeType;
  57. import org.openspcoop2.protocol.sdk.archive.IArchive;
  58. import org.openspcoop2.protocol.sdk.archive.ImportMode;
  59. import org.openspcoop2.protocol.sdk.archive.MapPlaceholder;
  60. import org.openspcoop2.utils.resources.FileSystemUtilities;
  61. import org.openspcoop2.utils.serialization.JavaDeserializer;
  62. import org.openspcoop2.utils.serialization.JavaSerializer;
  63. import org.openspcoop2.web.ctrlstat.core.SerialiableFormFile;
  64. import org.openspcoop2.web.ctrlstat.dao.PdDControlStation;
  65. import org.openspcoop2.web.ctrlstat.servlet.FileUploadForm;
  66. import org.openspcoop2.web.ctrlstat.servlet.ac.AccordiCooperazioneCore;
  67. import org.openspcoop2.web.ctrlstat.servlet.apc.AccordiServizioParteComuneCore;
  68. import org.openspcoop2.web.ctrlstat.servlet.pdd.PddCore;
  69. import org.openspcoop2.web.ctrlstat.servlet.soggetti.SoggettiCore;

  71. /**
  72.  * ImporterUtils
  73.  *
  74.  * @author Poli Andrea (apoli@link.it)
  75.  * @author $Author$
  76.  * @version $Rev$, $Date$
  77.  */
  78. public class ImporterUtils {

  80.     private SoggettiCore soggettiCore = null;
  81.     private AccordiServizioParteComuneCore aspcCore = null;
  82.     private AccordiCooperazioneCore acCore = null;
  83.     private PddCore pddCore = null;
  84.     public ImporterUtils(ArchiviCore archiviCore) throws Exception{
  85.         this.soggettiCore = new SoggettiCore(archiviCore);
  86.         this.aspcCore = new AccordiServizioParteComuneCore(archiviCore);
  87.         this.acCore = new AccordiCooperazioneCore(archiviCore);
  88.         this.pddCore = new PddCore(archiviCore);
  89.     }

  91.     public List<String> getIdSoggetti(List<String> protocolli,String importMode, 
  92.             String protocolloMissingInput,String tipoPdDMissingInput, Wizard wizard, ArchiviHelper helper) throws Exception{
  93.         List<String> listIdSoggetti = new ArrayList<>();
  94.         
  95.         List<String> protocolliDaScorrere = new ArrayList<>();
  96.         if(wizard!=null && wizard.getRequisiti()!=null && wizard.getRequisiti().sizeProtocolloList()>0){
  97.             for (int i = 0; i < wizard.getRequisiti().sizeProtocolloList(); i++) {
  98.                 protocolliDaScorrere.add(wizard.getRequisiti().getProtocollo(i).getNome());
  99.             }
  100.         }
  101.         else{
  102.             protocolliDaScorrere.addAll(protocolli);
  103.         }
  104.         
  105.         for (int i = 0; i < protocolliDaScorrere.size(); i++) {
  106.             String protocollo = protocolliDaScorrere.get(i);
  107.             if(ArchiviCostanti.PARAMETRO_ARCHIVI_PROTOCOLLO_UNDEFINDED.equals(protocollo) == false){
  108.                 
  109.                 IProtocolFactory<?> pf = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocollo);
  110.                 IArchive archiveEngine = pf.createArchive();
  111.                 List<ImportMode> importModesByProtocol = archiveEngine.getImportModes();
  112.                 if(importModesByProtocol.contains(new ImportMode(importMode))){
  113.                 
  114.                     List<String> tipi = this.soggettiCore.getTipiSoggettiGestitiProtocollo(protocollo);
  115.                     for (int j = 0; j < tipi.size(); j++) {
  116.                         String tipo = tipi.get(j);
  117.                         FiltroRicercaSoggetti filtro = new FiltroRicercaSoggetti();
  118.                         filtro.setTipo(tipo);
  119.                         List<IDSoggetto> idSoggetti = this.soggettiCore.getAllIdSoggettiRegistro(filtro);
  120.                         for (int k = 0; k < idSoggetti.size(); k++) {
  121.                             IDSoggetto id = idSoggetti.get(k);
  122.                             listIdSoggetti.add(id.getTipo()+"/"+id.getNome());
  123.                         }
  124.                     }
  125.                     
  126.                 }
  127.             }
  128.         }
  129.         
  130.         if(protocolloMissingInput==null && tipoPdDMissingInput==null){
  131.             
  132.             if(listIdSoggetti.size()<=0){
  133.                 throw new ProtocolException("Non risulta configurato alcun soggetto. Tale configurazione è richiesta per procedere con l'importazione");
  134.             }
  135.             
  136.             if(listIdSoggetti.size()!=1)
  137.                 listIdSoggetti.add(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_SOGGETTO_INPUT_UNDEFINDED);
  138.             java.util.Collections.sort(listIdSoggetti);
  139.             return listIdSoggetti;
  140.         }
  141.         
  142.         // filtro per protocollo e/o tipoPdD
  143.         List<String> listIdSoggettiFiltrati = new ArrayList<>();
  144.         for (String tipoNome : listIdSoggetti) {
  145.             String [] tmp = tipoNome.split("/");
  146.             String tipo = tmp[0];
  147.             String nome = tmp[1];
  148.             IDSoggetto idSoggetto = new IDSoggetto(tipo, nome);
  149.             if(protocolloMissingInput!=null){
  150.                 if(!protocolloMissingInput.equals(this.soggettiCore.getProtocolloAssociatoTipoSoggetto(tipo))){
  151.                     continue;
  152.                 }
  153.             }
  154.             if(tipoPdDMissingInput!=null){
  155.                 Soggetto sog = this.soggettiCore.getSoggettoRegistro(idSoggetto);
  156.                 if(sog.getPortaDominio()==null){
  157.                     continue;
  158.                 }
  159.                 PdDControlStation pdd = this.pddCore.getPdDControlStation(sog.getPortaDominio());
  160.                 if(!tipoPdDMissingInput.equals(pdd.getTipo())){
  161.                     continue;
  162.                 }
  163.             }
  164.             listIdSoggettiFiltrati.add(tipoNome);
  165.         }
  166.         
  167.         String criteri = "";
  168.         if(protocolloMissingInput!=null){
  169.             criteri+=" "+Costanti.LABEL_PARAMETRO_PROTOCOLLO_DI+":"+helper.getLabelProtocollo(protocolloMissingInput);
  170.         }
  171.         if(tipoPdDMissingInput!=null){
  172.             criteri+=" tipoPdDAssociata:"+tipoPdDMissingInput;
  173.         }
  174.         
  175.         if(listIdSoggettiFiltrati.size()<=0){
  176.             throw new ProtocolException("Non risulta configurato alcun soggetto che soddisfa i seguenti requisiti: "+criteri+". Tale configurazione è richiesta per procedere con l'importazione");
  177.         }
  178.         
  179.         if(listIdSoggettiFiltrati.size()!=1)
  180.             listIdSoggettiFiltrati.add(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_SOGGETTO_INPUT_UNDEFINDED);
  181.         java.util.Collections.sort(listIdSoggettiFiltrati);
  182.         return listIdSoggettiFiltrati;
  183.     }
  184.     
  185.     public List<String> getIdAccordiServizioParteComune(List<String> protocolli,String importMode, 
  186.             String protocolloMissingInput, ArchiviHelper helper) throws Exception{
  187.         List<String> listIdAccordiServizioParteComune = new ArrayList<>();
  188.         for (int i = 0; i < protocolli.size(); i++) {
  189.             String protocollo = protocolli.get(i);
  190.                         
  191.             if(ArchiviCostanti.PARAMETRO_ARCHIVI_PROTOCOLLO_UNDEFINDED.equals(protocollo) == false){
  192.                 
  193.                 if(protocolloMissingInput!=null){
  194.                     if(protocolloMissingInput.equals(protocollo)==false) {
  195.                         continue;
  196.                     }
  197.                 }
  198.                 
  199.                 IProtocolFactory<?> pf = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocollo);
  200.                 IArchive archiveEngine = pf.createArchive();
  201.                 List<ImportMode> importModesByProtocol = archiveEngine.getImportModes();
  202.                 if(importModesByProtocol.contains(new ImportMode(importMode))){
  203.                 
  204.                     List<String> tipi = this.soggettiCore.getTipiSoggettiGestitiProtocollo(protocollo);
  205.                     for (int j = 0; j < tipi.size(); j++) {
  206.                         String tipo = tipi.get(j);
  207.                         FiltroRicercaAccordi filtro = new FiltroRicercaAccordi();
  208.                         filtro.setTipoSoggettoReferente(tipo);
  209.                         try{
  210.                             List<IDAccordo> idAccordi = this.aspcCore.getAllIdAccordiServizio(filtro);
  211.                             for (int k = 0; k < idAccordi.size(); k++) {
  212.                                 listIdAccordiServizioParteComune.add(IDAccordoFactory.getInstance().getUriFromIDAccordo(idAccordi.get(k)));
  213.                             }
  214.                         }catch(DriverRegistroServiziNotFound dNotFound){
  215.                             // ignore
  216.                         }
  217.                     }
  218.                     
  219.                 }
  220.             }
  221.         }
  222.         
  223.         if(listIdAccordiServizioParteComune.size()<=0){
  224.             if(protocolloMissingInput==null){
  225.                 throw new ProtocolException("Non risulta configurata alcuna API. Tale configurazione è richiesta per procedere con l'importazione");
  226.             }
  227.             else {
  228.                 throw new ProtocolException("Non risulta configurata alcuna API ("+Costanti.LABEL_PARAMETRO_PROTOCOLLO_DI+": "+helper.getLabelProtocollo(protocolloMissingInput)
  229.                     +"). Tale configurazione è richiesta per procedere con l'importazione");
  230.             }
  231.         }
  232.         
  233.         if(listIdAccordiServizioParteComune.size()!=1)
  234.             listIdAccordiServizioParteComune.add(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_ACCORDO_INPUT_UNDEFINDED);
  235.         java.util.Collections.sort(listIdAccordiServizioParteComune);
  236.         return listIdAccordiServizioParteComune;
  237.         
  238.     }
  239.     
  240.     public List<String> getIdAccordiCooperazione(List<String> protocolli,String importMode, 
  241.             String protocolloMissingInput, ArchiviHelper helper) throws Exception{
  242.         List<String> listIdAccordiCooperazione = new ArrayList<>();
  243.         for (int i = 0; i < protocolli.size(); i++) {
  244.             String protocollo = protocolli.get(i);
  245.             if(ArchiviCostanti.PARAMETRO_ARCHIVI_PROTOCOLLO_UNDEFINDED.equals(protocollo) == false){
  246.                 
  247.                 if(protocolloMissingInput!=null){
  248.                     if(protocolloMissingInput.equals(protocollo)==false) {
  249.                         continue;
  250.                     }
  251.                 }
  252.                 
  253.                 IProtocolFactory<?> pf = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocollo);
  254.                 IArchive archiveEngine = pf.createArchive();
  255.                 List<ImportMode> importModesByProtocol = archiveEngine.getImportModes();
  256.                 if(importModesByProtocol.contains(new ImportMode(importMode))){
  257.                 
  258.                     List<String> tipi = this.soggettiCore.getTipiSoggettiGestitiProtocollo(protocollo);
  259.                     for (int j = 0; j < tipi.size(); j++) {
  260.                         String tipo = tipi.get(j);
  261.                         FiltroRicercaAccordi filtro = new FiltroRicercaAccordi();
  262.                         filtro.setTipoSoggettoReferente(tipo);
  263.                         try{                            
  264.                             List<IDAccordoCooperazione> idAccordi = this.acCore.getAllIdAccordiCooperazione(filtro);
  265.                             for (int k = 0; k < idAccordi.size(); k++) {
  266.                                 listIdAccordiCooperazione.add(IDAccordoCooperazioneFactory.getInstance().getUriFromIDAccordo(idAccordi.get(k)));
  267.                             }
  268.                         }catch(DriverRegistroServiziNotFound dNotFound){
  269.                             // ignore
  270.                         }
  271.                     }
  272.                     
  273.                 }
  274.             }
  275.         }
  276.         
  277.         if(listIdAccordiCooperazione.size()<=0){
  278.             if(protocolloMissingInput==null){
  279.                 throw new ProtocolException("Non risulta configurato alcun Accordo di Cooperazione. Tale configurazione è richiesta per procedere con l'importazione");
  280.             }
  281.             else {
  282.                 throw new ProtocolException("Non risulta configurato alcun Accordo di Cooperazione ("+Costanti.LABEL_PARAMETRO_PROTOCOLLO_DI+": "+helper.getLabelProtocollo(protocolloMissingInput)
  283.                     +"). Tale configurazione è richiesta per procedere con l'importazione");
  284.             }
  285.         }
  286.         
  287.         if(listIdAccordiCooperazione.size()!=1)
  288.             listIdAccordiCooperazione.add(ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_ACCORDO_INPUT_UNDEFINDED);
  289.         java.util.Collections.sort(listIdAccordiCooperazione);
  290.         return listIdAccordiCooperazione;
  291.         
  292.     }

  294.     public Map<String,String> getImportModesWithProtocol(List<String> protocolli) throws ProtocolException{

  296.         Map<String,String> importModes = new HashMap<>();
  297.         for (int i = 0; i < protocolli.size(); i++) {
  298.             String protocolName = protocolli.get(i);
  299.             if(ArchiviCostanti.PARAMETRO_ARCHIVI_PROTOCOLLO_UNDEFINDED.equals(protocolName)==false){
  300.                 IProtocolFactory<?> pf = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocolName);
  301.                 IArchive archiveEngine = pf.createArchive();
  302.                 List<ImportMode> importModesByProtocol = archiveEngine.getImportModes();
  303.                 for (ImportMode imp : importModesByProtocol) {
  304.                     if(importModes.containsKey(imp.toString())==false){
  305.                         importModes.put(imp.toString(),protocolName);
  306.                     }
  307.                 }
  308.             }
  309.         }

  311.         return importModes;
  312.     }

  314.     public List<ArchiveModeType> getImportModeTypes(ArchiveMode mode,String protocol) throws ProtocolException{

  316.         IProtocolFactory<?> pf = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocol);
  317.         IArchive archiveEngine = pf.createArchive();
  318.         return archiveEngine.getMappingTypesExtensions(mode).getAllTypes();

  320.     }

  322.     public List<String> getValidExtensions(ArchiveModeType type,ArchiveMode mode,String protocol) throws ProtocolException{

  324.         IProtocolFactory<?> pf = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocol);
  325.         IArchive archiveEngine = pf.createArchive();
  326.         return archiveEngine.getMappingTypesExtensions(mode).mappingTypeToExts(type);

  328.     }

  330.     private void writeSerializeObject(File tmpF,Object object) throws Exception{
  331.         JavaSerializer javaSerializer = new JavaSerializer();
  332.         FileOutputStream fout = null;
  333.         try{
  334.             fout = new FileOutputStream(tmpF);
  335.             javaSerializer.writeObject(object, fout);
  336.         }
  337.         finally{
  338.             try{
  339.                 if(fout!=null){
  340.                     fout.flush();
  341.                     fout.close();
  342.                 }
  343.             }catch(Exception eClose){
  344.                 // close
  345.             }
  346.         }
  347.     }

  349.     @SuppressWarnings("unchecked")
  350.     private <T> T readObject(File f,Class<T> c,boolean deleteFile) throws Exception{
  351.         FileInputStream fis = null;
  352.         JavaDeserializer javaDeserializer = new JavaDeserializer();
  353.         try{
  354.             fis = new FileInputStream(f);
  355.             return (T) javaDeserializer.readObject(fis, c);
  356.         }finally{
  357.             try{
  358.                 if(fis!=null){
  359.                     fis.close();
  360.                 }
  361.             }catch(Exception eClose){
  362.                 // close
  363.             }
  364.             if(deleteFile){
  365.                 try{
  366.                     if(!f.delete()) {
  367.                         // ignore
  368.                     }
  369.                 }catch(Exception e){
  370.                     // ignore
  371.                 }
  372.             }
  373.         }
  374.     }

  376.     public File writeFormFile(String sessionId,FormFile ff) throws Exception{
  377.         File tmpF = FileSystemUtilities.createTempFile(sessionId+"-"+ff.getFileName(), "tmp");
  378.         this.writeSerializeObject(tmpF, ff);
  379.         return tmpF;
  380.     }

  382.     public FormFile readFormFile(String filePath,ActionForm form) throws Exception{

  384.         FormFile ff = null;
  385.         if(StringUtils.isNotEmpty(filePath)){
  386.             File f = new File(filePath);
  387.             ff = this.readObject(f, FormFile.class, true);
  388.         }else{
  389.             FileUploadForm fileUpload = (FileUploadForm) form;
  390.             ff = fileUpload.getTheFile();
  391.         }
  392.         return (ff!=null && !(ff instanceof SerialiableFormFile) ) ? new SerialiableFormFile(ff) : ff;
  393.     }

  395.     public File writeImportInformationMissingCollectionFile(String sessionId,ImportInformationMissingCollection importInformationMissingCollection) throws Exception{
  396.         File tmpF = FileSystemUtilities.createTempFile(sessionId+"-importInformationMissingCollection", "tmp");
  397.         this.writeSerializeObject(tmpF, importInformationMissingCollection);
  398.         return tmpF;
  399.     }
  400.     public File writeImportInformationMissingObjectFile(String sessionId,Object object) throws Exception{
  401.         File tmpF = FileSystemUtilities.createTempFile(sessionId+"-importInformationMissingObject", "tmp");
  402.         this.writeSerializeObject(tmpF, object);
  403.         return tmpF;
  404.     }

  406.     public ImportInformationMissingCollection readImportInformationMissingCollectionFile(String filePath) throws Exception{

  408.         if(StringUtils.isNotEmpty(filePath)){
  409.             File f = new File(filePath);
  410.             return this.readObject(f, ImportInformationMissingCollection.class, true);
  411.         }
  412.         return null;
  413.     }
  414.     public <T> T readImportInformationMissingObjectFile(String filePath,Class<T> classObject) throws Exception{

  416.         if(StringUtils.isNotEmpty(filePath)){
  417.             File f = new File(filePath);
  418.             return this.readObject(f, classObject, true);
  419.         }
  420.         return null;
  421.     }

  423.     public ImportInformationMissingCollection updateInformationMissingCheckData(
  424.             HashMap<String, String> mapRequisitiInput, HashMap<String, String> mapRequisitiInputStepIncrement, 
  425.             String importInformationMissing_soggettoInput,String importInformationMissing_versioneInput,
  426.             List<PortType> importInformationMissing_portTypes, String importInformationMissing_portTypeImplementedInput,
  427.             String importInformationMissing_accordoServizioParteComuneInput,String importInformationMissing_accordoCooperazioneInput,
  428.             InvocazioneServizio importInformationMissing_invocazioneServizio, Connettore importInformationMissing_connettore,
  429.             Credenziali importInformationMissing_credenziali, MapPlaceholder importInformationMissing_placeholder,
  430.             String importInformationMissingCollectionFilePath,String importInformationMissingObjectId,
  431.             ImportInformationMissingCollection importInformationMissingCollection) throws Exception{

  433.         // importInformationMissing: soggetto
  434.         IDSoggetto idSoggetto = null;
  435.         if(importInformationMissing_soggettoInput!=null && 
  436.                 !"".equals(importInformationMissing_soggettoInput) &&
  437.                 !ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_SOGGETTO_INPUT_UNDEFINDED.equals(importInformationMissing_soggettoInput) ) {     
  438.             String[]splitSoggetto = importInformationMissing_soggettoInput.split("/");
  439.             idSoggetto = new IDSoggetto(splitSoggetto[0].trim(), splitSoggetto[1].trim());
  440.         }

  442.         // importInformationMissing: versione
  443.         Integer versione = null;
  444.         if(importInformationMissing_versioneInput!=null){
  445.             try{
  446.                 versione = Integer.parseInt(importInformationMissing_versioneInput);
  447.             }catch(Exception e){
  448.                 // ignore
  449.             }
  450.         }

  452.         // importInformationMissing: accordoServizioParteComune
  453.         IDAccordo idAccordoServizioParteComune = null;
  454.         if(importInformationMissing_accordoServizioParteComuneInput!=null && 
  455.                 !"".equals(importInformationMissing_accordoServizioParteComuneInput) &&
  456.                 !ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_ACCORDO_INPUT_UNDEFINDED.equals(importInformationMissing_accordoServizioParteComuneInput) ) {        
  457.             idAccordoServizioParteComune = IDAccordoFactory.getInstance().getIDAccordoFromUri(importInformationMissing_accordoServizioParteComuneInput.trim());
  458.         }
  459.         
  460.         // importInformationMissing: accordoCooperazione
  461.         IDAccordoCooperazione idAccordoCooperazione = null;
  462.         if(importInformationMissing_accordoCooperazioneInput!=null && 
  463.                 !"".equals(importInformationMissing_accordoCooperazioneInput) &&
  464.                 !ArchiviCostanti.PARAMETRO_ARCHIVI_IMPORT_INFO_MISSING_ACCORDO_INPUT_UNDEFINDED.equals(importInformationMissing_accordoCooperazioneInput) ) {       
  465.             idAccordoCooperazione = IDAccordoCooperazioneFactory.getInstance().getIDAccordoFromUri(importInformationMissing_accordoCooperazioneInput.trim());
  466.         }
  467.         
  468.         // Import Information Missing
  469.         ImportInformationMissing importInformationMissing = null;
  470.         if(importInformationMissingObjectId!=null){
  471.             if(importInformationMissingCollection!=null){
  472.                 importInformationMissing = importInformationMissingCollection.remove(importInformationMissingObjectId);
  473.             }else{
  474.                 importInformationMissingCollection = new ImportInformationMissingCollection();
  475.             }
  476.             if(importInformationMissing==null){
  477.                 importInformationMissing = new ImportInformationMissing();
  478.             }
  479.             if(mapRequisitiInput!=null) {
  480.                 importInformationMissing.setRequisitiInput(mapRequisitiInput);
  481.             }
  482.             if(mapRequisitiInputStepIncrement!=null) {
  483.                 importInformationMissing.setRequisitiInputStepIncrement(mapRequisitiInputStepIncrement);
  484.             }
  485.             if(idSoggetto!=null){
  486.                 importInformationMissing.setSoggetto(idSoggetto);
  487.             }
  488.             if(versione!=null){
  489.                 importInformationMissing.setVersione(versione); 
  490.             }
  491.             if(importInformationMissing_portTypes!=null){
  492.                 importInformationMissing.setPortTypes(importInformationMissing_portTypes);
  493.             }
  494.             if(importInformationMissing_portTypeImplementedInput!=null){
  495.                 importInformationMissing.setPortTypeImplemented(importInformationMissing_portTypeImplementedInput);
  496.             }
  497.             if(idAccordoServizioParteComune!=null){
  498.                 importInformationMissing.setIdAccordoServizioParteComune(idAccordoServizioParteComune);
  499.             }
  500.             if(idAccordoCooperazione!=null){
  501.                 importInformationMissing.setIdAccordoCooperazione(idAccordoCooperazione);
  502.             }
  503.             if(importInformationMissing_invocazioneServizio!=null){
  504.                 importInformationMissing.setInvocazioneServizio(importInformationMissing_invocazioneServizio);
  505.             }
  506.             if(importInformationMissing_connettore!=null){
  507.                 importInformationMissing.setConnettore(importInformationMissing_connettore);
  508.             }
  509.             if(importInformationMissing_credenziali!=null){
  510.                 importInformationMissing.setCredenziali(importInformationMissing_credenziali);
  511.             }
  512.             if(importInformationMissing_placeholder!=null){
  513.                 importInformationMissing.setInputPlaceholder(importInformationMissing_placeholder);
  514.             }
  515.             importInformationMissingCollection.add(importInformationMissingObjectId, importInformationMissing);
  516.         }

  518.         return importInformationMissingCollection;
  519.     }
  520.     


  523. }
Created with JaCoCo 0.8.8.202204050719