XMLDataConverter.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.  */



  23. package org.openspcoop2.core.config.driver.utils;

  25. import java.io.ByteArrayInputStream;
  26. import java.io.ByteArrayOutputStream;
  27. import java.io.File;
  28. import java.io.FileInputStream;
  29. import java.io.InputStream;
  30. import java.net.HttpURLConnection;
  31. import java.net.URL;
  32. import java.net.URLConnection;
  33. import java.sql.Connection;
  34. import java.sql.PreparedStatement;
  35. import java.sql.ResultSet;
  36. import java.sql.SQLException;
  37. import java.util.HashMap;

  39. import javax.net.ssl.KeyManagerFactory;
  40. import javax.net.ssl.TrustManagerFactory;

  42. import org.openspcoop2.core.commons.DBUtils;
  43. import org.openspcoop2.core.commons.ProtocolFactoryReflectionUtils;
  44. import org.openspcoop2.core.config.AccessoConfigurazionePdD;
  45. import org.openspcoop2.core.config.Connettore;
  46. import org.openspcoop2.core.config.Credenziali;
  47. import org.openspcoop2.core.config.InvocazionePorta;
  48. import org.openspcoop2.core.config.InvocazionePortaGestioneErrore;
  49. import org.openspcoop2.core.config.InvocazioneServizio;
  50. import org.openspcoop2.core.config.PortaApplicativa;
  51. import org.openspcoop2.core.config.PortaApplicativaServizioApplicativo;
  52. import org.openspcoop2.core.config.PortaDelegata;
  53. import org.openspcoop2.core.config.Property;
  54. import org.openspcoop2.core.config.RispostaAsincrona;
  55. import org.openspcoop2.core.config.ServizioApplicativo;
  56. import org.openspcoop2.core.config.Soggetto;
  57. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  58. import org.openspcoop2.core.config.constants.CredenzialeTipo;
  59. import org.openspcoop2.core.config.constants.InvocazioneServizioTipoAutenticazione;
  60. import org.openspcoop2.core.config.constants.PortaApplicativaAzioneIdentificazione;
  61. import org.openspcoop2.core.config.constants.PortaDelegataAzioneIdentificazione;
  62. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  63. import org.openspcoop2.core.config.constants.TipologiaErogazione;
  64. import org.openspcoop2.core.config.constants.TipologiaFruizione;
  65. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  66. import org.openspcoop2.core.config.driver.IDriverConfigurazioneCRUD;
  67. import org.openspcoop2.core.config.driver.IDriverConfigurazioneGet;
  68. import org.openspcoop2.core.config.driver.db.DriverConfigurazioneDB;
  69. import org.openspcoop2.core.config.driver.xml.DriverConfigurazioneXML;
  70. import org.openspcoop2.core.constants.Costanti;
  71. import org.openspcoop2.core.constants.CostantiDB;
  72. import org.openspcoop2.core.constants.TipiConnettore;
  73. import org.openspcoop2.core.id.IDPortaApplicativa;
  74. import org.openspcoop2.core.id.IDPortaDelegata;
  75. import org.openspcoop2.core.id.IDServizio;
  76. import org.openspcoop2.core.id.IDServizioApplicativo;
  77. import org.openspcoop2.core.id.IDSoggetto;
  78. import org.openspcoop2.core.mapping.DBMappingUtils;
  79. import org.openspcoop2.core.mapping.Implementation;
  80. import org.openspcoop2.core.mapping.ImplementationUtils;
  81. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  82. import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
  83. import org.openspcoop2.core.mapping.Subscription;
  84. import org.openspcoop2.core.mapping.SubscriptionUtils;
  85. import org.openspcoop2.core.registry.constants.ServiceBinding;
  86. import org.openspcoop2.core.registry.utils.RegistroServiziUtils;
  87. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  88. import org.openspcoop2.message.xml.ValidatoreXSD;
  89. import org.openspcoop2.message.xml.MessageXMLUtils;
  90. import org.openspcoop2.utils.CopyStream;
  91. import org.openspcoop2.utils.LoggerWrapperFactory;
  92. import org.openspcoop2.utils.certificate.KeystoreType;
  93. import org.openspcoop2.utils.sql.ISQLQueryObject;
  94. import org.openspcoop2.utils.sql.SQLObjectFactory;
  95. import org.openspcoop2.utils.xml.AbstractXMLUtils;
  96. import org.slf4j.Logger;
  97. import org.w3c.dom.Document;

  99. /**
  100.  * Classe utilizzata per convertire dati presenti in un file XML in un altra risorsa che implementa l'interfaccia CRUD.
  101.  *
  102.  * @author Poli Andrea (apoli@link.it)
  103.  * @author $Author$
  104.  * @version $Rev$, $Date$
  105.  */
  106. public class XMLDataConverter {

  108.     /** GestoreCRUD */
  109.     private IDriverConfigurazioneCRUD gestoreCRUD = null;
  110.     /** 'Root' della configurazione di  OpenSPCoop. */
  111.     private org.openspcoop2.core.config.Openspcoop2 sorgenteConfigurazione;
  112.     /** Logger */
  113.     private Logger log = null;
  114.     /** Logger alternativo per i driver */
  115.     private Logger logDriver = null;
  116.     /** SuperUser */
  117.     private String superUser = null;
  118.     /** Indicazione se deve essere convertita anche la configurazione */
  119.     private boolean gestioneConfigurazione;
  120.     /** Tipo del backend di destinazione */
  121.     private String tipoBEDestinazione;
  122.     
  123.     private AbstractXMLUtils xmlUtils = null;
  124.     
  125.     public XMLDataConverter(String sorgente,AccessoConfigurazionePdD destinazione,
  126.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault) throws DriverConfigurazioneException{
  127.         XMLDataConverterSetup(sorgente,destinazione,
  128.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  129.                 null,null);
  130.     }
  131.     public XMLDataConverter(String sorgente,AccessoConfigurazionePdD destinazione,
  132.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  133.             Logger log) throws DriverConfigurazioneException{
  134.         XMLDataConverterSetup(sorgente,destinazione,
  135.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  136.                 log,null);
  137.     }
  138.     public XMLDataConverter(String sorgente,AccessoConfigurazionePdD destinazione,
  139.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  140.             Logger log,Logger logDriver) throws DriverConfigurazioneException{
  141.         XMLDataConverterSetup(sorgente,destinazione,
  142.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  143.                 log,logDriver);
  144.     }
  145.     
  146.     public XMLDataConverter(byte[] sorgente,AccessoConfigurazionePdD destinazione,
  147.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault) throws DriverConfigurazioneException{
  148.         XMLDataConverterSetup(sorgente,destinazione,
  149.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  150.                 null,null);
  151.     }
  152.     public XMLDataConverter(byte[] sorgente,AccessoConfigurazionePdD destinazione,
  153.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  154.             Logger log) throws DriverConfigurazioneException{
  155.         XMLDataConverterSetup(sorgente,destinazione,
  156.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  157.                 log,null);
  158.     }
  159.     public XMLDataConverter(byte[] sorgente,AccessoConfigurazionePdD destinazione,
  160.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  161.             Logger log,Logger logDriver) throws DriverConfigurazioneException{
  162.         XMLDataConverterSetup(sorgente,destinazione,
  163.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  164.                 log,logDriver);
  165.     }
  166.     
  167.     public XMLDataConverter(InputStream sorgente,AccessoConfigurazionePdD destinazione,
  168.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault) throws DriverConfigurazioneException{
  169.         XMLDataConverterSetup(sorgente,destinazione,
  170.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  171.                 null,null);
  172.     }
  173.     public XMLDataConverter(InputStream sorgente,AccessoConfigurazionePdD destinazione,
  174.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  175.             Logger log) throws DriverConfigurazioneException{
  176.         XMLDataConverterSetup(sorgente,destinazione,
  177.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  178.                 log,null);
  179.     }
  180.     public XMLDataConverter(InputStream sorgente,AccessoConfigurazionePdD destinazione,
  181.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  182.             Logger log,Logger logDriver) throws DriverConfigurazioneException{
  183.         XMLDataConverterSetup(sorgente,destinazione,
  184.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  185.                 log,logDriver);
  186.     }
  187.     
  188.     public XMLDataConverter(File sorgente,AccessoConfigurazionePdD destinazione,
  189.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault) throws DriverConfigurazioneException{
  190.         XMLDataConverterSetup(sorgente,destinazione,
  191.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  192.                 null,null);
  193.     }
  194.     public XMLDataConverter(File sorgente,AccessoConfigurazionePdD destinazione,
  195.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  196.             Logger log) throws DriverConfigurazioneException{
  197.         XMLDataConverterSetup(sorgente,destinazione,
  198.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  199.                 log,null);
  200.     }
  201.     public XMLDataConverter(File sorgente,AccessoConfigurazionePdD destinazione,
  202.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  203.             Logger log,Logger logDriver) throws DriverConfigurazioneException{
  204.         XMLDataConverterSetup(sorgente,destinazione,
  205.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  206.                 log,logDriver);
  207.     }
  208.     
  209.     public XMLDataConverter(org.openspcoop2.core.config.Openspcoop2 sorgente,AccessoConfigurazionePdD destinazione,
  210.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault) throws DriverConfigurazioneException{
  211.         XMLDataConverterSetup(sorgente,destinazione,
  212.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  213.                 null,null);
  214.     }
  215.     public XMLDataConverter(org.openspcoop2.core.config.Openspcoop2 sorgente,AccessoConfigurazionePdD destinazione,
  216.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  217.             Logger log) throws DriverConfigurazioneException{
  218.         XMLDataConverterSetup(sorgente,destinazione,
  219.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  220.                 log,null);
  221.     }
  222.     public XMLDataConverter(org.openspcoop2.core.config.Openspcoop2 sorgente,AccessoConfigurazionePdD destinazione,
  223.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  224.             Logger log,Logger logDriver) throws DriverConfigurazioneException{
  225.         XMLDataConverterSetup(sorgente,destinazione,
  226.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  227.                 log,logDriver);
  228.     }
  229.     
  230.     private void XMLDataConverterSetup(Object sorgente,AccessoConfigurazionePdD destinazione,
  231.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  232.             Logger log,Logger logDriver) throws DriverConfigurazioneException{
  233.     
  234.         if(log == null)
  235.             this.log = LoggerWrapperFactory.getLogger(XMLDataConverter.class);
  236.         else
  237.             this.log = log;
  238.         this.logDriver = logDriver;
  239.         
  240.         this.gestioneConfigurazione = configurazione;
  241.         if(destinazione==null)
  242.             throw new DriverConfigurazioneException("GestoreCRUD non definito");
  243.         this.tipoBEDestinazione = destinazione.getTipo();
  244.         this.superUser = superUser;
  245.         
  246.         // Istanziazione sorgente
  247.         try{
  248.             if(sorgente instanceof org.openspcoop2.core.config.Openspcoop2){
  249.                 this.sorgenteConfigurazione = (org.openspcoop2.core.config.Openspcoop2) sorgente;
  250.             }
  251.             else if(sorgente instanceof String){
  252.                 createSorgente((String)sorgente);
  253.             }
  254.             else if (sorgente instanceof byte[]){
  255.                 createSorgente((byte[])sorgente);
  256.             }else if (sorgente instanceof InputStream){
  257.                 ByteArrayOutputStream bout = new ByteArrayOutputStream();
  258.                 InputStream is = (InputStream) sorgente;
  259. //              int letti = 0;
  260. //              byte [] reads = new byte[Utilities.DIMENSIONE_BUFFER];
  261. //              while( (letti=is.read(reads)) != -1 ){
  262. //                  bout.write(reads,0,letti);  
  263. //              }
  264.                 CopyStream.copy(is, bout);
  265.                 bout.flush();
  266.                 bout.close();
  267.                 createSorgente(bout.toByteArray());
  268.             }else if (sorgente instanceof File){
  269.                 createSorgente(((File)sorgente).getAbsolutePath());
  270.             }
  271.         }catch(DriverConfigurazioneException d){
  272.             throw d;
  273.         }catch(Exception e){
  274.             throw new DriverConfigurazioneException("Creazione sorgente ["+sorgente.getClass().getName()+"] non riuscita: "+e.getMessage(),e);
  275.         }
  276.         
  277.         // Istanziazione CRUD
  278.         try{
  279.             if(CostantiConfigurazione.REGISTRO_DB.equals(destinazione.getTipo())){
  280.                 if(destinazione.getLocation()==null)
  281.                     throw new Exception("Location (DataSource) non definita");
  282.                 if(destinazione.getContext()==null)
  283.                     throw new Exception("Contesto di localizzazione del datasource non definito in GenericProperties");
  284.                 if(destinazione.getTipoDatabase()==null)
  285.                     throw new Exception("TipoDatabase (DataSource) non definita");
  286.                 
  287.                 this.gestoreCRUD = new DriverConfigurazioneDB(destinazione.getLocation(),destinazione.getContext(),this.logDriver,
  288.                         destinazione.getTipoDatabase(),tabellaSoggettiCondivisaPddRegserv);
  289.                 if(((DriverConfigurazioneDB)this.gestoreCRUD).create)
  290.                     this.log.info("Inizializzato Configurazione DB");
  291.                 else
  292.                     throw new Exception("Configurazione DB non inizializzato");
  293.             }
  294.             else{
  295.                 throw new Exception("Tipo di configurazione CRUD non gestita: "+destinazione.getTipo());
  296.             }
  297.         }catch(Exception e){
  298.             throw new DriverConfigurazioneException("Errore durante l'istanziazione del driver di CRUD: "+e.getMessage(),e);
  299.         }
  300.         this.xmlUtils = MessageXMLUtils.DEFAULT;
  301.         
  302.         // Protocol initialize
  303.         try {
  304.             ProtocolFactoryReflectionUtils.initializeProtocolManager(protocolloDefault, this.log);
  305.         }catch(Exception e){
  306.             throw new DriverConfigurazioneException("Errore durante l'istanziazione del driver di CRUD: "+e.getMessage(),e);
  307.         }
  308.     }
  309.     
  310.     
  311.     public XMLDataConverter(String sorgente,IDriverConfigurazioneCRUD gestoreCRUD,String tipoDestinazione,
  312.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault) throws DriverConfigurazioneException{
  313.         XMLDataConverterSetup(sorgente,gestoreCRUD, tipoDestinazione,
  314.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  315.                 null,null);
  316.     }
  317.     public XMLDataConverter(String sorgente,IDriverConfigurazioneCRUD gestoreCRUD,String tipoDestinazione,
  318.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  319.             Logger log) throws DriverConfigurazioneException{
  320.         XMLDataConverterSetup(sorgente,gestoreCRUD, tipoDestinazione,
  321.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  322.                 log,null);
  323.     }
  324.     public XMLDataConverter(String sorgente,IDriverConfigurazioneCRUD gestoreCRUD,String tipoDestinazione,
  325.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  326.             Logger log,Logger logDriver) throws DriverConfigurazioneException{
  327.         XMLDataConverterSetup(sorgente,gestoreCRUD, tipoDestinazione,
  328.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  329.                 log,logDriver);
  330.     }
  331.     
  332.     public XMLDataConverter(byte[] sorgente,IDriverConfigurazioneCRUD gestoreCRUD,String tipoDestinazione,
  333.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault) throws DriverConfigurazioneException{
  334.         XMLDataConverterSetup(sorgente,gestoreCRUD, tipoDestinazione,
  335.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  336.                 null,null);
  337.     }
  338.     public XMLDataConverter(byte[] sorgente,IDriverConfigurazioneCRUD gestoreCRUD,String tipoDestinazione,
  339.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  340.             Logger log) throws DriverConfigurazioneException{
  341.         XMLDataConverterSetup(sorgente,gestoreCRUD, tipoDestinazione,
  342.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  343.                 log,null);
  344.     }
  345.     public XMLDataConverter(byte[] sorgente,IDriverConfigurazioneCRUD gestoreCRUD,String tipoDestinazione,
  346.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  347.             Logger log,Logger logDriver) throws DriverConfigurazioneException{
  348.         XMLDataConverterSetup(sorgente,gestoreCRUD, tipoDestinazione,
  349.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  350.                 log,logDriver);
  351.     }
  352.     
  353.     public XMLDataConverter(InputStream sorgente,IDriverConfigurazioneCRUD gestoreCRUD,String tipoDestinazione,
  354.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault) throws DriverConfigurazioneException{
  355.         XMLDataConverterSetup(sorgente,gestoreCRUD, tipoDestinazione,
  356.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  357.                 null,null);
  358.     }
  359.     public XMLDataConverter(InputStream sorgente,IDriverConfigurazioneCRUD gestoreCRUD,String tipoDestinazione,
  360.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  361.             Logger log) throws DriverConfigurazioneException{
  362.         XMLDataConverterSetup(sorgente,gestoreCRUD, tipoDestinazione,
  363.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  364.                 log,null);
  365.     }
  366.     public XMLDataConverter(InputStream sorgente,IDriverConfigurazioneCRUD gestoreCRUD,String tipoDestinazione,
  367.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  368.             Logger log,Logger logDriver) throws DriverConfigurazioneException{
  369.         XMLDataConverterSetup(sorgente,gestoreCRUD, tipoDestinazione,
  370.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  371.                 log,logDriver);
  372.     }
  373.     
  374.     public XMLDataConverter(File sorgente,IDriverConfigurazioneCRUD gestoreCRUD,String tipoDestinazione,
  375.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault) throws DriverConfigurazioneException{
  376.         XMLDataConverterSetup(sorgente,gestoreCRUD, tipoDestinazione,
  377.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  378.                 null,null);
  379.     }
  380.     public XMLDataConverter(File sorgente,IDriverConfigurazioneCRUD gestoreCRUD,String tipoDestinazione,
  381.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  382.             Logger log) throws DriverConfigurazioneException{
  383.         XMLDataConverterSetup(sorgente,gestoreCRUD, tipoDestinazione,
  384.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  385.                 log,null);
  386.     }
  387.     public XMLDataConverter(File sorgente,IDriverConfigurazioneCRUD gestoreCRUD,String tipoDestinazione,
  388.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  389.             Logger log,Logger logDriver) throws DriverConfigurazioneException{
  390.         XMLDataConverterSetup(sorgente,gestoreCRUD, tipoDestinazione,
  391.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  392.                 log,logDriver);
  393.     }
  394.     
  395.     public XMLDataConverter(org.openspcoop2.core.config.Openspcoop2 sorgente,IDriverConfigurazioneCRUD gestoreCRUD,String tipoDestinazione,
  396.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault) throws DriverConfigurazioneException{
  397.         XMLDataConverterSetup(sorgente,gestoreCRUD, tipoDestinazione,
  398.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  399.                 null,null);
  400.     }
  401.     public XMLDataConverter(org.openspcoop2.core.config.Openspcoop2 sorgente,IDriverConfigurazioneCRUD gestoreCRUD,String tipoDestinazione,
  402.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  403.             Logger log) throws DriverConfigurazioneException{
  404.         XMLDataConverterSetup(sorgente,gestoreCRUD, tipoDestinazione,
  405.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  406.                 log,null);
  407.     }
  408.     public XMLDataConverter(org.openspcoop2.core.config.Openspcoop2 sorgente,IDriverConfigurazioneCRUD gestoreCRUD,String tipoDestinazione,
  409.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  410.             Logger log,Logger logDriver) throws DriverConfigurazioneException{
  411.         XMLDataConverterSetup(sorgente,gestoreCRUD, tipoDestinazione,
  412.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  413.                 log,logDriver);
  414.     }
  415.     
  416.     private void XMLDataConverterSetup(Object sorgente,IDriverConfigurazioneCRUD gestoreCRUD,String tipoDestinazione,
  417.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  418.             Logger log,Logger logDriver) throws DriverConfigurazioneException{
  419.     
  420.         if(log == null)
  421.             this.log = LoggerWrapperFactory.getLogger(XMLDataConverter.class);
  422.         else
  423.             this.log = log;
  424.         this.logDriver = logDriver;
  425.         
  426.         this.gestioneConfigurazione = configurazione;
  427.         if(gestoreCRUD==null)
  428.             throw new DriverConfigurazioneException("GestoreCRUD non definito");
  429.         this.tipoBEDestinazione = tipoDestinazione;
  430.         this.superUser = superUser;
  431.         
  432.         // Istanziazione sorgente
  433.         try{
  434.             if(sorgente instanceof org.openspcoop2.core.config.Openspcoop2){
  435.                 this.sorgenteConfigurazione = (org.openspcoop2.core.config.Openspcoop2) sorgente;
  436.             }
  437.             else if(sorgente instanceof String){
  438.                 createSorgente((String)sorgente);
  439.             }
  440.             else if (sorgente instanceof byte[]){
  441.                 createSorgente((byte[])sorgente);
  442.             }else if (sorgente instanceof InputStream){
  443.                 ByteArrayOutputStream bout = new ByteArrayOutputStream();
  444.                 InputStream is = (InputStream) sorgente;
  445. //              int letti = 0;
  446. //              byte [] reads = new byte[Utilities.DIMENSIONE_BUFFER];
  447. //              while( (letti=is.read(reads)) != -1 ){
  448. //                  bout.write(reads,0,letti);  
  449. //              }
  450.                 CopyStream.copy(is, bout);
  451.                 bout.flush();
  452.                 bout.close();
  453.                 createSorgente(bout.toByteArray());
  454.             }else if (sorgente instanceof File){
  455.                 createSorgente(((File)sorgente).getAbsolutePath());
  456.             }
  457.         }catch(DriverConfigurazioneException d){
  458.             throw d;
  459.         }catch(Exception e){
  460.             throw new DriverConfigurazioneException("Creazione sorgente ["+sorgente.getClass().getName()+"] non riuscita: "+e.getMessage(),e);
  461.         }
  462.         
  463.         // Istanziazione CRUD
  464.         this.gestoreCRUD = gestoreCRUD;
  465.         this.xmlUtils = MessageXMLUtils.DEFAULT;
  466.         
  467.         // Protocol initialize
  468.         try {
  469.             ProtocolFactoryReflectionUtils.initializeProtocolManager(protocolloDefault, this.log);
  470.         }catch(Exception e){
  471.             throw new DriverConfigurazioneException("Errore durante l'istanziazione del driver di CRUD: "+e.getMessage(),e);
  472.         }
  473.     }
  474.     
  475.     
  476.     public XMLDataConverter(String sorgente,Connection connection,String tipoDatabase,
  477.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault) throws DriverConfigurazioneException{
  478.         XMLDataConverterSetup(sorgente,connection,tipoDatabase,
  479.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  480.                 null,null);
  481.     }
  482.     public XMLDataConverter(String sorgente,Connection connection,String tipoDatabase,
  483.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  484.             Logger log) throws DriverConfigurazioneException{
  485.         XMLDataConverterSetup(sorgente,connection,tipoDatabase,
  486.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  487.                 log,null);
  488.     }
  489.     public XMLDataConverter(String sorgente,Connection connection,String tipoDatabase,
  490.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  491.             Logger log,Logger logDriver) throws DriverConfigurazioneException{
  492.         XMLDataConverterSetup(sorgente,connection,tipoDatabase,
  493.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  494.                 log,logDriver);
  495.     }
  496.     
  497.     public XMLDataConverter(byte[] sorgente,Connection connection,String tipoDatabase,
  498.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault) throws DriverConfigurazioneException{
  499.         XMLDataConverterSetup(sorgente,connection,tipoDatabase,
  500.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  501.                 null,null);
  502.     }
  503.     public XMLDataConverter(byte[] sorgente,Connection connection,String tipoDatabase,
  504.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  505.             Logger log) throws DriverConfigurazioneException{
  506.         XMLDataConverterSetup(sorgente,connection,tipoDatabase,
  507.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  508.                 log,null);
  509.     }
  510.     public XMLDataConverter(byte[] sorgente,Connection connection,String tipoDatabase,
  511.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  512.             Logger log,Logger logDriver) throws DriverConfigurazioneException{
  513.         XMLDataConverterSetup(sorgente,connection,tipoDatabase,
  514.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  515.                 log,logDriver);
  516.     }
  517.     
  518.     public XMLDataConverter(InputStream sorgente,Connection connection,String tipoDatabase,
  519.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault) throws DriverConfigurazioneException{
  520.         XMLDataConverterSetup(sorgente,connection,tipoDatabase,
  521.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  522.                 null,null);
  523.     }
  524.     public XMLDataConverter(InputStream sorgente,Connection connection,String tipoDatabase,
  525.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  526.             Logger log) throws DriverConfigurazioneException{
  527.         XMLDataConverterSetup(sorgente,connection,tipoDatabase,
  528.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  529.                 log,null);
  530.     }
  531.     public XMLDataConverter(InputStream sorgente,Connection connection,String tipoDatabase,
  532.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  533.             Logger log,Logger logDriver) throws DriverConfigurazioneException{
  534.         XMLDataConverterSetup(sorgente,connection,tipoDatabase,
  535.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  536.                 log,logDriver);
  537.     }
  538.     
  539.     public XMLDataConverter(File sorgente,Connection connection,String tipoDatabase,
  540.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault) throws DriverConfigurazioneException{
  541.         XMLDataConverterSetup(sorgente,connection,tipoDatabase,
  542.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  543.                 null,null);
  544.     }
  545.     public XMLDataConverter(File sorgente,Connection connection,String tipoDatabase,
  546.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  547.             Logger log) throws DriverConfigurazioneException{
  548.         XMLDataConverterSetup(sorgente,connection,tipoDatabase,
  549.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  550.                 log,null);
  551.     }
  552.     public XMLDataConverter(File sorgente,Connection connection,String tipoDatabase,
  553.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  554.             Logger log,Logger logDriver) throws DriverConfigurazioneException{
  555.         XMLDataConverterSetup(sorgente,connection,tipoDatabase,
  556.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  557.                 log,logDriver);
  558.     }
  559.     
  560.     public XMLDataConverter(org.openspcoop2.core.config.Openspcoop2 sorgente,Connection connection,String tipoDatabase,
  561.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault) throws DriverConfigurazioneException{
  562.         XMLDataConverterSetup(sorgente,connection,tipoDatabase,
  563.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  564.                 null,null);
  565.     }
  566.     public XMLDataConverter(org.openspcoop2.core.config.Openspcoop2 sorgente,Connection connection,String tipoDatabase,
  567.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  568.             Logger log) throws DriverConfigurazioneException{
  569.         XMLDataConverterSetup(sorgente,connection,tipoDatabase,
  570.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  571.                 log,null);
  572.     }
  573.     public XMLDataConverter(org.openspcoop2.core.config.Openspcoop2 sorgente,Connection connection,String tipoDatabase,
  574.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  575.             Logger log,Logger logDriver) throws DriverConfigurazioneException{
  576.         XMLDataConverterSetup(sorgente,connection,tipoDatabase,
  577.                 configurazione,tabellaSoggettiCondivisaPddRegserv,superUser,protocolloDefault,
  578.                 log,logDriver);
  579.     }
  580.     
  581.     private void XMLDataConverterSetup(Object sorgente,Connection connection,String tipoDatabase,
  582.             boolean configurazione,boolean tabellaSoggettiCondivisaPddRegserv,String superUser,String protocolloDefault,
  583.             Logger log,Logger logDriver) throws DriverConfigurazioneException{
  584.     
  585.         if(log == null)
  586.             this.log = LoggerWrapperFactory.getLogger(XMLDataConverter.class);
  587.         else
  588.             this.log = log;
  589.         this.logDriver = logDriver;
  590.         
  591.         this.gestioneConfigurazione = configurazione;
  592.         this.tipoBEDestinazione = CostantiConfigurazione.REGISTRO_DB.toString();
  593.         this.superUser = superUser;
  594.         
  595.         // Istanziazione sorgente
  596.         try{
  597.             if(sorgente instanceof org.openspcoop2.core.config.Openspcoop2){
  598.                 this.sorgenteConfigurazione = (org.openspcoop2.core.config.Openspcoop2) sorgente;
  599.             }
  600.             else if(sorgente instanceof String){
  601.                 createSorgente((String)sorgente);
  602.             }
  603.             else if (sorgente instanceof byte[]){
  604.                 createSorgente((byte[])sorgente);
  605.             }else if (sorgente instanceof InputStream){
  606.                 ByteArrayOutputStream bout = new ByteArrayOutputStream();
  607.                 InputStream is = (InputStream) sorgente;
  608. //              int letti = 0;
  609. //              byte [] reads = new byte[Utilities.DIMENSIONE_BUFFER];
  610. //              while( (letti=is.read(reads)) != -1 ){
  611. //                  bout.write(reads,0,letti);  
  612. //              }
  613.                 CopyStream.copy(is, bout);
  614.                 bout.flush();
  615.                 bout.close();
  616.                 createSorgente(bout.toByteArray());
  617.             }else if (sorgente instanceof File){
  618.                 createSorgente(((File)sorgente).getAbsolutePath());
  619.             }
  620.         }catch(DriverConfigurazioneException d){
  621.             throw d;
  622.         }catch(Exception e){
  623.             throw new DriverConfigurazioneException("Creazione sorgente ["+sorgente.getClass().getName()+"] non riuscita: "+e.getMessage(),e);
  624.         }
  625.         
  626.         // Istanziazione CRUD in version DB
  627.         try{
  628.             this.gestoreCRUD = new DriverConfigurazioneDB(connection,this.logDriver,tipoDatabase,tabellaSoggettiCondivisaPddRegserv);
  629.             if(((DriverConfigurazioneDB)this.gestoreCRUD).create)
  630.                 this.log.info("Inizializzato Configurazione DB");
  631.             else
  632.                 throw new Exception("Configurazione DB non inizializzato");
  633.         }catch(Exception e){
  634.             throw new DriverConfigurazioneException("Errore durante l'istanziazione del driver di CRUD: "+e.getMessage(),e);
  635.         }
  636.         this.xmlUtils = MessageXMLUtils.DEFAULT;
  637.         
  638.         // Protocol initialize
  639.         try {
  640.             ProtocolFactoryReflectionUtils.initializeProtocolManager(protocolloDefault, this.log);
  641.         }catch(Exception e){
  642.             throw new DriverConfigurazioneException("Errore durante l'istanziazione del driver di CRUD: "+e.getMessage(),e);
  643.         }
  644.     }
  645.     
  646.     private static Implementation getImplementationDefault(ServiceBinding serviceBinding, IDServizio idServizio) throws DriverConfigurazioneException{
  647.         // Protocol initialize
  648.         try{
  649.             Class<?> cProtocolFactoryManager = Class.forName("org.openspcoop2.protocol.engine.ProtocolFactoryManager");
  650.             Object protocolFactoryManager = cProtocolFactoryManager.getMethod("getInstance").invoke(null);
  651.             
  652.             String protocollo = (String) cProtocolFactoryManager.getMethod("getProtocolByOrganizationType",String.class).invoke(protocolFactoryManager,idServizio.getSoggettoErogatore().getTipo());
  653.             
  654.             Class<?> cProtocolFactory = Class.forName("org.openspcoop2.protocol.sdk.IProtocolFactory");
  655.             Object protocolFactory = cProtocolFactoryManager.getMethod("getProtocolFactoryByName",String.class).invoke(protocolFactoryManager, protocollo);
  656.             
  657.             Class<?> cProtocolIntegrationConfiguration = Class.forName("org.openspcoop2.protocol.sdk.config.IProtocolIntegrationConfiguration");
  658.             Object protocolIntegrationConfiguration = cProtocolFactory.getMethod("createProtocolIntegrationConfiguration").invoke(protocolFactory);
  659.             
  660.             org.openspcoop2.message.constants.ServiceBinding serviceBindingMessage = RegistroServiziUtils.convertToMessage(serviceBinding);
  661.             
  662.             return (Implementation) cProtocolIntegrationConfiguration.getMethod("createDefaultImplementation", org.openspcoop2.message.constants.ServiceBinding.class, IDServizio.class).
  663.                     invoke(protocolIntegrationConfiguration, serviceBindingMessage, idServizio);
  664.                         
  665.         }catch(Exception e){
  666.             throw new DriverConfigurazioneException("Errore durante l'utilizzo della protocolFactory (getImplementationDefault): "+e.getMessage(),e);
  667.         }
  668.     }
  669.     private static Subscription getSubscriptionDefault(ServiceBinding serviceBinding, IDSoggetto idFruitore, IDServizio idServizio) throws DriverConfigurazioneException{
  670.         // Protocol initialize
  671.         try{
  672.             Class<?> cProtocolFactoryManager = Class.forName("org.openspcoop2.protocol.engine.ProtocolFactoryManager");
  673.             Object protocolFactoryManager = cProtocolFactoryManager.getMethod("getInstance").invoke(null);
  674.             
  675.             String protocollo = (String) cProtocolFactoryManager.getMethod("getProtocolByOrganizationType",String.class).invoke(protocolFactoryManager,idServizio.getSoggettoErogatore().getTipo());
  676.             
  677.             Class<?> cProtocolFactory = Class.forName("org.openspcoop2.protocol.sdk.IProtocolFactory");
  678.             Object protocolFactory = cProtocolFactoryManager.getMethod("getProtocolFactoryByName",String.class).invoke(protocolFactoryManager, protocollo);
  679.             
  680.             Class<?> cProtocolIntegrationConfiguration = Class.forName("org.openspcoop2.protocol.sdk.config.IProtocolIntegrationConfiguration");
  681.             Object protocolIntegrationConfiguration = cProtocolFactory.getMethod("createProtocolIntegrationConfiguration").invoke(protocolFactory);
  682.             
  683.             org.openspcoop2.message.constants.ServiceBinding serviceBindingMessage = RegistroServiziUtils.convertToMessage(serviceBinding);
  684.             
  685.             return (Subscription) cProtocolIntegrationConfiguration.getMethod("createDefaultSubscription", org.openspcoop2.message.constants.ServiceBinding.class, IDSoggetto.class, IDServizio.class).
  686.                     invoke(protocolIntegrationConfiguration, serviceBindingMessage, idFruitore, idServizio);
  687.                         
  688.         }catch(Exception e){
  689.             throw new DriverConfigurazioneException("Errore durante l'utilizzo della protocolFactory (getSubscriptionDefault): "+e.getMessage(),e);
  690.         }
  691.     }
  692.     
  693.     private void createSorgente(String sorgente)throws DriverConfigurazioneException{
  694.         // Istanziazione Sorgente
  695.         if(sorgente==null)
  696.             throw new DriverConfigurazioneException("Sorgente non definita");
  697.         
  698.         // ValidatoreXSD
  699.         ValidatoreXSD validatoreRegistro = null;
  700.         try{
  701.             validatoreRegistro = new ValidatoreXSD(OpenSPCoop2MessageFactory.getDefaultMessageFactory(), this.log,DriverConfigurazioneXML.class.getResourceAsStream("/config.xsd"));
  702.         }catch (Exception e) {
  703.             throw new DriverConfigurazioneException("Riscontrato errore durante l'inizializzazione dello schema della Configurazione XML di OpenSPCoop: "+e.getMessage());
  704.         }
  705.         FileInputStream fXML = null;
  706.         try{
  707.             if(sorgente.startsWith("http://") || sorgente.startsWith("file://")){
  708.                 validatoreRegistro.valida(sorgente);  
  709.             }else{
  710.                 fXML = new FileInputStream(sorgente);
  711.                 validatoreRegistro.valida(fXML);
  712.             }
  713.         }catch (Exception e) {
  714.             throw new DriverConfigurazioneException("Riscontrato errore durante la validazione XSD del Configurazione XML di OpenSPCoop: "+e.getMessage());
  715.         }finally{
  716.             if(fXML!=null){
  717.                 try{
  718.                     fXML.close();
  719.                 }catch(Exception e){}
  720.             }
  721.         }
  722.         
  723.         try{
  724.             InputStream iStream = null;
  725.             HttpURLConnection httpConn = null;
  726.             if(sorgente.startsWith("http://") || sorgente.startsWith("file://")){
  727.                 try{ 
  728.                     URL url = new URL(sorgente);
  729.                     URLConnection connection = url.openConnection();
  730.                     httpConn = (HttpURLConnection) connection;
  731.                     httpConn.setRequestMethod("GET");
  732.                     httpConn.setDoOutput(true);
  733.                     httpConn.setDoInput(true);
  734.                     iStream = httpConn.getInputStream();
  735.                     if(sorgente.startsWith("http://")) {
  736.                         /**System.out.println("HTTP");*/
  737.                     }
  738.                 }catch(Exception e) {
  739.                     try{  
  740.                         if(iStream!=null)
  741.                             iStream.close();
  742.                         if(httpConn !=null)
  743.                             httpConn.disconnect();
  744.                     } catch(Exception ef) {
  745.                         // ignore
  746.                     }
  747.                     throw new DriverConfigurazioneException("Riscontrato errore durante la creazione dell'inputStream del Configurazione (HTTP) : \n\n"+e.getMessage());
  748.                 }
  749.             }else{
  750.                 try{  
  751.                     iStream = new FileInputStream(sorgente);
  752.                 }catch(java.io.FileNotFoundException e) {
  753.                     throw new DriverConfigurazioneException("Riscontrato errore durante la creazione dell'inputStream del Configurazione (FILE) : \n\n"+e.getMessage());
  754.                 }
  755.             }

  757.             
  758.             /* ---- Unmarshall del file di configurazione ---- */
  759.             try{  
  760.                 org.openspcoop2.core.config.utils.serializer.JaxbDeserializer deserializer = new org.openspcoop2.core.config.utils.serializer.JaxbDeserializer();
  761.                 this.sorgenteConfigurazione = deserializer.readOpenspcoop2(readBytes(iStream));
  762.             } catch(Exception e) {
  763.                 try{  
  764.                     if(iStream!=null)
  765.                         iStream.close();
  766.                     if(httpConn !=null)
  767.                         httpConn.disconnect();
  768.                 } catch(Exception ef) {}
  769.                 throw new DriverConfigurazioneException("Riscontrato errore durante l'unmarshall del file di configurazione: "+e.getMessage());
  770.             }

  772.             try{  
  773.                 // Chiusura dello Stream
  774.                 if(iStream!=null)
  775.                     iStream.close();
  776.                 // Chiusura dell'eventuale connessione HTTP
  777.                 if(httpConn !=null)
  778.                     httpConn.disconnect();
  779.             } catch(Exception e) {
  780.                 throw new DriverConfigurazioneException("Riscontrato errore durante la chiusura dell'Input Stream: "+e.getMessage());
  781.             }
  782.             
  783.         } catch(Exception e) {
  784.             throw new DriverConfigurazioneException("Riscontrato errore durante l'istanziazione del registro: "+e.getMessage(),e);
  785.         }
  786.     }
  787.     
  788.     private InputStream readBytes(InputStream is) throws Exception{
  789.         // Leggo il data[] in modo da correggere gli eventuali entity imports
  790.         this.xmlUtils = MessageXMLUtils.DEFAULT;
  791.         byte[] b = new byte[0];
  792.         try {
  793.             Document d = this.xmlUtils.newDocument(is);
  794.             String xml = this.xmlUtils.toString(d, true);
  795.             xml = org.openspcoop2.utils.Utilities.eraserXmlAttribute(xml, "xml:base=");
  796.             b = xml.getBytes();
  797.             return new ByteArrayInputStream(b);
  798.         } catch (Exception e) {
  799.             e.printStackTrace(System.err);
  800.             throw e;
  801.         }
  802.     }
  803.     
  804.     private void createSorgente(byte[] sorgente)throws DriverConfigurazioneException{
  805.         // Istanziazione Sorgente
  806.         if(sorgente==null)
  807.             throw new DriverConfigurazioneException("Sorgente non definita");
  808.         
  809.         // ValidatoreXSD
  810.         ValidatoreXSD validatoreRegistro = null;
  811.         try{
  812.             validatoreRegistro = new ValidatoreXSD(OpenSPCoop2MessageFactory.getDefaultMessageFactory(), this.log,DriverConfigurazioneXML.class.getResourceAsStream("/config.xsd"));
  813.         }catch (Exception e) {
  814.             throw new DriverConfigurazioneException("Riscontrato errore durante l'inizializzazione dello schema della Configurazione XML di OpenSPCoop: "+e.getMessage());
  815.         }
  816.         try{
  817.             validatoreRegistro.valida(new ByteArrayInputStream(sorgente));
  818.         }catch (Exception e) {
  819.             throw new DriverConfigurazioneException("Riscontrato errore durante la validazione XSD del Configurazione XML di OpenSPCoop: "+e.getMessage());
  820.         }
  821.         
  822.         InputStream iStream = null;         
  823.         try{
  824.             try{  
  825.                 iStream = new ByteArrayInputStream(sorgente);
  826.             }catch(Exception e) {
  827.                 throw new DriverConfigurazioneException("Riscontrato errore durante la creazione dell'inputStreamReader della Configurazione : \n\n"+e.getMessage());
  828.             }
  829.             



  833.             /* ---- Unmarshall del file di configurazione ---- */
  834.             try{  
  835.                 org.openspcoop2.core.config.utils.serializer.JaxbDeserializer deserializer = new org.openspcoop2.core.config.utils.serializer.JaxbDeserializer();
  836.                 this.sorgenteConfigurazione = deserializer.readOpenspcoop2(readBytes(iStream));
  837.             } catch(Exception e) {
  838.                 try{  
  839.                     if(iStream!=null)
  840.                         iStream.close();
  841.                 } catch(Exception ef) {
  842.                     // close
  843.                 }
  844.                 throw new DriverConfigurazioneException("Riscontrato errore durante l'unmarshall del file di configurazione: "+e.getMessage());
  845.             }
  846.             
  847.         } catch(Exception e) {
  848.             throw new DriverConfigurazioneException("Riscontrato errore durante l'istanziazione del registro: "+e.getMessage(),e);
  849.         }finally {
  850.             try{  
  851.                 // Chiusura dello Stream
  852.                 if(iStream!=null)
  853.                     iStream.close();
  854.             } catch(Exception e) {
  855.                 // Ignore
  856.             }
  857.         }
  858.     }
  859.     
  860.     // Per motivi di dipendenze di compilazione non e' possibile usare  IDServizioFactory
  861.     @SuppressWarnings("deprecation")
  862.     private IDServizio toIdServizio(PortaDelegata pd) {
  863.         IDServizio idServizio = new IDServizio();
  864.         idServizio.setTipo(pd.getServizio().getTipo());
  865.         idServizio.setNome(pd.getServizio().getNome());
  866.         idServizio.setVersione(pd.getServizio().getVersione());
  867.         idServizio.setSoggettoErogatore(new IDSoggetto(pd.getSoggettoErogatore().getTipo(), pd.getSoggettoErogatore().getNome()));
  868.         return idServizio;
  869.     }
  870.     @SuppressWarnings("deprecation")
  871.     private IDServizio toIdServizio(PortaApplicativa pa) {
  872.         IDServizio idServizio = new IDServizio();
  873.         idServizio.setTipo(pa.getServizio().getTipo());
  874.         idServizio.setNome(pa.getServizio().getNome());
  875.         idServizio.setVersione(pa.getServizio().getVersione());
  876.         idServizio.setSoggettoErogatore(new IDSoggetto(pa.getTipoSoggettoProprietario(), pa.getNomeSoggettoProprietario()));
  877.         return idServizio;
  878.     }
  879.     
  880.     public void convertXML(boolean reset,boolean aggiornamentoSoggetti, boolean createMappingErogazioneFruizione) throws DriverConfigurazioneException{
  881.         convertXML(reset, aggiornamentoSoggetti, createMappingErogazioneFruizione, true);
  882.     }
  883.     public void convertXML(boolean reset,boolean aggiornamentoSoggetti, boolean createMappingErogazioneFruizione, boolean updateEnabled) throws DriverConfigurazioneException{
  884.         
  885.         // Reset
  886.         if(reset){
  887.             try{
  888.                 this.log.info("Configurazione, reset in corso (Reset configurazione:"+this.gestioneConfigurazione+")...");
  889.                 this.gestoreCRUD.reset(this.gestioneConfigurazione);
  890.                 this.log.info("Configurazione, reset effettuato.");
  891.             }catch(Exception e){
  892.                 e.printStackTrace(System.err);
  893.                 throw new DriverConfigurazioneException("Reset del Configurazione non riuscita: "+e.getMessage(),e);
  894.             }
  895.         }
  896.         
  897.         
  898.         // Soggetti
  899.         try{
  900.             for(int i=0; i<this.sorgenteConfigurazione.sizeSoggettoList(); i++){
  901.                 Soggetto soggetto = this.sorgenteConfigurazione.getSoggetto(i);
  902.                 soggetto.setSuperUser(this.superUser);
  903.                 
  904.                 // TODO GESTIRE TRAMITE FACTORY?        
  905.                 // Non e' possibile farlo in questo punto, non avendo i protocolli
  906.                 // Gestirlo prima o dopo quando si e' in possesso della protocol factory.
  907. //              if(CostantiConfigurazione.CONFIGURAZIONE_DB.equals(this.tipoBEDestinazione)){
  908. //                  if(soggetto.getIdentificativoPorta()==null)
  909. //                      soggetto.setIdentificativoPorta(soggetto.getNome()+"SPCoopIT");
  910. //              }
  911.                 
  912.                 IDSoggetto idSoggetto = new IDSoggetto(soggetto.getTipo(),soggetto.getNome());
  913.                 if( (reset==false) && this.gestoreCRUD.existsSoggetto(idSoggetto)){
  914.                     if(aggiornamentoSoggetti){
  915.                         if(updateEnabled) {
  916.                             this.log.info("Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome()+" aggiornamento in corso...");
  917.                             this.gestoreCRUD.updateSoggetto(soggetto);
  918.                             this.log.info("Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome()+" aggiornato.");
  919.                         }
  920.                         else {
  921.                             this.log.info("Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome()+" non aggiornato (aggiornamento disabilitato).");
  922.                         }
  923.                     }
  924.                 }else{
  925.                     this.log.info("Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome()+" creazione in corso...");
  926.                     this.gestoreCRUD.createSoggetto(soggetto);
  927.                     this.log.info("Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome()+" creato.");
  928.                 }
  929.             }
  930.         }catch(Exception e){
  931.             e.printStackTrace(System.err);
  932.             throw new DriverConfigurazioneException("Errore durante la conversione XML dei soggetti: "+e.getMessage(),e);
  933.         }
  934.         
  935.         // Servizi Applicativi
  936.         try{
  937.             for(int i=0; i<this.sorgenteConfigurazione.sizeSoggettoList(); i++){
  938.                 Soggetto soggetto = this.sorgenteConfigurazione.getSoggetto(i);
  939.                 for(int j=0;j<soggetto.sizeServizioApplicativoList();j++){
  940.                     ServizioApplicativo servizioApplicativo = soggetto.getServizioApplicativo(j);
  941.                     this.addServizioApplicativo(servizioApplicativo,soggetto,null,reset, updateEnabled);                
  942.                 }
  943.             }
  944.         }catch(Exception e){
  945.             e.printStackTrace(System.err);
  946.             throw new DriverConfigurazioneException("Errore durante la conversione XML dei servizi applicativi: "+e.getMessage(),e);
  947.         }
  948.         
  949.         // Porte Delegate
  950.         try{
  951.             for(int i=0; i<this.sorgenteConfigurazione.sizeSoggettoList(); i++){
  952.                 Soggetto soggetto = this.sorgenteConfigurazione.getSoggetto(i);
  953.                 HashMap<IDPortaDelegata, PortaDelegata> listPDModificare = new  HashMap<>(); 
  954.                 for(int j=0;j<soggetto.sizePortaDelegataList();j++){
  955.                     PortaDelegata pd = soggetto.getPortaDelegata(j);
  956.                     
  957.                     pd.setTipoSoggettoProprietario(soggetto.getTipo());
  958.                     pd.setNomeSoggettoProprietario(soggetto.getNome());
  959.                     
  960.                     impostaInformazioniConfigurazione_PortaDelegata(pd);
  961.                     
  962.                     IDPortaDelegata idPD = new IDPortaDelegata();
  963.                     idPD.setNome(pd.getNome());         
  964.                     if( (reset==false) && this.gestoreCRUD.existsPortaDelegata(idPD)){
  965.                         if(updateEnabled) {
  966.                             this.log.info("Porta delegata ["+pd.getNome()+"] del Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome()+" aggiornamento in corso...");
  967.                             this.gestoreCRUD.updatePortaDelegata(pd);
  968.                             this.log.info("Porta delegata ["+pd.getNome()+"] del Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome()+" aggiornato.");
  969.                         }
  970.                         else {
  971.                             this.log.info("Porta delegata ["+pd.getNome()+"] del Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome()+" non aggiornato (aggiornamento disabilitato).");
  972.                         }
  973.                     }else{
  974.                         this.log.info("Porta delegata ["+pd.getNome()+"] del Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome()+" creazione in corso...");
  975.                         this.gestoreCRUD.createPortaDelegata(pd);
  976.                         this.log.info("Porta delegata ["+pd.getNome()+"] del Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome()+" creato.");
  977.                     }
  978.                     
  979.                     if(createMappingErogazioneFruizione && this.gestoreCRUD instanceof DriverConfigurazioneDB) {
  980.                         DriverConfigurazioneDB driver = (DriverConfigurazioneDB) this.gestoreCRUD;
  981.                         Connection con = null;
  982.                         try {
  983.                             con = driver.getConnection("XMLDataConverter.mappingFruizione");
  984.                             IDSoggetto idFruitore = new IDSoggetto(soggetto.getTipo(), soggetto.getNome());
  985.                             IDServizio idServizio = toIdServizio(pd);
  986.                             boolean existsMapping = DBMappingUtils.existsMappingFruizione(idServizio, idFruitore, idPD, con, driver.getTipoDB());
  987.                             if(!existsMapping) {
  988.                                 boolean isDefault = false;
  989.                                 String nomeMapping = null;
  990.                                 boolean create = false;
  991.                                 if(SubscriptionUtils.isPortaDelegataUtilizzabileComeDefault(pd)) {
  992.                                     nomeMapping = SubscriptionUtils.getDefaultMappingName();
  993.                                     isDefault = true;
  994.                                     if(DBMappingUtils.existsIDPortaDelegataAssociataDefault(idServizio, idFruitore, con, driver.getTipoDB())==false) {
  995.                                         create = true;
  996.                                     }
  997.                                 }
  998.                                 else {
  999.                                     if(PortaDelegataAzioneIdentificazione.DELEGATED_BY.equals(pd.getAzione().getIdentificazione())) {
  1000.                                         // gia' nel nuovo formato devo solo creare il mapping che per qualche motivo si è perso
  1001.                                         if(pd.getAzione().sizeAzioneDelegataList()<=0) {
  1002.                                             this.log.error("Trovata porta delegata "+pd.getNome()+"] con un'identificazione dell'azione delegata senza pero' possedere azioni delegate");
  1003.                                             create=false;
  1004.                                         }
  1005.                                         else {
  1006.                                             String nomeAzione = pd.getAzione().getAzioneDelegata(0); // utilizzo un'azione a caso.
  1007.                                             nomeMapping = nomeAzione;
  1008.                                             idServizio.setAzione(nomeAzione);
  1009.                                             if(DBMappingUtils.existsIDPortaDelegataAssociataAzione(idServizio, idFruitore, con, driver.getTipoDB())==false) {
  1010.                                                 create = true;
  1011.                                             }
  1012.                                         }
  1013.                                     }
  1014.                                     else {
  1015.                                         nomeMapping = pd.getAzione().getNome();
  1016.                                         if(nomeMapping!=null && !"".equals(nomeMapping)) {
  1017.                                             idServizio.setAzione(pd.getAzione().getNome());
  1018.                                             if(DBMappingUtils.existsIDPortaDelegataAssociataAzione(idServizio, idFruitore, con, driver.getTipoDB())==false) {
  1019.                                                 create = true;
  1020.                                                 
  1021.                                                 // modifico porta applicativa adeguandola alla nuova specifica
  1022.                                                 SubscriptionUtils.setAzioneDelegate(pd, 
  1023.                                                         null, // nome porta delegante lo imposto dopo aver trovato la porta di default. 
  1024.                                                         pd.getAzione().getNome());
  1025.                                                 
  1026.                                                 listPDModificare.put(idPD, pd);
  1027.                                             }
  1028.                                         }
  1029.                                     }
  1030.                                 }
  1031.                                 if(create) {
  1032.                                     this.log.info("Creazione mapping di fruizione (nome:"+nomeMapping+" default:"+isDefault+") tra Porta delegata ["+pd.getNome()+"], fruitore ["+idFruitore+"] e servizio ["+idServizio+"] creazione in corso...");
  1033.                                     DBMappingUtils.createMappingFruizione(nomeMapping, isDefault ? Costanti.MAPPING_FRUIZIONE_PD_DESCRIZIONE_DEFAULT : nomeMapping, 
  1034.                                             isDefault, idServizio, idFruitore, idPD, con, driver.getTipoDB());
  1035.                                     this.log.info("Creazione mapping di fruizione (nome:"+nomeMapping+" default:"+isDefault+") tra Porta delegata ["+pd.getNome()+"], fruitore ["+idFruitore+"] e servizio ["+idServizio+"] creato.");
  1036.                                 }
  1037.                                 
  1038.                             }
  1039.                         }finally {
  1040.                             driver.releaseConnection(con);
  1041.                         }
  1042.                     }
  1043.                 }
  1044.                 if(listPDModificare!=null && listPDModificare.size()>0) {
  1045.                     DriverConfigurazioneDB driver = (DriverConfigurazioneDB) this.gestoreCRUD;
  1046.                     Connection con = null;
  1047.                     try {
  1048.                         con = driver.getConnection("XMLDataConverter.mappingFruizione");
  1049.                         for (IDPortaDelegata idPD : listPDModificare.keySet()) {
  1050.                             PortaDelegata pd = listPDModificare.get(idPD);
  1051.                             
  1052.                             IDSoggetto idFruitore = new IDSoggetto(pd.getTipoSoggettoProprietario(), pd.getNomeSoggettoProprietario());
  1053.                             IDServizio idServizio = this.toIdServizio(pd);
  1054.                             IDPortaDelegata idPDDefault = DBMappingUtils.getIDPortaDelegataAssociataDefault(idServizio, idFruitore, con, driver.getTipoDB());
  1055.                             
  1056.                             if(idPDDefault==null) {
  1057.                                 ServiceBinding serviceBinding = readServiceBinding(idServizio, con);
  1058.                                 Subscription subcription = XMLDataConverter.getSubscriptionDefault(serviceBinding, idFruitore, idServizio);
  1059.                                 PortaDelegata pdDefault = subcription.getPortaDelegata();
  1060.                                 MappingFruizionePortaDelegata mapping = subcription.getMapping();
  1061.                                 idPDDefault = mapping.getIdPortaDelegata();
  1062.                                 
  1063.                                 if(this.gestoreCRUD.existsPortaDelegata(idPDDefault) == false) {
  1064.                                     // creo porta delegata standard
  1065.                                     this.log.info("Porta delegata ["+pd.getNome()+"] del Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome()+" creazione delegante ["+pdDefault.getNome()+"] in corso...");
  1066.                                     this.gestoreCRUD.createPortaDelegata(pdDefault);
  1067.                                     this.log.info("Porta delegata ["+pd.getNome()+"] del Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome()+" creazione delegante ["+pdDefault.getNome()+"].");
  1068.                                 }
  1069.                                 
  1070.                                 this.log.info("Creazione mapping di fruizione di default (nome:"+mapping.getNome()+" default:"+mapping.isDefault()+") tra Porta delegata ["+pdDefault.getNome()+"], fruitore ["+idFruitore+"] e servizio ["+idServizio+"] creazione delegante in corso...");
  1071.                                 DBMappingUtils.createMappingFruizione(mapping.getNome(), mapping.getDescrizione(), mapping.isDefault(), idServizio, idFruitore, idPDDefault, con, driver.getTipoDB());
  1072.                                 this.log.info("Creazione mapping di fruizione di default (nome:"+mapping.getNome()+" default:"+mapping.isDefault()+") tra Porta delegata ["+pdDefault.getNome()+"], fruitore ["+idFruitore+"] e servizio ["+idServizio+"] creato delegante.");
  1073.                             }
  1074.                             
  1075.                             pd.getAzione().setNomePortaDelegante(idPDDefault.getNome());
  1076.                             
  1077.                             // comunque devo aggiornare i dati per delegatedBy
  1078.                             this.log.info("Porta delegata ["+pd.getNome()+"] del Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome()+" aggiornamento per nomeDelegante in corso...");
  1079.                             this.gestoreCRUD.updatePortaDelegata(pd);
  1080.                             this.log.info("Porta delegata ["+pd.getNome()+"] del Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome()+" aggiornato per nomeDelegante.");
  1081.                         }
  1082.                     }finally {
  1083.                         driver.releaseConnection(con);
  1084.                     }
  1085.                 }
  1086.             }
  1087.         }catch(Exception e){
  1088.             e.printStackTrace(System.err);
  1089.             throw new DriverConfigurazioneException("Errore durante la conversione XML delle porte delegate: "+e.getMessage(),e);
  1090.         }
  1091.         
  1092.         // Porte Applicative
  1093.         try{
  1094.             for(int i=0; i<this.sorgenteConfigurazione.sizeSoggettoList(); i++){
  1095.                 Soggetto soggetto = this.sorgenteConfigurazione.getSoggetto(i);
  1096.                 HashMap<IDPortaApplicativa, PortaApplicativa> listPAModificare = new  HashMap<>(); 
  1097.                 for(int j=0;j<soggetto.sizePortaApplicativaList();j++){
  1098.                     PortaApplicativa pa = soggetto.getPortaApplicativa(j);
  1099.                     
  1100.                     pa.setTipoSoggettoProprietario(soggetto.getTipo());
  1101.                     pa.setNomeSoggettoProprietario(soggetto.getNome());
  1102.                     
  1103.                     impostaInformazioniConfigurazione_PortaApplicativa(pa);
  1104.                     
  1105.                     IDPortaApplicativa idPA = new IDPortaApplicativa();
  1106.                     idPA.setNome(pa.getNome());
  1107.                     if( (reset==false) && this.gestoreCRUD.existsPortaApplicativa(idPA)){
  1108.                         if(updateEnabled) {
  1109.                             this.log.info("Porta applicativa ["+pa.getNome()+"] del Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome()+" aggiornamento in corso...");
  1110.                             this.gestoreCRUD.updatePortaApplicativa(pa);
  1111.                             this.log.info("Porta applicativa ["+pa.getNome()+"] del Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome()+" aggiornato.");
  1112.                         }
  1113.                         else {
  1114.                             this.log.info("Porta applicativa ["+pa.getNome()+"] del Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome()+" non aggiornato (aggiornamento disabilitato).");
  1115.                         }
  1116.                     }else{
  1117.                         this.log.info("Porta applicativa ["+pa.getNome()+"] del Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome()+" creazione in corso...");
  1118.                         this.gestoreCRUD.createPortaApplicativa(pa);
  1119.                         this.log.info("Porta applicativa ["+pa.getNome()+"] del Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome()+" creato.");
  1120.                     }
  1121.                     
  1122.                     if(createMappingErogazioneFruizione && this.gestoreCRUD instanceof DriverConfigurazioneDB) {
  1123.                         DriverConfigurazioneDB driver = (DriverConfigurazioneDB) this.gestoreCRUD;
  1124.                         Connection con = null;
  1125.                         try {
  1126.                             con = driver.getConnection("XMLDataConverter.mappingErogazione");
  1127.                             IDServizio idServizio = this.toIdServizio(pa);
  1128.                             boolean existsMapping = DBMappingUtils.existsMappingErogazione(idServizio, idPA, con, driver.getTipoDB());
  1129.                             if(!existsMapping) {
  1130.                                 boolean isDefault = false;
  1131.                                 String nomeMapping = null;
  1132.                                 boolean create = false;
  1133.                                 if(ImplementationUtils.isPortaApplicativaUtilizzabileComeDefault(pa)) {
  1134.                                     nomeMapping = ImplementationUtils.getDefaultMappingName();
  1135.                                     isDefault = true;
  1136.                                     if(DBMappingUtils.existsIDPortaApplicativaAssociataDefault(idServizio, con, driver.getTipoDB())==false) {
  1137.                                         create = true;
  1138.                                     }
  1139.                                 }
  1140.                                 else {
  1141.                                     if(PortaApplicativaAzioneIdentificazione.DELEGATED_BY.equals(pa.getAzione().getIdentificazione())) {
  1142.                                         // gia' nel nuovo formato devo solo creare il mapping che per qualche motivo si è perso
  1143.                                         if(pa.getAzione().sizeAzioneDelegataList()<=0) {
  1144.                                             this.log.error("Trovata porta applicativa "+pa.getNome()+"] con un'identificazione dell'azione delegata senza pero' possedere azioni delegate");
  1145.                                             create=false;
  1146.                                         }
  1147.                                         else {
  1148.                                             String nomeAzione = pa.getAzione().getAzioneDelegata(0); // utilizzo un'azione a caso.
  1149.                                             nomeMapping = nomeAzione;
  1150.                                             idServizio.setAzione(nomeAzione);
  1151.                                             if(DBMappingUtils.existsIDPortaApplicativaAssociataAzione(idServizio, con, driver.getTipoDB())==false) {
  1152.                                                 create = true;
  1153.                                             }
  1154.                                         }
  1155.                                     }
  1156.                                     else {
  1157.                                         nomeMapping = pa.getAzione().getNome();
  1158.                                         if(nomeMapping!=null && !"".equals(nomeMapping)) {
  1159.                                             idServizio.setAzione(pa.getAzione().getNome());
  1160.                                             if(DBMappingUtils.existsIDPortaApplicativaAssociataAzione(idServizio, con, driver.getTipoDB())==false) {
  1161.                                                 create = true;
  1162.                                                 
  1163.                                                 // modifico porta applicativa adeguandola alla nuova specifica
  1164.                                                 ImplementationUtils.setAzioneDelegate(pa, 
  1165.                                                         null, // nome porta delegante lo imposto dopo aver trovato la porta di default. 
  1166.                                                         pa.getAzione().getNome());

  1168.                                                 listPAModificare.put(idPA, pa);
  1169.                                             }
  1170.                                         }
  1171.                                     }
  1172.                                 }
  1173.                                 if(create) {
  1174.                                     this.log.info("Creazione mapping di erogazione (nome:"+nomeMapping+" default:"+isDefault+") tra Porta Applicativa ["+pa.getNome()+"] e servizio ["+idServizio+"] creazione in corso...");
  1175.                                     DBMappingUtils.createMappingErogazione(nomeMapping, isDefault ? Costanti.MAPPING_EROGAZIONE_PA_DESCRIZIONE_DEFAULT : nomeMapping, 
  1176.                                             isDefault, idServizio, idPA, con, driver.getTipoDB());
  1177.                                     this.log.info("Creazione mapping di erogazione (nome:"+nomeMapping+" default:"+isDefault+") tra Porta Applicativa ["+pa.getNome()+"] e servizio ["+idServizio+"] creato.");
  1178.                                 }
  1179.                                 
  1180.                             }
  1181.                         }finally {
  1182.                             driver.releaseConnection(con);
  1183.                         }
  1184.                     }
  1185.                 }
  1186.                 if(listPAModificare!=null && listPAModificare.size()>0) {
  1187.                     DriverConfigurazioneDB driver = (DriverConfigurazioneDB) this.gestoreCRUD;
  1188.                     Connection con = null;
  1189.                     try {
  1190.                         con = driver.getConnection("XMLDataConverter.mappingErogazione");
  1191.                         for (IDPortaApplicativa idPA : listPAModificare.keySet()) {
  1192.                             PortaApplicativa pa = listPAModificare.get(idPA);
  1193.                             
  1194.                             IDServizio idServizio = this.toIdServizio(pa);
  1195.                             IDPortaApplicativa idPADefault = DBMappingUtils.getIDPortaApplicativaAssociataDefault(idServizio, con, driver.getTipoDB());
  1196.                             
  1197.                             if(idPADefault==null) {
  1198.                                 // Creo una porta applicativa automaticamente simile a quella delegatedBy
  1199.                                 
  1200.                                 ServiceBinding serviceBinding = readServiceBinding(idServizio, con);
  1201.                                 Implementation implementation = XMLDataConverter.getImplementationDefault(serviceBinding, idServizio);
  1202.                                 PortaApplicativa paDefault = implementation.getPortaApplicativa();
  1203.                                 
  1204.                                 // associo sa erogatore della pa di partenza
  1205.                                 if(pa.sizeServizioApplicativoList()>0) {
  1206.                                     for (PortaApplicativaServizioApplicativo paSA : pa.getServizioApplicativoList()) {
  1207.                                         paDefault.addServizioApplicativo(paSA);
  1208.                                     }
  1209.                                 }
  1210.                                 
  1211.                                 MappingErogazionePortaApplicativa mapping = implementation.getMapping();
  1212.                                 idPADefault = mapping.getIdPortaApplicativa();
  1213.                                 if(this.gestoreCRUD.existsPortaApplicativa(idPADefault) == false) {
  1214.                                     // creo porta applicativa standard
  1215.                                     this.log.info("Porta applicativa ["+pa.getNome()+"] del Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome()+" creazione delegante ["+paDefault.getNome()+"] in corso...");
  1216.                                     this.gestoreCRUD.createPortaApplicativa(paDefault);
  1217.                                     this.log.info("Porta applicativa ["+pa.getNome()+"] del Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome()+" creazione delegante ["+paDefault.getNome()+"].");
  1218.                                 }
  1219.                                 
  1220.                                 this.log.info("Creazione mapping di erogazione di default (nome:"+mapping.getNome()+" default:"+mapping.isDefault()+") tra Porta Applicativa ["+paDefault.getNome()+"] e servizio ["+idServizio+"] creazione delegante in corso...");
  1221.                                 DBMappingUtils.createMappingErogazione(mapping.getNome(), mapping.getDescrizione(), mapping.isDefault(), idServizio, idPADefault, con, driver.getTipoDB());
  1222.                                 this.log.info("Creazione mapping di erogazione di default (nome:"+mapping.getNome()+" default:"+mapping.isDefault()+") tra Porta Applicativa ["+paDefault.getNome()+"] e servizio ["+idServizio+"] creato delegante.");
  1223.                         
  1224.                             }
  1225.                             
  1226.                             pa.getAzione().setNomePortaDelegante(idPADefault.getNome());
  1227.                             
  1228.                             // comunque devo aggiornare i dati per delegatedBy
  1229.                             this.log.info("Porta applicativa ["+pa.getNome()+"] del Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome()+" aggiornamento per nomeDelegante in corso...");
  1230.                             this.gestoreCRUD.updatePortaApplicativa(pa);
  1231.                             this.log.info("Porta applicativa ["+pa.getNome()+"] del Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome()+" aggiornato per nomeDelegante.");
  1232.                         }
  1233.                     }finally {
  1234.                         driver.releaseConnection(con);
  1235.                     }
  1236.                 }
  1237.             }
  1238.         }catch(Exception e){
  1239.             e.printStackTrace(System.err);
  1240.             throw new DriverConfigurazioneException("Errore durante la conversione XML delle porte applicative: "+e.getMessage(),e);
  1241.         }
  1242.         
  1243.         
  1244.         if(this.gestioneConfigurazione){
  1245.             // RoutingTable
  1246.             try{
  1247.                 this.log.info("Routing Table, creazione/aggiornamento in corso...");
  1248.                 if(this.sorgenteConfigurazione.getConfigurazione()!=null &&
  1249.                         this.sorgenteConfigurazione.getConfigurazione().getRoutingTable()!=null ){
  1250.                     if(reset){
  1251.                         this.gestoreCRUD.createRoutingTable(this.sorgenteConfigurazione.getConfigurazione().getRoutingTable());
  1252.                         this.log.info("Routing Table, creazione effettuata.");
  1253.                     }
  1254.                     else{
  1255.                         if(updateEnabled) {
  1256.                             this.gestoreCRUD.updateRoutingTable(this.sorgenteConfigurazione.getConfigurazione().getRoutingTable());
  1257.                             this.log.info("Routing Table, aggiornamento effettuato.");
  1258.                         }
  1259.                         else {
  1260.                             this.log.info("Routing Table, non aggiornato (aggiornamento disabilitato).");
  1261.                         }
  1262.                     }
  1263.                 }
  1264.                 
  1265.             }catch(Exception e){
  1266.                 e.printStackTrace(System.err);
  1267.                 throw new DriverConfigurazioneException("Errore durante la conversione XML della routing table: "+e.getMessage(),e);
  1268.             }
  1269.         
  1270.             // AccessoRegistro
  1271.             try{
  1272.                 this.log.info("Accesso registro, creazione in corso...");
  1273.                 if(this.sorgenteConfigurazione.getConfigurazione()!=null && 
  1274.                         this.sorgenteConfigurazione.getConfigurazione().getAccessoRegistro()!=null){
  1275.                     if(reset){
  1276.                         this.gestoreCRUD.createAccessoRegistro(this.sorgenteConfigurazione.getConfigurazione().getAccessoRegistro());
  1277.                         this.log.info("Accesso registro, creazione effettuata.");
  1278.                     }
  1279.                     else{
  1280.                         if(updateEnabled) {
  1281.                             this.gestoreCRUD.updateAccessoRegistro(this.sorgenteConfigurazione.getConfigurazione().getAccessoRegistro());
  1282.                             this.log.info("Accesso registro, aggiornamento effettuato.");
  1283.                         }
  1284.                         else {
  1285.                             this.log.info("Accesso registro, non aggiornato (aggiornamento disabilitato).");
  1286.                         }
  1287.                     }                       
  1288.                 }
  1289.             
  1290.             }catch(Exception e){
  1291.                 e.printStackTrace(System.err);
  1292.                 throw new DriverConfigurazioneException("Errore durante la conversione XML dei dati di accesso al registro: "+e.getMessage(),e);
  1293.             }
  1294.             
  1295.             // GestioneErrore di Cooperazione
  1296.             try{
  1297.                 this.log.info("GestioneErrore, creazione in corso...");
  1298.                 if(this.sorgenteConfigurazione.getConfigurazione()!=null && 
  1299.                         this.sorgenteConfigurazione.getConfigurazione().getGestioneErrore()!=null &&
  1300.                         this.sorgenteConfigurazione.getConfigurazione().getGestioneErrore().getComponenteCooperazione()!=null){
  1301.                     
  1302.                     if(reset){
  1303.                         this.gestoreCRUD.createGestioneErroreComponenteCooperazione(this.sorgenteConfigurazione.getConfigurazione().getGestioneErrore().getComponenteCooperazione());
  1304.                         this.log.info("GestioneErrore, creazione effettuata.");
  1305.                     }
  1306.                     else{
  1307.                         if(updateEnabled) {
  1308.                             this.gestoreCRUD.updateGestioneErroreComponenteCooperazione(this.sorgenteConfigurazione.getConfigurazione().getGestioneErrore().getComponenteCooperazione());
  1309.                             this.log.info("GestioneErrore, aggiornamento effettuato.");
  1310.                         }
  1311.                         else {
  1312.                             this.log.info("GestioneErrore, non aggiornato (aggiornamento disabilitato).");
  1313.                         }
  1314.                     }
  1315.                                 
  1316.                 }
  1317.                 
  1318.             }catch(Exception e){
  1319.                 e.printStackTrace(System.err);
  1320.                 throw new DriverConfigurazioneException("Errore durante la conversione XML dei dati di gestione dell'errore del connettore per il componente di cooperazione: "+
  1321.                         e.getMessage(),e);
  1322.             }
  1323.             
  1324.             // GestioneErrore di Integrazione
  1325.             try{
  1326.                 this.log.info("GestioneErrore, creazione in corso...");
  1327.                 if(this.sorgenteConfigurazione.getConfigurazione()!=null && 
  1328.                         this.sorgenteConfigurazione.getConfigurazione().getGestioneErrore()!=null &&
  1329.                         this.sorgenteConfigurazione.getConfigurazione().getGestioneErrore().getComponenteIntegrazione()!=null){
  1330.                     
  1331.                     if(reset){
  1332.                         this.gestoreCRUD.createGestioneErroreComponenteIntegrazione(this.sorgenteConfigurazione.getConfigurazione().getGestioneErrore().getComponenteIntegrazione());
  1333.                         this.log.info("GestioneErrore, creazione effettuata.");
  1334.                     }
  1335.                     else{
  1336.                         if(updateEnabled) {
  1337.                             this.gestoreCRUD.updateGestioneErroreComponenteIntegrazione(this.sorgenteConfigurazione.getConfigurazione().getGestioneErrore().getComponenteIntegrazione());
  1338.                             this.log.info("GestioneErrore, aggiornamento effettuato.");
  1339.                         }
  1340.                         else {
  1341.                             this.log.info("GestioneErrore, non aggiornato (aggiornamento disabilitato).");
  1342.                         }
  1343.                     }
  1344.                 }

  1346.             }catch(Exception e){
  1347.                 e.printStackTrace(System.err);
  1348.                 throw new DriverConfigurazioneException("Errore durante la conversione XML dei dati di gestione dell'errore del connettore per il componente di integrazione: "
  1349.                         +e.getMessage(),e);
  1350.             }
  1351.             
  1352.             // Configurazione
  1353.             try{
  1354.                 this.log.info("Configurazione, creazione in corso...");
  1355.                 if(this.sorgenteConfigurazione.getConfigurazione()!=null){
  1356.                     
  1357.                     if(reset){
  1358.                         this.gestoreCRUD.createConfigurazione(this.sorgenteConfigurazione.getConfigurazione());
  1359.                         this.log.info("Configurazione, creazione effettuata.");
  1360.                     }else{
  1361.                         if(updateEnabled) {
  1362.                             this.gestoreCRUD.updateConfigurazione(this.sorgenteConfigurazione.getConfigurazione());
  1363.                             this.log.info("Configurazione, aggiornamento effettuato.");
  1364.                         }
  1365.                         else {
  1366.                             this.log.info("Configurazione, non aggiornato (aggiornamento disabilitato).");
  1367.                         }
  1368.                     }
  1369.                 }
  1370.                 
  1371.             }catch(Exception e){
  1372.                 e.printStackTrace(System.err);
  1373.                 throw new DriverConfigurazioneException("Errore durante la conversione XML della Configurazione: "+e.getMessage(),e);
  1374.             }
  1375.         }
  1376.     }
  1377.     
  1378.     private ServiceBinding readServiceBinding(IDServizio idServizio, Connection con) throws DriverConfigurazioneException{
  1379.         DriverConfigurazioneDB driver = (DriverConfigurazioneDB) this.gestoreCRUD;
  1380.         long idServizioAsLong = -1;
  1381.         try {
  1382.             idServizioAsLong = DBUtils.getIdAccordoServizioParteSpecifica(idServizio, con, driver.getTipoDB());
  1383.             if(idServizioAsLong<=0) {
  1384.                 throw new Exception("Non trovato");
  1385.             }
  1386.         }catch(Exception e) {
  1387.             throw new DriverConfigurazioneException("Accordo Parte Specifica non trovato ["+idServizio+"]");
  1388.         }
  1389.         
  1390.         PreparedStatement stm = null;
  1391.         ResultSet rs = null;
  1392.         try
  1393.         {
  1394.             
  1395.             // NOTA: nell'APS, il soggetto e la versione sono obbligatori
  1396.             
  1397.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(driver.getTipoDB());
  1398.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  1399.             sqlQueryObject.addFromTable(CostantiDB.ACCORDI);
  1400.             sqlQueryObject.addSelectField("service_binding");
  1401.             sqlQueryObject.setANDLogicOperator(true);
  1402.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI+".id_accordo = "+CostantiDB.ACCORDI+".id");
  1403.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI+".id = ?");
  1404.             String query = sqlQueryObject.createSQLQuery();
  1405.             stm=con.prepareStatement(query);
  1406.             stm.setLong(1, idServizioAsLong);
  1407.             
  1408.             rs=stm.executeQuery();

  1410.             if(rs.next()){
  1411.                 return ServiceBinding.toEnumConstant(rs.getString("service_binding"),true);
  1412.             }

  1414.             throw new DriverConfigurazioneException("Accordo Parte Specifica non trovato ["+idServizio+"] (Lettura ServiceBinding)");

  1416.         }catch (SQLException e) {
  1417.             throw new DriverConfigurazioneException(e);
  1418.         }catch (Exception e) {
  1419.             throw new DriverConfigurazioneException(e);
  1420.         }finally
  1421.         {
  1422.             //Chiudo statement and resultset
  1423.             try{
  1424.                 if(rs!=null) 
  1425.                     rs.close();
  1426.             }catch (Exception e) {
  1427.                 //ignore
  1428.             }
  1429.             try{
  1430.                 if(stm!=null) 
  1431.                     stm.close();
  1432.             }catch (Exception e) {
  1433.                 //ignore
  1434.             }

  1436.         }
  1437.     }
  1438.     
  1439.     
  1440.     
  1441.     public void delete(boolean deleteSoggetti, boolean deleteMappingErogazioneFruizione) throws DriverConfigurazioneException{
  1442.         
  1443.         
  1444.         // Porte Delegate
  1445.         try{
  1446.             for(int i=0; i<this.sorgenteConfigurazione.sizeSoggettoList(); i++){
  1447.                 Soggetto soggetto = this.sorgenteConfigurazione.getSoggetto(i);
  1448.                 for(int j=0;j<soggetto.sizePortaDelegataList();j++){
  1449.                     PortaDelegata pd = soggetto.getPortaDelegata(j);
  1450.                     pd.setTipoSoggettoProprietario(soggetto.getTipo());
  1451.                     pd.setNomeSoggettoProprietario(soggetto.getNome()); 
  1452.                     IDPortaDelegata idPD = new IDPortaDelegata();
  1453.                     idPD.setNome(pd.getNome());     
  1454.                     
  1455.                     if(deleteMappingErogazioneFruizione && this.gestoreCRUD instanceof DriverConfigurazioneDB) {
  1456.                         DriverConfigurazioneDB driver = (DriverConfigurazioneDB) this.gestoreCRUD;
  1457.                         Connection con = null;
  1458.                         try {
  1459.                             con = driver.getConnection("XMLDataConverter.mappingFruizione");
  1460.                             IDSoggetto idFruitore = new IDSoggetto(soggetto.getTipo(), soggetto.getNome());
  1461.                             IDServizio idServizio = toIdServizio(pd);
  1462.                             boolean existsMapping = DBMappingUtils.existsMappingFruizione(idServizio, idFruitore, idPD, con, driver.getTipoDB());
  1463.                             if(existsMapping) {
  1464.                                 this.log.info("Eliminazione mapping di fruizione tra Porta delegata ["+pd.getNome()+"], fruitore ["+idFruitore+"] e servizio ["+idServizio+"] eliminazione in corso...");
  1465.                                 DBMappingUtils.deleteMappingFruizione(idServizio, idFruitore, idPD, con, driver.getTipoDB());
  1466.                                 this.log.info("Eliminazione mapping di fruizione tra Porta delegata ["+pd.getNome()+"], fruitore ["+idFruitore+"] e servizio ["+idServizio+"] eliminato.");
  1467.                             }
  1468.                         }finally {
  1469.                             driver.releaseConnection(con);
  1470.                         }
  1471.                     }
  1472.                     
  1473.                     this.log.info("Porta delegata ["+pd.getNome()+"] del Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome()+" eliminazione in corso...");
  1474.                     if(this.gestoreCRUD.existsPortaDelegata(idPD)){
  1475.                         this.gestoreCRUD.deletePortaDelegata(((IDriverConfigurazioneGet)this.gestoreCRUD).getPortaDelegata(idPD));
  1476.                     }
  1477.                     this.log.info("Porta delegata ["+pd.getNome()+"] del Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome()+" eliminata.");
  1478.                     
  1479.                 }
  1480.             }
  1481.         }catch(Exception e){
  1482.             e.printStackTrace(System.err);
  1483.             throw new DriverConfigurazioneException("Errore durante l'eliminazione delle porte delegate: "+e.getMessage(),e);
  1484.         }
  1485.         
  1486.         // Porte Applicative
  1487.         try{
  1488.             for(int i=0; i<this.sorgenteConfigurazione.sizeSoggettoList(); i++){
  1489.                 Soggetto soggetto = this.sorgenteConfigurazione.getSoggetto(i);
  1490.                 for(int j=0;j<soggetto.sizePortaApplicativaList();j++){
  1491.                     PortaApplicativa pa = soggetto.getPortaApplicativa(j);                  
  1492.                     pa.setTipoSoggettoProprietario(soggetto.getTipo());
  1493.                     pa.setNomeSoggettoProprietario(soggetto.getNome());             
  1494.                     IDPortaApplicativa idPA = new IDPortaApplicativa();
  1495.                     idPA.setNome(pa.getNome());
  1496.                     
  1497.                     if(deleteMappingErogazioneFruizione && this.gestoreCRUD instanceof DriverConfigurazioneDB) {
  1498.                         DriverConfigurazioneDB driver = (DriverConfigurazioneDB) this.gestoreCRUD;
  1499.                         Connection con = null;
  1500.                         try {
  1501.                             con = driver.getConnection("XMLDataConverter.mappingErogazione");
  1502.                             IDServizio idServizio = this.toIdServizio(pa);
  1503.                             boolean existsMapping = DBMappingUtils.existsMappingErogazione(idServizio, idPA, con, driver.getTipoDB());
  1504.                             if(existsMapping) {
  1505.                                 this.log.info("Eliminazione mapping di erogazione tra Porta Applicativa ["+pa.getNome()+"] e servizio ["+idServizio+"] eliminazione in corso...");
  1506.                                 DBMappingUtils.deleteMappingErogazione(idServizio, idPA, con, driver.getTipoDB());
  1507.                                 this.log.info("Eliminazione mapping di erogazione tra Porta Applicativa ["+pa.getNome()+"] e servizio ["+idServizio+"] eliminato.");
  1508.                             }
  1509.                         }finally {
  1510.                             driver.releaseConnection(con);
  1511.                         }
  1512.                     }
  1513.                     
  1514.                     this.log.info("Porta applicativa ["+pa.getNome()+"] del Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome()+" eliminazione in corso...");
  1515.                     if( this.gestoreCRUD.existsPortaApplicativa(idPA)){
  1516.                         this.gestoreCRUD.deletePortaApplicativa(((IDriverConfigurazioneGet)this.gestoreCRUD).getPortaApplicativa(idPA));
  1517.                     }
  1518.                     this.log.info("Porta applicativa ["+pa.getNome()+"] del Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome()+" eliminata.");
  1519.                     
  1520.                 }
  1521.             }
  1522.         }catch(Exception e){
  1523.             e.printStackTrace(System.err);
  1524.             throw new DriverConfigurazioneException("Errore durante l'eliminazione delle porte applicative: "+e.getMessage(),e);
  1525.         }
  1526.         
  1527.         
  1528.         // Servizi Applicativi
  1529.         try{
  1530.             for(int i=0; i<this.sorgenteConfigurazione.sizeSoggettoList(); i++){
  1531.                 Soggetto soggetto = this.sorgenteConfigurazione.getSoggetto(i);
  1532.                 for(int j=0;j<soggetto.sizeServizioApplicativoList();j++){
  1533.                     ServizioApplicativo servizioApplicativo = soggetto.getServizioApplicativo(j);
  1534.                     IDSoggetto idSoggetto = new IDSoggetto(soggetto.getTipo(),soggetto.getNome());
  1535.                     IDServizioApplicativo idSA = new IDServizioApplicativo();
  1536.                     idSA.setIdSoggettoProprietario(idSoggetto);
  1537.                     idSA.setNome(servizioApplicativo.getNome());
  1538.                     this.log.info("Servizio Applicativo ["+servizioApplicativo.getNome()+"] del Soggetto "+idSoggetto.getTipo()+"/"+idSoggetto.getNome()+" eliminazione in corso...");
  1539.                     if( this.gestoreCRUD.existsServizioApplicativo(idSA)){
  1540.                         this.gestoreCRUD.deleteServizioApplicativo(((IDriverConfigurazioneGet)this.gestoreCRUD).getServizioApplicativo(idSA));
  1541.                     }
  1542.                     this.log.info("Servizio Applicativo ["+servizioApplicativo.getNome()+"] del Soggetto "+idSoggetto.getTipo()+"/"+idSoggetto.getNome()+" eliminato.");
  1543.                 }
  1544.             }
  1545.         }catch(Exception e){
  1546.             e.printStackTrace(System.err);
  1547.             throw new DriverConfigurazioneException("Errore durante l'eliminazione dei servizi applicativi: "+e.getMessage(),e);
  1548.         }
  1549.         
  1550.         
  1551.         if(deleteSoggetti){
  1552.             // Soggetti
  1553.             try{
  1554.                 for(int i=0; i<this.sorgenteConfigurazione.sizeSoggettoList(); i++){
  1555.                     Soggetto soggetto = this.sorgenteConfigurazione.getSoggetto(i);
  1556.                     IDSoggetto idSoggetto = new IDSoggetto(soggetto.getTipo(),soggetto.getNome());
  1557.                     this.log.info("Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome()+" eliminazione in corso...");
  1558.                     if( this.gestoreCRUD.existsSoggetto(idSoggetto)){
  1559.                         this.gestoreCRUD.deleteSoggetto(((IDriverConfigurazioneGet)this.gestoreCRUD).getSoggetto(idSoggetto));
  1560.                     }
  1561.                     this.log.info("Soggetto "+soggetto.getTipo()+"/"+soggetto.getNome()+" eliminato.");
  1562.                 }
  1563.             }catch(Exception e){
  1564.                 e.printStackTrace(System.err);
  1565.                 throw new DriverConfigurazioneException("Errore durante l'eliminazione dei soggetti: "+e.getMessage(),e);
  1566.             }
  1567.         }
  1568.         
  1569.     }

  1571.     
  1572.     private static void gestioneDefaultConnettoreHTTP(Connettore connettore){
  1573.         if(connettore.getProperties()!=null){
  1574.             if(connettore.getProperties().containsKey(CostantiDB.CONNETTORE_HTTPS_TRUST_STORE_TYPE)==false){
  1575.                 Property cp = new Property();
  1576.                 cp.setNome(CostantiDB.CONNETTORE_HTTPS_TRUST_STORE_TYPE);
  1577.                 cp.setValore(KeystoreType.JKS.getNome()); // default
  1578.                 connettore.addProperty(cp);
  1579.             }
  1580.             if(connettore.getProperties().containsKey(CostantiDB.CONNETTORE_HTTPS_TRUST_MANAGEMENT_ALGORITM)==false){
  1581.                 Property cp = new Property();
  1582.                 cp.setNome(CostantiDB.CONNETTORE_HTTPS_TRUST_MANAGEMENT_ALGORITM);
  1583.                 cp.setValore(TrustManagerFactory.getDefaultAlgorithm()); // default
  1584.                 connettore.addProperty(cp);
  1585.             }
  1586.             if(connettore.getProperties().containsKey(CostantiDB.CONNETTORE_HTTPS_KEY_STORE_LOCATION)){
  1587.                 if(connettore.getProperties().containsKey(CostantiDB.CONNETTORE_HTTPS_KEY_STORE_TYPE)==false){
  1588.                     Property cp = new Property();
  1589.                     cp.setNome(CostantiDB.CONNETTORE_HTTPS_KEY_STORE_TYPE);
  1590.                     cp.setValore(KeystoreType.JKS.getNome()); // default
  1591.                     connettore.addProperty(cp);
  1592.                 }
  1593.                 if(connettore.getProperties().containsKey(CostantiDB.CONNETTORE_HTTPS_KEY_MANAGEMENT_ALGORITM)==false){
  1594.                     Property cp = new Property();
  1595.                     cp.setNome(CostantiDB.CONNETTORE_HTTPS_KEY_MANAGEMENT_ALGORITM);
  1596.                     cp.setValore(KeyManagerFactory.getDefaultAlgorithm()); // default
  1597.                     connettore.addProperty(cp);
  1598.                 }
  1599.             }   
  1600.         }
  1601.     }
  1602.     
  1603.     public static void impostaInformazioniConfigurazione_PortaDelegata(PortaDelegata pd){
  1604.         // messageSecurity
  1605.         if(pd.getMessageSecurity()!=null && 
  1606.                 ( 
  1607.                     (pd.getMessageSecurity().getRequestFlow()!=null && pd.getMessageSecurity().getRequestFlow().sizeParameterList()>0) 
  1608.                       || 
  1609.                     (pd.getMessageSecurity().getResponseFlow()!=null && pd.getMessageSecurity().getResponseFlow().sizeParameterList()>0)
  1610.                 )
  1611.         ){
  1612.             pd.setStatoMessageSecurity(CostantiConfigurazione.ABILITATO.toString());
  1613.         }
  1614.     }
  1615.     
  1616.     public static void impostaInformazioniConfigurazione_PortaApplicativa(PortaApplicativa pa){
  1617.         // messageSecurity
  1618.         if(pa.getMessageSecurity()!=null && 
  1619.                 ( 
  1620.                     (pa.getMessageSecurity().getRequestFlow()!=null && pa.getMessageSecurity().getRequestFlow().sizeParameterList()>0) 
  1621.                       || 
  1622.                     (pa.getMessageSecurity().getResponseFlow()!=null && pa.getMessageSecurity().getResponseFlow().sizeParameterList()>0)
  1623.                 )
  1624.         ){
  1625.             pa.setStatoMessageSecurity(CostantiConfigurazione.ABILITATO.toString());
  1626.         }
  1627.     }
  1628.     
  1629.     public static void impostaInformazioniConfigurazione_ServizioApplicativo(ServizioApplicativo servizioApplicativo,Soggetto soggettoProprietario,
  1630.             String posizione,Logger log,String tipoBEDestinazione){
  1631.         
  1632.         // **** InvocazionePorta ****
  1633.         if(servizioApplicativo.getInvocazionePorta()==null){
  1634.             InvocazionePorta saInv = new InvocazionePorta();
  1635.             Credenziali credenziali = new Credenziali();
  1636.             credenziali.setTipo(CredenzialeTipo.toEnumConstant(CostantiConfigurazione.NONE));
  1637.             saInv.addCredenziali(credenziali);
  1638.             InvocazionePortaGestioneErrore ge = new InvocazionePortaGestioneErrore();
  1639.             ge.setFault(CostantiConfigurazione.ERRORE_APPLICATIVO_SOAP);
  1640.             saInv.setGestioneErrore(ge);
  1641.             servizioApplicativo.setInvocazionePorta(saInv);
  1642.         }else{
  1643.             if(servizioApplicativo.getInvocazionePorta().getGestioneErrore()==null){
  1644.                 InvocazionePortaGestioneErrore ge = new InvocazionePortaGestioneErrore();
  1645.                 ge.setFault(CostantiConfigurazione.ERRORE_APPLICATIVO_SOAP);
  1646.                 servizioApplicativo.getInvocazionePorta().setGestioneErrore(ge);
  1647.             }else if(servizioApplicativo.getInvocazionePorta().getGestioneErrore().getFault()==null){
  1648.                 servizioApplicativo.getInvocazionePorta().getGestioneErrore().setFault(CostantiConfigurazione.ERRORE_APPLICATIVO_SOAP); 
  1649.             }
  1650.             if(servizioApplicativo.getInvocazionePorta().sizeCredenzialiList()==0){
  1651.                 Credenziali credenziali = new Credenziali();
  1652.                 credenziali.setTipo(CredenzialeTipo.toEnumConstant(CostantiConfigurazione.NONE));
  1653.                 servizioApplicativo.getInvocazionePorta().addCredenziali(credenziali);
  1654.             }
  1655.         }       
  1656.         
  1657.         // **** InvocazioneServizio ****
  1658.         // Check connettori non definit all'interno del servizio
  1659.         if(servizioApplicativo.getInvocazioneServizio()!=null && servizioApplicativo.getInvocazioneServizio().getConnettore()!=null){
  1660.             if(servizioApplicativo.getInvocazioneServizio().getConnettore().getTipo()==null){
  1661.                 // ricavo il connettore dal soggetto
  1662.                 for(int con=0;con<soggettoProprietario.sizeConnettoreList();con++){
  1663.                     if(soggettoProprietario.getConnettore(con).getNome().equals(servizioApplicativo.getInvocazioneServizio().getConnettore().getNome())){
  1664.                         servizioApplicativo.getInvocazioneServizio().setConnettore(soggettoProprietario.getConnettore(con));
  1665.                         break;
  1666.                     }
  1667.                 }
  1668.                 log.info("Servizio Applicativo ["+servizioApplicativo.getNome()+"]"+posizione+" del Soggetto "+soggettoProprietario.getTipo()+"/"+soggettoProprietario.getNome()+" connettore inv servizio di tipo, dopo ricerca ["+servizioApplicativo.getInvocazioneServizio().getConnettore().getTipo()+"]");
  1669.             }else{
  1670.                 log.info("Servizio Applicativo ["+servizioApplicativo.getNome()+"]"+posizione+" del Soggetto "+soggettoProprietario.getTipo()+"/"+soggettoProprietario.getNome()+" connettore inv servizio di tipo ["+servizioApplicativo.getInvocazioneServizio().getConnettore().getTipo()+"]");
  1671.             }
  1672.             if(CostantiConfigurazione.CONFIGURAZIONE_DB.equals(tipoBEDestinazione)){
  1673.                 // I nomi vengono autogenerati dal driver
  1674.                 servizioApplicativo.getInvocazioneServizio().getConnettore().setNome(null);
  1675.                 // I tipi diversi da disabilitato,http,jms,null,nullEcho sono custom
  1676.                 String tipoConnettore = servizioApplicativo.getInvocazioneServizio().getConnettore().getTipo();
  1677.                 if ( !TipiConnettore.JMS.getNome().equals(tipoConnettore) && !TipiConnettore.HTTP.getNome().equals(tipoConnettore) &&
  1678.                      !TipiConnettore.DISABILITATO.getNome().equals(tipoConnettore) && !TipiConnettore.NULL.getNome().equals(tipoConnettore) &&
  1679.                      !TipiConnettore.NULLECHO.getNome().equals(tipoConnettore) ){
  1680.                     servizioApplicativo.getInvocazioneServizio().getConnettore().setCustom(true);
  1681.                 }
  1682.                 // Gestione default per connettore https
  1683.                 if(TipiConnettore.HTTPS.getNome().equals(tipoConnettore)){
  1684.                     gestioneDefaultConnettoreHTTP(servizioApplicativo.getInvocazioneServizio().getConnettore());
  1685.                 }
  1686.             }
  1687.         }else if(servizioApplicativo.getInvocazioneServizio()==null){
  1688.             Credenziali credenziali = new Credenziali();
  1689.             credenziali.setTipo(CredenzialeTipo.toEnumConstant(CostantiConfigurazione.NONE));
  1690.             InvocazioneServizio invServizio = new InvocazioneServizio();
  1691.             invServizio.setAutenticazione(InvocazioneServizioTipoAutenticazione.toEnumConstant(CostantiConfigurazione.NONE));
  1692.             invServizio.setGetMessage(CostantiConfigurazione.DISABILITATO);
  1693.             servizioApplicativo.setInvocazioneServizio(invServizio);
  1694.         }
  1695.         // GetMessage
  1696.         if(servizioApplicativo.getInvocazioneServizio()!=null){
  1697.             if(servizioApplicativo.getInvocazioneServizio().getGetMessage()==null){
  1698.                 servizioApplicativo.getInvocazioneServizio().setGetMessage(CostantiConfigurazione.DISABILITATO);
  1699.             }
  1700.         }
  1701.         
  1702.         // **** RispostaAsincrona ****
  1703.         // Check connettori non definit all'interno del servizio
  1704.         if(servizioApplicativo.getRispostaAsincrona()!=null && servizioApplicativo.getRispostaAsincrona().getConnettore()!=null){
  1705.             if(servizioApplicativo.getRispostaAsincrona().getConnettore().getTipo()==null){
  1706.                 // ricavo il connettore dal soggetto
  1707.                 for(int con=0;con<soggettoProprietario.sizeConnettoreList();con++){
  1708.                     if(soggettoProprietario.getConnettore(con).getNome().equals(servizioApplicativo.getRispostaAsincrona().getConnettore().getNome())){
  1709.                         servizioApplicativo.getRispostaAsincrona().setConnettore(soggettoProprietario.getConnettore(con));
  1710.                         break;
  1711.                     }
  1712.                 }
  1713.                 log.info("Servizio Applicativo ["+servizioApplicativo.getNome()+"]"+posizione+" del Soggetto "+soggettoProprietario.getTipo()+"/"+soggettoProprietario.getNome()+" connettore risposta asincrona di tipo, dopo ricerca ["+servizioApplicativo.getRispostaAsincrona().getConnettore().getTipo()+"]");
  1714.             }else{
  1715.                 log.info("Servizio Applicativo ["+servizioApplicativo.getNome()+"]"+posizione+" del Soggetto "+soggettoProprietario.getTipo()+"/"+soggettoProprietario.getNome()+" connettore risposta asincrona di tipo ["+servizioApplicativo.getRispostaAsincrona().getConnettore().getTipo()+"]");
  1716.             }
  1717.             if(CostantiConfigurazione.CONFIGURAZIONE_DB.equals(tipoBEDestinazione)){
  1718.                 // I nomi vengono autogenerati dal driver
  1719.                 servizioApplicativo.getRispostaAsincrona().getConnettore().setNome(null);
  1720.                 // I tipi diversi da disabilitato,http,jms,null,nullEcho sono custom
  1721.                 String tipoConnettore = servizioApplicativo.getRispostaAsincrona().getConnettore().getTipo();
  1722.                 if ( !TipiConnettore.JMS.getNome().equals(tipoConnettore) && !TipiConnettore.HTTP.getNome().equals(tipoConnettore) &&
  1723.                      !TipiConnettore.DISABILITATO.getNome().equals(tipoConnettore) && !TipiConnettore.NULL.getNome().equals(tipoConnettore) &&
  1724.                      !TipiConnettore.NULLECHO.getNome().equals(tipoConnettore) ){
  1725.                     servizioApplicativo.getRispostaAsincrona().getConnettore().setCustom(true);
  1726.                 }
  1727.                 // Gestione default per connettore https
  1728.                 if(TipiConnettore.HTTPS.getNome().equals(tipoConnettore)){
  1729.                     gestioneDefaultConnettoreHTTP(servizioApplicativo.getRispostaAsincrona().getConnettore());
  1730.                 }
  1731.             }
  1732.         }else if(servizioApplicativo.getRispostaAsincrona()==null){
  1733.             Credenziali credenziali = new Credenziali();
  1734.             credenziali.setTipo(CredenzialeTipo.toEnumConstant(CostantiConfigurazione.NONE));
  1735.             RispostaAsincrona rispostaAsinc = new RispostaAsincrona();
  1736.             rispostaAsinc.setAutenticazione(InvocazioneServizioTipoAutenticazione.toEnumConstant(CostantiConfigurazione.NONE));
  1737.             rispostaAsinc.setGetMessage(CostantiConfigurazione.DISABILITATO);
  1738.             servizioApplicativo.setRispostaAsincrona(rispostaAsinc);
  1739.         }
  1740.         // GetMessage
  1741.         if(servizioApplicativo.getRispostaAsincrona()!=null){
  1742.             if(servizioApplicativo.getRispostaAsincrona().getGetMessage()==null){
  1743.                 servizioApplicativo.getRispostaAsincrona().setGetMessage(CostantiConfigurazione.DISABILITATO);
  1744.             }
  1745.         }
  1746.         
  1747.         
  1748.         // **** altre info per driver DB ***
  1749.         if(CostantiConfigurazione.REGISTRO_DB.equals(tipoBEDestinazione)){
  1750.             
  1751.             boolean isClient = false;
  1752.             
  1753.             if(servizioApplicativo.getInvocazioneServizio()!=null && servizioApplicativo.getInvocazioneServizio().getConnettore()!=null){
  1754.                 // I nomi dei connettorivengono autogenerati dal driver
  1755.                 servizioApplicativo.getInvocazioneServizio().getConnettore().setNome(null);
  1756.                 String tipoConnettore = servizioApplicativo.getInvocazioneServizio().getConnettore().getTipo();
  1757.                 if(!TipiConnettore.DISABILITATO.getNome().equals(tipoConnettore)) {
  1758.                     servizioApplicativo.setTipologiaErogazione(TipologiaErogazione.TRASPARENTE.getValue());
  1759.                 }
  1760.                 // I tipi diversi da disabilitato,http,jms,null,nullEcho sono custom
  1761.                 if ( !TipiConnettore.JMS.getNome().equals(tipoConnettore) && !TipiConnettore.HTTP.getNome().equals(tipoConnettore) &&
  1762.                      !TipiConnettore.DISABILITATO.getNome().equals(tipoConnettore) && !TipiConnettore.NULL.getNome().equals(tipoConnettore) &&
  1763.                      !TipiConnettore.NULLECHO.getNome().equals(tipoConnettore) ){
  1764.                     servizioApplicativo.getInvocazioneServizio().getConnettore().setCustom(true);
  1765.                 }
  1766.                 // Gestione default per connettore https
  1767.                 if(TipiConnettore.HTTPS.getNome().equals(tipoConnettore)){
  1768.                     gestioneDefaultConnettoreHTTP(servizioApplicativo.getInvocazioneServizio().getConnettore());
  1769.                 }
  1770.             }
  1771.             if(servizioApplicativo.getRispostaAsincrona()!=null && servizioApplicativo.getRispostaAsincrona().getConnettore()!=null){
  1772.                 // I nomi dei connettorivengono autogenerati dal driver
  1773.                 servizioApplicativo.getRispostaAsincrona().getConnettore().setNome(null);
  1774.                 String tipoConnettore = servizioApplicativo.getRispostaAsincrona().getConnettore().getTipo();
  1775.                 if(!TipiConnettore.DISABILITATO.getNome().equals(tipoConnettore)) {
  1776.                     servizioApplicativo.setTipologiaErogazione(TipologiaErogazione.ASINCRONA_ASIMMETRICA.getValue());
  1777.                 }
  1778.                 // I tipi diversi da disabilitato,http,jms,null,nullEcho sono custom
  1779.                 if ( !TipiConnettore.JMS.getNome().equals(tipoConnettore) && !TipiConnettore.HTTP.getNome().equals(tipoConnettore) &&
  1780.                      !TipiConnettore.DISABILITATO.getNome().equals(tipoConnettore) && !TipiConnettore.NULL.getNome().equals(tipoConnettore) &&
  1781.                      !TipiConnettore.NULLECHO.getNome().equals(tipoConnettore) ){
  1782.                     servizioApplicativo.getRispostaAsincrona().getConnettore().setCustom(true);
  1783.                 }
  1784.                 // Gestione default per connettore https
  1785.                 if(TipiConnettore.HTTPS.getNome().equals(tipoConnettore)){
  1786.                     gestioneDefaultConnettoreHTTP(servizioApplicativo.getRispostaAsincrona().getConnettore());
  1787.                 }
  1788.             }
  1789.             if(servizioApplicativo.getTipologiaErogazione()==null) {
  1790.                 if(servizioApplicativo.getInvocazioneServizio()!=null && servizioApplicativo.getInvocazioneServizio().getGetMessage()!=null &&
  1791.                         StatoFunzionalita.ABILITATO.equals(servizioApplicativo.getInvocazioneServizio().getGetMessage())) {
  1792.                     servizioApplicativo.setTipologiaErogazione(TipologiaErogazione.MESSAGE_BOX.getValue());
  1793.                 }
  1794.             }
  1795.             
  1796.             boolean isIMenabled = false;
  1797.             if(servizioApplicativo.getInvocazioneServizio()!=null && servizioApplicativo.getInvocazioneServizio().getGetMessage()!=null &&
  1798.                     StatoFunzionalita.ABILITATO.equals(servizioApplicativo.getInvocazioneServizio().getGetMessage())) {
  1799.                 isIMenabled = true;
  1800.             }
  1801.             else if(servizioApplicativo.getRispostaAsincrona()!=null && servizioApplicativo.getRispostaAsincrona().getGetMessage()!=null &&
  1802.                     StatoFunzionalita.ABILITATO.equals(servizioApplicativo.getRispostaAsincrona().getGetMessage())) {
  1803.                 isIMenabled = true;
  1804.             }
  1805.             
  1806.             if(servizioApplicativo.getInvocazionePorta()!=null && servizioApplicativo.getInvocazionePorta().sizeCredenzialiList()>0) {
  1807.                 // Verifico che esista una credenziale buona
  1808.                 boolean found = false;
  1809.                 for (int i = 0; i < servizioApplicativo.getInvocazionePorta().sizeCredenzialiList(); i++) {
  1810.                     Credenziali c = servizioApplicativo.getInvocazionePorta().getCredenziali(i);
  1811.                     if(c!=null && c.getTipo()!=null && (c.getUser()!=null || c.getSubject()!=null)) {
  1812.                         found = true;
  1813.                         break;
  1814.                     }
  1815.                 }
  1816.                 if(found) {
  1817.                     servizioApplicativo.setTipologiaFruizione(TipologiaFruizione.NORMALE.getValue());
  1818.                     isClient = true;
  1819.                 }
  1820.             }
  1821.             
  1822.             // FIX: il server deve esser impostato solamente se si crea un applicativo server, e non se c'è un connettore abilitato.
  1823.             // Se e' stato esportato, il tipo sarà valorizzato.
  1824.             if(isClient) {
  1825.                 if(servizioApplicativo.getTipo()==null) {
  1826.                     if(!isIMenabled) {
  1827.                         servizioApplicativo.setTipo(CostantiConfigurazione.CLIENT);
  1828.                     }
  1829.                     //else {
  1830.                         // si tratta di un servizio applicativo I.M. registrato in una erogazione 
  1831.                     //}
  1832.                 }
  1833.                 else {
  1834.                     if(CostantiConfigurazione.SERVER.equals(servizioApplicativo.getTipo())) {
  1835.                         servizioApplicativo.setUseAsClient(true);
  1836.                     }
  1837.                     //else {
  1838.                         // se e' client o clientOrServer va gia' bene
  1839.                     //}
  1840.                 }
  1841.             }
  1842.             
  1843.         }
  1844.     }
  1845.     
  1846.     public static void impostaInformazioniConfigurazione_ServizioApplicativo_update(ServizioApplicativo servizioApplicativo,ServizioApplicativo old){
  1847.         servizioApplicativo.setId(old.getId());
  1848.         if(servizioApplicativo.getInvocazioneServizio()!=null){
  1849.             if(servizioApplicativo.getInvocazioneServizio().getConnettore()==null){
  1850.                 if(old.getInvocazioneServizio()!=null)
  1851.                     servizioApplicativo.getInvocazioneServizio().setConnettore(old.getInvocazioneServizio().getConnettore());
  1852.             }else{
  1853.                 if(old.getInvocazioneServizio()!=null && old.getInvocazioneServizio().getConnettore()!=null){
  1854.                     servizioApplicativo.getInvocazioneServizio().getConnettore().setId(old.getInvocazioneServizio().getConnettore().getId());
  1855.                     servizioApplicativo.getInvocazioneServizio().getConnettore().setNome(old.getInvocazioneServizio().getConnettore().getNome());
  1856.                 }
  1857.             }
  1858.         }
  1859.         if(servizioApplicativo.getRispostaAsincrona()!=null){
  1860.             if(servizioApplicativo.getRispostaAsincrona().getConnettore()==null){
  1861.                 if(old.getRispostaAsincrona()!=null)
  1862.                     servizioApplicativo.getRispostaAsincrona().setConnettore(old.getRispostaAsincrona().getConnettore());
  1863.             }else{
  1864.                 if(old.getRispostaAsincrona()!=null && old.getRispostaAsincrona().getConnettore()!=null){
  1865.                     servizioApplicativo.getRispostaAsincrona().getConnettore().setId(old.getRispostaAsincrona().getConnettore().getId());
  1866.                     servizioApplicativo.getRispostaAsincrona().getConnettore().setNome(old.getRispostaAsincrona().getConnettore().getNome());
  1867.                 }
  1868.             }
  1869.         }
  1870.     }
  1871.     
  1872.     private void addServizioApplicativo(ServizioApplicativo servizioApplicativo,Soggetto soggettoProprietario,String posizione,boolean reset, boolean updateEnabled) throws Exception{
  1873.         servizioApplicativo.setTipoSoggettoProprietario(soggettoProprietario.getTipo());
  1874.         servizioApplicativo.setNomeSoggettoProprietario(soggettoProprietario.getNome());
  1875.         String pos = "";
  1876.         if(posizione!=null){
  1877.             pos = "["+posizione+"]";
  1878.         }
  1879.         
  1880.         impostaInformazioniConfigurazione_ServizioApplicativo(servizioApplicativo, soggettoProprietario, 
  1881.                 pos, this.log, this.tipoBEDestinazione);        
  1882.         
  1883.         // *** effettua create/update/delete
  1884.         IDSoggetto idSoggetto = new IDSoggetto(soggettoProprietario.getTipo(),soggettoProprietario.getNome());
  1885.         IDServizioApplicativo idSA = new IDServizioApplicativo();
  1886.         idSA.setIdSoggettoProprietario(idSoggetto);
  1887.         idSA.setNome(servizioApplicativo.getNome());
  1888.         if( (reset==false) && this.gestoreCRUD.existsServizioApplicativo(idSA)){
  1889.             if(updateEnabled) {
  1890.                 this.log.info("Servizio Applicativo ["+servizioApplicativo.getNome()+"]"+pos+" del Soggetto "+soggettoProprietario.getTipo()+"/"+soggettoProprietario.getNome()+" aggiornamento in corso...");
  1891.                 
  1892.                 ServizioApplicativo old = ((IDriverConfigurazioneGet) this.gestoreCRUD).getServizioApplicativo(idSA);
  1893.                 
  1894.                 impostaInformazioniConfigurazione_ServizioApplicativo_update(servizioApplicativo, old);
  1895.                 
  1896.                 this.gestoreCRUD.updateServizioApplicativo(servizioApplicativo);
  1897.                 this.log.info("Servizio Applicativo ["+servizioApplicativo.getNome()+"]"+pos+" del Soggetto "+soggettoProprietario.getTipo()+"/"+soggettoProprietario.getNome()+" aggiornato.");
  1898.             }
  1899.             else {
  1900.                 this.log.info("Servizio Applicativo ["+servizioApplicativo.getNome()+"]"+pos+" del Soggetto "+soggettoProprietario.getTipo()+"/"+soggettoProprietario.getNome()+" non aggiornato (aggiornamento disabilitato).");
  1901.             }
  1902.         }else{
  1903.             this.log.info("Servizio Applicativo ["+servizioApplicativo.getNome()+"]"+pos+" del Soggetto "+soggettoProprietario.getTipo()+"/"+soggettoProprietario.getNome()+" creazione in corso...");
  1904.             this.gestoreCRUD.createServizioApplicativo(servizioApplicativo);
  1905.             this.log.info("Servizio Applicativo ["+servizioApplicativo.getNome()+"]"+pos+" del Soggetto "+soggettoProprietario.getTipo()+"/"+soggettoProprietario.getNome()+" creato.");
  1906.         }
  1907.         
  1908.         
  1909.         
  1910.     }
  1911. }
Created with JaCoCo 0.8.8.202204050719